Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Write a version of this J function in Go with identical behavior. | stem =: <.@(%&10)
leaf =: 10&|
stemleaf =: (stem@{. ; leaf)/.~ stem
expandStems =: <./ ([ + i.@>:@-~) >./
expandLeaves=: (expandStems e. ])@[ #inv ]
showStemLeaf=: (":@,.@expandStems@[ ; ":&>@expandLeaves)&>/@(>@{. ; <@{:)@|:@stemleaf@/:~
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Convert this Julia snippet to C and keep its semantics consistent. | function stemleaf{T<:Real}(a::Array{T,1}, leafsize=1)
ls = 10^int(log10(leafsize))
(stem, leaf) = divrem(sort(int(a/ls)), 10)
leaf[sign(stem) .== -1] *= -1
negzero = leaf .< 0
if any(negzero)
leaf[negzero] *= -1
nz = @sprintf "%10s | " "-0"
nz *= join(map(string, leaf[negzero]), " ")
nz *= "\n"
stem = stem[!negzero]
leaf = leaf[!negzero]
else
nz = ""
end
slp = ""
for i in stem[1]:stem[end]
i != 0 || (slp *= nz)
slp *= @sprintf "%10d | " i
slp *= join(map(string, leaf[stem .== i]), " ")
slp *= "\n"
end
slp *= " Leaf Unit = " * string(convert(T, ls)) * "\n"
return slp
end
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Rewrite this program in C# while keeping its functionality equivalent to the Julia version. | function stemleaf{T<:Real}(a::Array{T,1}, leafsize=1)
ls = 10^int(log10(leafsize))
(stem, leaf) = divrem(sort(int(a/ls)), 10)
leaf[sign(stem) .== -1] *= -1
negzero = leaf .< 0
if any(negzero)
leaf[negzero] *= -1
nz = @sprintf "%10s | " "-0"
nz *= join(map(string, leaf[negzero]), " ")
nz *= "\n"
stem = stem[!negzero]
leaf = leaf[!negzero]
else
nz = ""
end
slp = ""
for i in stem[1]:stem[end]
i != 0 || (slp *= nz)
slp *= @sprintf "%10d | " i
slp *= join(map(string, leaf[stem .== i]), " ")
slp *= "\n"
end
slp *= " Leaf Unit = " * string(convert(T, ls)) * "\n"
return slp
end
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Change the following Julia code into C++ without altering its purpose. | function stemleaf{T<:Real}(a::Array{T,1}, leafsize=1)
ls = 10^int(log10(leafsize))
(stem, leaf) = divrem(sort(int(a/ls)), 10)
leaf[sign(stem) .== -1] *= -1
negzero = leaf .< 0
if any(negzero)
leaf[negzero] *= -1
nz = @sprintf "%10s | " "-0"
nz *= join(map(string, leaf[negzero]), " ")
nz *= "\n"
stem = stem[!negzero]
leaf = leaf[!negzero]
else
nz = ""
end
slp = ""
for i in stem[1]:stem[end]
i != 0 || (slp *= nz)
slp *= @sprintf "%10d | " i
slp *= join(map(string, leaf[stem .== i]), " ")
slp *= "\n"
end
slp *= " Leaf Unit = " * string(convert(T, ls)) * "\n"
return slp
end
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Transform the following Julia implementation into Java, maintaining the same output and logic. | function stemleaf{T<:Real}(a::Array{T,1}, leafsize=1)
ls = 10^int(log10(leafsize))
(stem, leaf) = divrem(sort(int(a/ls)), 10)
leaf[sign(stem) .== -1] *= -1
negzero = leaf .< 0
if any(negzero)
leaf[negzero] *= -1
nz = @sprintf "%10s | " "-0"
nz *= join(map(string, leaf[negzero]), " ")
nz *= "\n"
stem = stem[!negzero]
leaf = leaf[!negzero]
else
nz = ""
end
slp = ""
for i in stem[1]:stem[end]
i != 0 || (slp *= nz)
slp *= @sprintf "%10d | " i
slp *= join(map(string, leaf[stem .== i]), " ")
slp *= "\n"
end
slp *= " Leaf Unit = " * string(convert(T, ls)) * "\n"
return slp
end
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Rewrite the snippet below in Python so it works the same as the original Julia code. | function stemleaf{T<:Real}(a::Array{T,1}, leafsize=1)
ls = 10^int(log10(leafsize))
(stem, leaf) = divrem(sort(int(a/ls)), 10)
leaf[sign(stem) .== -1] *= -1
negzero = leaf .< 0
if any(negzero)
leaf[negzero] *= -1
nz = @sprintf "%10s | " "-0"
nz *= join(map(string, leaf[negzero]), " ")
nz *= "\n"
stem = stem[!negzero]
leaf = leaf[!negzero]
else
nz = ""
end
slp = ""
for i in stem[1]:stem[end]
i != 0 || (slp *= nz)
slp *= @sprintf "%10d | " i
slp *= join(map(string, leaf[stem .== i]), " ")
slp *= "\n"
end
slp *= " Leaf Unit = " * string(convert(T, ls)) * "\n"
return slp
end
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Maintain the same structure and functionality when rewriting this code in Go. | function stemleaf{T<:Real}(a::Array{T,1}, leafsize=1)
ls = 10^int(log10(leafsize))
(stem, leaf) = divrem(sort(int(a/ls)), 10)
leaf[sign(stem) .== -1] *= -1
negzero = leaf .< 0
if any(negzero)
leaf[negzero] *= -1
nz = @sprintf "%10s | " "-0"
nz *= join(map(string, leaf[negzero]), " ")
nz *= "\n"
stem = stem[!negzero]
leaf = leaf[!negzero]
else
nz = ""
end
slp = ""
for i in stem[1]:stem[end]
i != 0 || (slp *= nz)
slp *= @sprintf "%10d | " i
slp *= join(map(string, leaf[stem .== i]), " ")
slp *= "\n"
end
slp *= " Leaf Unit = " * string(convert(T, ls)) * "\n"
return slp
end
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Port the following code from Lua to C# with equivalent syntax and logic. | data = { 12,127,28,42,39,113, 42,18,44,118,44,37,113,124,37,48,127,36,29,31,
125,139,131,115,105,132,104,123,35,113,122,42,117,119,58,109,23,105,
63,27,44,105,99,41,128,121,116,125,32,61,37,127,29,113,121,58,114,126,
53,114,96,25,109,7,31,141,46,13,27,43,117,116,27,7,68,40,31,115,124,42,
128,52,71,118,117,38,27,106,33,117,116,111,40,119,47,105,57,122,109,
124,115,43,120,43,27,27,18,28,48,125,107,114,34,133,45,120, 30,127,
31,116,146
}
table.sort( data )
min, max = data[1], data[#data]
p = 1
for stem = math.floor(min/10), math.floor(max/10) do
io.write( string.format( "%2d | ", stem ) )
while data[p] ~= nil and math.floor( data[p]/10 ) == stem do
io.write( string.format( "%2d ", data[p] % 10 ) )
p = p + 1
end
print ""
end
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Convert this Lua block to C++, preserving its control flow and logic. | data = { 12,127,28,42,39,113, 42,18,44,118,44,37,113,124,37,48,127,36,29,31,
125,139,131,115,105,132,104,123,35,113,122,42,117,119,58,109,23,105,
63,27,44,105,99,41,128,121,116,125,32,61,37,127,29,113,121,58,114,126,
53,114,96,25,109,7,31,141,46,13,27,43,117,116,27,7,68,40,31,115,124,42,
128,52,71,118,117,38,27,106,33,117,116,111,40,119,47,105,57,122,109,
124,115,43,120,43,27,27,18,28,48,125,107,114,34,133,45,120, 30,127,
31,116,146
}
table.sort( data )
min, max = data[1], data[#data]
p = 1
for stem = math.floor(min/10), math.floor(max/10) do
io.write( string.format( "%2d | ", stem ) )
while data[p] ~= nil and math.floor( data[p]/10 ) == stem do
io.write( string.format( "%2d ", data[p] % 10 ) )
p = p + 1
end
print ""
end
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Write the same code in Java as shown below in Lua. | data = { 12,127,28,42,39,113, 42,18,44,118,44,37,113,124,37,48,127,36,29,31,
125,139,131,115,105,132,104,123,35,113,122,42,117,119,58,109,23,105,
63,27,44,105,99,41,128,121,116,125,32,61,37,127,29,113,121,58,114,126,
53,114,96,25,109,7,31,141,46,13,27,43,117,116,27,7,68,40,31,115,124,42,
128,52,71,118,117,38,27,106,33,117,116,111,40,119,47,105,57,122,109,
124,115,43,120,43,27,27,18,28,48,125,107,114,34,133,45,120, 30,127,
31,116,146
}
table.sort( data )
min, max = data[1], data[#data]
p = 1
for stem = math.floor(min/10), math.floor(max/10) do
io.write( string.format( "%2d | ", stem ) )
while data[p] ~= nil and math.floor( data[p]/10 ) == stem do
io.write( string.format( "%2d ", data[p] % 10 ) )
p = p + 1
end
print ""
end
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Write a version of this Lua function in Python with identical behavior. | data = { 12,127,28,42,39,113, 42,18,44,118,44,37,113,124,37,48,127,36,29,31,
125,139,131,115,105,132,104,123,35,113,122,42,117,119,58,109,23,105,
63,27,44,105,99,41,128,121,116,125,32,61,37,127,29,113,121,58,114,126,
53,114,96,25,109,7,31,141,46,13,27,43,117,116,27,7,68,40,31,115,124,42,
128,52,71,118,117,38,27,106,33,117,116,111,40,119,47,105,57,122,109,
124,115,43,120,43,27,27,18,28,48,125,107,114,34,133,45,120, 30,127,
31,116,146
}
table.sort( data )
min, max = data[1], data[#data]
p = 1
for stem = math.floor(min/10), math.floor(max/10) do
io.write( string.format( "%2d | ", stem ) )
while data[p] ~= nil and math.floor( data[p]/10 ) == stem do
io.write( string.format( "%2d ", data[p] % 10 ) )
p = p + 1
end
print ""
end
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Write a version of this Lua function in Go with identical behavior. | data = { 12,127,28,42,39,113, 42,18,44,118,44,37,113,124,37,48,127,36,29,31,
125,139,131,115,105,132,104,123,35,113,122,42,117,119,58,109,23,105,
63,27,44,105,99,41,128,121,116,125,32,61,37,127,29,113,121,58,114,126,
53,114,96,25,109,7,31,141,46,13,27,43,117,116,27,7,68,40,31,115,124,42,
128,52,71,118,117,38,27,106,33,117,116,111,40,119,47,105,57,122,109,
124,115,43,120,43,27,27,18,28,48,125,107,114,34,133,45,120, 30,127,
31,116,146
}
table.sort( data )
min, max = data[1], data[#data]
p = 1
for stem = math.floor(min/10), math.floor(max/10) do
io.write( string.format( "%2d | ", stem ) )
while data[p] ~= nil and math.floor( data[p]/10 ) == stem do
io.write( string.format( "%2d ", data[p] % 10 ) )
p = p + 1
end
print ""
end
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Convert the following code from Mathematica to C, ensuring the logic remains intact. | len[n_] := RealDigits[n][[2]]; padding = len[Max@ Quotient[inputdata, 10]];
For[i = Min@ Quotient[inputdata, 10],i <= Max@ Quotient[inputdata, 10], i++,
(Print[i, If[(padding - len[i]) > 0, (padding - len[i])*" " <> " |", " |"] ,
StringJoin[(" " <> #) & /@ Map[ToString, #]]])&@
Select[{Quotient[#, 10], Mod[#, 10]} & /@ Sort[inputdata],Part[#, 1] == i &][[;; , 2]]]
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Produce a language-to-language conversion: from Mathematica to C#, same semantics. | len[n_] := RealDigits[n][[2]]; padding = len[Max@ Quotient[inputdata, 10]];
For[i = Min@ Quotient[inputdata, 10],i <= Max@ Quotient[inputdata, 10], i++,
(Print[i, If[(padding - len[i]) > 0, (padding - len[i])*" " <> " |", " |"] ,
StringJoin[(" " <> #) & /@ Map[ToString, #]]])&@
Select[{Quotient[#, 10], Mod[#, 10]} & /@ Sort[inputdata],Part[#, 1] == i &][[;; , 2]]]
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Ensure the translated C++ code behaves exactly like the original Mathematica snippet. | len[n_] := RealDigits[n][[2]]; padding = len[Max@ Quotient[inputdata, 10]];
For[i = Min@ Quotient[inputdata, 10],i <= Max@ Quotient[inputdata, 10], i++,
(Print[i, If[(padding - len[i]) > 0, (padding - len[i])*" " <> " |", " |"] ,
StringJoin[(" " <> #) & /@ Map[ToString, #]]])&@
Select[{Quotient[#, 10], Mod[#, 10]} & /@ Sort[inputdata],Part[#, 1] == i &][[;; , 2]]]
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Transform the following Mathematica implementation into Java, maintaining the same output and logic. | len[n_] := RealDigits[n][[2]]; padding = len[Max@ Quotient[inputdata, 10]];
For[i = Min@ Quotient[inputdata, 10],i <= Max@ Quotient[inputdata, 10], i++,
(Print[i, If[(padding - len[i]) > 0, (padding - len[i])*" " <> " |", " |"] ,
StringJoin[(" " <> #) & /@ Map[ToString, #]]])&@
Select[{Quotient[#, 10], Mod[#, 10]} & /@ Sort[inputdata],Part[#, 1] == i &][[;; , 2]]]
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Can you help me rewrite this code in Python instead of Mathematica, keeping it the same logically? | len[n_] := RealDigits[n][[2]]; padding = len[Max@ Quotient[inputdata, 10]];
For[i = Min@ Quotient[inputdata, 10],i <= Max@ Quotient[inputdata, 10], i++,
(Print[i, If[(padding - len[i]) > 0, (padding - len[i])*" " <> " |", " |"] ,
StringJoin[(" " <> #) & /@ Map[ToString, #]]])&@
Select[{Quotient[#, 10], Mod[#, 10]} & /@ Sort[inputdata],Part[#, 1] == i &][[;; , 2]]]
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Produce a functionally identical Go code for the snippet given in Mathematica. | len[n_] := RealDigits[n][[2]]; padding = len[Max@ Quotient[inputdata, 10]];
For[i = Min@ Quotient[inputdata, 10],i <= Max@ Quotient[inputdata, 10], i++,
(Print[i, If[(padding - len[i]) > 0, (padding - len[i])*" " <> " |", " |"] ,
StringJoin[(" " <> #) & /@ Map[ToString, #]]])&@
Select[{Quotient[#, 10], Mod[#, 10]} & /@ Sort[inputdata],Part[#, 1] == i &][[;; , 2]]]
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Rewrite this program in C while keeping its functionality equivalent to the MATLAB version. | function stem_and_leaf_plot(x,stem_unit,leaf_unit)
if nargin < 2, stem_unit = 10; end;
if nargin < 3,
leaf_unit = 1;
else
x = leaf_unit*round(x/leaf_unit);
end;
stem = floor(x/stem_unit);
leaf = mod(x,stem_unit);
for k = min(stem):max(stem)
printf('\n
printf('
end;
printf('\nkey:6|3=63\n');
printf('leaf unit:
printf('stem unit:
end;
x = [12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146];
stem_and_leaf_plot(x);
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Transform the following MATLAB implementation into C#, maintaining the same output and logic. | function stem_and_leaf_plot(x,stem_unit,leaf_unit)
if nargin < 2, stem_unit = 10; end;
if nargin < 3,
leaf_unit = 1;
else
x = leaf_unit*round(x/leaf_unit);
end;
stem = floor(x/stem_unit);
leaf = mod(x,stem_unit);
for k = min(stem):max(stem)
printf('\n
printf('
end;
printf('\nkey:6|3=63\n');
printf('leaf unit:
printf('stem unit:
end;
x = [12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146];
stem_and_leaf_plot(x);
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Rewrite the snippet below in C++ so it works the same as the original MATLAB code. | function stem_and_leaf_plot(x,stem_unit,leaf_unit)
if nargin < 2, stem_unit = 10; end;
if nargin < 3,
leaf_unit = 1;
else
x = leaf_unit*round(x/leaf_unit);
end;
stem = floor(x/stem_unit);
leaf = mod(x,stem_unit);
for k = min(stem):max(stem)
printf('\n
printf('
end;
printf('\nkey:6|3=63\n');
printf('leaf unit:
printf('stem unit:
end;
x = [12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146];
stem_and_leaf_plot(x);
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Produce a functionally identical Java code for the snippet given in MATLAB. | function stem_and_leaf_plot(x,stem_unit,leaf_unit)
if nargin < 2, stem_unit = 10; end;
if nargin < 3,
leaf_unit = 1;
else
x = leaf_unit*round(x/leaf_unit);
end;
stem = floor(x/stem_unit);
leaf = mod(x,stem_unit);
for k = min(stem):max(stem)
printf('\n
printf('
end;
printf('\nkey:6|3=63\n');
printf('leaf unit:
printf('stem unit:
end;
x = [12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146];
stem_and_leaf_plot(x);
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Transform the following MATLAB implementation into Python, maintaining the same output and logic. | function stem_and_leaf_plot(x,stem_unit,leaf_unit)
if nargin < 2, stem_unit = 10; end;
if nargin < 3,
leaf_unit = 1;
else
x = leaf_unit*round(x/leaf_unit);
end;
stem = floor(x/stem_unit);
leaf = mod(x,stem_unit);
for k = min(stem):max(stem)
printf('\n
printf('
end;
printf('\nkey:6|3=63\n');
printf('leaf unit:
printf('stem unit:
end;
x = [12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146];
stem_and_leaf_plot(x);
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Rewrite this program in Go while keeping its functionality equivalent to the MATLAB version. | function stem_and_leaf_plot(x,stem_unit,leaf_unit)
if nargin < 2, stem_unit = 10; end;
if nargin < 3,
leaf_unit = 1;
else
x = leaf_unit*round(x/leaf_unit);
end;
stem = floor(x/stem_unit);
leaf = mod(x,stem_unit);
for k = min(stem):max(stem)
printf('\n
printf('
end;
printf('\nkey:6|3=63\n');
printf('leaf unit:
printf('stem unit:
end;
x = [12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146];
stem_and_leaf_plot(x);
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Can you help me rewrite this code in C instead of Nim, keeping it the same logically? | import tables
import math
import strutils
import algorithm
type
StemLeafPlot = ref object
leafDigits: int
multiplier: int
plot: TableRef[int, seq[int]]
proc `$`(s: seq[int]): string =
result = ""
for item in s:
result &= $item & " "
proc `$`(self: StemLeafPlot): string =
result = ""
var keys: seq[int] = @[]
for stem, _ in self.plot:
keys.add(stem)
for printedStem in keys.min..keys.max:
result &= align($printedStem & " | ", ($keys.max).len + 4)
if printedStem in keys:
self.plot[printedStem].sort(system.cmp[int])
result &= $self.plot[printedStem]
result &= "\n"
proc parse(self: StemLeafPlot, value: int): tuple[stem, leaf: int] =
(value div self.multiplier, abs(value mod self.multiplier))
proc init[T](self: StemLeafPlot, leafDigits: int, data: openArray[T]) =
self.leafDigits = leafDigits
self.multiplier = 10 ^ leafDigits
self.plot = newTable[int, seq[int]]()
for value in data:
let (stem, leaf) = self.parse(value)
if stem notin self.plot:
self.plot[stem] = @[leaf]
else:
self.plot[stem].add(leaf)
var taskData = @[12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146]
var negativeData = @[-24, -12, -3, 4, 6, 6, 17, 25, 57]
echo "Using the Task's Test Data"
var taskPlot = StemLeafPlot()
taskPlot.init(1, taskData)
echo taskPlot
echo "Test with Negative Stem"
var negativePlot = StemLeafPlot()
negativePlot.init(1, negativeData)
echo negativePlot
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Please provide an equivalent version of this Nim code in C#. | import tables
import math
import strutils
import algorithm
type
StemLeafPlot = ref object
leafDigits: int
multiplier: int
plot: TableRef[int, seq[int]]
proc `$`(s: seq[int]): string =
result = ""
for item in s:
result &= $item & " "
proc `$`(self: StemLeafPlot): string =
result = ""
var keys: seq[int] = @[]
for stem, _ in self.plot:
keys.add(stem)
for printedStem in keys.min..keys.max:
result &= align($printedStem & " | ", ($keys.max).len + 4)
if printedStem in keys:
self.plot[printedStem].sort(system.cmp[int])
result &= $self.plot[printedStem]
result &= "\n"
proc parse(self: StemLeafPlot, value: int): tuple[stem, leaf: int] =
(value div self.multiplier, abs(value mod self.multiplier))
proc init[T](self: StemLeafPlot, leafDigits: int, data: openArray[T]) =
self.leafDigits = leafDigits
self.multiplier = 10 ^ leafDigits
self.plot = newTable[int, seq[int]]()
for value in data:
let (stem, leaf) = self.parse(value)
if stem notin self.plot:
self.plot[stem] = @[leaf]
else:
self.plot[stem].add(leaf)
var taskData = @[12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146]
var negativeData = @[-24, -12, -3, 4, 6, 6, 17, 25, 57]
echo "Using the Task's Test Data"
var taskPlot = StemLeafPlot()
taskPlot.init(1, taskData)
echo taskPlot
echo "Test with Negative Stem"
var negativePlot = StemLeafPlot()
negativePlot.init(1, negativeData)
echo negativePlot
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Produce a language-to-language conversion: from Nim to C++, same semantics. | import tables
import math
import strutils
import algorithm
type
StemLeafPlot = ref object
leafDigits: int
multiplier: int
plot: TableRef[int, seq[int]]
proc `$`(s: seq[int]): string =
result = ""
for item in s:
result &= $item & " "
proc `$`(self: StemLeafPlot): string =
result = ""
var keys: seq[int] = @[]
for stem, _ in self.plot:
keys.add(stem)
for printedStem in keys.min..keys.max:
result &= align($printedStem & " | ", ($keys.max).len + 4)
if printedStem in keys:
self.plot[printedStem].sort(system.cmp[int])
result &= $self.plot[printedStem]
result &= "\n"
proc parse(self: StemLeafPlot, value: int): tuple[stem, leaf: int] =
(value div self.multiplier, abs(value mod self.multiplier))
proc init[T](self: StemLeafPlot, leafDigits: int, data: openArray[T]) =
self.leafDigits = leafDigits
self.multiplier = 10 ^ leafDigits
self.plot = newTable[int, seq[int]]()
for value in data:
let (stem, leaf) = self.parse(value)
if stem notin self.plot:
self.plot[stem] = @[leaf]
else:
self.plot[stem].add(leaf)
var taskData = @[12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146]
var negativeData = @[-24, -12, -3, 4, 6, 6, 17, 25, 57]
echo "Using the Task's Test Data"
var taskPlot = StemLeafPlot()
taskPlot.init(1, taskData)
echo taskPlot
echo "Test with Negative Stem"
var negativePlot = StemLeafPlot()
negativePlot.init(1, negativeData)
echo negativePlot
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Port the provided Nim code into Java while preserving the original functionality. | import tables
import math
import strutils
import algorithm
type
StemLeafPlot = ref object
leafDigits: int
multiplier: int
plot: TableRef[int, seq[int]]
proc `$`(s: seq[int]): string =
result = ""
for item in s:
result &= $item & " "
proc `$`(self: StemLeafPlot): string =
result = ""
var keys: seq[int] = @[]
for stem, _ in self.plot:
keys.add(stem)
for printedStem in keys.min..keys.max:
result &= align($printedStem & " | ", ($keys.max).len + 4)
if printedStem in keys:
self.plot[printedStem].sort(system.cmp[int])
result &= $self.plot[printedStem]
result &= "\n"
proc parse(self: StemLeafPlot, value: int): tuple[stem, leaf: int] =
(value div self.multiplier, abs(value mod self.multiplier))
proc init[T](self: StemLeafPlot, leafDigits: int, data: openArray[T]) =
self.leafDigits = leafDigits
self.multiplier = 10 ^ leafDigits
self.plot = newTable[int, seq[int]]()
for value in data:
let (stem, leaf) = self.parse(value)
if stem notin self.plot:
self.plot[stem] = @[leaf]
else:
self.plot[stem].add(leaf)
var taskData = @[12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146]
var negativeData = @[-24, -12, -3, 4, 6, 6, 17, 25, 57]
echo "Using the Task's Test Data"
var taskPlot = StemLeafPlot()
taskPlot.init(1, taskData)
echo taskPlot
echo "Test with Negative Stem"
var negativePlot = StemLeafPlot()
negativePlot.init(1, negativeData)
echo negativePlot
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Port the following code from Nim to Python with equivalent syntax and logic. | import tables
import math
import strutils
import algorithm
type
StemLeafPlot = ref object
leafDigits: int
multiplier: int
plot: TableRef[int, seq[int]]
proc `$`(s: seq[int]): string =
result = ""
for item in s:
result &= $item & " "
proc `$`(self: StemLeafPlot): string =
result = ""
var keys: seq[int] = @[]
for stem, _ in self.plot:
keys.add(stem)
for printedStem in keys.min..keys.max:
result &= align($printedStem & " | ", ($keys.max).len + 4)
if printedStem in keys:
self.plot[printedStem].sort(system.cmp[int])
result &= $self.plot[printedStem]
result &= "\n"
proc parse(self: StemLeafPlot, value: int): tuple[stem, leaf: int] =
(value div self.multiplier, abs(value mod self.multiplier))
proc init[T](self: StemLeafPlot, leafDigits: int, data: openArray[T]) =
self.leafDigits = leafDigits
self.multiplier = 10 ^ leafDigits
self.plot = newTable[int, seq[int]]()
for value in data:
let (stem, leaf) = self.parse(value)
if stem notin self.plot:
self.plot[stem] = @[leaf]
else:
self.plot[stem].add(leaf)
var taskData = @[12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146]
var negativeData = @[-24, -12, -3, 4, 6, 6, 17, 25, 57]
echo "Using the Task's Test Data"
var taskPlot = StemLeafPlot()
taskPlot.init(1, taskData)
echo taskPlot
echo "Test with Negative Stem"
var negativePlot = StemLeafPlot()
negativePlot.init(1, negativeData)
echo negativePlot
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Convert the following code from Nim to Go, ensuring the logic remains intact. | import tables
import math
import strutils
import algorithm
type
StemLeafPlot = ref object
leafDigits: int
multiplier: int
plot: TableRef[int, seq[int]]
proc `$`(s: seq[int]): string =
result = ""
for item in s:
result &= $item & " "
proc `$`(self: StemLeafPlot): string =
result = ""
var keys: seq[int] = @[]
for stem, _ in self.plot:
keys.add(stem)
for printedStem in keys.min..keys.max:
result &= align($printedStem & " | ", ($keys.max).len + 4)
if printedStem in keys:
self.plot[printedStem].sort(system.cmp[int])
result &= $self.plot[printedStem]
result &= "\n"
proc parse(self: StemLeafPlot, value: int): tuple[stem, leaf: int] =
(value div self.multiplier, abs(value mod self.multiplier))
proc init[T](self: StemLeafPlot, leafDigits: int, data: openArray[T]) =
self.leafDigits = leafDigits
self.multiplier = 10 ^ leafDigits
self.plot = newTable[int, seq[int]]()
for value in data:
let (stem, leaf) = self.parse(value)
if stem notin self.plot:
self.plot[stem] = @[leaf]
else:
self.plot[stem].add(leaf)
var taskData = @[12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146]
var negativeData = @[-24, -12, -3, 4, 6, 6, 17, 25, 57]
echo "Using the Task's Test Data"
var taskPlot = StemLeafPlot()
taskPlot.init(1, taskData)
echo taskPlot
echo "Test with Negative Stem"
var negativePlot = StemLeafPlot()
negativePlot.init(1, negativeData)
echo negativePlot
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Produce a functionally identical C code for the snippet given in OCaml. | let unique li =
let rec aux acc = function
| [] -> (List.rev acc)
| x::xs ->
if List.mem x acc
then aux acc xs
else aux (x::acc) xs
in
aux [] li
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Port the provided OCaml code into C# while preserving the original functionality. | let unique li =
let rec aux acc = function
| [] -> (List.rev acc)
| x::xs ->
if List.mem x acc
then aux acc xs
else aux (x::acc) xs
in
aux [] li
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Convert this OCaml snippet to C++ and keep its semantics consistent. | let unique li =
let rec aux acc = function
| [] -> (List.rev acc)
| x::xs ->
if List.mem x acc
then aux acc xs
else aux (x::acc) xs
in
aux [] li
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Write a version of this OCaml function in Java with identical behavior. | let unique li =
let rec aux acc = function
| [] -> (List.rev acc)
| x::xs ->
if List.mem x acc
then aux acc xs
else aux (x::acc) xs
in
aux [] li
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Produce a functionally identical Python code for the snippet given in OCaml. | let unique li =
let rec aux acc = function
| [] -> (List.rev acc)
| x::xs ->
if List.mem x acc
then aux acc xs
else aux (x::acc) xs
in
aux [] li
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Port the following code from OCaml to Go with equivalent syntax and logic. | let unique li =
let rec aux acc = function
| [] -> (List.rev acc)
| x::xs ->
if List.mem x acc
then aux acc xs
else aux (x::acc) xs
in
aux [] li
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Port the following code from Perl to C with equivalent syntax and logic. | my @data = sort {$a <=> $b} qw( 12 127 28 42 39 113 42 18 44 118 44
37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113
122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32
61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27
106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27
18 28 48 125 107 114 34 133 45 120 30 127 31 116 );
my $columns = @data;
my $laststem = undef;
for my $value (@data) {
my $stem = int($value / 10);
my $leaf = $value % 10;
while (not defined $laststem or $stem > $laststem) {
if (not defined $laststem) {
$laststem = $stem - 1;
} else {
print " \n";
}
$laststem++;
printf "%3d |", $laststem;
}
print " $leaf";
}
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Generate a C# translation of this Perl snippet without changing its computational steps. | my @data = sort {$a <=> $b} qw( 12 127 28 42 39 113 42 18 44 118 44
37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113
122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32
61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27
106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27
18 28 48 125 107 114 34 133 45 120 30 127 31 116 );
my $columns = @data;
my $laststem = undef;
for my $value (@data) {
my $stem = int($value / 10);
my $leaf = $value % 10;
while (not defined $laststem or $stem > $laststem) {
if (not defined $laststem) {
$laststem = $stem - 1;
} else {
print " \n";
}
$laststem++;
printf "%3d |", $laststem;
}
print " $leaf";
}
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Convert this Perl snippet to C++ and keep its semantics consistent. | my @data = sort {$a <=> $b} qw( 12 127 28 42 39 113 42 18 44 118 44
37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113
122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32
61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27
106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27
18 28 48 125 107 114 34 133 45 120 30 127 31 116 );
my $columns = @data;
my $laststem = undef;
for my $value (@data) {
my $stem = int($value / 10);
my $leaf = $value % 10;
while (not defined $laststem or $stem > $laststem) {
if (not defined $laststem) {
$laststem = $stem - 1;
} else {
print " \n";
}
$laststem++;
printf "%3d |", $laststem;
}
print " $leaf";
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Maintain the same structure and functionality when rewriting this code in Java. | my @data = sort {$a <=> $b} qw( 12 127 28 42 39 113 42 18 44 118 44
37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113
122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32
61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27
106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27
18 28 48 125 107 114 34 133 45 120 30 127 31 116 );
my $columns = @data;
my $laststem = undef;
for my $value (@data) {
my $stem = int($value / 10);
my $leaf = $value % 10;
while (not defined $laststem or $stem > $laststem) {
if (not defined $laststem) {
$laststem = $stem - 1;
} else {
print " \n";
}
$laststem++;
printf "%3d |", $laststem;
}
print " $leaf";
}
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Port the provided Perl code into Python while preserving the original functionality. | my @data = sort {$a <=> $b} qw( 12 127 28 42 39 113 42 18 44 118 44
37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113
122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32
61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27
106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27
18 28 48 125 107 114 34 133 45 120 30 127 31 116 );
my $columns = @data;
my $laststem = undef;
for my $value (@data) {
my $stem = int($value / 10);
my $leaf = $value % 10;
while (not defined $laststem or $stem > $laststem) {
if (not defined $laststem) {
$laststem = $stem - 1;
} else {
print " \n";
}
$laststem++;
printf "%3d |", $laststem;
}
print " $leaf";
}
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Generate an equivalent Go version of this Perl code. | my @data = sort {$a <=> $b} qw( 12 127 28 42 39 113 42 18 44 118 44
37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113
122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32
61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27
106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27
18 28 48 125 107 114 34 133 45 120 30 127 31 116 );
my $columns = @data;
my $laststem = undef;
for my $value (@data) {
my $stem = int($value / 10);
my $leaf = $value % 10;
while (not defined $laststem or $stem > $laststem) {
if (not defined $laststem) {
$laststem = $stem - 1;
} else {
print " \n";
}
$laststem++;
printf "%3d |", $laststem;
}
print " $leaf";
}
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Translate this program into C but keep the logic exactly as in PowerShell. | $Set = -split '12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146'
$Data = $Set | Select @{ Label = 'Stem'; Expression = { [string][int]$_.Substring( 0, $_.Length - 1 ) } }, @{ Label = 'Leaf'; Expression = { [string]$_[-1] } }
$StemStats = $Data | Measure-Object -Property Stem -Minimum -Maximum
ForEach ( $Stem in $StemStats.Minimum..$StemStats.Maximum )
{
@( $Stem.ToString().PadLeft( 2, " " ), '|' ) + ( ( $Data | Where Stem -eq $Stem ).Leaf | Sort ) -join " "
}
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Convert this PowerShell snippet to C# and keep its semantics consistent. | $Set = -split '12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146'
$Data = $Set | Select @{ Label = 'Stem'; Expression = { [string][int]$_.Substring( 0, $_.Length - 1 ) } }, @{ Label = 'Leaf'; Expression = { [string]$_[-1] } }
$StemStats = $Data | Measure-Object -Property Stem -Minimum -Maximum
ForEach ( $Stem in $StemStats.Minimum..$StemStats.Maximum )
{
@( $Stem.ToString().PadLeft( 2, " " ), '|' ) + ( ( $Data | Where Stem -eq $Stem ).Leaf | Sort ) -join " "
}
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Port the provided PowerShell code into C++ while preserving the original functionality. | $Set = -split '12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146'
$Data = $Set | Select @{ Label = 'Stem'; Expression = { [string][int]$_.Substring( 0, $_.Length - 1 ) } }, @{ Label = 'Leaf'; Expression = { [string]$_[-1] } }
$StemStats = $Data | Measure-Object -Property Stem -Minimum -Maximum
ForEach ( $Stem in $StemStats.Minimum..$StemStats.Maximum )
{
@( $Stem.ToString().PadLeft( 2, " " ), '|' ) + ( ( $Data | Where Stem -eq $Stem ).Leaf | Sort ) -join " "
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Translate this program into Java but keep the logic exactly as in PowerShell. | $Set = -split '12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146'
$Data = $Set | Select @{ Label = 'Stem'; Expression = { [string][int]$_.Substring( 0, $_.Length - 1 ) } }, @{ Label = 'Leaf'; Expression = { [string]$_[-1] } }
$StemStats = $Data | Measure-Object -Property Stem -Minimum -Maximum
ForEach ( $Stem in $StemStats.Minimum..$StemStats.Maximum )
{
@( $Stem.ToString().PadLeft( 2, " " ), '|' ) + ( ( $Data | Where Stem -eq $Stem ).Leaf | Sort ) -join " "
}
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Rewrite the snippet below in Python so it works the same as the original PowerShell code. | $Set = -split '12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146'
$Data = $Set | Select @{ Label = 'Stem'; Expression = { [string][int]$_.Substring( 0, $_.Length - 1 ) } }, @{ Label = 'Leaf'; Expression = { [string]$_[-1] } }
$StemStats = $Data | Measure-Object -Property Stem -Minimum -Maximum
ForEach ( $Stem in $StemStats.Minimum..$StemStats.Maximum )
{
@( $Stem.ToString().PadLeft( 2, " " ), '|' ) + ( ( $Data | Where Stem -eq $Stem ).Leaf | Sort ) -join " "
}
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Preserve the algorithm and functionality while converting the code from PowerShell to Go. | $Set = -split '12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146'
$Data = $Set | Select @{ Label = 'Stem'; Expression = { [string][int]$_.Substring( 0, $_.Length - 1 ) } }, @{ Label = 'Leaf'; Expression = { [string]$_[-1] } }
$StemStats = $Data | Measure-Object -Property Stem -Minimum -Maximum
ForEach ( $Stem in $StemStats.Minimum..$StemStats.Maximum )
{
@( $Stem.ToString().PadLeft( 2, " " ), '|' ) + ( ( $Data | Where Stem -eq $Stem ).Leaf | Sort ) -join " "
}
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Produce a functionally identical C code for the snippet given in R. | x <- c(12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37, 48, 127, 36,
29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109,
23, 105, 63, 27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27, 106, 33, 117,
116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115, 43, 120, 43, 27, 27, 18, 28,
48, 125, 107, 114, 34, 133, 45, 120, 30, 127, 31, 116, 146)
stem(x)
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Ensure the translated C# code behaves exactly like the original R snippet. | x <- c(12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37, 48, 127, 36,
29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109,
23, 105, 63, 27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27, 106, 33, 117,
116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115, 43, 120, 43, 27, 27, 18, 28,
48, 125, 107, 114, 34, 133, 45, 120, 30, 127, 31, 116, 146)
stem(x)
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Maintain the same structure and functionality when rewriting this code in C++. | x <- c(12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37, 48, 127, 36,
29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109,
23, 105, 63, 27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27, 106, 33, 117,
116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115, 43, 120, 43, 27, 27, 18, 28,
48, 125, 107, 114, 34, 133, 45, 120, 30, 127, 31, 116, 146)
stem(x)
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Rewrite the snippet below in Java so it works the same as the original R code. | x <- c(12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37, 48, 127, 36,
29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109,
23, 105, 63, 27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27, 106, 33, 117,
116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115, 43, 120, 43, 27, 27, 18, 28,
48, 125, 107, 114, 34, 133, 45, 120, 30, 127, 31, 116, 146)
stem(x)
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Transform the following R implementation into Python, maintaining the same output and logic. | x <- c(12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37, 48, 127, 36,
29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109,
23, 105, 63, 27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27, 106, 33, 117,
116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115, 43, 120, 43, 27, 27, 18, 28,
48, 125, 107, 114, 34, 133, 45, 120, 30, 127, 31, 116, 146)
stem(x)
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Maintain the same structure and functionality when rewriting this code in Go. | x <- c(12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37, 48, 127, 36,
29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109,
23, 105, 63, 27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27, 106, 33, 117,
116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115, 43, 120, 43, 27, 27, 18, 28,
48, 125, 107, 114, 34, 133, 45, 120, 30, 127, 31, 116, 146)
stem(x)
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Write a version of this Racket function in C with identical behavior. | #lang racket
(define (show-stem+leaf data)
(define xs (sort data <))
(for ([stem (add1 (floor (/ (last xs) 10)))])
(printf "~a|" (~a #:width 2 #:align 'right stem))
(for ([i xs])
(define-values [q r] (quotient/remainder i 10))
(when (= q stem) (printf " ~a" r)))
(newline)))
(show-stem+leaf (sequence->list (in-producer read eof)))
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Can you help me rewrite this code in C# instead of Racket, keeping it the same logically? | #lang racket
(define (show-stem+leaf data)
(define xs (sort data <))
(for ([stem (add1 (floor (/ (last xs) 10)))])
(printf "~a|" (~a #:width 2 #:align 'right stem))
(for ([i xs])
(define-values [q r] (quotient/remainder i 10))
(when (= q stem) (printf " ~a" r)))
(newline)))
(show-stem+leaf (sequence->list (in-producer read eof)))
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Rewrite this program in C++ while keeping its functionality equivalent to the Racket version. | #lang racket
(define (show-stem+leaf data)
(define xs (sort data <))
(for ([stem (add1 (floor (/ (last xs) 10)))])
(printf "~a|" (~a #:width 2 #:align 'right stem))
(for ([i xs])
(define-values [q r] (quotient/remainder i 10))
(when (= q stem) (printf " ~a" r)))
(newline)))
(show-stem+leaf (sequence->list (in-producer read eof)))
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Port the provided Racket code into Java while preserving the original functionality. | #lang racket
(define (show-stem+leaf data)
(define xs (sort data <))
(for ([stem (add1 (floor (/ (last xs) 10)))])
(printf "~a|" (~a #:width 2 #:align 'right stem))
(for ([i xs])
(define-values [q r] (quotient/remainder i 10))
(when (= q stem) (printf " ~a" r)))
(newline)))
(show-stem+leaf (sequence->list (in-producer read eof)))
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Convert the following code from Racket to Python, ensuring the logic remains intact. | #lang racket
(define (show-stem+leaf data)
(define xs (sort data <))
(for ([stem (add1 (floor (/ (last xs) 10)))])
(printf "~a|" (~a #:width 2 #:align 'right stem))
(for ([i xs])
(define-values [q r] (quotient/remainder i 10))
(when (= q stem) (printf " ~a" r)))
(newline)))
(show-stem+leaf (sequence->list (in-producer read eof)))
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Generate an equivalent Go version of this Racket code. | #lang racket
(define (show-stem+leaf data)
(define xs (sort data <))
(for ([stem (add1 (floor (/ (last xs) 10)))])
(printf "~a|" (~a #:width 2 #:align 'right stem))
(for ([i xs])
(define-values [q r] (quotient/remainder i 10))
(when (= q stem) (printf " ~a" r)))
(newline)))
(show-stem+leaf (sequence->list (in-producer read eof)))
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Generate a C translation of this REXX snippet without changing its computational steps. |
parse arg @
if @='' then @=12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139,
131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121,
116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117,
116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105,
57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146
#.=; bot=.; top=.
do j=1 for words(@); y=word(@, j)
if \datatype(y,"N") then do; say '***error*** item' j "isn't numeric:" y; exit; end
if y<0 then do; say '***error*** item' j "is negative:" y; exit; end
n=format(y, , 0) / 1
stem=word(left(n, length(n) -1) 0, 1)
parse var n '' -1 leaf; _=stem * sign(n)
if bot==. then do; bot=_; top=_; end
bot=min(bot, _); top=max(top, _)
#.stem.leaf= #.stem.leaf leaf
end
w=max(length(min), length(max) ) + 1
do k=bot to top; $=
do m=0 for 10; $=$ #.k.m
end
say right(k, w) '║' space($)
end
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Port the following code from REXX to C# with equivalent syntax and logic. |
parse arg @
if @='' then @=12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139,
131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121,
116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117,
116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105,
57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146
#.=; bot=.; top=.
do j=1 for words(@); y=word(@, j)
if \datatype(y,"N") then do; say '***error*** item' j "isn't numeric:" y; exit; end
if y<0 then do; say '***error*** item' j "is negative:" y; exit; end
n=format(y, , 0) / 1
stem=word(left(n, length(n) -1) 0, 1)
parse var n '' -1 leaf; _=stem * sign(n)
if bot==. then do; bot=_; top=_; end
bot=min(bot, _); top=max(top, _)
#.stem.leaf= #.stem.leaf leaf
end
w=max(length(min), length(max) ) + 1
do k=bot to top; $=
do m=0 for 10; $=$ #.k.m
end
say right(k, w) '║' space($)
end
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Rewrite this program in C++ while keeping its functionality equivalent to the REXX version. |
parse arg @
if @='' then @=12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139,
131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121,
116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117,
116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105,
57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146
#.=; bot=.; top=.
do j=1 for words(@); y=word(@, j)
if \datatype(y,"N") then do; say '***error*** item' j "isn't numeric:" y; exit; end
if y<0 then do; say '***error*** item' j "is negative:" y; exit; end
n=format(y, , 0) / 1
stem=word(left(n, length(n) -1) 0, 1)
parse var n '' -1 leaf; _=stem * sign(n)
if bot==. then do; bot=_; top=_; end
bot=min(bot, _); top=max(top, _)
#.stem.leaf= #.stem.leaf leaf
end
w=max(length(min), length(max) ) + 1
do k=bot to top; $=
do m=0 for 10; $=$ #.k.m
end
say right(k, w) '║' space($)
end
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Please provide an equivalent version of this REXX code in Java. |
parse arg @
if @='' then @=12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139,
131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121,
116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117,
116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105,
57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146
#.=; bot=.; top=.
do j=1 for words(@); y=word(@, j)
if \datatype(y,"N") then do; say '***error*** item' j "isn't numeric:" y; exit; end
if y<0 then do; say '***error*** item' j "is negative:" y; exit; end
n=format(y, , 0) / 1
stem=word(left(n, length(n) -1) 0, 1)
parse var n '' -1 leaf; _=stem * sign(n)
if bot==. then do; bot=_; top=_; end
bot=min(bot, _); top=max(top, _)
#.stem.leaf= #.stem.leaf leaf
end
w=max(length(min), length(max) ) + 1
do k=bot to top; $=
do m=0 for 10; $=$ #.k.m
end
say right(k, w) '║' space($)
end
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Keep all operations the same but rewrite the snippet in Python. |
parse arg @
if @='' then @=12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139,
131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121,
116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117,
116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105,
57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146
#.=; bot=.; top=.
do j=1 for words(@); y=word(@, j)
if \datatype(y,"N") then do; say '***error*** item' j "isn't numeric:" y; exit; end
if y<0 then do; say '***error*** item' j "is negative:" y; exit; end
n=format(y, , 0) / 1
stem=word(left(n, length(n) -1) 0, 1)
parse var n '' -1 leaf; _=stem * sign(n)
if bot==. then do; bot=_; top=_; end
bot=min(bot, _); top=max(top, _)
#.stem.leaf= #.stem.leaf leaf
end
w=max(length(min), length(max) ) + 1
do k=bot to top; $=
do m=0 for 10; $=$ #.k.m
end
say right(k, w) '║' space($)
end
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Preserve the algorithm and functionality while converting the code from REXX to Go. |
parse arg @
if @='' then @=12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139,
131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128 121,
116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117,
116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 105,
57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 133 45 120 30 127 31 116 146
#.=; bot=.; top=.
do j=1 for words(@); y=word(@, j)
if \datatype(y,"N") then do; say '***error*** item' j "isn't numeric:" y; exit; end
if y<0 then do; say '***error*** item' j "is negative:" y; exit; end
n=format(y, , 0) / 1
stem=word(left(n, length(n) -1) 0, 1)
parse var n '' -1 leaf; _=stem * sign(n)
if bot==. then do; bot=_; top=_; end
bot=min(bot, _); top=max(top, _)
#.stem.leaf= #.stem.leaf leaf
end
w=max(length(min), length(max) ) + 1
do k=bot to top; $=
do m=0 for 10; $=$ #.k.m
end
say right(k, w) '║' space($)
end
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Rewrite this program in C while keeping its functionality equivalent to the Ruby version. | class StemLeafPlot
def initialize(data, options = {})
opts = {:leaf_digits => 1}.merge(options)
@leaf_digits = opts[:leaf_digits]
@multiplier = 10 ** @leaf_digits
@plot = generate_structure(data)
end
private
def generate_structure(data)
plot = Hash.new {|h,k| h[k] = []}
data.sort.each do |value|
stem, leaf = parse(value)
plot[stem] << leaf
end
plot
end
def parse(value)
stem, leaf = value.abs.divmod(@multiplier)
[Stem.get(stem, value), leaf.round]
end
public
def print
stem_width = Math.log10(@plot.keys.max_by {|s| s.value}.value).ceil + 1
Stem.get_range(@plot.keys).each do |stem|
leaves = @plot[stem].inject("") {|str,leaf| str << "%*d " % [@leaf_digits, leaf]}
puts "%*s | %s" % [stem_width, stem, leaves]
end
puts "key: 5|4=
puts "leaf unit: 1"
puts "stem unit:
end
end
class Stem
@@cache = {}
def self.get(stem_value, datum)
sign = datum < 0 ? :- : :+
cache(stem_value, sign)
end
private
def self.cache(value, sign)
if @@cache[[value, sign]].nil?
@@cache[[value, sign]] = self.new(value, sign)
end
@@cache[[value, sign]]
end
def initialize(value, sign)
@value = value
@sign = sign
end
public
attr_accessor :value, :sign
def negative?
@sign == :-
end
def <=>(other)
if self.negative?
if other.negative?
other.value <=> self.value
else
-1
end
else
if other.negative?
1
else
self.value <=> other.value
end
end
end
def to_s
"%s%d" % [(self.negative? ? '-' : ' '), @value]
end
def self.get_range(array_of_stems)
min, max = array_of_stems.minmax
if min.negative?
if max.negative?
min.value.downto(max.value).collect {|n| cache(n, :-)}
else
min.value.downto(0).collect {|n| cache(n, :-)} + 0.upto(max.value).collect {|n| cache(n, :+)}
end
else
min.value.upto(max.value).collect {|n| cache(n, :+)}
end
end
end
data = DATA.read.split.map {|s| Float(s)}
StemLeafPlot.new(data).print
__END__
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131
115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128
121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116
111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34
133 45 120 30 127 31 116 146
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Convert the following code from Ruby to C#, ensuring the logic remains intact. | class StemLeafPlot
def initialize(data, options = {})
opts = {:leaf_digits => 1}.merge(options)
@leaf_digits = opts[:leaf_digits]
@multiplier = 10 ** @leaf_digits
@plot = generate_structure(data)
end
private
def generate_structure(data)
plot = Hash.new {|h,k| h[k] = []}
data.sort.each do |value|
stem, leaf = parse(value)
plot[stem] << leaf
end
plot
end
def parse(value)
stem, leaf = value.abs.divmod(@multiplier)
[Stem.get(stem, value), leaf.round]
end
public
def print
stem_width = Math.log10(@plot.keys.max_by {|s| s.value}.value).ceil + 1
Stem.get_range(@plot.keys).each do |stem|
leaves = @plot[stem].inject("") {|str,leaf| str << "%*d " % [@leaf_digits, leaf]}
puts "%*s | %s" % [stem_width, stem, leaves]
end
puts "key: 5|4=
puts "leaf unit: 1"
puts "stem unit:
end
end
class Stem
@@cache = {}
def self.get(stem_value, datum)
sign = datum < 0 ? :- : :+
cache(stem_value, sign)
end
private
def self.cache(value, sign)
if @@cache[[value, sign]].nil?
@@cache[[value, sign]] = self.new(value, sign)
end
@@cache[[value, sign]]
end
def initialize(value, sign)
@value = value
@sign = sign
end
public
attr_accessor :value, :sign
def negative?
@sign == :-
end
def <=>(other)
if self.negative?
if other.negative?
other.value <=> self.value
else
-1
end
else
if other.negative?
1
else
self.value <=> other.value
end
end
end
def to_s
"%s%d" % [(self.negative? ? '-' : ' '), @value]
end
def self.get_range(array_of_stems)
min, max = array_of_stems.minmax
if min.negative?
if max.negative?
min.value.downto(max.value).collect {|n| cache(n, :-)}
else
min.value.downto(0).collect {|n| cache(n, :-)} + 0.upto(max.value).collect {|n| cache(n, :+)}
end
else
min.value.upto(max.value).collect {|n| cache(n, :+)}
end
end
end
data = DATA.read.split.map {|s| Float(s)}
StemLeafPlot.new(data).print
__END__
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131
115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128
121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116
111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34
133 45 120 30 127 31 116 146
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Produce a functionally identical C++ code for the snippet given in Ruby. | class StemLeafPlot
def initialize(data, options = {})
opts = {:leaf_digits => 1}.merge(options)
@leaf_digits = opts[:leaf_digits]
@multiplier = 10 ** @leaf_digits
@plot = generate_structure(data)
end
private
def generate_structure(data)
plot = Hash.new {|h,k| h[k] = []}
data.sort.each do |value|
stem, leaf = parse(value)
plot[stem] << leaf
end
plot
end
def parse(value)
stem, leaf = value.abs.divmod(@multiplier)
[Stem.get(stem, value), leaf.round]
end
public
def print
stem_width = Math.log10(@plot.keys.max_by {|s| s.value}.value).ceil + 1
Stem.get_range(@plot.keys).each do |stem|
leaves = @plot[stem].inject("") {|str,leaf| str << "%*d " % [@leaf_digits, leaf]}
puts "%*s | %s" % [stem_width, stem, leaves]
end
puts "key: 5|4=
puts "leaf unit: 1"
puts "stem unit:
end
end
class Stem
@@cache = {}
def self.get(stem_value, datum)
sign = datum < 0 ? :- : :+
cache(stem_value, sign)
end
private
def self.cache(value, sign)
if @@cache[[value, sign]].nil?
@@cache[[value, sign]] = self.new(value, sign)
end
@@cache[[value, sign]]
end
def initialize(value, sign)
@value = value
@sign = sign
end
public
attr_accessor :value, :sign
def negative?
@sign == :-
end
def <=>(other)
if self.negative?
if other.negative?
other.value <=> self.value
else
-1
end
else
if other.negative?
1
else
self.value <=> other.value
end
end
end
def to_s
"%s%d" % [(self.negative? ? '-' : ' '), @value]
end
def self.get_range(array_of_stems)
min, max = array_of_stems.minmax
if min.negative?
if max.negative?
min.value.downto(max.value).collect {|n| cache(n, :-)}
else
min.value.downto(0).collect {|n| cache(n, :-)} + 0.upto(max.value).collect {|n| cache(n, :+)}
end
else
min.value.upto(max.value).collect {|n| cache(n, :+)}
end
end
end
data = DATA.read.split.map {|s| Float(s)}
StemLeafPlot.new(data).print
__END__
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131
115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128
121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116
111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34
133 45 120 30 127 31 116 146
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Convert the following code from Ruby to Java, ensuring the logic remains intact. | class StemLeafPlot
def initialize(data, options = {})
opts = {:leaf_digits => 1}.merge(options)
@leaf_digits = opts[:leaf_digits]
@multiplier = 10 ** @leaf_digits
@plot = generate_structure(data)
end
private
def generate_structure(data)
plot = Hash.new {|h,k| h[k] = []}
data.sort.each do |value|
stem, leaf = parse(value)
plot[stem] << leaf
end
plot
end
def parse(value)
stem, leaf = value.abs.divmod(@multiplier)
[Stem.get(stem, value), leaf.round]
end
public
def print
stem_width = Math.log10(@plot.keys.max_by {|s| s.value}.value).ceil + 1
Stem.get_range(@plot.keys).each do |stem|
leaves = @plot[stem].inject("") {|str,leaf| str << "%*d " % [@leaf_digits, leaf]}
puts "%*s | %s" % [stem_width, stem, leaves]
end
puts "key: 5|4=
puts "leaf unit: 1"
puts "stem unit:
end
end
class Stem
@@cache = {}
def self.get(stem_value, datum)
sign = datum < 0 ? :- : :+
cache(stem_value, sign)
end
private
def self.cache(value, sign)
if @@cache[[value, sign]].nil?
@@cache[[value, sign]] = self.new(value, sign)
end
@@cache[[value, sign]]
end
def initialize(value, sign)
@value = value
@sign = sign
end
public
attr_accessor :value, :sign
def negative?
@sign == :-
end
def <=>(other)
if self.negative?
if other.negative?
other.value <=> self.value
else
-1
end
else
if other.negative?
1
else
self.value <=> other.value
end
end
end
def to_s
"%s%d" % [(self.negative? ? '-' : ' '), @value]
end
def self.get_range(array_of_stems)
min, max = array_of_stems.minmax
if min.negative?
if max.negative?
min.value.downto(max.value).collect {|n| cache(n, :-)}
else
min.value.downto(0).collect {|n| cache(n, :-)} + 0.upto(max.value).collect {|n| cache(n, :+)}
end
else
min.value.upto(max.value).collect {|n| cache(n, :+)}
end
end
end
data = DATA.read.split.map {|s| Float(s)}
StemLeafPlot.new(data).print
__END__
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131
115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128
121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116
111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34
133 45 120 30 127 31 116 146
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Generate an equivalent Python version of this Ruby code. | class StemLeafPlot
def initialize(data, options = {})
opts = {:leaf_digits => 1}.merge(options)
@leaf_digits = opts[:leaf_digits]
@multiplier = 10 ** @leaf_digits
@plot = generate_structure(data)
end
private
def generate_structure(data)
plot = Hash.new {|h,k| h[k] = []}
data.sort.each do |value|
stem, leaf = parse(value)
plot[stem] << leaf
end
plot
end
def parse(value)
stem, leaf = value.abs.divmod(@multiplier)
[Stem.get(stem, value), leaf.round]
end
public
def print
stem_width = Math.log10(@plot.keys.max_by {|s| s.value}.value).ceil + 1
Stem.get_range(@plot.keys).each do |stem|
leaves = @plot[stem].inject("") {|str,leaf| str << "%*d " % [@leaf_digits, leaf]}
puts "%*s | %s" % [stem_width, stem, leaves]
end
puts "key: 5|4=
puts "leaf unit: 1"
puts "stem unit:
end
end
class Stem
@@cache = {}
def self.get(stem_value, datum)
sign = datum < 0 ? :- : :+
cache(stem_value, sign)
end
private
def self.cache(value, sign)
if @@cache[[value, sign]].nil?
@@cache[[value, sign]] = self.new(value, sign)
end
@@cache[[value, sign]]
end
def initialize(value, sign)
@value = value
@sign = sign
end
public
attr_accessor :value, :sign
def negative?
@sign == :-
end
def <=>(other)
if self.negative?
if other.negative?
other.value <=> self.value
else
-1
end
else
if other.negative?
1
else
self.value <=> other.value
end
end
end
def to_s
"%s%d" % [(self.negative? ? '-' : ' '), @value]
end
def self.get_range(array_of_stems)
min, max = array_of_stems.minmax
if min.negative?
if max.negative?
min.value.downto(max.value).collect {|n| cache(n, :-)}
else
min.value.downto(0).collect {|n| cache(n, :-)} + 0.upto(max.value).collect {|n| cache(n, :+)}
end
else
min.value.upto(max.value).collect {|n| cache(n, :+)}
end
end
end
data = DATA.read.split.map {|s| Float(s)}
StemLeafPlot.new(data).print
__END__
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131
115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128
121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116
111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34
133 45 120 30 127 31 116 146
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Convert this Ruby snippet to Go and keep its semantics consistent. | class StemLeafPlot
def initialize(data, options = {})
opts = {:leaf_digits => 1}.merge(options)
@leaf_digits = opts[:leaf_digits]
@multiplier = 10 ** @leaf_digits
@plot = generate_structure(data)
end
private
def generate_structure(data)
plot = Hash.new {|h,k| h[k] = []}
data.sort.each do |value|
stem, leaf = parse(value)
plot[stem] << leaf
end
plot
end
def parse(value)
stem, leaf = value.abs.divmod(@multiplier)
[Stem.get(stem, value), leaf.round]
end
public
def print
stem_width = Math.log10(@plot.keys.max_by {|s| s.value}.value).ceil + 1
Stem.get_range(@plot.keys).each do |stem|
leaves = @plot[stem].inject("") {|str,leaf| str << "%*d " % [@leaf_digits, leaf]}
puts "%*s | %s" % [stem_width, stem, leaves]
end
puts "key: 5|4=
puts "leaf unit: 1"
puts "stem unit:
end
end
class Stem
@@cache = {}
def self.get(stem_value, datum)
sign = datum < 0 ? :- : :+
cache(stem_value, sign)
end
private
def self.cache(value, sign)
if @@cache[[value, sign]].nil?
@@cache[[value, sign]] = self.new(value, sign)
end
@@cache[[value, sign]]
end
def initialize(value, sign)
@value = value
@sign = sign
end
public
attr_accessor :value, :sign
def negative?
@sign == :-
end
def <=>(other)
if self.negative?
if other.negative?
other.value <=> self.value
else
-1
end
else
if other.negative?
1
else
self.value <=> other.value
end
end
end
def to_s
"%s%d" % [(self.negative? ? '-' : ' '), @value]
end
def self.get_range(array_of_stems)
min, max = array_of_stems.minmax
if min.negative?
if max.negative?
min.value.downto(max.value).collect {|n| cache(n, :-)}
else
min.value.downto(0).collect {|n| cache(n, :-)} + 0.upto(max.value).collect {|n| cache(n, :+)}
end
else
min.value.upto(max.value).collect {|n| cache(n, :+)}
end
end
end
data = DATA.read.split.map {|s| Float(s)}
StemLeafPlot.new(data).print
__END__
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 125 139 131
115 105 132 104 123 35 113 122 42 117 119 58 109 23 105 63 27 44 105 99 41 128
121 116 125 32 61 37 127 29 113 121 58 114 126 53 114 96 25 109 7 31 141 46 13
27 43 117 116 27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117 116
111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34
133 45 120 30 127 31 116 146
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Translate this program into C but keep the logic exactly as in Scala. |
fun leafPlot(x: IntArray) {
x.sort()
var i = x[0] / 10 - 1
for (j in 0 until x.size) {
val d = x[j] / 10
while (d > i) print("%s%3d |".format(if (j != 0) "\n" else "", ++i))
print(" ${x[j] % 10}")
}
println()
}
fun main(args: Array<String>) {
val data = intArrayOf(
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146
)
leafPlot(data)
}
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Translate the given Scala code snippet into C# without altering its behavior. |
fun leafPlot(x: IntArray) {
x.sort()
var i = x[0] / 10 - 1
for (j in 0 until x.size) {
val d = x[j] / 10
while (d > i) print("%s%3d |".format(if (j != 0) "\n" else "", ++i))
print(" ${x[j] % 10}")
}
println()
}
fun main(args: Array<String>) {
val data = intArrayOf(
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146
)
leafPlot(data)
}
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Keep all operations the same but rewrite the snippet in C++. |
fun leafPlot(x: IntArray) {
x.sort()
var i = x[0] / 10 - 1
for (j in 0 until x.size) {
val d = x[j] / 10
while (d > i) print("%s%3d |".format(if (j != 0) "\n" else "", ++i))
print(" ${x[j] % 10}")
}
println()
}
fun main(args: Array<String>) {
val data = intArrayOf(
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146
)
leafPlot(data)
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Ensure the translated Java code behaves exactly like the original Scala snippet. |
fun leafPlot(x: IntArray) {
x.sort()
var i = x[0] / 10 - 1
for (j in 0 until x.size) {
val d = x[j] / 10
while (d > i) print("%s%3d |".format(if (j != 0) "\n" else "", ++i))
print(" ${x[j] % 10}")
}
println()
}
fun main(args: Array<String>) {
val data = intArrayOf(
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146
)
leafPlot(data)
}
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Produce a functionally identical Python code for the snippet given in Scala. |
fun leafPlot(x: IntArray) {
x.sort()
var i = x[0] / 10 - 1
for (j in 0 until x.size) {
val d = x[j] / 10
while (d > i) print("%s%3d |".format(if (j != 0) "\n" else "", ++i))
print(" ${x[j] % 10}")
}
println()
}
fun main(args: Array<String>) {
val data = intArrayOf(
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146
)
leafPlot(data)
}
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Produce a functionally identical Go code for the snippet given in Scala. |
fun leafPlot(x: IntArray) {
x.sort()
var i = x[0] / 10 - 1
for (j in 0 until x.size) {
val d = x[j] / 10
while (d > i) print("%s%3d |".format(if (j != 0) "\n" else "", ++i))
print(" ${x[j] % 10}")
}
println()
}
fun main(args: Array<String>) {
val data = intArrayOf(
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146
)
leafPlot(data)
}
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Please provide an equivalent version of this Tcl code in C. | package require Tcl 8.5
proc addSLValue {tblName value {splitFactor 10}} {
upvar 1 $tblName tbl
if {$value < 0} {
set value [expr {round(-$value)}]
set stem -[expr {$value / $splitFactor}]
} else {
set value [expr {round($value)}]
set stem [expr {$value / $splitFactor}]
}
if {![info exist tbl]} {
dict set tbl min $stem
}
dict set tbl max $stem
set leaf [expr {$value % $splitFactor}]
dict lappend tbl $stem $leaf
}
proc printSLTable {tblName} {
upvar 1 $tblName tbl
set min [dict get $tbl min]
set max [dict get $tbl max]
set l [expr {max([string length $min], [string length $max])}]
for {set i $min} {$i <= $max} {incr i} {
if {![dict exist $tbl $i]} {
puts [format " %*d |" $l $i]
} else {
puts [format " %*d | %s" $l $i [dict get $tbl $i]]
}
}
}
proc printStemLeaf {dataList {splitFactor 10}} {
foreach value [lsort -real $dataList] {
addSLValue tbl $value $splitFactor
}
printSLTable tbl
}
set data {
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36
29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109
23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113
121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116
27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117
116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28
48 125 107 114 34 133 45 120 30 127 31 116 146
}
printStemLeaf $data
| #include <stdio.h>
#include <stdlib.h>
int icmp(const void *a, const void *b)
{
return *(const int*)a < *(const int*)b ? -1 : *(const int*)a > *(const int*)b;
}
void leaf_plot(int *x, int len)
{
int i, j, d;
qsort(x, len, sizeof(int), icmp);
i = x[0] / 10 - 1;
for (j = 0; j < len; j++) {
d = x[j] / 10;
while (d > i) printf("%s%3d |", j ? "\n" : "", ++i);
printf(" %d", x[j] % 10);
}
}
int main()
{
int data[] = {
12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124,
37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123,
35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105,
99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58,
114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43,
117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114,
34, 133, 45, 120, 30, 127, 31, 116, 146 };
leaf_plot(data, sizeof(data)/sizeof(data[0]));
return 0;
}
|
Ensure the translated C# code behaves exactly like the original Tcl snippet. | package require Tcl 8.5
proc addSLValue {tblName value {splitFactor 10}} {
upvar 1 $tblName tbl
if {$value < 0} {
set value [expr {round(-$value)}]
set stem -[expr {$value / $splitFactor}]
} else {
set value [expr {round($value)}]
set stem [expr {$value / $splitFactor}]
}
if {![info exist tbl]} {
dict set tbl min $stem
}
dict set tbl max $stem
set leaf [expr {$value % $splitFactor}]
dict lappend tbl $stem $leaf
}
proc printSLTable {tblName} {
upvar 1 $tblName tbl
set min [dict get $tbl min]
set max [dict get $tbl max]
set l [expr {max([string length $min], [string length $max])}]
for {set i $min} {$i <= $max} {incr i} {
if {![dict exist $tbl $i]} {
puts [format " %*d |" $l $i]
} else {
puts [format " %*d | %s" $l $i [dict get $tbl $i]]
}
}
}
proc printStemLeaf {dataList {splitFactor 10}} {
foreach value [lsort -real $dataList] {
addSLValue tbl $value $splitFactor
}
printSLTable tbl
}
set data {
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36
29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109
23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113
121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116
27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117
116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28
48 125 107 114 34 133 45 120 30 127 31 116 146
}
printStemLeaf $data
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
class Program
{
static void Main()
{
const string data =
"12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36 29 31 " +
"125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109 23 " +
"105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113 121 58 " +
"114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116 27 7 68 40 31 " +
"115 124 42 128 52 71 118 117 38 27 106 33 117 116 111 40 119 47 " +
"105 57 122 109 124 115 43 120 43 27 27 18 28 48 125 107 114 34 " +
"133 45 120 30 127 31 116 146";
int[] ints = data.Split(' ').Select(int.Parse).ToArray();
StemAndLeafPlot(ints);
Console.ReadKey();
}
public static void StemAndLeafPlot(int[] arr)
{
int stemMax = arr.Max() / 10;
int stemMin = arr.Min() / 10;
Array.Sort(arr);
for (int i = stemMin; i <= stemMax; i++)
{
Console.Write("{0,3} | ", i);
foreach (var t in arr)
{
if (t < 10 * i)
continue;
if (t >= 10 * (i + 1))
break;
Console.Write("{0} ", t % 10);
}
Console.WriteLine("");
}
}
}
|
Convert this Tcl snippet to C++ and keep its semantics consistent. | package require Tcl 8.5
proc addSLValue {tblName value {splitFactor 10}} {
upvar 1 $tblName tbl
if {$value < 0} {
set value [expr {round(-$value)}]
set stem -[expr {$value / $splitFactor}]
} else {
set value [expr {round($value)}]
set stem [expr {$value / $splitFactor}]
}
if {![info exist tbl]} {
dict set tbl min $stem
}
dict set tbl max $stem
set leaf [expr {$value % $splitFactor}]
dict lappend tbl $stem $leaf
}
proc printSLTable {tblName} {
upvar 1 $tblName tbl
set min [dict get $tbl min]
set max [dict get $tbl max]
set l [expr {max([string length $min], [string length $max])}]
for {set i $min} {$i <= $max} {incr i} {
if {![dict exist $tbl $i]} {
puts [format " %*d |" $l $i]
} else {
puts [format " %*d | %s" $l $i [dict get $tbl $i]]
}
}
}
proc printStemLeaf {dataList {splitFactor 10}} {
foreach value [lsort -real $dataList] {
addSLValue tbl $value $splitFactor
}
printSLTable tbl
}
set data {
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36
29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109
23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113
121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116
27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117
116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28
48 125 107 114 34 133 45 120 30 127 31 116 146
}
printStemLeaf $data
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
const int dataset[] = {
12,127, 28, 42, 39,113, 42, 18, 44,118, 44, 37,113,124, 37, 48,127, 36,
29, 31,125,139,131,115,105,132,104,123, 35,113,122, 42,117,119, 58,109,
23,105, 63, 27, 44,105, 99, 41,128,121,116,125, 32, 61, 37,127, 29,113,
121, 58,114,126, 53,114, 96, 25,109, 7, 31,141, 46, 13, 27, 43,117,116,
27, 7, 68, 40, 31,115,124, 42,128, 52, 71,118,117, 38, 27,106, 33,117,
116,111, 40,119, 47,105, 57,122,109,124,115, 43,120, 43, 27, 27, 18, 28,
48,125,107,114, 34,133, 45,120, 30,127, 31,116,146
};
const int datasize = sizeof(dataset) / sizeof(dataset[0]);
int main()
{
typedef std::pair<int,int> StemLeaf;
std::vector<StemLeaf> stemplot;
for (int i = 0; i < datasize; ++i)
{
stemplot.push_back(StemLeaf(dataset[i] / 10, dataset[i] % 10));
}
std::sort(stemplot.begin(), stemplot.end());
int lo = stemplot.front().first;
int hi = stemplot.back().first;
for (std::vector<StemLeaf>::iterator itr = stemplot.begin(); lo <= hi; ++lo)
{
std::cout << std::setw(2) << lo << " |";
for ( ; itr != stemplot.end() && itr->first == lo; ++itr)
{
std::cout << " " << itr->second;
}
std::cout << std::endl;
}
}
|
Convert this Tcl snippet to Java and keep its semantics consistent. | package require Tcl 8.5
proc addSLValue {tblName value {splitFactor 10}} {
upvar 1 $tblName tbl
if {$value < 0} {
set value [expr {round(-$value)}]
set stem -[expr {$value / $splitFactor}]
} else {
set value [expr {round($value)}]
set stem [expr {$value / $splitFactor}]
}
if {![info exist tbl]} {
dict set tbl min $stem
}
dict set tbl max $stem
set leaf [expr {$value % $splitFactor}]
dict lappend tbl $stem $leaf
}
proc printSLTable {tblName} {
upvar 1 $tblName tbl
set min [dict get $tbl min]
set max [dict get $tbl max]
set l [expr {max([string length $min], [string length $max])}]
for {set i $min} {$i <= $max} {incr i} {
if {![dict exist $tbl $i]} {
puts [format " %*d |" $l $i]
} else {
puts [format " %*d | %s" $l $i [dict get $tbl $i]]
}
}
}
proc printStemLeaf {dataList {splitFactor 10}} {
foreach value [lsort -real $dataList] {
addSLValue tbl $value $splitFactor
}
printSLTable tbl
}
set data {
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36
29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109
23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113
121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116
27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117
116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28
48 125 107 114 34 133 45 120 30 127 31 116 146
}
printStemLeaf $data
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class StemAndLeaf {
private static int[] data = { 12, 127, 28, 42, 39, 113, 42, 18, 44, 118,
44, 37, 113, 124, 37, 48, 127, 36, 29, 31, 125, 139, 131, 115, 105,
132, 104, 123, 35, 113, 122, 42, 117, 119, 58, 109, 23, 105, 63,
27, 44, 105, 99, 41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113,
121, 58, 114, 126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27,
43, 117, 116, 27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118,
117, 38, 27, 106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122,
109, 124, 115, 43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34,
133, 45, 120, 30, 127, 31, 116, 146 };
public static Map<Integer, List<Integer>> createPlot(int... data){
Map<Integer, List<Integer>> plot = new TreeMap<Integer, List<Integer>>();
int highestStem = -1;
for(int datum:data){
int leaf = datum % 10;
int stem = datum / 10;
if(stem > highestStem){
highestStem = stem;
}
if(plot.containsKey(stem)){
plot.get(stem).add(leaf);
}else{
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(leaf);
plot.put(stem, list);
}
}
if(plot.keySet().size() < highestStem + 1 ){
for(int i = 0; i <= highestStem; i++){
if(!plot.containsKey(i)){
LinkedList<Integer> list = new LinkedList<Integer>();
plot.put(i, list);
}
}
}
return plot;
}
public static void printPlot(Map<Integer, List<Integer>> plot){
for(Map.Entry<Integer, List<Integer>> line : plot.entrySet()){
Collections.sort(line.getValue());
System.out.println(line.getKey() + " | " + line.getValue());
}
}
public static void main(String[] args){
Map<Integer, List<Integer>> plot = createPlot(data);
printPlot(plot);
}
}
|
Produce a functionally identical Python code for the snippet given in Tcl. | package require Tcl 8.5
proc addSLValue {tblName value {splitFactor 10}} {
upvar 1 $tblName tbl
if {$value < 0} {
set value [expr {round(-$value)}]
set stem -[expr {$value / $splitFactor}]
} else {
set value [expr {round($value)}]
set stem [expr {$value / $splitFactor}]
}
if {![info exist tbl]} {
dict set tbl min $stem
}
dict set tbl max $stem
set leaf [expr {$value % $splitFactor}]
dict lappend tbl $stem $leaf
}
proc printSLTable {tblName} {
upvar 1 $tblName tbl
set min [dict get $tbl min]
set max [dict get $tbl max]
set l [expr {max([string length $min], [string length $max])}]
for {set i $min} {$i <= $max} {incr i} {
if {![dict exist $tbl $i]} {
puts [format " %*d |" $l $i]
} else {
puts [format " %*d | %s" $l $i [dict get $tbl $i]]
}
}
}
proc printStemLeaf {dataList {splitFactor 10}} {
foreach value [lsort -real $dataList] {
addSLValue tbl $value $splitFactor
}
printSLTable tbl
}
set data {
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36
29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109
23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113
121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116
27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117
116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28
48 125 107 114 34 133 45 120 30 127 31 116 146
}
printStemLeaf $data
| from collections import namedtuple
from pprint import pprint as pp
from math import floor
Stem = namedtuple('Stem', 'data, leafdigits')
data0 = Stem((12, 127, 28, 42, 39, 113, 42, 18, 44, 118, 44, 37, 113, 124, 37,
48, 127, 36, 29, 31, 125, 139, 131, 115, 105, 132, 104, 123, 35,
113, 122, 42, 117, 119, 58, 109, 23, 105, 63, 27, 44, 105, 99,
41, 128, 121, 116, 125, 32, 61, 37, 127, 29, 113, 121, 58, 114,
126, 53, 114, 96, 25, 109, 7, 31, 141, 46, 13, 27, 43, 117, 116,
27, 7, 68, 40, 31, 115, 124, 42, 128, 52, 71, 118, 117, 38, 27,
106, 33, 117, 116, 111, 40, 119, 47, 105, 57, 122, 109, 124, 115,
43, 120, 43, 27, 27, 18, 28, 48, 125, 107, 114, 34, 133, 45, 120,
30, 127, 31, 116, 146),
1.0)
def stemplot(stem):
d = []
interval = int(10**int(stem.leafdigits))
for data in sorted(stem.data):
data = int(floor(data))
stm, lf = divmod(data,interval)
d.append( (int(stm), int(lf)) )
stems, leafs = list(zip(*d))
stemwidth = max(len(str(x)) for x in stems)
leafwidth = max(len(str(x)) for x in leafs)
laststem, out = min(stems) - 1, []
for s,l in d:
while laststem < s:
laststem += 1
out.append('\n%*i |' % ( stemwidth, laststem))
out.append(' %0*i' % (leafwidth, l))
out.append('\n\nKey:\n Stem multiplier: %i\n X | Y => %i*X+Y\n'
% (interval, interval))
return ''.join(out)
if __name__ == '__main__':
print( stemplot(data0) )
|
Generate an equivalent Go version of this Tcl code. | package require Tcl 8.5
proc addSLValue {tblName value {splitFactor 10}} {
upvar 1 $tblName tbl
if {$value < 0} {
set value [expr {round(-$value)}]
set stem -[expr {$value / $splitFactor}]
} else {
set value [expr {round($value)}]
set stem [expr {$value / $splitFactor}]
}
if {![info exist tbl]} {
dict set tbl min $stem
}
dict set tbl max $stem
set leaf [expr {$value % $splitFactor}]
dict lappend tbl $stem $leaf
}
proc printSLTable {tblName} {
upvar 1 $tblName tbl
set min [dict get $tbl min]
set max [dict get $tbl max]
set l [expr {max([string length $min], [string length $max])}]
for {set i $min} {$i <= $max} {incr i} {
if {![dict exist $tbl $i]} {
puts [format " %*d |" $l $i]
} else {
puts [format " %*d | %s" $l $i [dict get $tbl $i]]
}
}
}
proc printStemLeaf {dataList {splitFactor 10}} {
foreach value [lsort -real $dataList] {
addSLValue tbl $value $splitFactor
}
printSLTable tbl
}
set data {
12 127 28 42 39 113 42 18 44 118 44 37 113 124 37 48 127 36
29 31 125 139 131 115 105 132 104 123 35 113 122 42 117 119 58 109
23 105 63 27 44 105 99 41 128 121 116 125 32 61 37 127 29 113
121 58 114 126 53 114 96 25 109 7 31 141 46 13 27 43 117 116
27 7 68 40 31 115 124 42 128 52 71 118 117 38 27 106 33 117
116 111 40 119 47 105 57 122 109 124 115 43 120 43 27 27 18 28
48 125 107 114 34 133 45 120 30 127 31 116 146
}
printStemLeaf $data
| package main
import (
"fmt"
"sort"
"strconv"
"strings"
)
var data = `12 127 28 42`
func main() {
m := make(map[int][]string)
for _, s := range strings.Fields(data) {
if len(s) == 1 {
m[0] = append(m[0], s)
} else if i, err := strconv.Atoi(s[:len(s)-1]); err == nil {
m[i] = append(m[i], s[len(s)-1:])
} else {
panic("non numeric data")
}
}
s := make([]int, len(m))
var i int
for k := range m {
s[i] = k
i++
}
sort.Ints(s)
for k := s[0]; ; k++ {
v := m[k]
sort.Strings(v)
fmt.Printf("%2d | %s\n", k, strings.Join(v, " "))
if k == s[len(s)-1] {
break
}
}
}
|
Translate the given Ada code snippet into C# without altering its behavior. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| using System;
using System.Collections;
using System.Linq;
namespace RosettaCodeTasks
{
static class FlattenList
{
public static ArrayList Flatten(this ArrayList List)
{
ArrayList NewList = new ArrayList ( );
NewList.AddRange ( List );
while ( NewList.OfType<ArrayList> ( ).Count ( ) > 0 )
{
int index = NewList.IndexOf ( NewList.OfType<ArrayList> ( ).ElementAt ( 0 ) );
ArrayList Temp = (ArrayList)NewList[index];
NewList.RemoveAt ( index );
NewList.InsertRange ( index, Temp );
}
return NewList;
}
}
}
|
Convert the following code from Ada to C#, ensuring the logic remains intact. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| using System;
using System.Collections;
using System.Linq;
namespace RosettaCodeTasks
{
static class FlattenList
{
public static ArrayList Flatten(this ArrayList List)
{
ArrayList NewList = new ArrayList ( );
NewList.AddRange ( List );
while ( NewList.OfType<ArrayList> ( ).Count ( ) > 0 )
{
int index = NewList.IndexOf ( NewList.OfType<ArrayList> ( ).ElementAt ( 0 ) );
ArrayList Temp = (ArrayList)NewList[index];
NewList.RemoveAt ( index );
NewList.InsertRange ( index, Temp );
}
return NewList;
}
}
}
|
Write the same code in C as shown below in Ada. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct list_t list_t, *list;
struct list_t{
int is_list, ival;
list *lst;
};
list new_list()
{
list x = malloc(sizeof(list_t));
x->ival = 0;
x->is_list = 1;
x->lst = 0;
return x;
}
void append(list parent, list child)
{
parent->lst = realloc(parent->lst, sizeof(list) * (parent->ival + 1));
parent->lst[parent->ival++] = child;
}
list from_string(char *s, char **e, list parent)
{
list ret = 0;
if (!parent) parent = new_list();
while (*s != '\0') {
if (*s == ']') {
if (e) *e = s + 1;
return parent;
}
if (*s == '[') {
ret = new_list();
ret->is_list = 1;
ret->ival = 0;
append(parent, ret);
from_string(s + 1, &s, ret);
continue;
}
if (*s >= '0' && *s <= '9') {
ret = new_list();
ret->is_list = 0;
ret->ival = strtol(s, &s, 10);
append(parent, ret);
continue;
}
s++;
}
if (e) *e = s;
return parent;
}
void show_list(list l)
{
int i;
if (!l) return;
if (!l->is_list) {
printf("%d", l->ival);
return;
}
printf("[");
for (i = 0; i < l->ival; i++) {
show_list(l->lst[i]);
if (i < l->ival - 1) printf(", ");
}
printf("]");
}
list flatten(list from, list to)
{
int i;
list t;
if (!to) to = new_list();
if (!from->is_list) {
t = new_list();
*t = *from;
append(to, t);
} else
for (i = 0; i < from->ival; i++)
flatten(from->lst[i], to);
return to;
}
void delete_list(list l)
{
int i;
if (!l) return;
if (l->is_list && l->ival) {
for (i = 0; i < l->ival; i++)
delete_list(l->lst[i]);
free(l->lst);
}
free(l);
}
int main()
{
list l = from_string("[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []", 0, 0);
printf("Nested: ");
show_list(l);
printf("\n");
list flat = flatten(l, 0);
printf("Flattened: ");
show_list(flat);
return 0;
}
|
Produce a functionally identical C code for the snippet given in Ada. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct list_t list_t, *list;
struct list_t{
int is_list, ival;
list *lst;
};
list new_list()
{
list x = malloc(sizeof(list_t));
x->ival = 0;
x->is_list = 1;
x->lst = 0;
return x;
}
void append(list parent, list child)
{
parent->lst = realloc(parent->lst, sizeof(list) * (parent->ival + 1));
parent->lst[parent->ival++] = child;
}
list from_string(char *s, char **e, list parent)
{
list ret = 0;
if (!parent) parent = new_list();
while (*s != '\0') {
if (*s == ']') {
if (e) *e = s + 1;
return parent;
}
if (*s == '[') {
ret = new_list();
ret->is_list = 1;
ret->ival = 0;
append(parent, ret);
from_string(s + 1, &s, ret);
continue;
}
if (*s >= '0' && *s <= '9') {
ret = new_list();
ret->is_list = 0;
ret->ival = strtol(s, &s, 10);
append(parent, ret);
continue;
}
s++;
}
if (e) *e = s;
return parent;
}
void show_list(list l)
{
int i;
if (!l) return;
if (!l->is_list) {
printf("%d", l->ival);
return;
}
printf("[");
for (i = 0; i < l->ival; i++) {
show_list(l->lst[i]);
if (i < l->ival - 1) printf(", ");
}
printf("]");
}
list flatten(list from, list to)
{
int i;
list t;
if (!to) to = new_list();
if (!from->is_list) {
t = new_list();
*t = *from;
append(to, t);
} else
for (i = 0; i < from->ival; i++)
flatten(from->lst[i], to);
return to;
}
void delete_list(list l)
{
int i;
if (!l) return;
if (l->is_list && l->ival) {
for (i = 0; i < l->ival; i++)
delete_list(l->lst[i]);
free(l->lst);
}
free(l);
}
int main()
{
list l = from_string("[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []", 0, 0);
printf("Nested: ");
show_list(l);
printf("\n");
list flat = flatten(l, 0);
printf("Flattened: ");
show_list(flat);
return 0;
}
|
Translate this program into C++ but keep the logic exactly as in Ada. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| #include <list>
#include <boost/any.hpp>
typedef std::list<boost::any> anylist;
void flatten(std::list<boost::any>& list)
{
typedef anylist::iterator iterator;
iterator current = list.begin();
while (current != list.end())
{
if (current->type() == typeid(anylist))
{
iterator next = current;
++next;
list.splice(next, boost::any_cast<anylist&>(*current));
current = list.erase(current);
}
else
++current;
}
}
|
Rewrite this program in C++ while keeping its functionality equivalent to the Ada version. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| #include <list>
#include <boost/any.hpp>
typedef std::list<boost::any> anylist;
void flatten(std::list<boost::any>& list)
{
typedef anylist::iterator iterator;
iterator current = list.begin();
while (current != list.end())
{
if (current->type() == typeid(anylist))
{
iterator next = current;
++next;
list.splice(next, boost::any_cast<anylist&>(*current));
current = list.erase(current);
}
else
++current;
}
}
|
Change the programming language of this snippet from Ada to Go without modifying what it does. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| package main
import "fmt"
func list(s ...interface{}) []interface{} {
return s
}
func main() {
s := list(list(1),
2,
list(list(3, 4), 5),
list(list(list())),
list(list(list(6))),
7,
8,
list(),
)
fmt.Println(s)
fmt.Println(flatten(s))
}
func flatten(s []interface{}) (r []int) {
for _, e := range s {
switch i := e.(type) {
case int:
r = append(r, i)
case []interface{}:
r = append(r, flatten(i)...)
}
}
return
}
|
Maintain the same structure and functionality when rewriting this code in Go. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| package main
import "fmt"
func list(s ...interface{}) []interface{} {
return s
}
func main() {
s := list(list(1),
2,
list(list(3, 4), 5),
list(list(list())),
list(list(list(6))),
7,
8,
list(),
)
fmt.Println(s)
fmt.Println(flatten(s))
}
func flatten(s []interface{}) (r []int) {
for _, e := range s {
switch i := e.(type) {
case int:
r = append(r, i)
case []interface{}:
r = append(r, flatten(i)...)
}
}
return
}
|
Keep all operations the same but rewrite the snippet in Java. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| import java.util.LinkedList;
import java.util.List;
public final class FlattenUtil {
public static List<Object> flatten(List<?> list) {
List<Object> retVal = new LinkedList<Object>();
flatten(list, retVal);
return retVal;
}
public static void flatten(List<?> fromTreeList, List<Object> toFlatList) {
for (Object item : fromTreeList) {
if (item instanceof List<?>) {
flatten((List<?>) item, toFlatList);
} else {
toFlatList.add(item);
}
}
}
}
|
Preserve the algorithm and functionality while converting the code from Ada to Java. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| import java.util.LinkedList;
import java.util.List;
public final class FlattenUtil {
public static List<Object> flatten(List<?> list) {
List<Object> retVal = new LinkedList<Object>();
flatten(list, retVal);
return retVal;
}
public static void flatten(List<?> fromTreeList, List<Object> toFlatList) {
for (Object item : fromTreeList) {
if (item instanceof List<?>) {
flatten((List<?>) item, toFlatList);
} else {
toFlatList.add(item);
}
}
}
}
|
Maintain the same structure and functionality when rewriting this code in Python. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| >>> def flatten(lst):
return sum( ([x] if not isinstance(x, list) else flatten(x)
for x in lst), [] )
>>> lst = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]
>>> flatten(lst)
[1, 2, 3, 4, 5, 6, 7, 8]
|
Port the provided Ada code into Python while preserving the original functionality. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| >>> def flatten(lst):
return sum( ([x] if not isinstance(x, list) else flatten(x)
for x in lst), [] )
>>> lst = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]
>>> flatten(lst)
[1, 2, 3, 4, 5, 6, 7, 8]
|
Port the provided Ada code into VB while preserving the original functionality. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| class flattener
dim separator
sub class_initialize
separator = ","
end sub
private function makeflat( a )
dim i
dim res
for i = lbound( a ) to ubound( a )
if isarray( a( i ) ) then
res = res & makeflat( a( i ) )
else
res = res & a( i ) & separator
end if
next
makeflat = res
end function
public function flatten( a )
dim res
res = makeflat( a )
res = left( res, len( res ) - len(separator))
res = split( res, separator )
flatten = res
end function
public property let itemSeparator( c )
separator = c
end property
end class
|
Change the programming language of this snippet from Ada to VB without modifying what it does. | generic
type Element_Type is private;
with function To_String (E : Element_Type) return String is <>;
package Nestable_Lists is
type Node_Kind is (Data_Node, List_Node);
type Node (Kind : Node_Kind);
type List is access Node;
type Node (Kind : Node_Kind) is record
Next : List;
case Kind is
when Data_Node =>
Data : Element_Type;
when List_Node =>
Sublist : List;
end case;
end record;
procedure Append (L : in out List; E : Element_Type);
procedure Append (L : in out List; N : List);
function Flatten (L : List) return List;
function New_List (E : Element_Type) return List;
function New_List (N : List) return List;
function To_String (L : List) return String;
end Nestable_Lists;
| class flattener
dim separator
sub class_initialize
separator = ","
end sub
private function makeflat( a )
dim i
dim res
for i = lbound( a ) to ubound( a )
if isarray( a( i ) ) then
res = res & makeflat( a( i ) )
else
res = res & a( i ) & separator
end if
next
makeflat = res
end function
public function flatten( a )
dim res
res = makeflat( a )
res = left( res, len( res ) - len(separator))
res = split( res, separator )
flatten = res
end function
public property let itemSeparator( c )
separator = c
end property
end class
|
Convert this Arturo block to C, preserving its control flow and logic. | print flatten [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct list_t list_t, *list;
struct list_t{
int is_list, ival;
list *lst;
};
list new_list()
{
list x = malloc(sizeof(list_t));
x->ival = 0;
x->is_list = 1;
x->lst = 0;
return x;
}
void append(list parent, list child)
{
parent->lst = realloc(parent->lst, sizeof(list) * (parent->ival + 1));
parent->lst[parent->ival++] = child;
}
list from_string(char *s, char **e, list parent)
{
list ret = 0;
if (!parent) parent = new_list();
while (*s != '\0') {
if (*s == ']') {
if (e) *e = s + 1;
return parent;
}
if (*s == '[') {
ret = new_list();
ret->is_list = 1;
ret->ival = 0;
append(parent, ret);
from_string(s + 1, &s, ret);
continue;
}
if (*s >= '0' && *s <= '9') {
ret = new_list();
ret->is_list = 0;
ret->ival = strtol(s, &s, 10);
append(parent, ret);
continue;
}
s++;
}
if (e) *e = s;
return parent;
}
void show_list(list l)
{
int i;
if (!l) return;
if (!l->is_list) {
printf("%d", l->ival);
return;
}
printf("[");
for (i = 0; i < l->ival; i++) {
show_list(l->lst[i]);
if (i < l->ival - 1) printf(", ");
}
printf("]");
}
list flatten(list from, list to)
{
int i;
list t;
if (!to) to = new_list();
if (!from->is_list) {
t = new_list();
*t = *from;
append(to, t);
} else
for (i = 0; i < from->ival; i++)
flatten(from->lst[i], to);
return to;
}
void delete_list(list l)
{
int i;
if (!l) return;
if (l->is_list && l->ival) {
for (i = 0; i < l->ival; i++)
delete_list(l->lst[i]);
free(l->lst);
}
free(l);
}
int main()
{
list l = from_string("[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []", 0, 0);
printf("Nested: ");
show_list(l);
printf("\n");
list flat = flatten(l, 0);
printf("Flattened: ");
show_list(flat);
return 0;
}
|
Change the following Arturo code into C without altering its purpose. | print flatten [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct list_t list_t, *list;
struct list_t{
int is_list, ival;
list *lst;
};
list new_list()
{
list x = malloc(sizeof(list_t));
x->ival = 0;
x->is_list = 1;
x->lst = 0;
return x;
}
void append(list parent, list child)
{
parent->lst = realloc(parent->lst, sizeof(list) * (parent->ival + 1));
parent->lst[parent->ival++] = child;
}
list from_string(char *s, char **e, list parent)
{
list ret = 0;
if (!parent) parent = new_list();
while (*s != '\0') {
if (*s == ']') {
if (e) *e = s + 1;
return parent;
}
if (*s == '[') {
ret = new_list();
ret->is_list = 1;
ret->ival = 0;
append(parent, ret);
from_string(s + 1, &s, ret);
continue;
}
if (*s >= '0' && *s <= '9') {
ret = new_list();
ret->is_list = 0;
ret->ival = strtol(s, &s, 10);
append(parent, ret);
continue;
}
s++;
}
if (e) *e = s;
return parent;
}
void show_list(list l)
{
int i;
if (!l) return;
if (!l->is_list) {
printf("%d", l->ival);
return;
}
printf("[");
for (i = 0; i < l->ival; i++) {
show_list(l->lst[i]);
if (i < l->ival - 1) printf(", ");
}
printf("]");
}
list flatten(list from, list to)
{
int i;
list t;
if (!to) to = new_list();
if (!from->is_list) {
t = new_list();
*t = *from;
append(to, t);
} else
for (i = 0; i < from->ival; i++)
flatten(from->lst[i], to);
return to;
}
void delete_list(list l)
{
int i;
if (!l) return;
if (l->is_list && l->ival) {
for (i = 0; i < l->ival; i++)
delete_list(l->lst[i]);
free(l->lst);
}
free(l);
}
int main()
{
list l = from_string("[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []", 0, 0);
printf("Nested: ");
show_list(l);
printf("\n");
list flat = flatten(l, 0);
printf("Flattened: ");
show_list(flat);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.