Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Preserve the algorithm and functionality while converting the code from Elixir to C#. | IO.puts :stderr, "Goodbye, World!"
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Keep all operations the same but rewrite the snippet in C++. | IO.puts :stderr, "Goodbye, World!"
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Produce a language-to-language conversion: from Elixir to Java, same semantics. | IO.puts :stderr, "Goodbye, World!"
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Convert this Erlang block to C, preserving its control flow and logic. | io:put_chars(standard_error, "Goodbye, World!\n").
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Keep all operations the same but rewrite the snippet in C#. | io:put_chars(standard_error, "Goodbye, World!\n").
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Write the same algorithm in C++ as shown in this Erlang implementation. | io:put_chars(standard_error, "Goodbye, World!\n").
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Preserve the algorithm and functionality while converting the code from Erlang to Java. | io:put_chars(standard_error, "Goodbye, World!\n").
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Keep all operations the same but rewrite the snippet in C. | eprintfn "%s" "Goodbye, World!"
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Preserve the algorithm and functionality while converting the code from F# to C#. | eprintfn "%s" "Goodbye, World!"
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Port the provided F# code into C++ while preserving the original functionality. | eprintfn "%s" "Goodbye, World!"
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Change the programming language of this snippet from F# to Java without modifying what it does. | eprintfn "%s" "Goodbye, World!"
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Translate this program into C but keep the logic exactly as in Factor. | error-stream get [ "Goodbye, World
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Change the following Factor code into C# without altering its purpose. | error-stream get [ "Goodbye, World
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Keep all operations the same but rewrite the snippet in C++. | error-stream get [ "Goodbye, World
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Convert this Factor block to Java, preserving its control flow and logic. | error-stream get [ "Goodbye, World
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Change the following Forth code into C without altering its purpose. | outfile-id
stderr to outfile-id
." Goodbye, World!" cr
to outfile-id
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Port the provided Forth code into C# while preserving the original functionality. | outfile-id
stderr to outfile-id
." Goodbye, World!" cr
to outfile-id
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Convert the following code from Forth to C++, ensuring the logic remains intact. | outfile-id
stderr to outfile-id
." Goodbye, World!" cr
to outfile-id
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Write the same algorithm in Java as shown in this Forth implementation. | outfile-id
stderr to outfile-id
." Goodbye, World!" cr
to outfile-id
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Rewrite this program in Python while keeping its functionality equivalent to the Forth version. | outfile-id
stderr to outfile-id
." Goodbye, World!" cr
to outfile-id
| import sys
print >> sys.stderr, "Goodbye, World!"
|
Rewrite this program in VB while keeping its functionality equivalent to the Forth version. | outfile-id
stderr to outfile-id
." Goodbye, World!" cr
to outfile-id
| Sub StandardError()
Debug.Print "Goodbye World!"
End Sub
|
Change the programming language of this snippet from Forth to Go without modifying what it does. | outfile-id
stderr to outfile-id
." Goodbye, World!" cr
to outfile-id
| package main
func main() { println("Goodbye, World!") }
|
Can you help me rewrite this code in C# instead of Fortran, keeping it the same logically? | program StdErr
use iso_fortran_env
write (ERROR_UNIT, *) "Goodbye, World
end program StdErr
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Generate a C++ translation of this Fortran snippet without changing its computational steps. | program StdErr
use iso_fortran_env
write (ERROR_UNIT, *) "Goodbye, World
end program StdErr
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Maintain the same structure and functionality when rewriting this code in C. | program StdErr
use iso_fortran_env
write (ERROR_UNIT, *) "Goodbye, World
end program StdErr
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Convert this Fortran snippet to Java and keep its semantics consistent. | program StdErr
use iso_fortran_env
write (ERROR_UNIT, *) "Goodbye, World
end program StdErr
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Maintain the same structure and functionality when rewriting this code in Python. | program StdErr
use iso_fortran_env
write (ERROR_UNIT, *) "Goodbye, World
end program StdErr
| import sys
print >> sys.stderr, "Goodbye, World!"
|
Write the same code in VB as shown below in Fortran. | program StdErr
use iso_fortran_env
write (ERROR_UNIT, *) "Goodbye, World
end program StdErr
| Sub StandardError()
Debug.Print "Goodbye World!"
End Sub
|
Preserve the algorithm and functionality while converting the code from Fortran to PHP. | program StdErr
use iso_fortran_env
write (ERROR_UNIT, *) "Goodbye, World
end program StdErr
| fprintf(STDERR, "Goodbye, World!\n");
|
Convert this Groovy block to C, preserving its control flow and logic. | System.err.println("Goodbye, World!")
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Convert this Groovy snippet to C# and keep its semantics consistent. | System.err.println("Goodbye, World!")
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Rewrite the snippet below in C++ so it works the same as the original Groovy code. | System.err.println("Goodbye, World!")
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Change the programming language of this snippet from Groovy to Java without modifying what it does. | System.err.println("Goodbye, World!")
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Write a version of this Haskell function in C with identical behavior. | import System.IO
main = hPutStrLn stderr "Goodbye, World!"
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Produce a language-to-language conversion: from Haskell to C++, same semantics. | import System.IO
main = hPutStrLn stderr "Goodbye, World!"
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Write a version of this Haskell function in Java with identical behavior. | import System.IO
main = hPutStrLn stderr "Goodbye, World!"
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Maintain the same structure and functionality when rewriting this code in C. | procedure main()
write(&errout, "Goodbye World" )
end
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Keep all operations the same but rewrite the snippet in C#. | procedure main()
write(&errout, "Goodbye World" )
end
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Change the programming language of this snippet from Icon to C++ without modifying what it does. | procedure main()
write(&errout, "Goodbye World" )
end
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Maintain the same structure and functionality when rewriting this code in Java. | procedure main()
write(&errout, "Goodbye World" )
end
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Produce a functionally identical Python code for the snippet given in Icon. | procedure main()
write(&errout, "Goodbye World" )
end
| import sys
print >> sys.stderr, "Goodbye, World!"
|
Transform the following Icon implementation into VB, maintaining the same output and logic. | procedure main()
write(&errout, "Goodbye World" )
end
| Sub StandardError()
Debug.Print "Goodbye World!"
End Sub
|
Produce a language-to-language conversion: from Icon to Go, same semantics. | procedure main()
write(&errout, "Goodbye World" )
end
| package main
func main() { println("Goodbye, World!") }
|
Write the same algorithm in C as shown in this J implementation. | stderr =: 1!:2&4
stderr 'Goodbye, World!'
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Write the same code in C# as shown below in J. | stderr =: 1!:2&4
stderr 'Goodbye, World!'
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Change the programming language of this snippet from J to C++ without modifying what it does. | stderr =: 1!:2&4
stderr 'Goodbye, World!'
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Keep all operations the same but rewrite the snippet in Java. | stderr =: 1!:2&4
stderr 'Goodbye, World!'
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Rewrite the snippet below in C so it works the same as the original Julia code. | println(STDERR, "Goodbye, World!")
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Please provide an equivalent version of this Julia code in C#. | println(STDERR, "Goodbye, World!")
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Generate an equivalent C++ version of this Julia code. | println(STDERR, "Goodbye, World!")
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Rewrite this program in Java while keeping its functionality equivalent to the Julia version. | println(STDERR, "Goodbye, World!")
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Convert the following code from Lua to C, ensuring the logic remains intact. | io.stderr:write("Goodbye, World!\n")
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Generate an equivalent C# version of this Lua code. | io.stderr:write("Goodbye, World!\n")
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Convert this Lua block to C++, preserving its control flow and logic. | io.stderr:write("Goodbye, World!\n")
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Please provide an equivalent version of this Lua code in Java. | io.stderr:write("Goodbye, World!\n")
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Maintain the same structure and functionality when rewriting this code in C. | Write[Streams["stderr"], "Goodbye, World!"]
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Generate an equivalent C# version of this Mathematica code. | Write[Streams["stderr"], "Goodbye, World!"]
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Please provide an equivalent version of this Mathematica code in C++. | Write[Streams["stderr"], "Goodbye, World!"]
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Preserve the algorithm and functionality while converting the code from Mathematica to Java. | Write[Streams["stderr"], "Goodbye, World!"]
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Port the following code from MATLAB to C with equivalent syntax and logic. | fprintf(2,'Goodbye, World!')
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Change the programming language of this snippet from MATLAB to C# without modifying what it does. | fprintf(2,'Goodbye, World!')
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Produce a language-to-language conversion: from MATLAB to C++, same semantics. | fprintf(2,'Goodbye, World!')
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Port the following code from MATLAB to Java with equivalent syntax and logic. | fprintf(2,'Goodbye, World!')
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Change the following Nim code into C without altering its purpose. | stderr.writeln "Hello World"
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Please provide an equivalent version of this Nim code in C#. | stderr.writeln "Hello World"
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Generate a C++ translation of this Nim snippet without changing its computational steps. | stderr.writeln "Hello World"
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Write a version of this Nim function in Java with identical behavior. | stderr.writeln "Hello World"
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Produce a language-to-language conversion: from OCaml to C, same semantics. | prerr_endline "Goodbye, World!";
Printf.eprintf "Goodbye, World!\n";
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Produce a functionally identical C# code for the snippet given in OCaml. | prerr_endline "Goodbye, World!";
Printf.eprintf "Goodbye, World!\n";
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Change the following OCaml code into C++ without altering its purpose. | prerr_endline "Goodbye, World!";
Printf.eprintf "Goodbye, World!\n";
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Can you help me rewrite this code in Java instead of OCaml, keeping it the same logically? | prerr_endline "Goodbye, World!";
Printf.eprintf "Goodbye, World!\n";
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Preserve the algorithm and functionality while converting the code from OCaml to Python. | prerr_endline "Goodbye, World!";
Printf.eprintf "Goodbye, World!\n";
| import sys
print >> sys.stderr, "Goodbye, World!"
|
Write the same code in VB as shown below in OCaml. | prerr_endline "Goodbye, World!";
Printf.eprintf "Goodbye, World!\n";
| Sub StandardError()
Debug.Print "Goodbye World!"
End Sub
|
Write the same algorithm in Go as shown in this OCaml implementation. | prerr_endline "Goodbye, World!";
Printf.eprintf "Goodbye, World!\n";
| package main
func main() { println("Goodbye, World!") }
|
Port the following code from Pascal to C with equivalent syntax and logic. | program byeworld;
begin
writeln(StdErr, 'Goodbye, World!');
end.
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Port the following code from Pascal to C# with equivalent syntax and logic. | program byeworld;
begin
writeln(StdErr, 'Goodbye, World!');
end.
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Translate the given Pascal code snippet into C++ without altering its behavior. | program byeworld;
begin
writeln(StdErr, 'Goodbye, World!');
end.
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Preserve the algorithm and functionality while converting the code from Pascal to Java. | program byeworld;
begin
writeln(StdErr, 'Goodbye, World!');
end.
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Produce a functionally identical Python code for the snippet given in Pascal. | program byeworld;
begin
writeln(StdErr, 'Goodbye, World!');
end.
| import sys
print >> sys.stderr, "Goodbye, World!"
|
Rewrite this program in VB while keeping its functionality equivalent to the Pascal version. | program byeworld;
begin
writeln(StdErr, 'Goodbye, World!');
end.
| Sub StandardError()
Debug.Print "Goodbye World!"
End Sub
|
Rewrite this program in Go while keeping its functionality equivalent to the Pascal version. | program byeworld;
begin
writeln(StdErr, 'Goodbye, World!');
end.
| package main
func main() { println("Goodbye, World!") }
|
Write the same code in C as shown below in Perl. | warn "Goodbye, World!\n";
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Maintain the same structure and functionality when rewriting this code in C#. | warn "Goodbye, World!\n";
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Rewrite the snippet below in C++ so it works the same as the original Perl code. | warn "Goodbye, World!\n";
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Generate a Java translation of this Perl snippet without changing its computational steps. | warn "Goodbye, World!\n";
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Change the following PowerShell code into C without altering its purpose. | Write-Error "Goodbye, World!"
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Translate this program into C# but keep the logic exactly as in PowerShell. | Write-Error "Goodbye, World!"
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Translate this program into C++ but keep the logic exactly as in PowerShell. | Write-Error "Goodbye, World!"
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Write the same algorithm in Java as shown in this PowerShell implementation. | Write-Error "Goodbye, World!"
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Write a version of this R function in C with identical behavior. | cat("Goodbye, World!", file=stderr())
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Port the following code from R to C# with equivalent syntax and logic. | cat("Goodbye, World!", file=stderr())
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Please provide an equivalent version of this R code in C++. | cat("Goodbye, World!", file=stderr())
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Change the programming language of this snippet from R to Java without modifying what it does. | cat("Goodbye, World!", file=stderr())
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Can you help me rewrite this code in C instead of Racket, keeping it the same logically? | (eprintf "Goodbye, World!\n")
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Produce a language-to-language conversion: from Racket to C#, same semantics. | (eprintf "Goodbye, World!\n")
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Preserve the algorithm and functionality while converting the code from Racket to C++. | (eprintf "Goodbye, World!\n")
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Keep all operations the same but rewrite the snippet in Java. | (eprintf "Goodbye, World!\n")
| public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}
|
Ensure the translated C code behaves exactly like the original COBOL snippet. | program-id. ehello.
procedure division.
display "Goodbye, world!" upon syserr.
stop run.
| #include <stdio.h>
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
return 0;
}
|
Convert this COBOL block to C#, preserving its control flow and logic. | program-id. ehello.
procedure division.
display "Goodbye, world!" upon syserr.
stop run.
| static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}
|
Port the following code from COBOL to C++ with equivalent syntax and logic. | program-id. ehello.
procedure division.
display "Goodbye, world!" upon syserr.
stop run.
| #include <iostream>
int main() {
std::cerr << "Goodbye, World!\n";
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.