Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Convert the following code from Groovy to C#, ensuring the logic remains intact. | def rng = new java.security.SecureRandom()
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Produce a functionally identical C++ code for the snippet given in Groovy. | def rng = new java.security.SecureRandom()
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Port the provided Groovy code into C++ while preserving the original functionality. | def rng = new java.security.SecureRandom()
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Rewrite the snippet below in Java so it works the same as the original Groovy code. | def rng = new java.security.SecureRandom()
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Rewrite this program in Java while keeping its functionality equivalent to the Groovy version. | def rng = new java.security.SecureRandom()
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Rewrite the snippet below in Go so it works the same as the original Groovy code. | def rng = new java.security.SecureRandom()
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Change the following Groovy code into Go without altering its purpose. | def rng = new java.security.SecureRandom()
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Translate the given Haskell code snippet into C without altering its behavior. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Change the programming language of this snippet from Haskell to C without modifying what it does. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Port the provided Haskell code into C# while preserving the original functionality. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Change the following Haskell code into C# without altering its purpose. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Maintain the same structure and functionality when rewriting this code in C++. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Generate an equivalent C++ version of this Haskell code. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Transform the following Haskell implementation into Java, maintaining the same output and logic. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Rewrite the snippet below in Java so it works the same as the original Haskell code. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Convert this Haskell block to Python, preserving its control flow and logic. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Keep all operations the same but rewrite the snippet in Python. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Generate an equivalent Go version of this Haskell code. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Transform the following Haskell implementation into Go, maintaining the same output and logic. | #!/usr/bin/env runhaskell
import System.Entropy
import Data.Binary.Get
import qualified Data.ByteString.Lazy as B
main = do
bytes <- getEntropy 4
print (runGet getWord32be $ B.fromChunks [bytes])
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Produce a language-to-language conversion: from J to C, same semantics. | 256#.a.i.1!:11'/dev/urandom';0 4
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Write the same algorithm in C as shown in this J implementation. | 256#.a.i.1!:11'/dev/urandom';0 4
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Please provide an equivalent version of this J code in C#. | 256#.a.i.1!:11'/dev/urandom';0 4
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Convert this J snippet to C# and keep its semantics consistent. | 256#.a.i.1!:11'/dev/urandom';0 4
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Transform the following J implementation into C++, maintaining the same output and logic. | 256#.a.i.1!:11'/dev/urandom';0 4
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Convert the following code from J to C++, ensuring the logic remains intact. | 256#.a.i.1!:11'/dev/urandom';0 4
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Keep all operations the same but rewrite the snippet in Java. | 256#.a.i.1!:11'/dev/urandom';0 4
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Generate a Java translation of this J snippet without changing its computational steps. | 256#.a.i.1!:11'/dev/urandom';0 4
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Change the following J code into Python without altering its purpose. | 256#.a.i.1!:11'/dev/urandom';0 4
| import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Produce a functionally identical Python code for the snippet given in J. | 256#.a.i.1!:11'/dev/urandom';0 4
| import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Preserve the algorithm and functionality while converting the code from J to Go. | 256#.a.i.1!:11'/dev/urandom';0 4
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Change the following J code into Go without altering its purpose. | 256#.a.i.1!:11'/dev/urandom';0 4
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Produce a language-to-language conversion: from Julia to C, same semantics. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Produce a language-to-language conversion: from Julia to C, same semantics. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Write the same code in C# as shown below in Julia. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Keep all operations the same but rewrite the snippet in C#. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Rewrite the snippet below in C++ so it works the same as the original Julia code. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Generate a C++ translation of this Julia snippet without changing its computational steps. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Translate the given Julia code snippet into Java without altering its behavior. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Convert the following code from Julia to Java, ensuring the logic remains intact. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Ensure the translated Python code behaves exactly like the original Julia snippet. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Translate the given Julia code snippet into Python without altering its behavior. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Convert this Julia snippet to Go and keep its semantics consistent. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Convert this Julia snippet to Go and keep its semantics consistent. | const rdev = "/dev/random"
rstream = try
open(rdev, "r")
catch
false
end
if isa(rstream, IOStream)
b = readbytes(rstream, 4)
close(rstream)
i = reinterpret(Int32, b)[1]
println("A hardware random number is: ", i)
else
println("The hardware random number stream, ", rdev, ", was unavailable.... | package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Change the following Mathematica code into C without altering its purpose. | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Port the provided Mathematica code into C while preserving the original functionality. | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Can you help me rewrite this code in C# instead of Mathematica, keeping it the same logically? | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Port the following code from Mathematica to C# with equivalent syntax and logic. | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Write the same code in C++ as shown below in Mathematica. | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Write the same algorithm in C++ as shown in this Mathematica implementation. | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Rewrite this program in Java while keeping its functionality equivalent to the Mathematica version. | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Produce a language-to-language conversion: from Mathematica to Java, same semantics. | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Port the following code from Mathematica to Python with equivalent syntax and logic. | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Convert this Mathematica block to Python, preserving its control flow and logic. | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Generate a Go translation of this Mathematica snippet without changing its computational steps. | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Ensure the translated Go code behaves exactly like the original Mathematica snippet. | rand32[] := RandomInteger[{-2^31, 2^31 - 1}]
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Translate the given Nim code snippet into C without altering its behavior. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Write the same algorithm in C as shown in this Nim implementation. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Ensure the translated C# code behaves exactly like the original Nim snippet. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Produce a functionally identical C# code for the snippet given in Nim. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Maintain the same structure and functionality when rewriting this code in C++. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Keep all operations the same but rewrite the snippet in C++. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Maintain the same structure and functionality when rewriting this code in Java. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Rewrite the snippet below in Java so it works the same as the original Nim code. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Preserve the algorithm and functionality while converting the code from Nim to Python. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Generate an equivalent Python version of this Nim code. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Ensure the translated Go code behaves exactly like the original Nim snippet. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Port the following code from Nim to Go with equivalent syntax and logic. | var f = open("/dev/urandom")
var r: int32
discard f.readBuffer(addr r, 4)
close(f)
echo r
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Can you help me rewrite this code in C instead of OCaml, keeping it the same logically? | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Maintain the same structure and functionality when rewriting this code in C. | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Produce a functionally identical C# code for the snippet given in OCaml. | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Port the provided OCaml code into C# while preserving the original functionality. | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Rewrite the snippet below in C++ so it works the same as the original OCaml code. | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Translate the given OCaml code snippet into C++ without altering its behavior. | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Rewrite the snippet below in Java so it works the same as the original OCaml code. | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Can you help me rewrite this code in Java instead of OCaml, keeping it the same logically? | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Write a version of this OCaml function in Python with identical behavior. | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Generate an equivalent Python version of this OCaml code. | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Produce a language-to-language conversion: from OCaml to Go, same semantics. | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Port the following code from OCaml to Go with equivalent syntax and logic. | let input_rand_int ic =
let i1 = int_of_char (input_char ic)
and i2 = int_of_char (input_char ic)
and i3 = int_of_char (input_char ic)
and i4 = int_of_char (input_char ic) in
i1 lor (i2 lsl 8) lor (i3 lsl 16) lor (i4 lsl 24)
let () =
let ic = open_in "/dev/urandom" in
let ri31 = input_rand_int ic in
cl... | package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Produce a language-to-language conversion: from Pascal to C, same semantics. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Keep all operations the same but rewrite the snippet in C. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Convert this Pascal block to C#, preserving its control flow and logic. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Convert this Pascal snippet to C# and keep its semantics consistent. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Write the same code in C++ as shown below in Pascal. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Translate this program into C++ but keep the logic exactly as in Pascal. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Rewrite the snippet below in Java so it works the same as the original Pascal code. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Translate this program into Java but keep the logic exactly as in Pascal. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Generate an equivalent Python version of this Pascal code. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Preserve the algorithm and functionality while converting the code from Pascal to Python. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Translate this program into Go but keep the logic exactly as in Pascal. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Change the programming language of this snippet from Pascal to Go without modifying what it does. | program RandomNumberDevice;
var
byteFile: file of byte;
randomByte: byte;
begin
assign(byteFile, '/dev/urandom');
reset (byteFile);
read (byteFile, randomByte);
close (byteFile);
writeln('The random byte is: ', randomByte);
end.
| package main
import (
"crypto/rand"
"encoding/binary"
"fmt"
"io"
"os"
)
func main() {
testRandom("crypto/rand", rand.Reader)
testRandom("dev/random", newDevRandom())
}
func newDevRandom() (f *os.File) {
var err error
if f, err = os.Open("/dev/random"); err != nil {
panic(e... |
Please provide an equivalent version of this Perl code in C. | use Crypt::Random::Seed;
my $source = Crypt::Random::Seed->new( NonBlocking => 1 );
print "$_\n" for $source->random_values(10);
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Can you help me rewrite this code in C instead of Perl, keeping it the same logically? | use Crypt::Random::Seed;
my $source = Crypt::Random::Seed->new( NonBlocking => 1 );
print "$_\n" for $source->random_values(10);
| #include <stdio.h>
#include <stdlib.h>
#define RANDOM_PATH "/dev/urandom"
int main(void)
{
unsigned char buf[4];
unsigned long v;
FILE *fin;
if ((fin = fopen(RANDOM_PATH, "r")) == NULL) {
fprintf(stderr, "%s: unable to open file\n", RANDOM_PATH);
return... |
Convert this Perl block to C#, preserving its control flow and logic. | use Crypt::Random::Seed;
my $source = Crypt::Random::Seed->new( NonBlocking => 1 );
print "$_\n" for $source->random_values(10);
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Convert this Perl block to C#, preserving its control flow and logic. | use Crypt::Random::Seed;
my $source = Crypt::Random::Seed->new( NonBlocking => 1 );
print "$_\n" for $source->random_values(10);
| using System;
using System.Security.Cryptography;
private static int GetRandomInt()
{
int result = 0;
var rng = new RNGCryptoServiceProvider();
var buffer = new byte[4];
rng.GetBytes(buffer);
result = BitConverter.ToInt32(buffer, 0);
return result;
}
|
Maintain the same structure and functionality when rewriting this code in C++. | use Crypt::Random::Seed;
my $source = Crypt::Random::Seed->new( NonBlocking => 1 );
print "$_\n" for $source->random_values(10);
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Can you help me rewrite this code in C++ instead of Perl, keeping it the same logically? | use Crypt::Random::Seed;
my $source = Crypt::Random::Seed->new( NonBlocking => 1 );
print "$_\n" for $source->random_values(10);
| #include <iostream>
#include <random>
int main()
{
std::random_device rd;
std::uniform_int_distribution<long> dist;
std::cout << "Random Number: " << dist(rd) << std::endl;
}
|
Change the following Perl code into Java without altering its purpose. | use Crypt::Random::Seed;
my $source = Crypt::Random::Seed->new( NonBlocking => 1 );
print "$_\n" for $source->random_values(10);
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Write the same code in Java as shown below in Perl. | use Crypt::Random::Seed;
my $source = Crypt::Random::Seed->new( NonBlocking => 1 );
print "$_\n" for $source->random_values(10);
| import java.security.SecureRandom;
public class RandomExample {
public static void main(String[] args) {
SecureRandom rng = new SecureRandom();
System.out.println(rng.nextInt());
}
}
|
Change the programming language of this snippet from Perl to Python without modifying what it does. | use Crypt::Random::Seed;
my $source = Crypt::Random::Seed->new( NonBlocking => 1 );
print "$_\n" for $source->random_values(10);
| import random
rand = random.SystemRandom()
rand.randint(1,10)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.