Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Port the provided Arturo code into C# while preserving the original functionality. | prin "Goodbye, World!"
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Keep all operations the same but rewrite the snippet in C++. | prin "Goodbye, World!"
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Translate this program into Java but keep the logic exactly as in Arturo. | prin "Goodbye, World!"
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Preserve the algorithm and functionality while converting the code from Arturo to VB. | prin "Goodbye, World!"
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Rewrite this program in C while keeping its functionality equivalent to the AWK version. | BEGIN { printf("Goodbye, World!") }
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Produce a functionally identical C# code for the snippet given in AWK. | BEGIN { printf("Goodbye, World!") }
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Port the following code from AWK to C++ with equivalent syntax and logic. | BEGIN { printf("Goodbye, World!") }
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Change the following AWK code into Java without altering its purpose. | BEGIN { printf("Goodbye, World!") }
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Ensure the translated VB code behaves exactly like the original AWK snippet. | BEGIN { printf("Goodbye, World!") }
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Preserve the algorithm and functionality while converting the code from AWK to Go. | BEGIN { printf("Goodbye, World!") }
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Generate a C translation of this BBC_Basic snippet without changing its computational steps. |
PRINT "Goodbye World!";
GW$ = "Goodbye World!"
FOR i% = 1 TO LEN(GW$)
VDU ASCMID$(GW$, i%)
NEXT
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Change the following BBC_Basic code into C# without altering its purpose. |
PRINT "Goodbye World!";
GW$ = "Goodbye World!"
FOR i% = 1 TO LEN(GW$)
VDU ASCMID$(GW$, i%)
NEXT
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Rewrite the snippet below in C++ so it works the same as the original BBC_Basic code. |
PRINT "Goodbye World!";
GW$ = "Goodbye World!"
FOR i% = 1 TO LEN(GW$)
VDU ASCMID$(GW$, i%)
NEXT
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Convert this BBC_Basic block to Java, preserving its control flow and logic. |
PRINT "Goodbye World!";
GW$ = "Goodbye World!"
FOR i% = 1 TO LEN(GW$)
VDU ASCMID$(GW$, i%)
NEXT
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Change the following BBC_Basic code into Python without altering its purpose. |
PRINT "Goodbye World!";
GW$ = "Goodbye World!"
FOR i% = 1 TO LEN(GW$)
VDU ASCMID$(GW$, i%)
NEXT
| import sys
sys.stdout.write("Goodbye, World!")
|
Ensure the translated VB code behaves exactly like the original BBC_Basic snippet. |
PRINT "Goodbye World!";
GW$ = "Goodbye World!"
FOR i% = 1 TO LEN(GW$)
VDU ASCMID$(GW$, i%)
NEXT
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Ensure the translated Go code behaves exactly like the original BBC_Basic snippet. |
PRINT "Goodbye World!";
GW$ = "Goodbye World!"
FOR i% = 1 TO LEN(GW$)
VDU ASCMID$(GW$, i%)
NEXT
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Translate the given Clojure code snippet into C without altering its behavior. | (print "Goodbye, World!")
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Convert this Clojure snippet to C# and keep its semantics consistent. | (print "Goodbye, World!")
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Change the programming language of this snippet from Clojure to C++ without modifying what it does. | (print "Goodbye, World!")
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Please provide an equivalent version of this Clojure code in Java. | (print "Goodbye, World!")
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Change the following Clojure code into VB without altering its purpose. | (print "Goodbye, World!")
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Maintain the same structure and functionality when rewriting this code in C. | (cw "Goodbye, World!")
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Convert this Common_Lisp snippet to C# and keep its semantics consistent. | (cw "Goodbye, World!")
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Ensure the translated C++ code behaves exactly like the original Common_Lisp snippet. | (cw "Goodbye, World!")
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Produce a language-to-language conversion: from Common_Lisp to Java, same semantics. | (cw "Goodbye, World!")
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Produce a language-to-language conversion: from Common_Lisp to VB, same semantics. | (cw "Goodbye, World!")
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Convert this Common_Lisp snippet to Go and keep its semantics consistent. | (cw "Goodbye, World!")
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Write the same algorithm in C as shown in this D implementation. | import std.stdio;
void main() {
write("Goodbye, World!");
}
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Translate the given D code snippet into C# without altering its behavior. | import std.stdio;
void main() {
write("Goodbye, World!");
}
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Convert this D snippet to C++ and keep its semantics consistent. | import std.stdio;
void main() {
write("Goodbye, World!");
}
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Translate the given D code snippet into Java without altering its behavior. | import std.stdio;
void main() {
write("Goodbye, World!");
}
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Produce a language-to-language conversion: from D to Python, same semantics. | import std.stdio;
void main() {
write("Goodbye, World!");
}
| import sys
sys.stdout.write("Goodbye, World!")
|
Ensure the translated VB code behaves exactly like the original D snippet. | import std.stdio;
void main() {
write("Goodbye, World!");
}
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Maintain the same structure and functionality when rewriting this code in Go. | import std.stdio;
void main() {
write("Goodbye, World!");
}
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Keep all operations the same but rewrite the snippet in C. | program Project1;
begin
Write('Goodbye, World!');
end.
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Change the programming language of this snippet from Delphi to C# without modifying what it does. | program Project1;
begin
Write('Goodbye, World!');
end.
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Port the provided Delphi code into C++ while preserving the original functionality. | program Project1;
begin
Write('Goodbye, World!');
end.
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Can you help me rewrite this code in Java instead of Delphi, keeping it the same logically? | program Project1;
begin
Write('Goodbye, World!');
end.
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Ensure the translated Python code behaves exactly like the original Delphi snippet. | program Project1;
begin
Write('Goodbye, World!');
end.
| import sys
sys.stdout.write("Goodbye, World!")
|
Convert this Delphi block to VB, preserving its control flow and logic. | program Project1;
begin
Write('Goodbye, World!');
end.
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Convert the following code from Delphi to Go, ensuring the logic remains intact. | program Project1;
begin
Write('Goodbye, World!');
end.
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Rewrite this program in C while keeping its functionality equivalent to the Elixir version. | IO.write "Goodbye, World!"
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Please provide an equivalent version of this Elixir code in C#. | IO.write "Goodbye, World!"
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Generate an equivalent C++ version of this Elixir code. | IO.write "Goodbye, World!"
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Change the following Elixir code into Java without altering its purpose. | IO.write "Goodbye, World!"
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Rewrite this program in VB while keeping its functionality equivalent to the Elixir version. | IO.write "Goodbye, World!"
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Translate this program into C but keep the logic exactly as in Erlang. | io:format("Goodbye, world!").
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Translate the given Erlang code snippet into C# without altering its behavior. | io:format("Goodbye, world!").
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Produce a functionally identical C++ code for the snippet given in Erlang. | io:format("Goodbye, world!").
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Rewrite the snippet below in Java so it works the same as the original Erlang code. | io:format("Goodbye, world!").
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Port the provided Erlang code into VB while preserving the original functionality. | io:format("Goodbye, world!").
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Port the provided Erlang code into Go while preserving the original functionality. | io:format("Goodbye, world!").
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Generate a C translation of this F# snippet without changing its computational steps. |
printf "Goodbye, World!";;
[<EntryPoint>]
let main args =
printf "Goodbye, World!"
0
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Rewrite the snippet below in C# so it works the same as the original F# code. |
printf "Goodbye, World!";;
[<EntryPoint>]
let main args =
printf "Goodbye, World!"
0
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Convert this F# snippet to C++ and keep its semantics consistent. |
printf "Goodbye, World!";;
[<EntryPoint>]
let main args =
printf "Goodbye, World!"
0
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Port the following code from F# to Java with equivalent syntax and logic. |
printf "Goodbye, World!";;
[<EntryPoint>]
let main args =
printf "Goodbye, World!"
0
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Preserve the algorithm and functionality while converting the code from F# to Python. |
printf "Goodbye, World!";;
[<EntryPoint>]
let main args =
printf "Goodbye, World!"
0
| import sys
sys.stdout.write("Goodbye, World!")
|
Port the provided F# code into VB while preserving the original functionality. |
printf "Goodbye, World!";;
[<EntryPoint>]
let main args =
printf "Goodbye, World!"
0
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Write the same code in Go as shown below in F#. |
printf "Goodbye, World!";;
[<EntryPoint>]
let main args =
printf "Goodbye, World!"
0
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Convert the following code from Factor to C, ensuring the logic remains intact. | USE: io
"Goodbye, World
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Ensure the translated C# code behaves exactly like the original Factor snippet. | USE: io
"Goodbye, World
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Maintain the same structure and functionality when rewriting this code in C++. | USE: io
"Goodbye, World
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Generate an equivalent Java version of this Factor code. | USE: io
"Goodbye, World
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Change the following Factor code into VB without altering its purpose. | USE: io
"Goodbye, World
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Change the programming language of this snippet from Forth to C without modifying what it does. |
." Goodbye, World!"
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Port the following code from Forth to C# with equivalent syntax and logic. |
." Goodbye, World!"
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Ensure the translated C++ code behaves exactly like the original Forth snippet. |
." Goodbye, World!"
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Translate the given Forth code snippet into Java without altering its behavior. |
." Goodbye, World!"
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Produce a functionally identical VB code for the snippet given in Forth. |
." Goodbye, World!"
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Produce a functionally identical C# code for the snippet given in Fortran. | program bye
write (*,'(a)',advance='no') 'Goodbye, World
end program bye
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Produce a language-to-language conversion: from Fortran to C++, same semantics. | program bye
write (*,'(a)',advance='no') 'Goodbye, World
end program bye
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Write a version of this Fortran function in C with identical behavior. | program bye
write (*,'(a)',advance='no') 'Goodbye, World
end program bye
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Preserve the algorithm and functionality while converting the code from Fortran to Go. | program bye
write (*,'(a)',advance='no') 'Goodbye, World
end program bye
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Translate the given Fortran code snippet into Java without altering its behavior. | program bye
write (*,'(a)',advance='no') 'Goodbye, World
end program bye
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Port the provided Fortran code into Python while preserving the original functionality. | program bye
write (*,'(a)',advance='no') 'Goodbye, World
end program bye
| import sys
sys.stdout.write("Goodbye, World!")
|
Port the provided Fortran code into VB while preserving the original functionality. | program bye
write (*,'(a)',advance='no') 'Goodbye, World
end program bye
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Write the same code in PHP as shown below in Fortran. | program bye
write (*,'(a)',advance='no') 'Goodbye, World
end program bye
| echo "Goodbye, World !";
|
Ensure the translated C code behaves exactly like the original Groovy snippet. | print "Goodbye, world"
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Convert this Groovy snippet to C# and keep its semantics consistent. | print "Goodbye, world"
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Write a version of this Groovy function in C++ with identical behavior. | print "Goodbye, world"
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Transform the following Groovy implementation into Java, maintaining the same output and logic. | print "Goodbye, world"
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Write the same code in VB as shown below in Groovy. | print "Goodbye, world"
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Write a version of this Haskell function in C with identical behavior. | main = putStr "Goodbye, world"
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Translate the given Haskell code snippet into C# without altering its behavior. | main = putStr "Goodbye, world"
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Maintain the same structure and functionality when rewriting this code in C++. | main = putStr "Goodbye, world"
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Keep all operations the same but rewrite the snippet in Java. | main = putStr "Goodbye, world"
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Produce a language-to-language conversion: from Haskell to VB, same semantics. | main = putStr "Goodbye, world"
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Port the following code from Haskell to Go with equivalent syntax and logic. | main = putStr "Goodbye, world"
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Generate a C translation of this Icon snippet without changing its computational steps. | procedure main()
writes("Goodbye, World!")
end
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Translate this program into C# but keep the logic exactly as in Icon. | procedure main()
writes("Goodbye, World!")
end
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Generate an equivalent C++ version of this Icon code. | procedure main()
writes("Goodbye, World!")
end
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Generate an equivalent Java version of this Icon code. | procedure main()
writes("Goodbye, World!")
end
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Change the following Icon code into VB without altering its purpose. | procedure main()
writes("Goodbye, World!")
end
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Maintain the same structure and functionality when rewriting this code in Go. | procedure main()
writes("Goodbye, World!")
end
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Ensure the translated C code behaves exactly like the original J snippet. | 'Goodbye, World!' 1!:3 <'/proc/self/fd/1'
Goodbye, World!
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Convert the following code from J to C#, ensuring the logic remains intact. | 'Goodbye, World!' 1!:3 <'/proc/self/fd/1'
Goodbye, World!
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Keep all operations the same but rewrite the snippet in C++. | 'Goodbye, World!' 1!:3 <'/proc/self/fd/1'
Goodbye, World!
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Port the following code from J to Java with equivalent syntax and logic. | 'Goodbye, World!' 1!:3 <'/proc/self/fd/1'
Goodbye, World!
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Generate a Python translation of this J snippet without changing its computational steps. | 'Goodbye, World!' 1!:3 <'/proc/self/fd/1'
Goodbye, World!
| import sys
sys.stdout.write("Goodbye, World!")
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.