Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Translate this program into C but keep the logic exactly as in Icon. | procedure main(arglist)
rounds := integer(arglist[1]) | 10000
doors := '123'
strategy1 := strategy2 := 0
every 1 to rounds do {
goats := doors -- ( car := ?doors )
guess1 := ?doors
show := goats -- guess1
if guess1 == car then strategy1 +:= 1
else strategy2 +:= 1
}
write("Monty Hall simulation... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Generate a C# translation of this Icon snippet without changing its computational steps. | procedure main(arglist)
rounds := integer(arglist[1]) | 10000
doors := '123'
strategy1 := strategy2 := 0
every 1 to rounds do {
goats := doors -- ( car := ?doors )
guess1 := ?doors
show := goats -- guess1
if guess1 == car then strategy1 +:= 1
else strategy2 +:= 1
}
write("Monty Hall simulation... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Write a version of this Icon function in C++ with identical behavior. | procedure main(arglist)
rounds := integer(arglist[1]) | 10000
doors := '123'
strategy1 := strategy2 := 0
every 1 to rounds do {
goats := doors -- ( car := ?doors )
guess1 := ?doors
show := goats -- guess1
if guess1 == car then strategy1 +:= 1
else strategy2 +:= 1
}
write("Monty Hall simulation... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Preserve the algorithm and functionality while converting the code from Icon to Java. | procedure main(arglist)
rounds := integer(arglist[1]) | 10000
doors := '123'
strategy1 := strategy2 := 0
every 1 to rounds do {
goats := doors -- ( car := ?doors )
guess1 := ?doors
show := goats -- guess1
if guess1 == car then strategy1 +:= 1
else strategy2 +:= 1
}
write("Monty Hall simulation... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Keep all operations the same but rewrite the snippet in Python. | procedure main(arglist)
rounds := integer(arglist[1]) | 10000
doors := '123'
strategy1 := strategy2 := 0
every 1 to rounds do {
goats := doors -- ( car := ?doors )
guess1 := ?doors
show := goats -- guess1
if guess1 == car then strategy1 +:= 1
else strategy2 +:= 1
}
write("Monty Hall simulation... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Produce a functionally identical Go code for the snippet given in Icon. | procedure main(arglist)
rounds := integer(arglist[1]) | 10000
doors := '123'
strategy1 := strategy2 := 0
every 1 to rounds do {
goats := doors -- ( car := ?doors )
guess1 := ?doors
show := goats -- guess1
if guess1 == car then strategy1 +:= 1
else strategy2 +:= 1
}
write("Monty Hall simulation... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Port the provided J code into C while preserving the original functionality. | pick=: {~ ?@#
|
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Change the following J code into C# without altering its purpose. | pick=: {~ ?@#
| using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Ensure the translated C++ code behaves exactly like the original J snippet. | pick=: {~ ?@#
| #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Convert this J snippet to Java and keep its semantics consistent. | pick=: {~ ?@#
| import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Rewrite the snippet below in Python so it works the same as the original J code. | pick=: {~ ?@#
|
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Keep all operations the same but rewrite the snippet in Go. | pick=: {~ ?@#
| package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Write a version of this Julia function in C with identical behavior. | using Printf
function play_mh_literal{T<:Integer}(ncur::T=3, ncar::T=1)
ncar < ncur || throw(DomainError())
curtains = shuffle(collect(1:ncur))
cars = curtains[1:ncar]
goats = curtains[(ncar+1):end]
pick = rand(1:ncur)
isstickwin = pick in cars
deleteat!(curtains, findin(curtains, pick))
... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Convert this Julia block to C#, preserving its control flow and logic. | using Printf
function play_mh_literal{T<:Integer}(ncur::T=3, ncar::T=1)
ncar < ncur || throw(DomainError())
curtains = shuffle(collect(1:ncur))
cars = curtains[1:ncar]
goats = curtains[(ncar+1):end]
pick = rand(1:ncur)
isstickwin = pick in cars
deleteat!(curtains, findin(curtains, pick))
... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Translate the given Julia code snippet into C++ without altering its behavior. | using Printf
function play_mh_literal{T<:Integer}(ncur::T=3, ncar::T=1)
ncar < ncur || throw(DomainError())
curtains = shuffle(collect(1:ncur))
cars = curtains[1:ncar]
goats = curtains[(ncar+1):end]
pick = rand(1:ncur)
isstickwin = pick in cars
deleteat!(curtains, findin(curtains, pick))
... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Write the same code in Java as shown below in Julia. | using Printf
function play_mh_literal{T<:Integer}(ncur::T=3, ncar::T=1)
ncar < ncur || throw(DomainError())
curtains = shuffle(collect(1:ncur))
cars = curtains[1:ncar]
goats = curtains[(ncar+1):end]
pick = rand(1:ncur)
isstickwin = pick in cars
deleteat!(curtains, findin(curtains, pick))
... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Change the following Julia code into Python without altering its purpose. | using Printf
function play_mh_literal{T<:Integer}(ncur::T=3, ncar::T=1)
ncar < ncur || throw(DomainError())
curtains = shuffle(collect(1:ncur))
cars = curtains[1:ncar]
goats = curtains[(ncar+1):end]
pick = rand(1:ncur)
isstickwin = pick in cars
deleteat!(curtains, findin(curtains, pick))
... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Generate an equivalent Go version of this Julia code. | using Printf
function play_mh_literal{T<:Integer}(ncur::T=3, ncar::T=1)
ncar < ncur || throw(DomainError())
curtains = shuffle(collect(1:ncur))
cars = curtains[1:ncar]
goats = curtains[(ncar+1):end]
pick = rand(1:ncur)
isstickwin = pick in cars
deleteat!(curtains, findin(curtains, pick))
... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Change the programming language of this snippet from Lua to C without modifying what it does. | function playgame(player)
local car = math.random(3)
local pchoice = player.choice()
local function neither(a, b)
local el = math.random(3)
return (el ~= a and el ~= b) and el or neither(a, b)
end
local el = neither(car, pchoice)
if(player.switch) then pchoice = neither(pchoice, el) end
... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Can you help me rewrite this code in C# instead of Lua, keeping it the same logically? | function playgame(player)
local car = math.random(3)
local pchoice = player.choice()
local function neither(a, b)
local el = math.random(3)
return (el ~= a and el ~= b) and el or neither(a, b)
end
local el = neither(car, pchoice)
if(player.switch) then pchoice = neither(pchoice, el) end
... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Write a version of this Lua function in C++ with identical behavior. | function playgame(player)
local car = math.random(3)
local pchoice = player.choice()
local function neither(a, b)
local el = math.random(3)
return (el ~= a and el ~= b) and el or neither(a, b)
end
local el = neither(car, pchoice)
if(player.switch) then pchoice = neither(pchoice, el) end
... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Port the following code from Lua to Java with equivalent syntax and logic. | function playgame(player)
local car = math.random(3)
local pchoice = player.choice()
local function neither(a, b)
local el = math.random(3)
return (el ~= a and el ~= b) and el or neither(a, b)
end
local el = neither(car, pchoice)
if(player.switch) then pchoice = neither(pchoice, el) end
... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Change the programming language of this snippet from Lua to Python without modifying what it does. | function playgame(player)
local car = math.random(3)
local pchoice = player.choice()
local function neither(a, b)
local el = math.random(3)
return (el ~= a and el ~= b) and el or neither(a, b)
end
local el = neither(car, pchoice)
if(player.switch) then pchoice = neither(pchoice, el) end
... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Convert the following code from Lua to Go, ensuring the logic remains intact. | function playgame(player)
local car = math.random(3)
local pchoice = player.choice()
local function neither(a, b)
local el = math.random(3)
return (el ~= a and el ~= b) and el or neither(a, b)
end
local el = neither(car, pchoice)
if(player.switch) then pchoice = neither(pchoice, el) end
... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Port the provided Mathematica code into C while preserving the original functionality. | montyHall[nGames_] :=
Module[{r, winningDoors, firstChoices, nStayWins, nSwitchWins, s},
r := RandomInteger[{1, 3}, nGames];
winningDoors = r;
firstChoices = r;
nStayWins = Count[Transpose[{winningDoors, firstChoices}], {d_, d_}];
nSwitchWins = nGames - nStayWins;
... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Produce a functionally identical C# code for the snippet given in Mathematica. | montyHall[nGames_] :=
Module[{r, winningDoors, firstChoices, nStayWins, nSwitchWins, s},
r := RandomInteger[{1, 3}, nGames];
winningDoors = r;
firstChoices = r;
nStayWins = Count[Transpose[{winningDoors, firstChoices}], {d_, d_}];
nSwitchWins = nGames - nStayWins;
... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Translate the given Mathematica code snippet into C++ without altering its behavior. | montyHall[nGames_] :=
Module[{r, winningDoors, firstChoices, nStayWins, nSwitchWins, s},
r := RandomInteger[{1, 3}, nGames];
winningDoors = r;
firstChoices = r;
nStayWins = Count[Transpose[{winningDoors, firstChoices}], {d_, d_}];
nSwitchWins = nGames - nStayWins;
... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Rewrite this program in Java while keeping its functionality equivalent to the Mathematica version. | montyHall[nGames_] :=
Module[{r, winningDoors, firstChoices, nStayWins, nSwitchWins, s},
r := RandomInteger[{1, 3}, nGames];
winningDoors = r;
firstChoices = r;
nStayWins = Count[Transpose[{winningDoors, firstChoices}], {d_, d_}];
nSwitchWins = nGames - nStayWins;
... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Transform the following Mathematica implementation into Python, maintaining the same output and logic. | montyHall[nGames_] :=
Module[{r, winningDoors, firstChoices, nStayWins, nSwitchWins, s},
r := RandomInteger[{1, 3}, nGames];
winningDoors = r;
firstChoices = r;
nStayWins = Count[Transpose[{winningDoors, firstChoices}], {d_, d_}];
nSwitchWins = nGames - nStayWins;
... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Write the same code in Go as shown below in Mathematica. | montyHall[nGames_] :=
Module[{r, winningDoors, firstChoices, nStayWins, nSwitchWins, s},
r := RandomInteger[{1, 3}, nGames];
winningDoors = r;
firstChoices = r;
nStayWins = Count[Transpose[{winningDoors, firstChoices}], {d_, d_}];
nSwitchWins = nGames - nStayWins;
... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Convert this MATLAB snippet to C and keep its semantics consistent. | function montyHall(numDoors,numSimulations)
assert(numDoors > 2);
function num = randInt(n)
num = floor( n*rand()+1 );
end
switchedDoors = [0 0];
stayed = [0 0];
for i = (1:numSimulations)
availableDoors = (1:numDoors);
winningDoor = randInt(numDoo... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Rewrite this program in C# while keeping its functionality equivalent to the MATLAB version. | function montyHall(numDoors,numSimulations)
assert(numDoors > 2);
function num = randInt(n)
num = floor( n*rand()+1 );
end
switchedDoors = [0 0];
stayed = [0 0];
for i = (1:numSimulations)
availableDoors = (1:numDoors);
winningDoor = randInt(numDoo... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Translate the given MATLAB code snippet into C++ without altering its behavior. | function montyHall(numDoors,numSimulations)
assert(numDoors > 2);
function num = randInt(n)
num = floor( n*rand()+1 );
end
switchedDoors = [0 0];
stayed = [0 0];
for i = (1:numSimulations)
availableDoors = (1:numDoors);
winningDoor = randInt(numDoo... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Translate this program into Java but keep the logic exactly as in MATLAB. | function montyHall(numDoors,numSimulations)
assert(numDoors > 2);
function num = randInt(n)
num = floor( n*rand()+1 );
end
switchedDoors = [0 0];
stayed = [0 0];
for i = (1:numSimulations)
availableDoors = (1:numDoors);
winningDoor = randInt(numDoo... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Port the provided MATLAB code into Python while preserving the original functionality. | function montyHall(numDoors,numSimulations)
assert(numDoors > 2);
function num = randInt(n)
num = floor( n*rand()+1 );
end
switchedDoors = [0 0];
stayed = [0 0];
for i = (1:numSimulations)
availableDoors = (1:numDoors);
winningDoor = randInt(numDoo... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Translate the given MATLAB code snippet into Go without altering its behavior. | function montyHall(numDoors,numSimulations)
assert(numDoors > 2);
function num = randInt(n)
num = floor( n*rand()+1 );
end
switchedDoors = [0 0];
stayed = [0 0];
for i = (1:numSimulations)
availableDoors = (1:numDoors);
winningDoor = randInt(numDoo... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Port the following code from Nim to C with equivalent syntax and logic. | import random
randomize()
proc shuffle[T](x: var seq[T]) =
for i in countdown(x.high, 0):
let j = rand(i)
swap(x[i], x[j])
var
stay = 0
switch = 0
for i in 1..1000:
var lst = @[1,0,0]
shuffle(lst)
let ran = rand(2 )
let user = lst[ran]
del lst, ran
var huh = 0
... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Ensure the translated C# code behaves exactly like the original Nim snippet. | import random
randomize()
proc shuffle[T](x: var seq[T]) =
for i in countdown(x.high, 0):
let j = rand(i)
swap(x[i], x[j])
var
stay = 0
switch = 0
for i in 1..1000:
var lst = @[1,0,0]
shuffle(lst)
let ran = rand(2 )
let user = lst[ran]
del lst, ran
var huh = 0
... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Transform the following Nim implementation into C++, maintaining the same output and logic. | import random
randomize()
proc shuffle[T](x: var seq[T]) =
for i in countdown(x.high, 0):
let j = rand(i)
swap(x[i], x[j])
var
stay = 0
switch = 0
for i in 1..1000:
var lst = @[1,0,0]
shuffle(lst)
let ran = rand(2 )
let user = lst[ran]
del lst, ran
var huh = 0
... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Ensure the translated Java code behaves exactly like the original Nim snippet. | import random
randomize()
proc shuffle[T](x: var seq[T]) =
for i in countdown(x.high, 0):
let j = rand(i)
swap(x[i], x[j])
var
stay = 0
switch = 0
for i in 1..1000:
var lst = @[1,0,0]
shuffle(lst)
let ran = rand(2 )
let user = lst[ran]
del lst, ran
var huh = 0
... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Write a version of this Nim function in Python with identical behavior. | import random
randomize()
proc shuffle[T](x: var seq[T]) =
for i in countdown(x.high, 0):
let j = rand(i)
swap(x[i], x[j])
var
stay = 0
switch = 0
for i in 1..1000:
var lst = @[1,0,0]
shuffle(lst)
let ran = rand(2 )
let user = lst[ran]
del lst, ran
var huh = 0
... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Produce a language-to-language conversion: from Nim to Go, same semantics. | import random
randomize()
proc shuffle[T](x: var seq[T]) =
for i in countdown(x.high, 0):
let j = rand(i)
swap(x[i], x[j])
var
stay = 0
switch = 0
for i in 1..1000:
var lst = @[1,0,0]
shuffle(lst)
let ran = rand(2 )
let user = lst[ran]
del lst, ran
var huh = 0
... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Write a version of this OCaml function in C with identical behavior. | let trials = 10000
type door = Car | Goat
let play switch =
let n = Random.int 3 in
let d1 = [|Car; Goat; Goat|].(n) in
if not switch then d1
else match d1 with
Car -> Goat
| Goat -> Car
let cars n switch =
let total = ref 0 in
for i = 1 to n do
let prize = play switch in
if priz... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Convert this OCaml snippet to C# and keep its semantics consistent. | let trials = 10000
type door = Car | Goat
let play switch =
let n = Random.int 3 in
let d1 = [|Car; Goat; Goat|].(n) in
if not switch then d1
else match d1 with
Car -> Goat
| Goat -> Car
let cars n switch =
let total = ref 0 in
for i = 1 to n do
let prize = play switch in
if priz... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Transform the following OCaml implementation into C++, maintaining the same output and logic. | let trials = 10000
type door = Car | Goat
let play switch =
let n = Random.int 3 in
let d1 = [|Car; Goat; Goat|].(n) in
if not switch then d1
else match d1 with
Car -> Goat
| Goat -> Car
let cars n switch =
let total = ref 0 in
for i = 1 to n do
let prize = play switch in
if priz... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Preserve the algorithm and functionality while converting the code from OCaml to Java. | let trials = 10000
type door = Car | Goat
let play switch =
let n = Random.int 3 in
let d1 = [|Car; Goat; Goat|].(n) in
if not switch then d1
else match d1 with
Car -> Goat
| Goat -> Car
let cars n switch =
let total = ref 0 in
for i = 1 to n do
let prize = play switch in
if priz... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Maintain the same structure and functionality when rewriting this code in Python. | let trials = 10000
type door = Car | Goat
let play switch =
let n = Random.int 3 in
let d1 = [|Car; Goat; Goat|].(n) in
if not switch then d1
else match d1 with
Car -> Goat
| Goat -> Car
let cars n switch =
let total = ref 0 in
for i = 1 to n do
let prize = play switch in
if priz... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Write the same code in Go as shown below in OCaml. | let trials = 10000
type door = Car | Goat
let play switch =
let n = Random.int 3 in
let d1 = [|Car; Goat; Goat|].(n) in
if not switch then d1
else match d1 with
Car -> Goat
| Goat -> Car
let cars n switch =
let total = ref 0 in
for i = 1 to n do
let prize = play switch in
if priz... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Convert this Pascal block to C, preserving its control flow and logic. | program MontyHall;
uses
sysutils;
const
NumGames = 1000;
function PickDoor(): Integer;
begin
Exit(Trunc(Random * 3));
end;
var
i: Integer;
PrizeDoor: Integer;
ChosenDoor: Integer;
WinsChangingDoors: Integer = 0;
WinsNotChangingDoors: Integer = 0;
begin
Randomize;
for i := 0 to NumGames - 1 do
... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Convert this Pascal block to C#, preserving its control flow and logic. | program MontyHall;
uses
sysutils;
const
NumGames = 1000;
function PickDoor(): Integer;
begin
Exit(Trunc(Random * 3));
end;
var
i: Integer;
PrizeDoor: Integer;
ChosenDoor: Integer;
WinsChangingDoors: Integer = 0;
WinsNotChangingDoors: Integer = 0;
begin
Randomize;
for i := 0 to NumGames - 1 do
... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Convert the following code from Pascal to C++, ensuring the logic remains intact. | program MontyHall;
uses
sysutils;
const
NumGames = 1000;
function PickDoor(): Integer;
begin
Exit(Trunc(Random * 3));
end;
var
i: Integer;
PrizeDoor: Integer;
ChosenDoor: Integer;
WinsChangingDoors: Integer = 0;
WinsNotChangingDoors: Integer = 0;
begin
Randomize;
for i := 0 to NumGames - 1 do
... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Change the programming language of this snippet from Pascal to Java without modifying what it does. | program MontyHall;
uses
sysutils;
const
NumGames = 1000;
function PickDoor(): Integer;
begin
Exit(Trunc(Random * 3));
end;
var
i: Integer;
PrizeDoor: Integer;
ChosenDoor: Integer;
WinsChangingDoors: Integer = 0;
WinsNotChangingDoors: Integer = 0;
begin
Randomize;
for i := 0 to NumGames - 1 do
... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Port the following code from Pascal to Go with equivalent syntax and logic. | program MontyHall;
uses
sysutils;
const
NumGames = 1000;
function PickDoor(): Integer;
begin
Exit(Trunc(Random * 3));
end;
var
i: Integer;
PrizeDoor: Integer;
ChosenDoor: Integer;
WinsChangingDoors: Integer = 0;
WinsNotChangingDoors: Integer = 0;
begin
Randomize;
for i := 0 to NumGames - 1 do
... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Change the programming language of this snippet from Perl to C without modifying what it does. |
use strict;
my $trials = 10000;
my $stay = 0;
my $switch = 0;
foreach (1 .. $trials)
{
my $prize = int(rand 3);
my $chosen = int(rand 3);
my $show;
do { $show = int(rand 3) } while $show == $chosen || $show == $prize;
$stay++ if $prize == $chosen;
$switch++ if $prize == 3 -... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Write the same code in C# as shown below in Perl. |
use strict;
my $trials = 10000;
my $stay = 0;
my $switch = 0;
foreach (1 .. $trials)
{
my $prize = int(rand 3);
my $chosen = int(rand 3);
my $show;
do { $show = int(rand 3) } while $show == $chosen || $show == $prize;
$stay++ if $prize == $chosen;
$switch++ if $prize == 3 -... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Generate an equivalent C++ version of this Perl code. |
use strict;
my $trials = 10000;
my $stay = 0;
my $switch = 0;
foreach (1 .. $trials)
{
my $prize = int(rand 3);
my $chosen = int(rand 3);
my $show;
do { $show = int(rand 3) } while $show == $chosen || $show == $prize;
$stay++ if $prize == $chosen;
$switch++ if $prize == 3 -... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Please provide an equivalent version of this Perl code in Java. |
use strict;
my $trials = 10000;
my $stay = 0;
my $switch = 0;
foreach (1 .. $trials)
{
my $prize = int(rand 3);
my $chosen = int(rand 3);
my $show;
do { $show = int(rand 3) } while $show == $chosen || $show == $prize;
$stay++ if $prize == $chosen;
$switch++ if $prize == 3 -... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Can you help me rewrite this code in Python instead of Perl, keeping it the same logically? |
use strict;
my $trials = 10000;
my $stay = 0;
my $switch = 0;
foreach (1 .. $trials)
{
my $prize = int(rand 3);
my $chosen = int(rand 3);
my $show;
do { $show = int(rand 3) } while $show == $chosen || $show == $prize;
$stay++ if $prize == $chosen;
$switch++ if $prize == 3 -... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Write the same code in Go as shown below in Perl. |
use strict;
my $trials = 10000;
my $stay = 0;
my $switch = 0;
foreach (1 .. $trials)
{
my $prize = int(rand 3);
my $chosen = int(rand 3);
my $show;
do { $show = int(rand 3) } while $show == $chosen || $show == $prize;
$stay++ if $prize == $chosen;
$switch++ if $prize == 3 -... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Please provide an equivalent version of this PowerShell code in C. |
$intIterations = 10000
$intKept = 0
$intSwitched = 0
Function Play-MontyHall()
{
$objRandom = New-Object -TypeName System.Random
$intWin = $objRandom.Next(1,4)
$intChoice = $objRandom.Next(1,4)
$intLose = $objRandom.Next(1,4)
While (($intLose ... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Produce a language-to-language conversion: from PowerShell to C#, same semantics. |
$intIterations = 10000
$intKept = 0
$intSwitched = 0
Function Play-MontyHall()
{
$objRandom = New-Object -TypeName System.Random
$intWin = $objRandom.Next(1,4)
$intChoice = $objRandom.Next(1,4)
$intLose = $objRandom.Next(1,4)
While (($intLose ... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Preserve the algorithm and functionality while converting the code from PowerShell to C++. |
$intIterations = 10000
$intKept = 0
$intSwitched = 0
Function Play-MontyHall()
{
$objRandom = New-Object -TypeName System.Random
$intWin = $objRandom.Next(1,4)
$intChoice = $objRandom.Next(1,4)
$intLose = $objRandom.Next(1,4)
While (($intLose ... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Change the following PowerShell code into Java without altering its purpose. |
$intIterations = 10000
$intKept = 0
$intSwitched = 0
Function Play-MontyHall()
{
$objRandom = New-Object -TypeName System.Random
$intWin = $objRandom.Next(1,4)
$intChoice = $objRandom.Next(1,4)
$intLose = $objRandom.Next(1,4)
While (($intLose ... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Generate a Python translation of this PowerShell snippet without changing its computational steps. |
$intIterations = 10000
$intKept = 0
$intSwitched = 0
Function Play-MontyHall()
{
$objRandom = New-Object -TypeName System.Random
$intWin = $objRandom.Next(1,4)
$intChoice = $objRandom.Next(1,4)
$intLose = $objRandom.Next(1,4)
While (($intLose ... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Produce a functionally identical Go code for the snippet given in PowerShell. |
$intIterations = 10000
$intKept = 0
$intSwitched = 0
Function Play-MontyHall()
{
$objRandom = New-Object -TypeName System.Random
$intWin = $objRandom.Next(1,4)
$intChoice = $objRandom.Next(1,4)
$intLose = $objRandom.Next(1,4)
While (($intLose ... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Ensure the translated C code behaves exactly like the original Racket snippet. | #lang racket
(define (get-last-door a b)
(vector-ref '#(- 2 1
2 - 0
1 0 -)
(+ a (* 3 b))))
(define (run-game strategy)
(define car-door (random 3))
(define first-choice (random 3))
(define revealed-goat
(if (= car-door first-choice)
(let ([r (random 2... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Rewrite the snippet below in C# so it works the same as the original Racket code. | #lang racket
(define (get-last-door a b)
(vector-ref '#(- 2 1
2 - 0
1 0 -)
(+ a (* 3 b))))
(define (run-game strategy)
(define car-door (random 3))
(define first-choice (random 3))
(define revealed-goat
(if (= car-door first-choice)
(let ([r (random 2... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Port the provided Racket code into C++ while preserving the original functionality. | #lang racket
(define (get-last-door a b)
(vector-ref '#(- 2 1
2 - 0
1 0 -)
(+ a (* 3 b))))
(define (run-game strategy)
(define car-door (random 3))
(define first-choice (random 3))
(define revealed-goat
(if (= car-door first-choice)
(let ([r (random 2... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Produce a language-to-language conversion: from Racket to Java, same semantics. | #lang racket
(define (get-last-door a b)
(vector-ref '#(- 2 1
2 - 0
1 0 -)
(+ a (* 3 b))))
(define (run-game strategy)
(define car-door (random 3))
(define first-choice (random 3))
(define revealed-goat
(if (= car-door first-choice)
(let ([r (random 2... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Convert this Racket snippet to Python and keep its semantics consistent. | #lang racket
(define (get-last-door a b)
(vector-ref '#(- 2 1
2 - 0
1 0 -)
(+ a (* 3 b))))
(define (run-game strategy)
(define car-door (random 3))
(define first-choice (random 3))
(define revealed-goat
(if (= car-door first-choice)
(let ([r (random 2... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Translate the given Racket code snippet into Go without altering its behavior. | #lang racket
(define (get-last-door a b)
(vector-ref '#(- 2 1
2 - 0
1 0 -)
(+ a (* 3 b))))
(define (run-game strategy)
(define car-door (random 3))
(define first-choice (random 3))
(define revealed-goat
(if (= car-door first-choice)
(let ([r (random 2... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Preserve the algorithm and functionality while converting the code from COBOL to C. | IDENTIFICATION DIVISION.
PROGRAM-ID. monty-hall.
DATA DIVISION.
WORKING-STORAGE SECTION.
78 Num-Games VALUE 1000000.
01 One PIC 9 VALUE 1.
01 Three PIC 9 VALUE 3.
01 doors-area.
... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Keep all operations the same but rewrite the snippet in C#. | IDENTIFICATION DIVISION.
PROGRAM-ID. monty-hall.
DATA DIVISION.
WORKING-STORAGE SECTION.
78 Num-Games VALUE 1000000.
01 One PIC 9 VALUE 1.
01 Three PIC 9 VALUE 3.
01 doors-area.
... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Generate an equivalent C++ version of this COBOL code. | IDENTIFICATION DIVISION.
PROGRAM-ID. monty-hall.
DATA DIVISION.
WORKING-STORAGE SECTION.
78 Num-Games VALUE 1000000.
01 One PIC 9 VALUE 1.
01 Three PIC 9 VALUE 3.
01 doors-area.
... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Convert this COBOL block to Java, preserving its control flow and logic. | IDENTIFICATION DIVISION.
PROGRAM-ID. monty-hall.
DATA DIVISION.
WORKING-STORAGE SECTION.
78 Num-Games VALUE 1000000.
01 One PIC 9 VALUE 1.
01 Three PIC 9 VALUE 3.
01 doors-area.
... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Rewrite this program in Python while keeping its functionality equivalent to the COBOL version. | IDENTIFICATION DIVISION.
PROGRAM-ID. monty-hall.
DATA DIVISION.
WORKING-STORAGE SECTION.
78 Num-Games VALUE 1000000.
01 One PIC 9 VALUE 1.
01 Three PIC 9 VALUE 3.
01 doors-area.
... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Rewrite the snippet below in Go so it works the same as the original COBOL code. | IDENTIFICATION DIVISION.
PROGRAM-ID. monty-hall.
DATA DIVISION.
WORKING-STORAGE SECTION.
78 Num-Games VALUE 1000000.
01 One PIC 9 VALUE 1.
01 Three PIC 9 VALUE 3.
01 doors-area.
... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Change the following REXX code into C without altering its purpose. |
* 30.08.2013 Walter Pachl translated from Java/REXX/PL/I
**********************************************************************/
options replace format comments java crossref savelog symbols nobinary
doors = create_doors
switchWins = 0
stayWins = 0
shown=0
Loop plays=1 To 1000000
doors=0
r=r3()
doors[r]=1
ch... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Convert the following code from REXX to C#, ensuring the logic remains intact. |
* 30.08.2013 Walter Pachl translated from Java/REXX/PL/I
**********************************************************************/
options replace format comments java crossref savelog symbols nobinary
doors = create_doors
switchWins = 0
stayWins = 0
shown=0
Loop plays=1 To 1000000
doors=0
r=r3()
doors[r]=1
ch... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Translate the given REXX code snippet into C++ without altering its behavior. |
* 30.08.2013 Walter Pachl translated from Java/REXX/PL/I
**********************************************************************/
options replace format comments java crossref savelog symbols nobinary
doors = create_doors
switchWins = 0
stayWins = 0
shown=0
Loop plays=1 To 1000000
doors=0
r=r3()
doors[r]=1
ch... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Ensure the translated Java code behaves exactly like the original REXX snippet. |
* 30.08.2013 Walter Pachl translated from Java/REXX/PL/I
**********************************************************************/
options replace format comments java crossref savelog symbols nobinary
doors = create_doors
switchWins = 0
stayWins = 0
shown=0
Loop plays=1 To 1000000
doors=0
r=r3()
doors[r]=1
ch... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Write the same code in Python as shown below in REXX. |
* 30.08.2013 Walter Pachl translated from Java/REXX/PL/I
**********************************************************************/
options replace format comments java crossref savelog symbols nobinary
doors = create_doors
switchWins = 0
stayWins = 0
shown=0
Loop plays=1 To 1000000
doors=0
r=r3()
doors[r]=1
ch... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Convert the following code from REXX to Go, ensuring the logic remains intact. |
* 30.08.2013 Walter Pachl translated from Java/REXX/PL/I
**********************************************************************/
options replace format comments java crossref savelog symbols nobinary
doors = create_doors
switchWins = 0
stayWins = 0
shown=0
Loop plays=1 To 1000000
doors=0
r=r3()
doors[r]=1
ch... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Rewrite this program in C while keeping its functionality equivalent to the Ruby version. | n = 10_000
stay = switch = 0
n.times do
doors = [ :goat, :goat, :car ].shuffle
guess = rand(3)
begin shown = rand(3) end while shown == guess || doors[shown] == :car
if doors[guess] == :car
stay += 1
else
switch += 1
end... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Produce a functionally identical C# code for the snippet given in Ruby. | n = 10_000
stay = switch = 0
n.times do
doors = [ :goat, :goat, :car ].shuffle
guess = rand(3)
begin shown = rand(3) end while shown == guess || doors[shown] == :car
if doors[guess] == :car
stay += 1
else
switch += 1
end... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Can you help me rewrite this code in C++ instead of Ruby, keeping it the same logically? | n = 10_000
stay = switch = 0
n.times do
doors = [ :goat, :goat, :car ].shuffle
guess = rand(3)
begin shown = rand(3) end while shown == guess || doors[shown] == :car
if doors[guess] == :car
stay += 1
else
switch += 1
end... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Preserve the algorithm and functionality while converting the code from Ruby to Java. | n = 10_000
stay = switch = 0
n.times do
doors = [ :goat, :goat, :car ].shuffle
guess = rand(3)
begin shown = rand(3) end while shown == guess || doors[shown] == :car
if doors[guess] == :car
stay += 1
else
switch += 1
end... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Convert this Ruby block to Python, preserving its control flow and logic. | n = 10_000
stay = switch = 0
n.times do
doors = [ :goat, :goat, :car ].shuffle
guess = rand(3)
begin shown = rand(3) end while shown == guess || doors[shown] == :car
if doors[guess] == :car
stay += 1
else
switch += 1
end... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Ensure the translated Go code behaves exactly like the original Ruby snippet. | n = 10_000
stay = switch = 0
n.times do
doors = [ :goat, :goat, :car ].shuffle
guess = rand(3)
begin shown = rand(3) end while shown == guess || doors[shown] == :car
if doors[guess] == :car
stay += 1
else
switch += 1
end... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Please provide an equivalent version of this Scala code in C. |
import java.util.Random
fun montyHall(games: Int) {
var switchWins = 0
var stayWins = 0
val rnd = Random()
(1..games).forEach {
val doors = IntArray(3)
doors[rnd.nextInt(3)] = 1
val choice = rnd.nextInt(3)
var shown: Int
do {
shown... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Maintain the same structure and functionality when rewriting this code in C#. |
import java.util.Random
fun montyHall(games: Int) {
var switchWins = 0
var stayWins = 0
val rnd = Random()
(1..games).forEach {
val doors = IntArray(3)
doors[rnd.nextInt(3)] = 1
val choice = rnd.nextInt(3)
var shown: Int
do {
shown... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Translate this program into C++ but keep the logic exactly as in Scala. |
import java.util.Random
fun montyHall(games: Int) {
var switchWins = 0
var stayWins = 0
val rnd = Random()
(1..games).forEach {
val doors = IntArray(3)
doors[rnd.nextInt(3)] = 1
val choice = rnd.nextInt(3)
var shown: Int
do {
shown... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Translate this program into Java but keep the logic exactly as in Scala. |
import java.util.Random
fun montyHall(games: Int) {
var switchWins = 0
var stayWins = 0
val rnd = Random()
(1..games).forEach {
val doors = IntArray(3)
doors[rnd.nextInt(3)] = 1
val choice = rnd.nextInt(3)
var shown: Int
do {
shown... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Ensure the translated Python code behaves exactly like the original Scala snippet. |
import java.util.Random
fun montyHall(games: Int) {
var switchWins = 0
var stayWins = 0
val rnd = Random()
(1..games).forEach {
val doors = IntArray(3)
doors[rnd.nextInt(3)] = 1
val choice = rnd.nextInt(3)
var shown: Int
do {
shown... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Change the following Scala code into Go without altering its purpose. |
import java.util.Random
fun montyHall(games: Int) {
var switchWins = 0
var stayWins = 0
val rnd = Random()
(1..games).forEach {
val doors = IntArray(3)
doors[rnd.nextInt(3)] = 1
val choice = rnd.nextInt(3)
var shown: Int
do {
shown... | package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
games := 100000
r := rand.New(rand.NewSource(time.Now().UnixNano()))
var switcherWins, keeperWins, shown int
for i := 0; i < games; i++ {
doors := []int{0, 0, 0}
doors[r.Intn(3)] = 1
choice := r.Intn(3)
for shown = r.Intn(3); shown == ch... |
Change the programming language of this snippet from Swift to C without modifying what it does. | import Foundation
func montyHall(doors: Int = 3, guess: Int, switch: Bool) -> Bool {
guard doors > 2, guess > 0, guess <= doors else { fatalError() }
let winningDoor = Int.random(in: 1...doors)
return winningDoor == guess ? !`switch` : `switch`
}
var switchResults = [Bool]()
for _ in 0..<1_000 {
let guess ... |
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <math.h>
#define NumSim 1000000000
void main() {
unsigned long int i,stay=0;
int ChosenDoor,WinningDoor;
bool door[3]={0,0,0};
srand(time(NULL));
for(i=0;i<=NumSim;i++){
WinningD... |
Change the programming language of this snippet from Swift to C# without modifying what it does. | import Foundation
func montyHall(doors: Int = 3, guess: Int, switch: Bool) -> Bool {
guard doors > 2, guess > 0, guess <= doors else { fatalError() }
let winningDoor = Int.random(in: 1...doors)
return winningDoor == guess ? !`switch` : `switch`
}
var switchResults = [Bool]()
for _ in 0..<1_000 {
let guess ... | using System;
class Program
{
static void Main(string[] args)
{
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0; plays < 1000000; plays++ )
{
int[] doors = {0,0,0};
var winner = gen.Next(3);
... |
Write a version of this Swift function in C++ with identical behavior. | import Foundation
func montyHall(doors: Int = 3, guess: Int, switch: Bool) -> Bool {
guard doors > 2, guess > 0, guess <= doors else { fatalError() }
let winningDoor = Int.random(in: 1...doors)
return winningDoor == guess ? !`switch` : `switch`
}
var switchResults = [Bool]()
for _ in 0..<1_000 {
let guess ... | #include <iostream>
#include <cstdlib>
#include <ctime>
int randint(int n)
{
return (1.0*n*std::rand())/(1.0+RAND_MAX);
}
int other(int doorA, int doorB)
{
int doorC;
if (doorA == doorB)
{
doorC = randint(2);
if (doorC >= doorA)
++doorC;
}
else
{
for (doorC = 0; doorC == doorA || door... |
Write a version of this Swift function in Java with identical behavior. | import Foundation
func montyHall(doors: Int = 3, guess: Int, switch: Bool) -> Bool {
guard doors > 2, guess > 0, guess <= doors else { fatalError() }
let winningDoor = Int.random(in: 1...doors)
return winningDoor == guess ? !`switch` : `switch`
}
var switchResults = [Bool]()
for _ in 0..<1_000 {
let guess ... | import java.util.Random;
public class Monty{
public static void main(String[] args){
int switchWins = 0;
int stayWins = 0;
Random gen = new Random();
for(int plays = 0;plays < 32768;plays++ ){
int[] doors = {0,0,0};
doors[gen.nextInt(3)] = 1;
int choice = gen.nextInt(3);
int shown;
do{
sho... |
Produce a language-to-language conversion: from Swift to Python, same semantics. | import Foundation
func montyHall(doors: Int = 3, guess: Int, switch: Bool) -> Bool {
guard doors > 2, guess > 0, guess <= doors else { fatalError() }
let winningDoor = Int.random(in: 1...doors)
return winningDoor == guess ? !`switch` : `switch`
}
var switchResults = [Bool]()
for _ in 0..<1_000 {
let guess ... |
from random import randrange
doors, iterations = 3,100000
def monty_hall(choice, switch=False, doorCount=doors):
door = [False]*doorCount
door[randrange(doorCount)] = True
chosen = door[choice]
unpicked = door
del unpicked[choice]
alternative = True in unpicked
if switch:
retur... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.