Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Port the following code from Icon to Python with equivalent syntax and logic. | procedure main()
write("Non-decimal radices/Output")
every i := 255 | 2 | 5 | 16 do {
printf("%%d = %d\n",i)
printf("%%x = %x\n",i)
printf("%%o = %o\n",i)
printf("%%s = %s\n",i)
printf("%%i = %i\n",i)
}
end
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Translate this program into Go but keep the logic exactly as in Icon. | procedure main()
write("Non-decimal radices/Output")
every i := 255 | 2 | 5 | 16 do {
printf("%%d = %d\n",i)
printf("%%x = %x\n",i)
printf("%%o = %o\n",i)
printf("%%s = %s\n",i)
printf("%%i = %i\n",i)
}
end
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Can you help me rewrite this code in C instead of J, keeping it the same logically? | 2 #.inv 12
1 1 0 0
3 #.inv 100
1 0 2 0 1
16 #.inv 180097588
10 11 12 1 2 3 4
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Convert this J block to C#, preserving its control flow and logic. | 2 #.inv 12
1 1 0 0
3 #.inv 100
1 0 2 0 1
16 #.inv 180097588
10 11 12 1 2 3 4
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Preserve the algorithm and functionality while converting the code from J to C++. | 2 #.inv 12
1 1 0 0
3 #.inv 100
1 0 2 0 1
16 #.inv 180097588
10 11 12 1 2 3 4
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Translate this program into Java but keep the logic exactly as in J. | 2 #.inv 12
1 1 0 0
3 #.inv 100
1 0 2 0 1
16 #.inv 180097588
10 11 12 1 2 3 4
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Can you help me rewrite this code in Python instead of J, keeping it the same logically? | 2 #.inv 12
1 1 0 0
3 #.inv 100
1 0 2 0 1
16 #.inv 180097588
10 11 12 1 2 3 4
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Write the same code in Go as shown below in J. | 2 #.inv 12
1 1 0 0
3 #.inv 100
1 0 2 0 1
16 #.inv 180097588
10 11 12 1 2 3 4
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Keep all operations the same but rewrite the snippet in C. | using Primes, Printf
println("Primes ≤ $hi written in common bases.")
@printf("%8s%8s%8s%8s", "bin", "oct", "dec", "hex")
for i in primes(50)
@printf("%8s%8s%8s%8s\n", bin(i), oct(i), dec(i), hex(i))
end
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Produce a functionally identical C# code for the snippet given in Julia. | using Primes, Printf
println("Primes ≤ $hi written in common bases.")
@printf("%8s%8s%8s%8s", "bin", "oct", "dec", "hex")
for i in primes(50)
@printf("%8s%8s%8s%8s\n", bin(i), oct(i), dec(i), hex(i))
end
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Convert this Julia snippet to C++ and keep its semantics consistent. | using Primes, Printf
println("Primes ≤ $hi written in common bases.")
@printf("%8s%8s%8s%8s", "bin", "oct", "dec", "hex")
for i in primes(50)
@printf("%8s%8s%8s%8s\n", bin(i), oct(i), dec(i), hex(i))
end
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Transform the following Julia implementation into Java, maintaining the same output and logic. | using Primes, Printf
println("Primes ≤ $hi written in common bases.")
@printf("%8s%8s%8s%8s", "bin", "oct", "dec", "hex")
for i in primes(50)
@printf("%8s%8s%8s%8s\n", bin(i), oct(i), dec(i), hex(i))
end
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Change the following Julia code into Python without altering its purpose. | using Primes, Printf
println("Primes ≤ $hi written in common bases.")
@printf("%8s%8s%8s%8s", "bin", "oct", "dec", "hex")
for i in primes(50)
@printf("%8s%8s%8s%8s\n", bin(i), oct(i), dec(i), hex(i))
end
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Maintain the same structure and functionality when rewriting this code in Go. | using Primes, Printf
println("Primes ≤ $hi written in common bases.")
@printf("%8s%8s%8s%8s", "bin", "oct", "dec", "hex")
for i in primes(50)
@printf("%8s%8s%8s%8s\n", bin(i), oct(i), dec(i), hex(i))
end
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Change the programming language of this snippet from Lua to C without modifying what it does. | for i = 1, 33 do
print( string.format( "%o \t %d \t %x", i, i, i ) )
end
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Transform the following Lua implementation into C#, maintaining the same output and logic. | for i = 1, 33 do
print( string.format( "%o \t %d \t %x", i, i, i ) )
end
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Translate the given Lua code snippet into C++ without altering its behavior. | for i = 1, 33 do
print( string.format( "%o \t %d \t %x", i, i, i ) )
end
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Translate the given Lua code snippet into Java without altering its behavior. | for i = 1, 33 do
print( string.format( "%o \t %d \t %x", i, i, i ) )
end
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Convert this Lua snippet to Python and keep its semantics consistent. | for i = 1, 33 do
print( string.format( "%o \t %d \t %x", i, i, i ) )
end
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Preserve the algorithm and functionality while converting the code from Lua to Go. | for i = 1, 33 do
print( string.format( "%o \t %d \t %x", i, i, i ) )
end
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Rewrite this program in C while keeping its functionality equivalent to the Mathematica version. | Table[IntegerString[n,b], {n,Range@38}, {b,{2,8,16,36}}] // Grid
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Write the same code in C# as shown below in Mathematica. | Table[IntegerString[n,b], {n,Range@38}, {b,{2,8,16,36}}] // Grid
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Produce a functionally identical C++ code for the snippet given in Mathematica. | Table[IntegerString[n,b], {n,Range@38}, {b,{2,8,16,36}}] // Grid
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Produce a language-to-language conversion: from Mathematica to Java, same semantics. | Table[IntegerString[n,b], {n,Range@38}, {b,{2,8,16,36}}] // Grid
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Preserve the algorithm and functionality while converting the code from Mathematica to Python. | Table[IntegerString[n,b], {n,Range@38}, {b,{2,8,16,36}}] // Grid
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Maintain the same structure and functionality when rewriting this code in Go. | Table[IntegerString[n,b], {n,Range@38}, {b,{2,8,16,36}}] // Grid
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Write a version of this MATLAB function in C with identical behavior. | fprintf('
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Convert the following code from MATLAB to C#, ensuring the logic remains intact. | fprintf('
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Change the following MATLAB code into C++ without altering its purpose. | fprintf('
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Write the same algorithm in Java as shown in this MATLAB implementation. | fprintf('
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Maintain the same structure and functionality when rewriting this code in Python. | fprintf('
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Write the same algorithm in Go as shown in this MATLAB implementation. | fprintf('
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Change the following Nim code into C without altering its purpose. | import strutils
for i in 0..33:
echo toBin(i, 6)," ",toOct(i, 3)," ",align($i,2)," ",toHex(i,2)
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Generate a C# translation of this Nim snippet without changing its computational steps. | import strutils
for i in 0..33:
echo toBin(i, 6)," ",toOct(i, 3)," ",align($i,2)," ",toHex(i,2)
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Port the following code from Nim to C++ with equivalent syntax and logic. | import strutils
for i in 0..33:
echo toBin(i, 6)," ",toOct(i, 3)," ",align($i,2)," ",toHex(i,2)
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Generate a Java translation of this Nim snippet without changing its computational steps. | import strutils
for i in 0..33:
echo toBin(i, 6)," ",toOct(i, 3)," ",align($i,2)," ",toHex(i,2)
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Port the provided Nim code into Python while preserving the original functionality. | import strutils
for i in 0..33:
echo toBin(i, 6)," ",toOct(i, 3)," ",align($i,2)," ",toHex(i,2)
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Ensure the translated Go code behaves exactly like the original Nim snippet. | import strutils
for i in 0..33:
echo toBin(i, 6)," ",toOct(i, 3)," ",align($i,2)," ",toHex(i,2)
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Can you help me rewrite this code in C instead of OCaml, keeping it the same logically? | for n = 0 to 33 do
Printf.printf " %3o %2d %2X\n" n n n
done
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Produce a language-to-language conversion: from OCaml to C#, same semantics. | for n = 0 to 33 do
Printf.printf " %3o %2d %2X\n" n n n
done
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Ensure the translated C++ code behaves exactly like the original OCaml snippet. | for n = 0 to 33 do
Printf.printf " %3o %2d %2X\n" n n n
done
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Write the same code in Java as shown below in OCaml. | for n = 0 to 33 do
Printf.printf " %3o %2d %2X\n" n n n
done
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Convert this OCaml snippet to Python and keep its semantics consistent. | for n = 0 to 33 do
Printf.printf " %3o %2d %2X\n" n n n
done
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Write a version of this OCaml function in Go with identical behavior. | for n = 0 to 33 do
Printf.printf " %3o %2d %2X\n" n n n
done
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Ensure the translated C code behaves exactly like the original Perl snippet. | foreach my $n (0..33) {
printf " %6b %3o %2d %2X\n", $n, $n, $n, $n;
}
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Port the provided Perl code into C# while preserving the original functionality. | foreach my $n (0..33) {
printf " %6b %3o %2d %2X\n", $n, $n, $n, $n;
}
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Generate an equivalent C++ version of this Perl code. | foreach my $n (0..33) {
printf " %6b %3o %2d %2X\n", $n, $n, $n, $n;
}
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Ensure the translated Java code behaves exactly like the original Perl snippet. | foreach my $n (0..33) {
printf " %6b %3o %2d %2X\n", $n, $n, $n, $n;
}
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Change the programming language of this snippet from Perl to Python without modifying what it does. | foreach my $n (0..33) {
printf " %6b %3o %2d %2X\n", $n, $n, $n, $n;
}
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Write the same algorithm in Go as shown in this Perl implementation. | foreach my $n (0..33) {
printf " %6b %3o %2d %2X\n", $n, $n, $n, $n;
}
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Write the same algorithm in C as shown in this PowerShell implementation. | foreach ($n in 0..33) {
"Base 2: " + [Convert]::ToString($n, 2)
"Base 8: " + [Convert]::ToString($n, 8)
"Base 10: " + $n
"Base 10: " + [Convert]::ToString($n, 10)
"Base 10: " + ("{0:D}" -f $n)
"Base 16: " + [Convert]::ToString($n, 16)
"Base 16: " + ("{0:X}" -f $n)
}
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Preserve the algorithm and functionality while converting the code from PowerShell to C#. | foreach ($n in 0..33) {
"Base 2: " + [Convert]::ToString($n, 2)
"Base 8: " + [Convert]::ToString($n, 8)
"Base 10: " + $n
"Base 10: " + [Convert]::ToString($n, 10)
"Base 10: " + ("{0:D}" -f $n)
"Base 16: " + [Convert]::ToString($n, 16)
"Base 16: " + ("{0:X}" -f $n)
}
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Ensure the translated C++ code behaves exactly like the original PowerShell snippet. | foreach ($n in 0..33) {
"Base 2: " + [Convert]::ToString($n, 2)
"Base 8: " + [Convert]::ToString($n, 8)
"Base 10: " + $n
"Base 10: " + [Convert]::ToString($n, 10)
"Base 10: " + ("{0:D}" -f $n)
"Base 16: " + [Convert]::ToString($n, 16)
"Base 16: " + ("{0:X}" -f $n)
}
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Rewrite the snippet below in Java so it works the same as the original PowerShell code. | foreach ($n in 0..33) {
"Base 2: " + [Convert]::ToString($n, 2)
"Base 8: " + [Convert]::ToString($n, 8)
"Base 10: " + $n
"Base 10: " + [Convert]::ToString($n, 10)
"Base 10: " + ("{0:D}" -f $n)
"Base 16: " + [Convert]::ToString($n, 16)
"Base 16: " + ("{0:X}" -f $n)
}
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Rewrite this program in Python while keeping its functionality equivalent to the PowerShell version. | foreach ($n in 0..33) {
"Base 2: " + [Convert]::ToString($n, 2)
"Base 8: " + [Convert]::ToString($n, 8)
"Base 10: " + $n
"Base 10: " + [Convert]::ToString($n, 10)
"Base 10: " + ("{0:D}" -f $n)
"Base 16: " + [Convert]::ToString($n, 16)
"Base 16: " + ("{0:X}" -f $n)
}
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Maintain the same structure and functionality when rewriting this code in Go. | foreach ($n in 0..33) {
"Base 2: " + [Convert]::ToString($n, 2)
"Base 8: " + [Convert]::ToString($n, 8)
"Base 10: " + $n
"Base 10: " + [Convert]::ToString($n, 10)
"Base 10: " + ("{0:D}" -f $n)
"Base 16: " + [Convert]::ToString($n, 16)
"Base 16: " + ("{0:X}" -f $n)
}
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Generate an equivalent C version of this R code. |
as.octmode(x)
as.hexmode(x)
as.integer(x)
as.numeric(x)
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Generate a C# translation of this R snippet without changing its computational steps. |
as.octmode(x)
as.hexmode(x)
as.integer(x)
as.numeric(x)
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Keep all operations the same but rewrite the snippet in C++. |
as.octmode(x)
as.hexmode(x)
as.integer(x)
as.numeric(x)
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Write the same algorithm in Java as shown in this R implementation. |
as.octmode(x)
as.hexmode(x)
as.integer(x)
as.numeric(x)
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Can you help me rewrite this code in Python instead of R, keeping it the same logically? |
as.octmode(x)
as.hexmode(x)
as.integer(x)
as.numeric(x)
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Port the provided R code into Go while preserving the original functionality. |
as.octmode(x)
as.hexmode(x)
as.integer(x)
as.numeric(x)
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Preserve the algorithm and functionality while converting the code from Racket to C. | #lang racket
(map (λ(r) (number->string 123 r)) '(2 8 10 16))
(for/list ([r (in-range 2 37)]) (~r 123 #:base r))
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Write the same algorithm in C# as shown in this Racket implementation. | #lang racket
(map (λ(r) (number->string 123 r)) '(2 8 10 16))
(for/list ([r (in-range 2 37)]) (~r 123 #:base r))
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Rewrite this program in C++ while keeping its functionality equivalent to the Racket version. | #lang racket
(map (λ(r) (number->string 123 r)) '(2 8 10 16))
(for/list ([r (in-range 2 37)]) (~r 123 #:base r))
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Preserve the algorithm and functionality while converting the code from Racket to Java. | #lang racket
(map (λ(r) (number->string 123 r)) '(2 8 10 16))
(for/list ([r (in-range 2 37)]) (~r 123 #:base r))
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Transform the following Racket implementation into Python, maintaining the same output and logic. | #lang racket
(map (λ(r) (number->string 123 r)) '(2 8 10 16))
(for/list ([r (in-range 2 37)]) (~r 123 #:base r))
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Port the provided Racket code into Go while preserving the original functionality. | #lang racket
(map (λ(r) (number->string 123 r)) '(2 8 10 16))
(for/list ([r (in-range 2 37)]) (~r 123 #:base r))
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Maintain the same structure and functionality when rewriting this code in C. |
options replace format comments java crossref symbols nobinary
import java.util.Formatter
loop i_ = 1 to 3
loop n_ = 20 to 20000 by 2131
select case i_
when 1 then say useBif(n_)
when 2 then say useJavaFormat(n_)
when 3 then say useJavaNumber(n_)
otherwise nop
end
end n_
say
end i_
return
-- NetRexx doesn't have a decimal to octal conversion
method useBif(n_) public static
d_ = '_'
return '[Base 16='n_.d2x().right(8)',Base 10='n_.right(8)',Base 8='d_.right(8)',Base 2='n_.d2x().x2b().right(20)']'
-- Some of Java's java.lang.Number classes have conversion methods
method useJavaNumber(n_) public static
nx = Long.toHexString(n_)
nd = Long.toString(n_)
no = Long.toOctalString(n_)
nb = Long.toBinaryString(n_)
return '[Base 16='Rexx(nx).right(8)',Base 10='Rexx(nd).right(8)',Base 8='Rexx(no).right(8)',Base 2='Rexx(nb).right(20)']'
-- Java Formatter doesn't have a decimal to binary conversion
method useJavaFormat(n_) public static
fb = StringBuilder()
fm = Formatter(fb)
fm.format("[Base 16=%1$8x,Base 10=%1$8d,Base 8=%1$8o,Base 2=%2$20s]", [Object Long(n_), String('_')])
return fb.toString()
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Can you help me rewrite this code in C# instead of REXX, keeping it the same logically? |
options replace format comments java crossref symbols nobinary
import java.util.Formatter
loop i_ = 1 to 3
loop n_ = 20 to 20000 by 2131
select case i_
when 1 then say useBif(n_)
when 2 then say useJavaFormat(n_)
when 3 then say useJavaNumber(n_)
otherwise nop
end
end n_
say
end i_
return
-- NetRexx doesn't have a decimal to octal conversion
method useBif(n_) public static
d_ = '_'
return '[Base 16='n_.d2x().right(8)',Base 10='n_.right(8)',Base 8='d_.right(8)',Base 2='n_.d2x().x2b().right(20)']'
-- Some of Java's java.lang.Number classes have conversion methods
method useJavaNumber(n_) public static
nx = Long.toHexString(n_)
nd = Long.toString(n_)
no = Long.toOctalString(n_)
nb = Long.toBinaryString(n_)
return '[Base 16='Rexx(nx).right(8)',Base 10='Rexx(nd).right(8)',Base 8='Rexx(no).right(8)',Base 2='Rexx(nb).right(20)']'
-- Java Formatter doesn't have a decimal to binary conversion
method useJavaFormat(n_) public static
fb = StringBuilder()
fm = Formatter(fb)
fm.format("[Base 16=%1$8x,Base 10=%1$8d,Base 8=%1$8o,Base 2=%2$20s]", [Object Long(n_), String('_')])
return fb.toString()
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Transform the following REXX implementation into C++, maintaining the same output and logic. |
options replace format comments java crossref symbols nobinary
import java.util.Formatter
loop i_ = 1 to 3
loop n_ = 20 to 20000 by 2131
select case i_
when 1 then say useBif(n_)
when 2 then say useJavaFormat(n_)
when 3 then say useJavaNumber(n_)
otherwise nop
end
end n_
say
end i_
return
-- NetRexx doesn't have a decimal to octal conversion
method useBif(n_) public static
d_ = '_'
return '[Base 16='n_.d2x().right(8)',Base 10='n_.right(8)',Base 8='d_.right(8)',Base 2='n_.d2x().x2b().right(20)']'
-- Some of Java's java.lang.Number classes have conversion methods
method useJavaNumber(n_) public static
nx = Long.toHexString(n_)
nd = Long.toString(n_)
no = Long.toOctalString(n_)
nb = Long.toBinaryString(n_)
return '[Base 16='Rexx(nx).right(8)',Base 10='Rexx(nd).right(8)',Base 8='Rexx(no).right(8)',Base 2='Rexx(nb).right(20)']'
-- Java Formatter doesn't have a decimal to binary conversion
method useJavaFormat(n_) public static
fb = StringBuilder()
fm = Formatter(fb)
fm.format("[Base 16=%1$8x,Base 10=%1$8d,Base 8=%1$8o,Base 2=%2$20s]", [Object Long(n_), String('_')])
return fb.toString()
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Rewrite this program in Java while keeping its functionality equivalent to the REXX version. |
options replace format comments java crossref symbols nobinary
import java.util.Formatter
loop i_ = 1 to 3
loop n_ = 20 to 20000 by 2131
select case i_
when 1 then say useBif(n_)
when 2 then say useJavaFormat(n_)
when 3 then say useJavaNumber(n_)
otherwise nop
end
end n_
say
end i_
return
-- NetRexx doesn't have a decimal to octal conversion
method useBif(n_) public static
d_ = '_'
return '[Base 16='n_.d2x().right(8)',Base 10='n_.right(8)',Base 8='d_.right(8)',Base 2='n_.d2x().x2b().right(20)']'
-- Some of Java's java.lang.Number classes have conversion methods
method useJavaNumber(n_) public static
nx = Long.toHexString(n_)
nd = Long.toString(n_)
no = Long.toOctalString(n_)
nb = Long.toBinaryString(n_)
return '[Base 16='Rexx(nx).right(8)',Base 10='Rexx(nd).right(8)',Base 8='Rexx(no).right(8)',Base 2='Rexx(nb).right(20)']'
-- Java Formatter doesn't have a decimal to binary conversion
method useJavaFormat(n_) public static
fb = StringBuilder()
fm = Formatter(fb)
fm.format("[Base 16=%1$8x,Base 10=%1$8d,Base 8=%1$8o,Base 2=%2$20s]", [Object Long(n_), String('_')])
return fb.toString()
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Produce a functionally identical Python code for the snippet given in REXX. |
options replace format comments java crossref symbols nobinary
import java.util.Formatter
loop i_ = 1 to 3
loop n_ = 20 to 20000 by 2131
select case i_
when 1 then say useBif(n_)
when 2 then say useJavaFormat(n_)
when 3 then say useJavaNumber(n_)
otherwise nop
end
end n_
say
end i_
return
-- NetRexx doesn't have a decimal to octal conversion
method useBif(n_) public static
d_ = '_'
return '[Base 16='n_.d2x().right(8)',Base 10='n_.right(8)',Base 8='d_.right(8)',Base 2='n_.d2x().x2b().right(20)']'
-- Some of Java's java.lang.Number classes have conversion methods
method useJavaNumber(n_) public static
nx = Long.toHexString(n_)
nd = Long.toString(n_)
no = Long.toOctalString(n_)
nb = Long.toBinaryString(n_)
return '[Base 16='Rexx(nx).right(8)',Base 10='Rexx(nd).right(8)',Base 8='Rexx(no).right(8)',Base 2='Rexx(nb).right(20)']'
-- Java Formatter doesn't have a decimal to binary conversion
method useJavaFormat(n_) public static
fb = StringBuilder()
fm = Formatter(fb)
fm.format("[Base 16=%1$8x,Base 10=%1$8d,Base 8=%1$8o,Base 2=%2$20s]", [Object Long(n_), String('_')])
return fb.toString()
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Produce a functionally identical Go code for the snippet given in REXX. |
options replace format comments java crossref symbols nobinary
import java.util.Formatter
loop i_ = 1 to 3
loop n_ = 20 to 20000 by 2131
select case i_
when 1 then say useBif(n_)
when 2 then say useJavaFormat(n_)
when 3 then say useJavaNumber(n_)
otherwise nop
end
end n_
say
end i_
return
-- NetRexx doesn't have a decimal to octal conversion
method useBif(n_) public static
d_ = '_'
return '[Base 16='n_.d2x().right(8)',Base 10='n_.right(8)',Base 8='d_.right(8)',Base 2='n_.d2x().x2b().right(20)']'
-- Some of Java's java.lang.Number classes have conversion methods
method useJavaNumber(n_) public static
nx = Long.toHexString(n_)
nd = Long.toString(n_)
no = Long.toOctalString(n_)
nb = Long.toBinaryString(n_)
return '[Base 16='Rexx(nx).right(8)',Base 10='Rexx(nd).right(8)',Base 8='Rexx(no).right(8)',Base 2='Rexx(nb).right(20)']'
-- Java Formatter doesn't have a decimal to binary conversion
method useJavaFormat(n_) public static
fb = StringBuilder()
fm = Formatter(fb)
fm.format("[Base 16=%1$8x,Base 10=%1$8d,Base 8=%1$8o,Base 2=%2$20s]", [Object Long(n_), String('_')])
return fb.toString()
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Produce a language-to-language conversion: from Ruby to C, same semantics. | for n in 0..33
puts " %6b %3o %2d %2X" % [n, n, n, n]
end
puts
[2,8,10,16,36].each {|i| puts " 100.to_s(
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Translate the given Ruby code snippet into C# without altering its behavior. | for n in 0..33
puts " %6b %3o %2d %2X" % [n, n, n, n]
end
puts
[2,8,10,16,36].each {|i| puts " 100.to_s(
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Change the programming language of this snippet from Ruby to C++ without modifying what it does. | for n in 0..33
puts " %6b %3o %2d %2X" % [n, n, n, n]
end
puts
[2,8,10,16,36].each {|i| puts " 100.to_s(
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Translate this program into Java but keep the logic exactly as in Ruby. | for n in 0..33
puts " %6b %3o %2d %2X" % [n, n, n, n]
end
puts
[2,8,10,16,36].each {|i| puts " 100.to_s(
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Write the same code in Python as shown below in Ruby. | for n in 0..33
puts " %6b %3o %2d %2X" % [n, n, n, n]
end
puts
[2,8,10,16,36].each {|i| puts " 100.to_s(
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Produce a functionally identical Go code for the snippet given in Ruby. | for n in 0..33
puts " %6b %3o %2d %2X" % [n, n, n, n]
end
puts
[2,8,10,16,36].each {|i| puts " 100.to_s(
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Translate this program into C but keep the logic exactly as in Scala. |
fun main(args: Array<String>) {
val bases = intArrayOf(2, 8, 10, 16, 19, 36)
for (base in bases) print("%6s".format(base))
println()
println("-".repeat(6 * bases.size))
for (i in 0..35) {
for (base in bases) print("%6s".format(i.toString(base)))
println()
}
}
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Change the following Scala code into C# without altering its purpose. |
fun main(args: Array<String>) {
val bases = intArrayOf(2, 8, 10, 16, 19, 36)
for (base in bases) print("%6s".format(base))
println()
println("-".repeat(6 * bases.size))
for (i in 0..35) {
for (base in bases) print("%6s".format(i.toString(base)))
println()
}
}
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Write the same algorithm in C++ as shown in this Scala implementation. |
fun main(args: Array<String>) {
val bases = intArrayOf(2, 8, 10, 16, 19, 36)
for (base in bases) print("%6s".format(base))
println()
println("-".repeat(6 * bases.size))
for (i in 0..35) {
for (base in bases) print("%6s".format(i.toString(base)))
println()
}
}
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Change the following Scala code into Java without altering its purpose. |
fun main(args: Array<String>) {
val bases = intArrayOf(2, 8, 10, 16, 19, 36)
for (base in bases) print("%6s".format(base))
println()
println("-".repeat(6 * bases.size))
for (i in 0..35) {
for (base in bases) print("%6s".format(i.toString(base)))
println()
}
}
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Can you help me rewrite this code in Python instead of Scala, keeping it the same logically? |
fun main(args: Array<String>) {
val bases = intArrayOf(2, 8, 10, 16, 19, 36)
for (base in bases) print("%6s".format(base))
println()
println("-".repeat(6 * bases.size))
for (i in 0..35) {
for (base in bases) print("%6s".format(i.toString(base)))
println()
}
}
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Generate a Go translation of this Scala snippet without changing its computational steps. |
fun main(args: Array<String>) {
val bases = intArrayOf(2, 8, 10, 16, 19, 36)
for (base in bases) print("%6s".format(base))
println()
println("-".repeat(6 * bases.size))
for (i in 0..35) {
for (base in bases) print("%6s".format(i.toString(base)))
println()
}
}
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Write a version of this Tcl function in C with identical behavior. | for {set n 0} {$n <= 33} {incr n} {
puts [format " %3o %2d %2X" $n $n $n]
}
| #include <stdio.h>
int main()
{
int i;
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
return 0;
}
|
Keep all operations the same but rewrite the snippet in C#. | for {set n 0} {$n <= 33} {incr n} {
puts [format " %3o %2d %2X" $n $n $n]
}
| using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
|
Port the provided Tcl code into C++ while preserving the original functionality. | for {set n 0} {$n <= 33} {incr n} {
puts [format " %3o %2d %2X" $n $n $n]
}
| #include <iostream>
#include <iomanip>
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
return 0;
}
|
Transform the following Tcl implementation into Java, maintaining the same output and logic. | for {set n 0} {$n <= 33} {incr n} {
puts [format " %3o %2d %2X" $n $n $n]
}
| public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
System.out.printf("%3o %2d %2x\n",a ,a ,a);
}
}
|
Write a version of this Tcl function in Python with identical behavior. | for {set n 0} {$n <= 33} {incr n} {
puts [format " %3o %2d %2X" $n $n $n]
}
| >>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
|
Transform the following Tcl implementation into Go, maintaining the same output and logic. | for {set n 0} {$n <= 33} {incr n} {
puts [format " %3o %2d %2X" $n $n $n]
}
| package main
import (
"fmt"
"math/big"
"strconv"
)
func main() {
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
fmt.Println(strconv.FormatInt(1313, 19))
}
|
Write a version of this Rust function in PHP with identical behavior. | fn main() {
println!("Binary: {:b}", 0xdeadbeefu32);
println!("Binary with 0b prefix: {:#b}", 0xdeadbeefu32);
println!("Octal: {:o}", 0xdeadbeefu32);
println!("Octal with 0o prefix: {:#o}", 0xdeadbeefu32);
println!("Decimal: {}", 0xdeadbeefu32);
println!("Lowercase hexadecimal: {:x}", 0xdeadbeefu32);
println!("Lowercase hexadecimal with 0x prefix: {:#x}", 0xdeadbeefu32);
println!("Uppercase hexadecimal: {:X}", 0xdeadbeefu32);
println!("Uppercase hexadecimal with 0x prefix: {:#X}", 0xdeadbeefu32);
}
| <?php
foreach (range(0, 33) as $n) {
echo decbin($n), "\t", decoct($n), "\t", $n, "\t", dechex($n), "\n";
}
?>
|
Write the same algorithm in PHP as shown in this Ada implementation. | with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
with Ada.Text_IO; use Ada.Text_IO;
procedure Test_Integer_Text_IO is
begin
for I in 1..33 loop
Put (I, Width =>3, Base=> 10);
Put (I, Width =>7, Base=> 16);
Put (I, Width =>6, Base=> 8);
New_Line;
end loop;
end Test_Integer_Text_IO;
| <?php
foreach (range(0, 33) as $n) {
echo decbin($n), "\t", decoct($n), "\t", $n, "\t", dechex($n), "\n";
}
?>
|
Write a version of this Arturo function in PHP with identical behavior. | loop 0..33 'i ->
print [
pad as.binary i 6
pad as.octal i 2
pad to :string i 2
pad as.hex i 2
]
| <?php
foreach (range(0, 33) as $n) {
echo decbin($n), "\t", decoct($n), "\t", $n, "\t", dechex($n), "\n";
}
?>
|
Port the provided AutoHotKey code into PHP while preserving the original functionality. | MsgBox % BC("FF",16,3)
BC(NumStr,InputBase=8,OutputBase=10) {
Static S = 12345678901234567890123456789012345678901234567890123456789012345
DllCall("msvcrt\_i64toa","Int64",DllCall("msvcrt\_strtoui64","Str",NumStr,"Uint",0,"UInt",InputBase,"CDECLInt64"),"Str",S,"UInt",OutputBase,"CDECL")
Return S
}
| <?php
foreach (range(0, 33) as $n) {
echo decbin($n), "\t", decoct($n), "\t", $n, "\t", dechex($n), "\n";
}
?>
|
Ensure the translated PHP code behaves exactly like the original AWK snippet. | $ awk '{printf("%d 0%o 0x%x\n",$1,$1,$1)}'
10
10 012 0xa
16
16 020 0x10
255
255 0377 0xff
| <?php
foreach (range(0, 33) as $n) {
echo decbin($n), "\t", decoct($n), "\t", $n, "\t", dechex($n), "\n";
}
?>
|
Translate this program into PHP but keep the logic exactly as in BBC_Basic. |
PRINT STR$(0)
PRINT STR$(123456789)
PRINT STR$(-987654321)
PRINT STR$~(43981)
PRINT STR$~(-1)
| <?php
foreach (range(0, 33) as $n) {
echo decbin($n), "\t", decoct($n), "\t", $n, "\t", dechex($n), "\n";
}
?>
|
Produce a functionally identical PHP code for the snippet given in Common_Lisp. | (Integer/toBinaryString 25)
(Integer/toOctalString 25)
(Integer/toHexString 25)
(dotimes [i 20]
(println (Integer/toHexString i)))
| <?php
foreach (range(0, 33) as $n) {
echo decbin($n), "\t", decoct($n), "\t", $n, "\t", dechex($n), "\n";
}
?>
|
Preserve the algorithm and functionality while converting the code from D to PHP. | import std.stdio;
void main() {
writeln("Base: 2 8 10 16");
writeln("----------------------------");
foreach (i; 0 .. 34)
writefln(" %6b %6o %6d %6x", i, i, i, i);
}
| <?php
foreach (range(0, 33) as $n) {
echo decbin($n), "\t", decoct($n), "\t", $n, "\t", dechex($n), "\n";
}
?>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.