Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Write the same code in VB as shown below in J. | 'Goodbye, World!' 1!:3 <'/proc/self/fd/1'
Goodbye, World!
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Can you help me rewrite this code in Go instead of J, keeping it the same logically? | 'Goodbye, World!' 1!:3 <'/proc/self/fd/1'
Goodbye, World!
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Generate an equivalent C version of this Julia code. | print("Goodbye, World!")
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Generate a C# translation of this Julia snippet without changing its computational steps. | print("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++. | print("Goodbye, World!")
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Keep all operations the same but rewrite the snippet in Java. | print("Goodbye, World!")
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Can you help me rewrite this code in VB instead of Julia, keeping it the same logically? | print("Goodbye, World!")
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Please provide an equivalent version of this Lua code in C. | io.write("Goodbye, World!")
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Generate a C# translation of this Lua snippet without changing its computational steps. | io.write("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 Lua snippet. | io.write("Goodbye, World!")
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Port the provided Lua code into Java while preserving the original functionality. | io.write("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 Lua. | io.write("Goodbye, World!")
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Translate the given Lua code snippet into Go without altering its behavior. | io.write("Goodbye, World!")
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Port the provided Mathematica code into C while preserving the original functionality. | NotebookWrite[EvaluationNotebook[], "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 Mathematica to C#, ensuring the logic remains intact. | NotebookWrite[EvaluationNotebook[], "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++. | NotebookWrite[EvaluationNotebook[], "Goodbye, World!"]
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Keep all operations the same but rewrite the snippet in Java. | NotebookWrite[EvaluationNotebook[], "Goodbye, World!"]
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Please provide an equivalent version of this Mathematica code in VB. | NotebookWrite[EvaluationNotebook[], "Goodbye, World!"]
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Rewrite the snippet below in Go so it works the same as the original Mathematica code. | NotebookWrite[EvaluationNotebook[], "Goodbye, World!"]
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Please provide an equivalent version of this MATLAB code in C. | fprintf('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 MATLAB. | fprintf('Goodbye, World!');
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Rewrite this program in C++ while keeping its functionality equivalent to the MATLAB version. | fprintf('Goodbye, World!');
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Ensure the translated Java code behaves exactly like the original MATLAB snippet. | fprintf('Goodbye, World!');
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Write the same code in C as shown below in Nim. | stdout.write "Goodbye, World!"
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Convert this Nim block to C#, preserving its control flow and logic. | stdout.write "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++. | stdout.write "Goodbye, World!"
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Write the same code in Java as shown below in Nim. | stdout.write "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 Nim. | stdout.write "Goodbye, World!"
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Rewrite the snippet below in C so it works the same as the original OCaml code. | print_string "Goodbye, World!"
| #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 OCaml code. | print_string "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 OCaml to C++ without modifying what it does. | print_string "Goodbye, World!"
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Please provide an equivalent version of this OCaml code in Java. | print_string "Goodbye, World!"
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Translate the given OCaml code snippet into VB without altering its behavior. | print_string "Goodbye, World!"
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Rewrite the snippet below in C so it works the same as the original Pascal code. | program NewLineOmission(output);
begin
write('Goodbye, World!');
end.
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Convert this Pascal snippet to C# and keep its semantics consistent. | program NewLineOmission(output);
begin
write('Goodbye, World!');
end.
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Please provide an equivalent version of this Pascal code in C++. | program NewLineOmission(output);
begin
write('Goodbye, World!');
end.
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Generate an equivalent Java version of this Pascal code. | program NewLineOmission(output);
begin
write('Goodbye, World!');
end.
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Produce a functionally identical Python code for the snippet given in Pascal. | program NewLineOmission(output);
begin
write('Goodbye, World!');
end.
| import sys
sys.stdout.write("Goodbye, World!")
|
Convert this Pascal block to VB, preserving its control flow and logic. | program NewLineOmission(output);
begin
write('Goodbye, World!');
end.
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Please provide an equivalent version of this Pascal code in Go. | program NewLineOmission(output);
begin
write('Goodbye, World!');
end.
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Convert this Perl block to C, preserving its control flow and logic. | print "Goodbye, World!";
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Generate an equivalent C# version of this Perl code. | print "Goodbye, World!";
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Port the provided Perl code into C++ while preserving the original functionality. | print "Goodbye, World!";
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Port the provided Perl code into Java while preserving the original functionality. | print "Goodbye, World!";
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Please provide an equivalent version of this Perl code in VB. | print "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 PowerShell. | Write-Host -NoNewLine "Goodbye, "
Write-Host -NoNewLine "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 PowerShell to C# with equivalent syntax and logic. | Write-Host -NoNewLine "Goodbye, "
Write-Host -NoNewLine "World!"
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Convert this PowerShell snippet to C++ and keep its semantics consistent. | Write-Host -NoNewLine "Goodbye, "
Write-Host -NoNewLine "World!"
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Write the same code in Java as shown below in PowerShell. | Write-Host -NoNewLine "Goodbye, "
Write-Host -NoNewLine "World!"
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Write the same code in Python as shown below in PowerShell. | Write-Host -NoNewLine "Goodbye, "
Write-Host -NoNewLine "World!"
| import sys
sys.stdout.write("Goodbye, World!")
|
Rewrite this program in VB while keeping its functionality equivalent to the PowerShell version. | Write-Host -NoNewLine "Goodbye, "
Write-Host -NoNewLine "World!"
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Change the following PowerShell code into Go without altering its purpose. | Write-Host -NoNewLine "Goodbye, "
Write-Host -NoNewLine "World!"
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Change the programming language of this snippet from R to C without modifying what it does. | cat("Goodbye, world!")
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Rewrite this program in C# while keeping its functionality equivalent to the R version. | cat("Goodbye, world!")
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Write a version of this R function in C++ with identical behavior. | cat("Goodbye, world!")
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Convert this R snippet to Java and keep its semantics consistent. | cat("Goodbye, world!")
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Produce a language-to-language conversion: from R to VB, same semantics. | cat("Goodbye, world!")
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Change the programming language of this snippet from Racket to C without modifying what it does. | #lang racket
(display "Goodbye, World!")
| #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 Racket to C#. | #lang racket
(display "Goodbye, World!")
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Transform the following Racket implementation into C++, maintaining the same output and logic. | #lang racket
(display "Goodbye, World!")
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Generate an equivalent Java version of this Racket code. | #lang racket
(display "Goodbye, World!")
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Transform the following Racket implementation into VB, maintaining the same output and logic. | #lang racket
(display "Goodbye, World!")
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Write the same code in Go as shown below in Racket. | #lang racket
(display "Goodbye, World!")
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Can you help me rewrite this code in C instead of COBOL, keeping it the same logically? | IDENTIFICATION DIVISION.
PROGRAM-ID. GOODBYE-WORLD.
PROCEDURE DIVISION.
DISPLAY 'Goodbye, World!'
WITH NO ADVANCING
END-DISPLAY
.
STOP RUN.
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Rewrite this program in C# while keeping its functionality equivalent to the COBOL version. | IDENTIFICATION DIVISION.
PROGRAM-ID. GOODBYE-WORLD.
PROCEDURE DIVISION.
DISPLAY 'Goodbye, World!'
WITH NO ADVANCING
END-DISPLAY
.
STOP RUN.
| 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++. | IDENTIFICATION DIVISION.
PROGRAM-ID. GOODBYE-WORLD.
PROCEDURE DIVISION.
DISPLAY 'Goodbye, World!'
WITH NO ADVANCING
END-DISPLAY
.
STOP RUN.
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Rewrite the snippet below in Java so it works the same as the original COBOL code. | IDENTIFICATION DIVISION.
PROGRAM-ID. GOODBYE-WORLD.
PROCEDURE DIVISION.
DISPLAY 'Goodbye, World!'
WITH NO ADVANCING
END-DISPLAY
.
STOP RUN.
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Produce a functionally identical Python code for the snippet given in COBOL. | IDENTIFICATION DIVISION.
PROGRAM-ID. GOODBYE-WORLD.
PROCEDURE DIVISION.
DISPLAY 'Goodbye, World!'
WITH NO ADVANCING
END-DISPLAY
.
STOP RUN.
| import sys
sys.stdout.write("Goodbye, World!")
|
Rewrite the snippet below in VB so it works the same as the original COBOL code. | IDENTIFICATION DIVISION.
PROGRAM-ID. GOODBYE-WORLD.
PROCEDURE DIVISION.
DISPLAY 'Goodbye, World!'
WITH NO ADVANCING
END-DISPLAY
.
STOP RUN.
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Generate a Go translation of this COBOL snippet without changing its computational steps. | IDENTIFICATION DIVISION.
PROGRAM-ID. GOODBYE-WORLD.
PROCEDURE DIVISION.
DISPLAY 'Goodbye, World!'
WITH NO ADVANCING
END-DISPLAY
.
STOP RUN.
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Keep all operations the same but rewrite the snippet in C. |
options replace format comments java crossref symbols binary
say '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 REXX to C# with equivalent syntax and logic. |
options replace format comments java crossref symbols binary
say '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++. |
options replace format comments java crossref symbols binary
say 'Goodbye, World!\-'
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Generate a Java translation of this REXX snippet without changing its computational steps. |
options replace format comments java crossref symbols binary
say 'Goodbye, World!\-'
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Port the provided REXX code into Python while preserving the original functionality. |
options replace format comments java crossref symbols binary
say 'Goodbye, World!\-'
| import sys
sys.stdout.write("Goodbye, World!")
|
Generate an equivalent VB version of this REXX code. |
options replace format comments java crossref symbols binary
say 'Goodbye, World!\-'
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Translate this program into Go but keep the logic exactly as in REXX. |
options replace format comments java crossref symbols binary
say 'Goodbye, World!\-'
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Can you help me rewrite this code in C instead of Ruby, keeping it the same logically? | print "Goodbye, World!"
| #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 Ruby to C# without modifying what it does. | print "Goodbye, World!"
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Translate this program into C++ but keep the logic exactly as in Ruby. | print "Goodbye, World!"
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Please provide an equivalent version of this Ruby code in Java. | print "Goodbye, World!"
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Produce a language-to-language conversion: from Ruby to VB, same semantics. | print "Goodbye, World!"
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Write the same algorithm in C as shown in this Scala implementation. | fun main(args: Array<String>) = print("Goodbye, World!")
| #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
(void) printf("Goodbye, World!");
return EXIT_SUCCESS;
}
|
Port the provided Scala code into C# while preserving the original functionality. | fun main(args: Array<String>) = print("Goodbye, World!")
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Write the same code in C++ as shown below in Scala. | fun main(args: Array<String>) = print("Goodbye, World!")
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Can you help me rewrite this code in Java instead of Scala, keeping it the same logically? | fun main(args: Array<String>) = print("Goodbye, World!")
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Translate the given Scala code snippet into VB without altering its behavior. | fun main(args: Array<String>) = 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 Go. | fun main(args: Array<String>) = print("Goodbye, World!")
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Write a version of this Swift function in C with identical behavior. | print("Goodbye, World!", terminator: "")
| #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 Swift. | print("Goodbye, World!", terminator: "")
| 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 Swift snippet. | print("Goodbye, World!", terminator: "")
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Write a version of this Swift function in Java with identical behavior. | print("Goodbye, World!", terminator: "")
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Convert this Swift snippet to VB and keep its semantics consistent. | print("Goodbye, World!", terminator: "")
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Generate a Go translation of this Swift snippet without changing its computational steps. | print("Goodbye, World!", terminator: "")
| package main
import "fmt"
func main() { fmt.Print("Goodbye, World!") }
|
Can you help me rewrite this code in C instead of Tcl, keeping it the same logically? | 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 Tcl code snippet into C# without altering its behavior. | write Goodbye, World!
| using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Goodbye, World!");
Console.Write("Goodbye, World!");
}
}
|
Generate a C++ translation of this Tcl snippet without changing its computational steps. | write Goodbye, World!
| #include <iostream>
int main() {
std::cout << "Goodbye, World!";
return 0;
}
|
Can you help me rewrite this code in Java instead of Tcl, keeping it the same logically? | write Goodbye, World!
| public class HelloWorld
{
public static void main(String[] args)
{
System.out.print("Goodbye, World!");
}
}
|
Rewrite the snippet below in VB so it works the same as the original Tcl code. | write Goodbye, World!
| Module Module1
Sub Main()
Console.Write("Goodbye, World!")
End Sub
End Module
|
Generate a PHP translation of this Ada snippet without changing its computational steps. | with Ada.Text_IO;
procedure Goodbye_World is
begin
Ada.Text_IO.Put("Goodbye, World!");
end Goodbye_World;
| echo "Goodbye, World !";
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.