Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Change the programming language of this snippet from Mathematica to C without modifying what it does. | listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]
| #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Generate an equivalent C# version of this Mathematica code. | listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]
| using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Write the same algorithm in C# as shown in this Mathematica implementation. | listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]
| using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Ensure the translated C++ code behaves exactly like the original Mathematica snippet. | listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]
| #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Convert this Mathematica snippet to C++ and keep its semantics consistent. | listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]
| #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Rewrite the snippet below in Java so it works the same as the original Mathematica code. | listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]
| import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Translate this program into Java but keep the logic exactly as in Mathematica. | listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]
| import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Transform the following Mathematica implementation into Python, maintaining the same output and logic. | listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]
| import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Write a version of this Mathematica function in Python with identical behavior. | listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]
| import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Rewrite the snippet below in Go so it works the same as the original Mathematica code. | listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]
| package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Rewrite the snippet below in Go so it works the same as the original Mathematica code. | listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]
| package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Change the following Nim code into C without altering its purpose. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Keep all operations the same but rewrite the snippet in C. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Port the provided Nim code into C# while preserving the original functionality. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Generate an equivalent C# version of this Nim code. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Produce a language-to-language conversion: from Nim to C++, same semantics. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Keep all operations the same but rewrite the snippet in C++. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Generate a Java translation of this Nim snippet without changing its computational steps. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Translate this program into Java but keep the logic exactly as in Nim. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Write a version of this Nim function in Python with identical behavior. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Ensure the translated Python code behaves exactly like the original Nim snippet. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Write the same code in Go as shown below in Nim. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Port the following code from Nim to Go with equivalent syntax and logic. | import strutils
let fr = "Goodbye London!"
let to = "Hello, New York!"
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)
| package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Please provide an equivalent version of this Pascal code in C. | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Rewrite this program in C while keeping its functionality equivalent to the Pascal version. | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Generate a C# translation of this Pascal snippet without changing its computational steps. | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Produce a functionally identical C# code for the snippet given in Pascal. | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Please provide an equivalent version of this Pascal code in C++. | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Can you help me rewrite this code in C++ instead of Pascal, keeping it the same logically? | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Write the same code in Java as shown below in Pascal. | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Rewrite this program in Java while keeping its functionality equivalent to the Pascal version. | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Change the following Pascal code into Python without altering its purpose. | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Produce a functionally identical Python code for the snippet given in Pascal. | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Convert the following code from Pascal to Go, ensuring the logic remains intact. | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Produce a language-to-language conversion: from Pascal to Go, same semantics. | Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist;
i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringli... | package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Translate the given PowerShell code snippet into C without altering its behavior. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Produce a functionally identical C code for the snippet given in PowerShell. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Change the programming language of this snippet from PowerShell to C# without modifying what it does. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Write a version of this PowerShell function in C# with identical behavior. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Preserve the algorithm and functionality while converting the code from PowerShell to C++. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Convert the following code from PowerShell to C++, ensuring the logic remains intact. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Transform the following PowerShell implementation into Java, maintaining the same output and logic. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Keep all operations the same but rewrite the snippet in Java. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Preserve the algorithm and functionality while converting the code from PowerShell to Python. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Preserve the algorithm and functionality while converting the code from PowerShell to Python. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Translate the given PowerShell code snippet into Go without altering its behavior. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Convert this PowerShell snippet to Go and keep its semantics consistent. | $listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
| package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Please provide an equivalent version of this Racket code in C. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Produce a functionally identical C code for the snippet given in Racket. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Write a version of this Racket function in C# with identical behavior. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Port the following code from Racket to C# with equivalent syntax and logic. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Convert this Racket snippet to C++ and keep its semantics consistent. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Change the following Racket code into C++ without altering its purpose. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Convert the following code from Racket to Java, ensuring the logic remains intact. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Generate a Java translation of this Racket snippet without changing its computational steps. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Please provide an equivalent version of this Racket code in Python. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Translate the given Racket code snippet into Python without altering its behavior. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Produce a language-to-language conversion: from Racket to Go, same semantics. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Port the provided Racket code into Go while preserving the original functionality. | #!/usr/bin/env racket
#lang racket
(define from-string #f)
(define to-string #f)
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (erro... | package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Can you help me rewrite this code in C instead of REXX, keeping it the same logically? |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Rewrite the snippet below in C so it works the same as the original REXX code. |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Rewrite the snippet below in C# so it works the same as the original REXX code. |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Rewrite the snippet below in C# so it works the same as the original REXX code. |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Translate the given REXX code snippet into C++ without altering its behavior. |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Can you help me rewrite this code in C++ instead of REXX, keeping it the same logically? |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Convert this REXX snippet to Java and keep its semantics consistent. |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Preserve the algorithm and functionality while converting the code from REXX to Java. |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Preserve the algorithm and functionality while converting the code from REXX to Python. |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Convert this REXX snippet to Python and keep its semantics consistent. |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Produce a language-to-language conversion: from REXX to Go, same semantics. |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Write the same code in Go as shown below in REXX. |
old= "Goodbye London!"
new= "Hello New York!"
parse arg fileList
#= words(fileList)
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ... | package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Preserve the algorithm and functionality while converting the code from Ruby to C. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Preserve the algorithm and functionality while converting the code from Ruby to C. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Translate this program into C# but keep the logic exactly as in Ruby. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Write a version of this Ruby function in C# with identical behavior. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Rewrite the snippet below in C++ so it works the same as the original Ruby code. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Rewrite the snippet below in C++ so it works the same as the original Ruby code. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Port the provided Ruby code into Java while preserving the original functionality. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Please provide an equivalent version of this Ruby code in Java. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Convert this Ruby snippet to Python and keep its semantics consistent. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Generate a Python translation of this Ruby snippet without changing its computational steps. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Produce a language-to-language conversion: from Ruby to Go, same semantics. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Generate a Go translation of this Ruby snippet without changing its computational steps. | var names = %w(
a.txt
b.txt
c.txt
)
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}
| package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Generate a C translation of this Scala snippet without changing its computational steps. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Produce a language-to-language conversion: from Scala to C, same semantics. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Translate the given Scala code snippet into C# without altering its behavior. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Port the following code from Scala to C# with equivalent syntax and logic. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Produce a functionally identical C++ code for the snippet given in Scala. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Generate an equivalent C++ version of this Scala code. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Write the same code in Java as shown below in Scala. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Write the same code in Java as shown below in Scala. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | import java.io.*;
import java.nio.file.*;
public class GloballyReplaceText {
public static void main(String[] args) throws IOException {
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye Lond... |
Write a version of this Scala function in Python with identical behavior. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Ensure the translated Python code behaves exactly like the original Scala snippet. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
|
Translate the given Scala code snippet into Go without altering its behavior. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Convert this Scala snippet to Go and keep its semantics consistent. |
import java.io.File
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(... | package main
import (
"bytes"
"io/ioutil"
"log"
"os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
fo... |
Generate a C translation of this Tcl snippet without changing its computational steps. | package require Tcl 8.5
package require fileutil
set from "Goodbye London!"
set to "Hello New York!"
set fileList [list a.txt b.txt c.txt]
set replacementCmd [list string map [list $from $to]]
foreach filename $fileList {
fileutil::updateInPlace $filename $replacementCmd
}
| #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Rewrite the snippet below in C so it works the same as the original Tcl code. | package require Tcl 8.5
package require fileutil
set from "Goodbye London!"
set to "Hello New York!"
set fileList [list a.txt b.txt c.txt]
set replacementCmd [list string map [list $from $to]]
foreach filename $fileList {
fileutil::updateInPlace $filename $replacementCmd
}
| #include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>
#include <string.h>
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
char *start = bu... |
Convert this Tcl block to C#, preserving its control flow and logic. | package require Tcl 8.5
package require fileutil
set from "Goodbye London!"
set to "Hello New York!"
set fileList [list a.txt b.txt c.txt]
set replacementCmd [list string map [list $from $to]]
foreach filename $fileList {
fileutil::updateInPlace $filename $replacementCmd
}
| using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Generate an equivalent C# version of this Tcl code. | package require Tcl 8.5
package require fileutil
set from "Goodbye London!"
set to "Hello New York!"
set fileList [list a.txt b.txt c.txt]
set replacementCmd [list string map [list $from $to]]
foreach filename $fileList {
fileutil::updateInPlace $filename $replacementCmd
}
| using System.Collections.Generic;
using System.IO;
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "... |
Can you help me rewrite this code in C++ instead of Tcl, keeping it the same logically? | package require Tcl 8.5
package require fileutil
set from "Goodbye London!"
set to "Hello New York!"
set fileList [list a.txt b.txt c.txt]
set replacementCmd [list string map [list $from $to]]
foreach filename $fileList {
fileutil::updateInPlace $filename $replacementCmd
}
| #include <fstream>
#include <iterator>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile (... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.