Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Ensure the translated C code behaves exactly like the original Ruby snippet. | begin
check = STDIN.read_nonblock(1)
rescue IO::WaitReadable
check = false
end
puts check if check
| #include <stdio.h>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
void set_mode(int want_key)
{
static struct termios old, new;
if (!want_key) {
tcsetattr(STDIN_FILENO, TCSANOW, &old);
return;
}
tcgetattr(STDIN_FILENO, &old);
new = old;
new.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &new);
}
int get_key()
{
int c = 0;
struct timeval tv;
fd_set fs;
tv.tv_usec = tv.tv_sec = 0;
FD_ZERO(&fs);
FD_SET(STDIN_FILENO, &fs);
select(STDIN_FILENO + 1, &fs, 0, 0, &tv);
if (FD_ISSET(STDIN_FILENO, &fs)) {
c = getchar();
set_mode(0);
}
return c;
}
int main()
{
int c;
while(1) {
set_mode(1);
fflush(stdout);
while (!(c = get_key())) usleep(10000);
printf("key %d\n", c);
}
}
|
Rewrite this program in C# while keeping its functionality equivalent to the Ruby version. | begin
check = STDIN.read_nonblock(1)
rescue IO::WaitReadable
check = false
end
puts check if check
| string chr = string.Empty;
if(Console.KeyAvailable)
chr = Console.ReadKey().Key.ToString();
|
Generate a Java translation of this Ruby snippet without changing its computational steps. | begin
check = STDIN.read_nonblock(1)
rescue IO::WaitReadable
check = false
end
puts check if check
| import java.awt.event.*;
import javax.swing.*;
public class Test extends JFrame {
Test() {
addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
int keyCode = e.getKeyCode();
System.out.println(keyCode);
}
});
}
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {
Test f = new Test();
f.setFocusable(true);
f.setVisible(true);
});
}
}
|
Port the following code from Ruby to Python with equivalent syntax and logic. | begin
check = STDIN.read_nonblock(1)
rescue IO::WaitReadable
check = false
end
puts check if check
|
from __future__ import absolute_import, division, unicode_literals, print_function
import tty, termios
import sys
if sys.version_info.major < 3:
import thread as _thread
else:
import _thread
import time
try:
from msvcrt import getch
except ImportError:
def getch():
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
def keypress():
global char
char = getch()
def main():
global char
char = None
_thread.start_new_thread(keypress, ())
while True:
if char is not None:
try:
print("Key pressed is " + char.decode('utf-8'))
except UnicodeDecodeError:
print("character can not be decoded, sorry!")
char = None
_thread.start_new_thread(keypress, ())
if char == 'q' or char == '\x1b':
exit()
char = None
print("Program is running")
time.sleep(1)
if __name__ == "__main__":
main()
|
Convert this Ruby block to Go, preserving its control flow and logic. | begin
check = STDIN.read_nonblock(1)
rescue IO::WaitReadable
check = false
end
puts check if check
| package main
import (
"log"
"time"
gc "code.google.com/p/goncurses"
)
func main() {
s, err := gc.Init()
if err != nil {
log.Fatal("init:", err)
}
defer gc.End()
gc.Cursor(0)
s.Move(20, 0)
s.Print("Key check in ")
for i := 3; i >= 1; i-- {
s.MovePrint(20, 13, i)
s.Refresh()
time.Sleep(500 * time.Millisecond)
}
|
Change the following Scala code into C without altering its purpose. |
import java.awt.event.KeyAdapter
import java.awt.event.KeyEvent
import javax.swing.JFrame
import javax.swing.SwingUtilities
class Test : JFrame() {
init {
println("Press any key to see its code or 'enter' to quit\n")
addKeyListener(object : KeyAdapter() {
override fun keyPressed(e: KeyEvent) {
if (e.keyCode == KeyEvent.VK_ENTER) {
isVisible = false
dispose()
System.exit(0)
}
else
println(e.keyCode)
}
})
}
}
fun main(args: Array<String>) {
SwingUtilities.invokeLater {
val f = Test()
f.isFocusable = true
f.isVisible = true
}
}
| #include <stdio.h>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
void set_mode(int want_key)
{
static struct termios old, new;
if (!want_key) {
tcsetattr(STDIN_FILENO, TCSANOW, &old);
return;
}
tcgetattr(STDIN_FILENO, &old);
new = old;
new.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &new);
}
int get_key()
{
int c = 0;
struct timeval tv;
fd_set fs;
tv.tv_usec = tv.tv_sec = 0;
FD_ZERO(&fs);
FD_SET(STDIN_FILENO, &fs);
select(STDIN_FILENO + 1, &fs, 0, 0, &tv);
if (FD_ISSET(STDIN_FILENO, &fs)) {
c = getchar();
set_mode(0);
}
return c;
}
int main()
{
int c;
while(1) {
set_mode(1);
fflush(stdout);
while (!(c = get_key())) usleep(10000);
printf("key %d\n", c);
}
}
|
Produce a functionally identical C# code for the snippet given in Scala. |
import java.awt.event.KeyAdapter
import java.awt.event.KeyEvent
import javax.swing.JFrame
import javax.swing.SwingUtilities
class Test : JFrame() {
init {
println("Press any key to see its code or 'enter' to quit\n")
addKeyListener(object : KeyAdapter() {
override fun keyPressed(e: KeyEvent) {
if (e.keyCode == KeyEvent.VK_ENTER) {
isVisible = false
dispose()
System.exit(0)
}
else
println(e.keyCode)
}
})
}
}
fun main(args: Array<String>) {
SwingUtilities.invokeLater {
val f = Test()
f.isFocusable = true
f.isVisible = true
}
}
| string chr = string.Empty;
if(Console.KeyAvailable)
chr = Console.ReadKey().Key.ToString();
|
Write the same code in Java as shown below in Scala. |
import java.awt.event.KeyAdapter
import java.awt.event.KeyEvent
import javax.swing.JFrame
import javax.swing.SwingUtilities
class Test : JFrame() {
init {
println("Press any key to see its code or 'enter' to quit\n")
addKeyListener(object : KeyAdapter() {
override fun keyPressed(e: KeyEvent) {
if (e.keyCode == KeyEvent.VK_ENTER) {
isVisible = false
dispose()
System.exit(0)
}
else
println(e.keyCode)
}
})
}
}
fun main(args: Array<String>) {
SwingUtilities.invokeLater {
val f = Test()
f.isFocusable = true
f.isVisible = true
}
}
| import java.awt.event.*;
import javax.swing.*;
public class Test extends JFrame {
Test() {
addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
int keyCode = e.getKeyCode();
System.out.println(keyCode);
}
});
}
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {
Test f = new Test();
f.setFocusable(true);
f.setVisible(true);
});
}
}
|
Produce a functionally identical Python code for the snippet given in Scala. |
import java.awt.event.KeyAdapter
import java.awt.event.KeyEvent
import javax.swing.JFrame
import javax.swing.SwingUtilities
class Test : JFrame() {
init {
println("Press any key to see its code or 'enter' to quit\n")
addKeyListener(object : KeyAdapter() {
override fun keyPressed(e: KeyEvent) {
if (e.keyCode == KeyEvent.VK_ENTER) {
isVisible = false
dispose()
System.exit(0)
}
else
println(e.keyCode)
}
})
}
}
fun main(args: Array<String>) {
SwingUtilities.invokeLater {
val f = Test()
f.isFocusable = true
f.isVisible = true
}
}
|
from __future__ import absolute_import, division, unicode_literals, print_function
import tty, termios
import sys
if sys.version_info.major < 3:
import thread as _thread
else:
import _thread
import time
try:
from msvcrt import getch
except ImportError:
def getch():
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
def keypress():
global char
char = getch()
def main():
global char
char = None
_thread.start_new_thread(keypress, ())
while True:
if char is not None:
try:
print("Key pressed is " + char.decode('utf-8'))
except UnicodeDecodeError:
print("character can not be decoded, sorry!")
char = None
_thread.start_new_thread(keypress, ())
if char == 'q' or char == '\x1b':
exit()
char = None
print("Program is running")
time.sleep(1)
if __name__ == "__main__":
main()
|
Please provide an equivalent version of this Scala code in Go. |
import java.awt.event.KeyAdapter
import java.awt.event.KeyEvent
import javax.swing.JFrame
import javax.swing.SwingUtilities
class Test : JFrame() {
init {
println("Press any key to see its code or 'enter' to quit\n")
addKeyListener(object : KeyAdapter() {
override fun keyPressed(e: KeyEvent) {
if (e.keyCode == KeyEvent.VK_ENTER) {
isVisible = false
dispose()
System.exit(0)
}
else
println(e.keyCode)
}
})
}
}
fun main(args: Array<String>) {
SwingUtilities.invokeLater {
val f = Test()
f.isFocusable = true
f.isVisible = true
}
}
| package main
import (
"log"
"time"
gc "code.google.com/p/goncurses"
)
func main() {
s, err := gc.Init()
if err != nil {
log.Fatal("init:", err)
}
defer gc.End()
gc.Cursor(0)
s.Move(20, 0)
s.Print("Key check in ")
for i := 3; i >= 1; i-- {
s.MovePrint(20, 13, i)
s.Refresh()
time.Sleep(500 * time.Millisecond)
}
|
Translate the given Tcl code snippet into C without altering its behavior. | fconfigure stdin -blocking 0
set ch [read stdin 1]
fconfigure stdin -blocking 1
if {$ch eq ""} {
} else {
}
| #include <stdio.h>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
void set_mode(int want_key)
{
static struct termios old, new;
if (!want_key) {
tcsetattr(STDIN_FILENO, TCSANOW, &old);
return;
}
tcgetattr(STDIN_FILENO, &old);
new = old;
new.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &new);
}
int get_key()
{
int c = 0;
struct timeval tv;
fd_set fs;
tv.tv_usec = tv.tv_sec = 0;
FD_ZERO(&fs);
FD_SET(STDIN_FILENO, &fs);
select(STDIN_FILENO + 1, &fs, 0, 0, &tv);
if (FD_ISSET(STDIN_FILENO, &fs)) {
c = getchar();
set_mode(0);
}
return c;
}
int main()
{
int c;
while(1) {
set_mode(1);
fflush(stdout);
while (!(c = get_key())) usleep(10000);
printf("key %d\n", c);
}
}
|
Rewrite this program in C# while keeping its functionality equivalent to the Tcl version. | fconfigure stdin -blocking 0
set ch [read stdin 1]
fconfigure stdin -blocking 1
if {$ch eq ""} {
} else {
}
| string chr = string.Empty;
if(Console.KeyAvailable)
chr = Console.ReadKey().Key.ToString();
|
Ensure the translated Java code behaves exactly like the original Tcl snippet. | fconfigure stdin -blocking 0
set ch [read stdin 1]
fconfigure stdin -blocking 1
if {$ch eq ""} {
} else {
}
| import java.awt.event.*;
import javax.swing.*;
public class Test extends JFrame {
Test() {
addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
int keyCode = e.getKeyCode();
System.out.println(keyCode);
}
});
}
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {
Test f = new Test();
f.setFocusable(true);
f.setVisible(true);
});
}
}
|
Generate an equivalent Python version of this Tcl code. | fconfigure stdin -blocking 0
set ch [read stdin 1]
fconfigure stdin -blocking 1
if {$ch eq ""} {
} else {
}
|
from __future__ import absolute_import, division, unicode_literals, print_function
import tty, termios
import sys
if sys.version_info.major < 3:
import thread as _thread
else:
import _thread
import time
try:
from msvcrt import getch
except ImportError:
def getch():
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
def keypress():
global char
char = getch()
def main():
global char
char = None
_thread.start_new_thread(keypress, ())
while True:
if char is not None:
try:
print("Key pressed is " + char.decode('utf-8'))
except UnicodeDecodeError:
print("character can not be decoded, sorry!")
char = None
_thread.start_new_thread(keypress, ())
if char == 'q' or char == '\x1b':
exit()
char = None
print("Program is running")
time.sleep(1)
if __name__ == "__main__":
main()
|
Port the provided Tcl code into Go while preserving the original functionality. | fconfigure stdin -blocking 0
set ch [read stdin 1]
fconfigure stdin -blocking 1
if {$ch eq ""} {
} else {
}
| package main
import (
"log"
"time"
gc "code.google.com/p/goncurses"
)
func main() {
s, err := gc.Init()
if err != nil {
log.Fatal("init:", err)
}
defer gc.End()
gc.Cursor(0)
s.Move(20, 0)
s.Print("Key check in ")
for i := 3; i >= 1; i-- {
s.MovePrint(20, 13, i)
s.Refresh()
time.Sleep(500 * time.Millisecond)
}
|
Change the following Ada code into C# without altering its purpose. | with Ada.Text_IO; use Ada.Text_IO;
procedure FreeCell is
type State is mod 2**31;
type Deck is array (0..51) of String(1..2);
package Random is
procedure Init(Seed: State);
function Rand return State;
end Random;
package body Random is
S : State := State'First;
procedure Init(Seed: State) is begin S := Seed; end Init;
function Rand return State is begin
S := S * 214013 + 2531011; return S / 2**16;
end Rand;
end Random;
procedure Deal (num : State) is
thedeck : Deck; pick : State;
Chars : constant String := "A23456789TJQKCDHS";
begin
for i in thedeck'Range loop
thedeck(i):= Chars(i/4+1) & Chars(i mod 4 + 14);
end loop;
Random.Init(num);
for i in 0..51 loop
pick := Random.Rand mod State(52-i);
Put(thedeck(Natural(pick))&' ');
if (i+1) mod 8 = 0 then New_Line; end if;
thedeck(Natural(pick)) := thedeck(51-i);
end loop; New_Line;
end Deal;
begin
Deal(1);
New_Line;
Deal(617);
end FreeCell;
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Change the following Ada code into C without altering its purpose. | with Ada.Text_IO; use Ada.Text_IO;
procedure FreeCell is
type State is mod 2**31;
type Deck is array (0..51) of String(1..2);
package Random is
procedure Init(Seed: State);
function Rand return State;
end Random;
package body Random is
S : State := State'First;
procedure Init(Seed: State) is begin S := Seed; end Init;
function Rand return State is begin
S := S * 214013 + 2531011; return S / 2**16;
end Rand;
end Random;
procedure Deal (num : State) is
thedeck : Deck; pick : State;
Chars : constant String := "A23456789TJQKCDHS";
begin
for i in thedeck'Range loop
thedeck(i):= Chars(i/4+1) & Chars(i mod 4 + 14);
end loop;
Random.Init(num);
for i in 0..51 loop
pick := Random.Rand mod State(52-i);
Put(thedeck(Natural(pick))&' ');
if (i+1) mod 8 = 0 then New_Line; end if;
thedeck(Natural(pick)) := thedeck(51-i);
end loop; New_Line;
end Deal;
begin
Deal(1);
New_Line;
Deal(617);
end FreeCell;
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Generate a C++ translation of this Ada snippet without changing its computational steps. | with Ada.Text_IO; use Ada.Text_IO;
procedure FreeCell is
type State is mod 2**31;
type Deck is array (0..51) of String(1..2);
package Random is
procedure Init(Seed: State);
function Rand return State;
end Random;
package body Random is
S : State := State'First;
procedure Init(Seed: State) is begin S := Seed; end Init;
function Rand return State is begin
S := S * 214013 + 2531011; return S / 2**16;
end Rand;
end Random;
procedure Deal (num : State) is
thedeck : Deck; pick : State;
Chars : constant String := "A23456789TJQKCDHS";
begin
for i in thedeck'Range loop
thedeck(i):= Chars(i/4+1) & Chars(i mod 4 + 14);
end loop;
Random.Init(num);
for i in 0..51 loop
pick := Random.Rand mod State(52-i);
Put(thedeck(Natural(pick))&' ');
if (i+1) mod 8 = 0 then New_Line; end if;
thedeck(Natural(pick)) := thedeck(51-i);
end loop; New_Line;
end Deal;
begin
Deal(1);
New_Line;
Deal(617);
end FreeCell;
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Change the programming language of this snippet from Ada to Go without modifying what it does. | with Ada.Text_IO; use Ada.Text_IO;
procedure FreeCell is
type State is mod 2**31;
type Deck is array (0..51) of String(1..2);
package Random is
procedure Init(Seed: State);
function Rand return State;
end Random;
package body Random is
S : State := State'First;
procedure Init(Seed: State) is begin S := Seed; end Init;
function Rand return State is begin
S := S * 214013 + 2531011; return S / 2**16;
end Rand;
end Random;
procedure Deal (num : State) is
thedeck : Deck; pick : State;
Chars : constant String := "A23456789TJQKCDHS";
begin
for i in thedeck'Range loop
thedeck(i):= Chars(i/4+1) & Chars(i mod 4 + 14);
end loop;
Random.Init(num);
for i in 0..51 loop
pick := Random.Rand mod State(52-i);
Put(thedeck(Natural(pick))&' ');
if (i+1) mod 8 = 0 then New_Line; end if;
thedeck(Natural(pick)) := thedeck(51-i);
end loop; New_Line;
end Deal;
begin
Deal(1);
New_Line;
Deal(617);
end FreeCell;
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Change the following Ada code into Java without altering its purpose. | with Ada.Text_IO; use Ada.Text_IO;
procedure FreeCell is
type State is mod 2**31;
type Deck is array (0..51) of String(1..2);
package Random is
procedure Init(Seed: State);
function Rand return State;
end Random;
package body Random is
S : State := State'First;
procedure Init(Seed: State) is begin S := Seed; end Init;
function Rand return State is begin
S := S * 214013 + 2531011; return S / 2**16;
end Rand;
end Random;
procedure Deal (num : State) is
thedeck : Deck; pick : State;
Chars : constant String := "A23456789TJQKCDHS";
begin
for i in thedeck'Range loop
thedeck(i):= Chars(i/4+1) & Chars(i mod 4 + 14);
end loop;
Random.Init(num);
for i in 0..51 loop
pick := Random.Rand mod State(52-i);
Put(thedeck(Natural(pick))&' ');
if (i+1) mod 8 = 0 then New_Line; end if;
thedeck(Natural(pick)) := thedeck(51-i);
end loop; New_Line;
end Deal;
begin
Deal(1);
New_Line;
Deal(617);
end FreeCell;
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Generate an equivalent Python version of this Ada code. | with Ada.Text_IO; use Ada.Text_IO;
procedure FreeCell is
type State is mod 2**31;
type Deck is array (0..51) of String(1..2);
package Random is
procedure Init(Seed: State);
function Rand return State;
end Random;
package body Random is
S : State := State'First;
procedure Init(Seed: State) is begin S := Seed; end Init;
function Rand return State is begin
S := S * 214013 + 2531011; return S / 2**16;
end Rand;
end Random;
procedure Deal (num : State) is
thedeck : Deck; pick : State;
Chars : constant String := "A23456789TJQKCDHS";
begin
for i in thedeck'Range loop
thedeck(i):= Chars(i/4+1) & Chars(i mod 4 + 14);
end loop;
Random.Init(num);
for i in 0..51 loop
pick := Random.Rand mod State(52-i);
Put(thedeck(Natural(pick))&' ');
if (i+1) mod 8 = 0 then New_Line; end if;
thedeck(Natural(pick)) := thedeck(51-i);
end loop; New_Line;
end Deal;
begin
Deal(1);
New_Line;
Deal(617);
end FreeCell;
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Convert this AutoHotKey block to C, preserving its control flow and logic. | FreeCell(num){
cards := "A23456789TJQK", suits := "♣♦♥♠", card := [], Counter := 0
loop, parse, cards
{
ThisCard := A_LoopField
loop, parse, suits
Card[Counter++] := ThisCard . A_LoopField
}
loop, 52
{
a := MS(num)
num:=a[1]
MyCardNo := mod(a[2],53-A_Index)
MyCard := Card[MyCardNo]
Card[MyCardNo] := Card[52-A_Index]
Card.Remove(52-A_Index)
Res .= MyCard (Mod(A_Index,8)?" ":"`n")
}
return Res
}
MS(Seed) {
Seed := Mod(214013 * Seed + 2531011, 2147483648)
return, [Seed, Seed // 65536]
}
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Write the same algorithm in C# as shown in this AutoHotKey implementation. | FreeCell(num){
cards := "A23456789TJQK", suits := "♣♦♥♠", card := [], Counter := 0
loop, parse, cards
{
ThisCard := A_LoopField
loop, parse, suits
Card[Counter++] := ThisCard . A_LoopField
}
loop, 52
{
a := MS(num)
num:=a[1]
MyCardNo := mod(a[2],53-A_Index)
MyCard := Card[MyCardNo]
Card[MyCardNo] := Card[52-A_Index]
Card.Remove(52-A_Index)
Res .= MyCard (Mod(A_Index,8)?" ":"`n")
}
return Res
}
MS(Seed) {
Seed := Mod(214013 * Seed + 2531011, 2147483648)
return, [Seed, Seed // 65536]
}
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Port the provided AutoHotKey code into C++ while preserving the original functionality. | FreeCell(num){
cards := "A23456789TJQK", suits := "♣♦♥♠", card := [], Counter := 0
loop, parse, cards
{
ThisCard := A_LoopField
loop, parse, suits
Card[Counter++] := ThisCard . A_LoopField
}
loop, 52
{
a := MS(num)
num:=a[1]
MyCardNo := mod(a[2],53-A_Index)
MyCard := Card[MyCardNo]
Card[MyCardNo] := Card[52-A_Index]
Card.Remove(52-A_Index)
Res .= MyCard (Mod(A_Index,8)?" ":"`n")
}
return Res
}
MS(Seed) {
Seed := Mod(214013 * Seed + 2531011, 2147483648)
return, [Seed, Seed // 65536]
}
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Generate an equivalent Java version of this AutoHotKey code. | FreeCell(num){
cards := "A23456789TJQK", suits := "♣♦♥♠", card := [], Counter := 0
loop, parse, cards
{
ThisCard := A_LoopField
loop, parse, suits
Card[Counter++] := ThisCard . A_LoopField
}
loop, 52
{
a := MS(num)
num:=a[1]
MyCardNo := mod(a[2],53-A_Index)
MyCard := Card[MyCardNo]
Card[MyCardNo] := Card[52-A_Index]
Card.Remove(52-A_Index)
Res .= MyCard (Mod(A_Index,8)?" ":"`n")
}
return Res
}
MS(Seed) {
Seed := Mod(214013 * Seed + 2531011, 2147483648)
return, [Seed, Seed // 65536]
}
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Port the provided AutoHotKey code into Python while preserving the original functionality. | FreeCell(num){
cards := "A23456789TJQK", suits := "♣♦♥♠", card := [], Counter := 0
loop, parse, cards
{
ThisCard := A_LoopField
loop, parse, suits
Card[Counter++] := ThisCard . A_LoopField
}
loop, 52
{
a := MS(num)
num:=a[1]
MyCardNo := mod(a[2],53-A_Index)
MyCard := Card[MyCardNo]
Card[MyCardNo] := Card[52-A_Index]
Card.Remove(52-A_Index)
Res .= MyCard (Mod(A_Index,8)?" ":"`n")
}
return Res
}
MS(Seed) {
Seed := Mod(214013 * Seed + 2531011, 2147483648)
return, [Seed, Seed // 65536]
}
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Maintain the same structure and functionality when rewriting this code in Go. | FreeCell(num){
cards := "A23456789TJQK", suits := "♣♦♥♠", card := [], Counter := 0
loop, parse, cards
{
ThisCard := A_LoopField
loop, parse, suits
Card[Counter++] := ThisCard . A_LoopField
}
loop, 52
{
a := MS(num)
num:=a[1]
MyCardNo := mod(a[2],53-A_Index)
MyCard := Card[MyCardNo]
Card[MyCardNo] := Card[52-A_Index]
Card.Remove(52-A_Index)
Res .= MyCard (Mod(A_Index,8)?" ":"`n")
}
return Res
}
MS(Seed) {
Seed := Mod(214013 * Seed + 2531011, 2147483648)
return, [Seed, Seed // 65536]
}
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Maintain the same structure and functionality when rewriting this code in C. | *FLOAT 64
hand% = 617
SYS "LoadLibrary", "CARDS.DLL" TO cards%
IF cards% = 0 ERROR 100, "No CARDS library"
SYS "GetProcAddress", cards%, "cdtInit" TO cdtInit%
SYS "GetProcAddress", cards%, "cdtDraw" TO cdtDraw%
SYS cdtInit%, ^dx%, ^dy%
VDU 23,22,8*dx%;5*dy%;8,16,16,128
DIM card&(51)
FOR I% = 0 TO 51 : card&(I%) = I% : NEXT
dummy% = FNrng(hand%)
FOR I% = 51 TO 0 STEP -1
C% = FNrng(-1) MOD (I% + 1)
SWAP card&(C%), card&(I%)
NEXT
FOR I% = 0 TO 51
C% = card&(51 - I%)
X% = (I% MOD 8) * dx%
Y% = (I% DIV 8) * dy% * 2 / 3
SYS cdtDraw%, @memhdc%, X%, Y%, C%, 0, 0
NEXT
SYS "InvalidateRect", @hwnd%, 0, 0
*GSAVE freecell
END
DEF FNrng(seed)
PRIVATE state, M%
IF seed >= 0 THEN
state = seed
ELSE
state = (state * 214013 + 2531011)
FOR M% = 52 TO 31 STEP -1
IF state >= 2^M% state -= 2^M%
NEXT
ENDIF
= state >> 16
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Port the following code from BBC_Basic to C# with equivalent syntax and logic. | *FLOAT 64
hand% = 617
SYS "LoadLibrary", "CARDS.DLL" TO cards%
IF cards% = 0 ERROR 100, "No CARDS library"
SYS "GetProcAddress", cards%, "cdtInit" TO cdtInit%
SYS "GetProcAddress", cards%, "cdtDraw" TO cdtDraw%
SYS cdtInit%, ^dx%, ^dy%
VDU 23,22,8*dx%;5*dy%;8,16,16,128
DIM card&(51)
FOR I% = 0 TO 51 : card&(I%) = I% : NEXT
dummy% = FNrng(hand%)
FOR I% = 51 TO 0 STEP -1
C% = FNrng(-1) MOD (I% + 1)
SWAP card&(C%), card&(I%)
NEXT
FOR I% = 0 TO 51
C% = card&(51 - I%)
X% = (I% MOD 8) * dx%
Y% = (I% DIV 8) * dy% * 2 / 3
SYS cdtDraw%, @memhdc%, X%, Y%, C%, 0, 0
NEXT
SYS "InvalidateRect", @hwnd%, 0, 0
*GSAVE freecell
END
DEF FNrng(seed)
PRIVATE state, M%
IF seed >= 0 THEN
state = seed
ELSE
state = (state * 214013 + 2531011)
FOR M% = 52 TO 31 STEP -1
IF state >= 2^M% state -= 2^M%
NEXT
ENDIF
= state >> 16
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Generate an equivalent C++ version of this BBC_Basic code. | *FLOAT 64
hand% = 617
SYS "LoadLibrary", "CARDS.DLL" TO cards%
IF cards% = 0 ERROR 100, "No CARDS library"
SYS "GetProcAddress", cards%, "cdtInit" TO cdtInit%
SYS "GetProcAddress", cards%, "cdtDraw" TO cdtDraw%
SYS cdtInit%, ^dx%, ^dy%
VDU 23,22,8*dx%;5*dy%;8,16,16,128
DIM card&(51)
FOR I% = 0 TO 51 : card&(I%) = I% : NEXT
dummy% = FNrng(hand%)
FOR I% = 51 TO 0 STEP -1
C% = FNrng(-1) MOD (I% + 1)
SWAP card&(C%), card&(I%)
NEXT
FOR I% = 0 TO 51
C% = card&(51 - I%)
X% = (I% MOD 8) * dx%
Y% = (I% DIV 8) * dy% * 2 / 3
SYS cdtDraw%, @memhdc%, X%, Y%, C%, 0, 0
NEXT
SYS "InvalidateRect", @hwnd%, 0, 0
*GSAVE freecell
END
DEF FNrng(seed)
PRIVATE state, M%
IF seed >= 0 THEN
state = seed
ELSE
state = (state * 214013 + 2531011)
FOR M% = 52 TO 31 STEP -1
IF state >= 2^M% state -= 2^M%
NEXT
ENDIF
= state >> 16
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Change the following BBC_Basic code into Java without altering its purpose. | *FLOAT 64
hand% = 617
SYS "LoadLibrary", "CARDS.DLL" TO cards%
IF cards% = 0 ERROR 100, "No CARDS library"
SYS "GetProcAddress", cards%, "cdtInit" TO cdtInit%
SYS "GetProcAddress", cards%, "cdtDraw" TO cdtDraw%
SYS cdtInit%, ^dx%, ^dy%
VDU 23,22,8*dx%;5*dy%;8,16,16,128
DIM card&(51)
FOR I% = 0 TO 51 : card&(I%) = I% : NEXT
dummy% = FNrng(hand%)
FOR I% = 51 TO 0 STEP -1
C% = FNrng(-1) MOD (I% + 1)
SWAP card&(C%), card&(I%)
NEXT
FOR I% = 0 TO 51
C% = card&(51 - I%)
X% = (I% MOD 8) * dx%
Y% = (I% DIV 8) * dy% * 2 / 3
SYS cdtDraw%, @memhdc%, X%, Y%, C%, 0, 0
NEXT
SYS "InvalidateRect", @hwnd%, 0, 0
*GSAVE freecell
END
DEF FNrng(seed)
PRIVATE state, M%
IF seed >= 0 THEN
state = seed
ELSE
state = (state * 214013 + 2531011)
FOR M% = 52 TO 31 STEP -1
IF state >= 2^M% state -= 2^M%
NEXT
ENDIF
= state >> 16
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Write a version of this BBC_Basic function in Python with identical behavior. | *FLOAT 64
hand% = 617
SYS "LoadLibrary", "CARDS.DLL" TO cards%
IF cards% = 0 ERROR 100, "No CARDS library"
SYS "GetProcAddress", cards%, "cdtInit" TO cdtInit%
SYS "GetProcAddress", cards%, "cdtDraw" TO cdtDraw%
SYS cdtInit%, ^dx%, ^dy%
VDU 23,22,8*dx%;5*dy%;8,16,16,128
DIM card&(51)
FOR I% = 0 TO 51 : card&(I%) = I% : NEXT
dummy% = FNrng(hand%)
FOR I% = 51 TO 0 STEP -1
C% = FNrng(-1) MOD (I% + 1)
SWAP card&(C%), card&(I%)
NEXT
FOR I% = 0 TO 51
C% = card&(51 - I%)
X% = (I% MOD 8) * dx%
Y% = (I% DIV 8) * dy% * 2 / 3
SYS cdtDraw%, @memhdc%, X%, Y%, C%, 0, 0
NEXT
SYS "InvalidateRect", @hwnd%, 0, 0
*GSAVE freecell
END
DEF FNrng(seed)
PRIVATE state, M%
IF seed >= 0 THEN
state = seed
ELSE
state = (state * 214013 + 2531011)
FOR M% = 52 TO 31 STEP -1
IF state >= 2^M% state -= 2^M%
NEXT
ENDIF
= state >> 16
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Preserve the algorithm and functionality while converting the code from BBC_Basic to Go. | *FLOAT 64
hand% = 617
SYS "LoadLibrary", "CARDS.DLL" TO cards%
IF cards% = 0 ERROR 100, "No CARDS library"
SYS "GetProcAddress", cards%, "cdtInit" TO cdtInit%
SYS "GetProcAddress", cards%, "cdtDraw" TO cdtDraw%
SYS cdtInit%, ^dx%, ^dy%
VDU 23,22,8*dx%;5*dy%;8,16,16,128
DIM card&(51)
FOR I% = 0 TO 51 : card&(I%) = I% : NEXT
dummy% = FNrng(hand%)
FOR I% = 51 TO 0 STEP -1
C% = FNrng(-1) MOD (I% + 1)
SWAP card&(C%), card&(I%)
NEXT
FOR I% = 0 TO 51
C% = card&(51 - I%)
X% = (I% MOD 8) * dx%
Y% = (I% DIV 8) * dy% * 2 / 3
SYS cdtDraw%, @memhdc%, X%, Y%, C%, 0, 0
NEXT
SYS "InvalidateRect", @hwnd%, 0, 0
*GSAVE freecell
END
DEF FNrng(seed)
PRIVATE state, M%
IF seed >= 0 THEN
state = seed
ELSE
state = (state * 214013 + 2531011)
FOR M% = 52 TO 31 STEP -1
IF state >= 2^M% state -= 2^M%
NEXT
ENDIF
= state >> 16
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Convert the following code from Clojure to C, ensuring the logic remains intact. | (def deck (into [] (for [rank "A23456789TJQK" suit "CDHS"] (str rank suit))))
(defn lcg [seed]
(map #(bit-shift-right % 16)
(rest (iterate #(mod (+ (* % 214013) 2531011) (bit-shift-left 1 31)) seed))))
(defn gen [seed]
(map (fn [rnd rng] (into [] [(mod rnd rng) (dec rng)]))
(lcg seed) (range 52 0 -1)))
(defn xchg [v [src dst]] (assoc v dst (v src) src (v dst)))
(defn show [seed] (map #(println %) (partition 8 8 ""
(reverse (reduce xchg deck (gen seed))))))
(show 1)
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Produce a language-to-language conversion: from Clojure to C#, same semantics. | (def deck (into [] (for [rank "A23456789TJQK" suit "CDHS"] (str rank suit))))
(defn lcg [seed]
(map #(bit-shift-right % 16)
(rest (iterate #(mod (+ (* % 214013) 2531011) (bit-shift-left 1 31)) seed))))
(defn gen [seed]
(map (fn [rnd rng] (into [] [(mod rnd rng) (dec rng)]))
(lcg seed) (range 52 0 -1)))
(defn xchg [v [src dst]] (assoc v dst (v src) src (v dst)))
(defn show [seed] (map #(println %) (partition 8 8 ""
(reverse (reduce xchg deck (gen seed))))))
(show 1)
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Write a version of this Clojure function in C++ with identical behavior. | (def deck (into [] (for [rank "A23456789TJQK" suit "CDHS"] (str rank suit))))
(defn lcg [seed]
(map #(bit-shift-right % 16)
(rest (iterate #(mod (+ (* % 214013) 2531011) (bit-shift-left 1 31)) seed))))
(defn gen [seed]
(map (fn [rnd rng] (into [] [(mod rnd rng) (dec rng)]))
(lcg seed) (range 52 0 -1)))
(defn xchg [v [src dst]] (assoc v dst (v src) src (v dst)))
(defn show [seed] (map #(println %) (partition 8 8 ""
(reverse (reduce xchg deck (gen seed))))))
(show 1)
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Convert this Clojure block to Java, preserving its control flow and logic. | (def deck (into [] (for [rank "A23456789TJQK" suit "CDHS"] (str rank suit))))
(defn lcg [seed]
(map #(bit-shift-right % 16)
(rest (iterate #(mod (+ (* % 214013) 2531011) (bit-shift-left 1 31)) seed))))
(defn gen [seed]
(map (fn [rnd rng] (into [] [(mod rnd rng) (dec rng)]))
(lcg seed) (range 52 0 -1)))
(defn xchg [v [src dst]] (assoc v dst (v src) src (v dst)))
(defn show [seed] (map #(println %) (partition 8 8 ""
(reverse (reduce xchg deck (gen seed))))))
(show 1)
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Translate the given Clojure code snippet into Python without altering its behavior. | (def deck (into [] (for [rank "A23456789TJQK" suit "CDHS"] (str rank suit))))
(defn lcg [seed]
(map #(bit-shift-right % 16)
(rest (iterate #(mod (+ (* % 214013) 2531011) (bit-shift-left 1 31)) seed))))
(defn gen [seed]
(map (fn [rnd rng] (into [] [(mod rnd rng) (dec rng)]))
(lcg seed) (range 52 0 -1)))
(defn xchg [v [src dst]] (assoc v dst (v src) src (v dst)))
(defn show [seed] (map #(println %) (partition 8 8 ""
(reverse (reduce xchg deck (gen seed))))))
(show 1)
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Preserve the algorithm and functionality while converting the code from Clojure to Go. | (def deck (into [] (for [rank "A23456789TJQK" suit "CDHS"] (str rank suit))))
(defn lcg [seed]
(map #(bit-shift-right % 16)
(rest (iterate #(mod (+ (* % 214013) 2531011) (bit-shift-left 1 31)) seed))))
(defn gen [seed]
(map (fn [rnd rng] (into [] [(mod rnd rng) (dec rng)]))
(lcg seed) (range 52 0 -1)))
(defn xchg [v [src dst]] (assoc v dst (v src) src (v dst)))
(defn show [seed] (map #(println %) (partition 8 8 ""
(reverse (reduce xchg deck (gen seed))))))
(show 1)
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Can you help me rewrite this code in C instead of Common_Lisp, keeping it the same logically? | (defun make-rng (seed)
#'(lambda ()
(ash (setf seed (mod (+ (* 214013 seed) 2531011) (expt 2 31))) -16)))
(defun split (s) (map 'list #'string s))
(defun make-deck (seed)
(let ((hand (make-array 52 :fill-pointer 0))
(rng (make-rng seed)))
(dolist (d (split "A23456789TJQK"))
(dolist (s (split "♣♦♥♠"))
(vector-push (concatenate 'string d s) hand)))
(dotimes (i 52)
(rotatef (aref hand (- 51 i))
(aref hand (mod (funcall rng) (- 52 i)))))
(nreverse hand)))
(defun show-deck (seed)
(let ((hand (make-deck seed)))
(format t "~%Hand ~d~%" seed)
(dotimes (i 52)
(format t "~A " (aref hand i))
(if (= (mod i 8) 7) (write-line "")))))
(show-deck 1)
(show-deck 617)
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Produce a language-to-language conversion: from Common_Lisp to C#, same semantics. | (defun make-rng (seed)
#'(lambda ()
(ash (setf seed (mod (+ (* 214013 seed) 2531011) (expt 2 31))) -16)))
(defun split (s) (map 'list #'string s))
(defun make-deck (seed)
(let ((hand (make-array 52 :fill-pointer 0))
(rng (make-rng seed)))
(dolist (d (split "A23456789TJQK"))
(dolist (s (split "♣♦♥♠"))
(vector-push (concatenate 'string d s) hand)))
(dotimes (i 52)
(rotatef (aref hand (- 51 i))
(aref hand (mod (funcall rng) (- 52 i)))))
(nreverse hand)))
(defun show-deck (seed)
(let ((hand (make-deck seed)))
(format t "~%Hand ~d~%" seed)
(dotimes (i 52)
(format t "~A " (aref hand i))
(if (= (mod i 8) 7) (write-line "")))))
(show-deck 1)
(show-deck 617)
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Produce a language-to-language conversion: from Common_Lisp to C++, same semantics. | (defun make-rng (seed)
#'(lambda ()
(ash (setf seed (mod (+ (* 214013 seed) 2531011) (expt 2 31))) -16)))
(defun split (s) (map 'list #'string s))
(defun make-deck (seed)
(let ((hand (make-array 52 :fill-pointer 0))
(rng (make-rng seed)))
(dolist (d (split "A23456789TJQK"))
(dolist (s (split "♣♦♥♠"))
(vector-push (concatenate 'string d s) hand)))
(dotimes (i 52)
(rotatef (aref hand (- 51 i))
(aref hand (mod (funcall rng) (- 52 i)))))
(nreverse hand)))
(defun show-deck (seed)
(let ((hand (make-deck seed)))
(format t "~%Hand ~d~%" seed)
(dotimes (i 52)
(format t "~A " (aref hand i))
(if (= (mod i 8) 7) (write-line "")))))
(show-deck 1)
(show-deck 617)
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Translate this program into Java but keep the logic exactly as in Common_Lisp. | (defun make-rng (seed)
#'(lambda ()
(ash (setf seed (mod (+ (* 214013 seed) 2531011) (expt 2 31))) -16)))
(defun split (s) (map 'list #'string s))
(defun make-deck (seed)
(let ((hand (make-array 52 :fill-pointer 0))
(rng (make-rng seed)))
(dolist (d (split "A23456789TJQK"))
(dolist (s (split "♣♦♥♠"))
(vector-push (concatenate 'string d s) hand)))
(dotimes (i 52)
(rotatef (aref hand (- 51 i))
(aref hand (mod (funcall rng) (- 52 i)))))
(nreverse hand)))
(defun show-deck (seed)
(let ((hand (make-deck seed)))
(format t "~%Hand ~d~%" seed)
(dotimes (i 52)
(format t "~A " (aref hand i))
(if (= (mod i 8) 7) (write-line "")))))
(show-deck 1)
(show-deck 617)
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Change the following Common_Lisp code into Python without altering its purpose. | (defun make-rng (seed)
#'(lambda ()
(ash (setf seed (mod (+ (* 214013 seed) 2531011) (expt 2 31))) -16)))
(defun split (s) (map 'list #'string s))
(defun make-deck (seed)
(let ((hand (make-array 52 :fill-pointer 0))
(rng (make-rng seed)))
(dolist (d (split "A23456789TJQK"))
(dolist (s (split "♣♦♥♠"))
(vector-push (concatenate 'string d s) hand)))
(dotimes (i 52)
(rotatef (aref hand (- 51 i))
(aref hand (mod (funcall rng) (- 52 i)))))
(nreverse hand)))
(defun show-deck (seed)
(let ((hand (make-deck seed)))
(format t "~%Hand ~d~%" seed)
(dotimes (i 52)
(format t "~A " (aref hand i))
(if (= (mod i 8) 7) (write-line "")))))
(show-deck 1)
(show-deck 617)
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Preserve the algorithm and functionality while converting the code from Common_Lisp to Go. | (defun make-rng (seed)
#'(lambda ()
(ash (setf seed (mod (+ (* 214013 seed) 2531011) (expt 2 31))) -16)))
(defun split (s) (map 'list #'string s))
(defun make-deck (seed)
(let ((hand (make-array 52 :fill-pointer 0))
(rng (make-rng seed)))
(dolist (d (split "A23456789TJQK"))
(dolist (s (split "♣♦♥♠"))
(vector-push (concatenate 'string d s) hand)))
(dotimes (i 52)
(rotatef (aref hand (- 51 i))
(aref hand (mod (funcall rng) (- 52 i)))))
(nreverse hand)))
(defun show-deck (seed)
(let ((hand (make-deck seed)))
(format t "~%Hand ~d~%" seed)
(dotimes (i 52)
(format t "~A " (aref hand i))
(if (= (mod i 8) 7) (write-line "")))))
(show-deck 1)
(show-deck 617)
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Generate a C translation of this D snippet without changing its computational steps. | import std.stdio, std.conv, std.algorithm, std.range;
struct RandomGenerator {
uint seed = 1;
@property uint next() pure nothrow @safe @nogc {
seed = (seed * 214_013 + 2_531_011) & int.max;
return seed >> 16;
}
}
struct Deck {
int[52] cards;
void deal(in uint seed) pure nothrow @safe @nogc {
enum int nc = cards.length;
nc.iota.retro.copy(cards[]);
auto rnd = RandomGenerator(seed);
foreach (immutable i, ref c; cards)
c.swap(cards[(nc - 1) - rnd.next % (nc - i)]);
}
void show() const @safe {
writefln("%(%-( %s%)\n%)",
cards[]
.chunks(8)
.map!(row => row.map!(c => only("A23456789TJQK"[c / 4],
"CDHS"[c % 4]))));
}
}
void main(in string[] args) @safe {
immutable seed = (args.length == 2) ? args[1].to!uint : 11_982;
writeln("Hand ", seed);
Deck cards;
cards.deal(seed);
cards.show;
}
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Rewrite this program in C# while keeping its functionality equivalent to the D version. | import std.stdio, std.conv, std.algorithm, std.range;
struct RandomGenerator {
uint seed = 1;
@property uint next() pure nothrow @safe @nogc {
seed = (seed * 214_013 + 2_531_011) & int.max;
return seed >> 16;
}
}
struct Deck {
int[52] cards;
void deal(in uint seed) pure nothrow @safe @nogc {
enum int nc = cards.length;
nc.iota.retro.copy(cards[]);
auto rnd = RandomGenerator(seed);
foreach (immutable i, ref c; cards)
c.swap(cards[(nc - 1) - rnd.next % (nc - i)]);
}
void show() const @safe {
writefln("%(%-( %s%)\n%)",
cards[]
.chunks(8)
.map!(row => row.map!(c => only("A23456789TJQK"[c / 4],
"CDHS"[c % 4]))));
}
}
void main(in string[] args) @safe {
immutable seed = (args.length == 2) ? args[1].to!uint : 11_982;
writeln("Hand ", seed);
Deck cards;
cards.deal(seed);
cards.show;
}
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Write the same code in C++ as shown below in D. | import std.stdio, std.conv, std.algorithm, std.range;
struct RandomGenerator {
uint seed = 1;
@property uint next() pure nothrow @safe @nogc {
seed = (seed * 214_013 + 2_531_011) & int.max;
return seed >> 16;
}
}
struct Deck {
int[52] cards;
void deal(in uint seed) pure nothrow @safe @nogc {
enum int nc = cards.length;
nc.iota.retro.copy(cards[]);
auto rnd = RandomGenerator(seed);
foreach (immutable i, ref c; cards)
c.swap(cards[(nc - 1) - rnd.next % (nc - i)]);
}
void show() const @safe {
writefln("%(%-( %s%)\n%)",
cards[]
.chunks(8)
.map!(row => row.map!(c => only("A23456789TJQK"[c / 4],
"CDHS"[c % 4]))));
}
}
void main(in string[] args) @safe {
immutable seed = (args.length == 2) ? args[1].to!uint : 11_982;
writeln("Hand ", seed);
Deck cards;
cards.deal(seed);
cards.show;
}
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Transform the following D implementation into Java, maintaining the same output and logic. | import std.stdio, std.conv, std.algorithm, std.range;
struct RandomGenerator {
uint seed = 1;
@property uint next() pure nothrow @safe @nogc {
seed = (seed * 214_013 + 2_531_011) & int.max;
return seed >> 16;
}
}
struct Deck {
int[52] cards;
void deal(in uint seed) pure nothrow @safe @nogc {
enum int nc = cards.length;
nc.iota.retro.copy(cards[]);
auto rnd = RandomGenerator(seed);
foreach (immutable i, ref c; cards)
c.swap(cards[(nc - 1) - rnd.next % (nc - i)]);
}
void show() const @safe {
writefln("%(%-( %s%)\n%)",
cards[]
.chunks(8)
.map!(row => row.map!(c => only("A23456789TJQK"[c / 4],
"CDHS"[c % 4]))));
}
}
void main(in string[] args) @safe {
immutable seed = (args.length == 2) ? args[1].to!uint : 11_982;
writeln("Hand ", seed);
Deck cards;
cards.deal(seed);
cards.show;
}
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Maintain the same structure and functionality when rewriting this code in Python. | import std.stdio, std.conv, std.algorithm, std.range;
struct RandomGenerator {
uint seed = 1;
@property uint next() pure nothrow @safe @nogc {
seed = (seed * 214_013 + 2_531_011) & int.max;
return seed >> 16;
}
}
struct Deck {
int[52] cards;
void deal(in uint seed) pure nothrow @safe @nogc {
enum int nc = cards.length;
nc.iota.retro.copy(cards[]);
auto rnd = RandomGenerator(seed);
foreach (immutable i, ref c; cards)
c.swap(cards[(nc - 1) - rnd.next % (nc - i)]);
}
void show() const @safe {
writefln("%(%-( %s%)\n%)",
cards[]
.chunks(8)
.map!(row => row.map!(c => only("A23456789TJQK"[c / 4],
"CDHS"[c % 4]))));
}
}
void main(in string[] args) @safe {
immutable seed = (args.length == 2) ? args[1].to!uint : 11_982;
writeln("Hand ", seed);
Deck cards;
cards.deal(seed);
cards.show;
}
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Generate a Go translation of this D snippet without changing its computational steps. | import std.stdio, std.conv, std.algorithm, std.range;
struct RandomGenerator {
uint seed = 1;
@property uint next() pure nothrow @safe @nogc {
seed = (seed * 214_013 + 2_531_011) & int.max;
return seed >> 16;
}
}
struct Deck {
int[52] cards;
void deal(in uint seed) pure nothrow @safe @nogc {
enum int nc = cards.length;
nc.iota.retro.copy(cards[]);
auto rnd = RandomGenerator(seed);
foreach (immutable i, ref c; cards)
c.swap(cards[(nc - 1) - rnd.next % (nc - i)]);
}
void show() const @safe {
writefln("%(%-( %s%)\n%)",
cards[]
.chunks(8)
.map!(row => row.map!(c => only("A23456789TJQK"[c / 4],
"CDHS"[c % 4]))));
}
}
void main(in string[] args) @safe {
immutable seed = (args.length == 2) ? args[1].to!uint : 11_982;
writeln("Hand ", seed);
Deck cards;
cards.deal(seed);
cards.show;
}
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Convert this Delphi snippet to C and keep its semantics consistent. | program Deal_cards_for_FreeCell;
uses
System.SysUtils;
type
TRandom = record
Seed: Int64;
function Next: Integer;
end;
TCard = record
const
kSuits = '♣♦♥♠';
kValues = 'A23456789TJQK';
var
Value: Integer;
Suit: Integer;
procedure Create(rawvalue: Integer); overload;
procedure Create(value, suit: Integer); overload;
procedure Assign(other: TCard);
function ToString: string;
end;
TDeck = record
Cards: TArray<TCard>;
procedure Create(Seed: Integer);
function ToString: string;
end;
function TRandom.Next: Integer;
begin
Seed := ((Seed * 214013 + 2531011) and Integer.MaxValue);
Result := Seed shr 16;
end;
procedure TCard.Create(rawvalue: Integer);
begin
Create(rawvalue div 4, rawvalue mod 4);
end;
procedure TCard.Assign(other: TCard);
begin
Create(other.Value, other.Suit);
end;
procedure TCard.Create(value, suit: Integer);
begin
self.Value := value;
self.Suit := suit;
end;
function TCard.ToString: string;
begin
result := format('%s%s', [kValues[value + 1], kSuits[suit + 1]]);
end;
procedure TDeck.Create(Seed: Integer);
var
r: TRandom;
i, j: integer;
tmp: Tcard;
begin
r.Seed := Seed;
SetLength(Cards, 52);
for i := 0 to 51 do
Cards[i].Create(51 - i);
for i := 0 to 50 do
begin
j := 51 - (r.Next mod (52 - i));
tmp.Assign(Cards[i]);
Cards[i].Assign(Cards[j]);
Cards[j].Assign(tmp);
end;
end;
function TDeck.ToString: string;
var
i: Integer;
begin
Result := '';
for i := 0 to length(Cards) - 1 do
begin
Result := Result + Cards[i].ToString;
if i mod 8 = 7 then
Result := Result + #10
else
Result := Result + ' ';
end;
end;
var
Deck: TDeck;
begin
Deck.Create(1);
Writeln('Deck 1'#10, Deck.ToString, #10);
Deck.Create(617);
Writeln('Deck 617'#10, Deck.ToString);
readln;
end.
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Translate the given Delphi code snippet into C# without altering its behavior. | program Deal_cards_for_FreeCell;
uses
System.SysUtils;
type
TRandom = record
Seed: Int64;
function Next: Integer;
end;
TCard = record
const
kSuits = '♣♦♥♠';
kValues = 'A23456789TJQK';
var
Value: Integer;
Suit: Integer;
procedure Create(rawvalue: Integer); overload;
procedure Create(value, suit: Integer); overload;
procedure Assign(other: TCard);
function ToString: string;
end;
TDeck = record
Cards: TArray<TCard>;
procedure Create(Seed: Integer);
function ToString: string;
end;
function TRandom.Next: Integer;
begin
Seed := ((Seed * 214013 + 2531011) and Integer.MaxValue);
Result := Seed shr 16;
end;
procedure TCard.Create(rawvalue: Integer);
begin
Create(rawvalue div 4, rawvalue mod 4);
end;
procedure TCard.Assign(other: TCard);
begin
Create(other.Value, other.Suit);
end;
procedure TCard.Create(value, suit: Integer);
begin
self.Value := value;
self.Suit := suit;
end;
function TCard.ToString: string;
begin
result := format('%s%s', [kValues[value + 1], kSuits[suit + 1]]);
end;
procedure TDeck.Create(Seed: Integer);
var
r: TRandom;
i, j: integer;
tmp: Tcard;
begin
r.Seed := Seed;
SetLength(Cards, 52);
for i := 0 to 51 do
Cards[i].Create(51 - i);
for i := 0 to 50 do
begin
j := 51 - (r.Next mod (52 - i));
tmp.Assign(Cards[i]);
Cards[i].Assign(Cards[j]);
Cards[j].Assign(tmp);
end;
end;
function TDeck.ToString: string;
var
i: Integer;
begin
Result := '';
for i := 0 to length(Cards) - 1 do
begin
Result := Result + Cards[i].ToString;
if i mod 8 = 7 then
Result := Result + #10
else
Result := Result + ' ';
end;
end;
var
Deck: TDeck;
begin
Deck.Create(1);
Writeln('Deck 1'#10, Deck.ToString, #10);
Deck.Create(617);
Writeln('Deck 617'#10, Deck.ToString);
readln;
end.
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Can you help me rewrite this code in C++ instead of Delphi, keeping it the same logically? | program Deal_cards_for_FreeCell;
uses
System.SysUtils;
type
TRandom = record
Seed: Int64;
function Next: Integer;
end;
TCard = record
const
kSuits = '♣♦♥♠';
kValues = 'A23456789TJQK';
var
Value: Integer;
Suit: Integer;
procedure Create(rawvalue: Integer); overload;
procedure Create(value, suit: Integer); overload;
procedure Assign(other: TCard);
function ToString: string;
end;
TDeck = record
Cards: TArray<TCard>;
procedure Create(Seed: Integer);
function ToString: string;
end;
function TRandom.Next: Integer;
begin
Seed := ((Seed * 214013 + 2531011) and Integer.MaxValue);
Result := Seed shr 16;
end;
procedure TCard.Create(rawvalue: Integer);
begin
Create(rawvalue div 4, rawvalue mod 4);
end;
procedure TCard.Assign(other: TCard);
begin
Create(other.Value, other.Suit);
end;
procedure TCard.Create(value, suit: Integer);
begin
self.Value := value;
self.Suit := suit;
end;
function TCard.ToString: string;
begin
result := format('%s%s', [kValues[value + 1], kSuits[suit + 1]]);
end;
procedure TDeck.Create(Seed: Integer);
var
r: TRandom;
i, j: integer;
tmp: Tcard;
begin
r.Seed := Seed;
SetLength(Cards, 52);
for i := 0 to 51 do
Cards[i].Create(51 - i);
for i := 0 to 50 do
begin
j := 51 - (r.Next mod (52 - i));
tmp.Assign(Cards[i]);
Cards[i].Assign(Cards[j]);
Cards[j].Assign(tmp);
end;
end;
function TDeck.ToString: string;
var
i: Integer;
begin
Result := '';
for i := 0 to length(Cards) - 1 do
begin
Result := Result + Cards[i].ToString;
if i mod 8 = 7 then
Result := Result + #10
else
Result := Result + ' ';
end;
end;
var
Deck: TDeck;
begin
Deck.Create(1);
Writeln('Deck 1'#10, Deck.ToString, #10);
Deck.Create(617);
Writeln('Deck 617'#10, Deck.ToString);
readln;
end.
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Change the programming language of this snippet from Delphi to Java without modifying what it does. | program Deal_cards_for_FreeCell;
uses
System.SysUtils;
type
TRandom = record
Seed: Int64;
function Next: Integer;
end;
TCard = record
const
kSuits = '♣♦♥♠';
kValues = 'A23456789TJQK';
var
Value: Integer;
Suit: Integer;
procedure Create(rawvalue: Integer); overload;
procedure Create(value, suit: Integer); overload;
procedure Assign(other: TCard);
function ToString: string;
end;
TDeck = record
Cards: TArray<TCard>;
procedure Create(Seed: Integer);
function ToString: string;
end;
function TRandom.Next: Integer;
begin
Seed := ((Seed * 214013 + 2531011) and Integer.MaxValue);
Result := Seed shr 16;
end;
procedure TCard.Create(rawvalue: Integer);
begin
Create(rawvalue div 4, rawvalue mod 4);
end;
procedure TCard.Assign(other: TCard);
begin
Create(other.Value, other.Suit);
end;
procedure TCard.Create(value, suit: Integer);
begin
self.Value := value;
self.Suit := suit;
end;
function TCard.ToString: string;
begin
result := format('%s%s', [kValues[value + 1], kSuits[suit + 1]]);
end;
procedure TDeck.Create(Seed: Integer);
var
r: TRandom;
i, j: integer;
tmp: Tcard;
begin
r.Seed := Seed;
SetLength(Cards, 52);
for i := 0 to 51 do
Cards[i].Create(51 - i);
for i := 0 to 50 do
begin
j := 51 - (r.Next mod (52 - i));
tmp.Assign(Cards[i]);
Cards[i].Assign(Cards[j]);
Cards[j].Assign(tmp);
end;
end;
function TDeck.ToString: string;
var
i: Integer;
begin
Result := '';
for i := 0 to length(Cards) - 1 do
begin
Result := Result + Cards[i].ToString;
if i mod 8 = 7 then
Result := Result + #10
else
Result := Result + ' ';
end;
end;
var
Deck: TDeck;
begin
Deck.Create(1);
Writeln('Deck 1'#10, Deck.ToString, #10);
Deck.Create(617);
Writeln('Deck 617'#10, Deck.ToString);
readln;
end.
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Maintain the same structure and functionality when rewriting this code in Python. | program Deal_cards_for_FreeCell;
uses
System.SysUtils;
type
TRandom = record
Seed: Int64;
function Next: Integer;
end;
TCard = record
const
kSuits = '♣♦♥♠';
kValues = 'A23456789TJQK';
var
Value: Integer;
Suit: Integer;
procedure Create(rawvalue: Integer); overload;
procedure Create(value, suit: Integer); overload;
procedure Assign(other: TCard);
function ToString: string;
end;
TDeck = record
Cards: TArray<TCard>;
procedure Create(Seed: Integer);
function ToString: string;
end;
function TRandom.Next: Integer;
begin
Seed := ((Seed * 214013 + 2531011) and Integer.MaxValue);
Result := Seed shr 16;
end;
procedure TCard.Create(rawvalue: Integer);
begin
Create(rawvalue div 4, rawvalue mod 4);
end;
procedure TCard.Assign(other: TCard);
begin
Create(other.Value, other.Suit);
end;
procedure TCard.Create(value, suit: Integer);
begin
self.Value := value;
self.Suit := suit;
end;
function TCard.ToString: string;
begin
result := format('%s%s', [kValues[value + 1], kSuits[suit + 1]]);
end;
procedure TDeck.Create(Seed: Integer);
var
r: TRandom;
i, j: integer;
tmp: Tcard;
begin
r.Seed := Seed;
SetLength(Cards, 52);
for i := 0 to 51 do
Cards[i].Create(51 - i);
for i := 0 to 50 do
begin
j := 51 - (r.Next mod (52 - i));
tmp.Assign(Cards[i]);
Cards[i].Assign(Cards[j]);
Cards[j].Assign(tmp);
end;
end;
function TDeck.ToString: string;
var
i: Integer;
begin
Result := '';
for i := 0 to length(Cards) - 1 do
begin
Result := Result + Cards[i].ToString;
if i mod 8 = 7 then
Result := Result + #10
else
Result := Result + ' ';
end;
end;
var
Deck: TDeck;
begin
Deck.Create(1);
Writeln('Deck 1'#10, Deck.ToString, #10);
Deck.Create(617);
Writeln('Deck 617'#10, Deck.ToString);
readln;
end.
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Generate an equivalent Go version of this Delphi code. | program Deal_cards_for_FreeCell;
uses
System.SysUtils;
type
TRandom = record
Seed: Int64;
function Next: Integer;
end;
TCard = record
const
kSuits = '♣♦♥♠';
kValues = 'A23456789TJQK';
var
Value: Integer;
Suit: Integer;
procedure Create(rawvalue: Integer); overload;
procedure Create(value, suit: Integer); overload;
procedure Assign(other: TCard);
function ToString: string;
end;
TDeck = record
Cards: TArray<TCard>;
procedure Create(Seed: Integer);
function ToString: string;
end;
function TRandom.Next: Integer;
begin
Seed := ((Seed * 214013 + 2531011) and Integer.MaxValue);
Result := Seed shr 16;
end;
procedure TCard.Create(rawvalue: Integer);
begin
Create(rawvalue div 4, rawvalue mod 4);
end;
procedure TCard.Assign(other: TCard);
begin
Create(other.Value, other.Suit);
end;
procedure TCard.Create(value, suit: Integer);
begin
self.Value := value;
self.Suit := suit;
end;
function TCard.ToString: string;
begin
result := format('%s%s', [kValues[value + 1], kSuits[suit + 1]]);
end;
procedure TDeck.Create(Seed: Integer);
var
r: TRandom;
i, j: integer;
tmp: Tcard;
begin
r.Seed := Seed;
SetLength(Cards, 52);
for i := 0 to 51 do
Cards[i].Create(51 - i);
for i := 0 to 50 do
begin
j := 51 - (r.Next mod (52 - i));
tmp.Assign(Cards[i]);
Cards[i].Assign(Cards[j]);
Cards[j].Assign(tmp);
end;
end;
function TDeck.ToString: string;
var
i: Integer;
begin
Result := '';
for i := 0 to length(Cards) - 1 do
begin
Result := Result + Cards[i].ToString;
if i mod 8 = 7 then
Result := Result + #10
else
Result := Result + ' ';
end;
end;
var
Deck: TDeck;
begin
Deck.Create(1);
Writeln('Deck 1'#10, Deck.ToString, #10);
Deck.Create(617);
Writeln('Deck 617'#10, Deck.ToString);
readln;
end.
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Produce a language-to-language conversion: from Elixir to C, same semantics. | defmodule FreeCell do
import Bitwise
@suits ~w( C D H S )
@pips ~w( A 2 3 4 5 6 7 8 9 T J Q K )
@orig_deck for pip <- @pips, suit <- @suits, do: pip <> suit
def deal(games) do
games = if length(games) == 0, do: [Enum.random(1..32000)], else: games
Enum.each(games, fn seed ->
IO.puts "Game
Enum.reduce(52..2, {seed,@orig_deck}, fn len,{state,deck} ->
state = ((214013 * state) + 2531011) &&& 0x7fff_ffff
index = rem(state >>> 16, len)
last = len - 1
{a, b} = {Enum.at(deck, index), Enum.at(deck, last)}
{state, deck |> List.replace_at(index, b) |> List.replace_at(last, a)}
end)
|> elem(1)
|> Enum.reverse
|> Enum.chunk(8,8,[])
|> Enum.each(fn row -> Enum.join(row, " ") |> IO.puts end)
IO.puts ""
end)
end
end
System.argv |> Enum.map(&String.to_integer/1)
|> FreeCell.deal
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Produce a functionally identical C# code for the snippet given in Elixir. | defmodule FreeCell do
import Bitwise
@suits ~w( C D H S )
@pips ~w( A 2 3 4 5 6 7 8 9 T J Q K )
@orig_deck for pip <- @pips, suit <- @suits, do: pip <> suit
def deal(games) do
games = if length(games) == 0, do: [Enum.random(1..32000)], else: games
Enum.each(games, fn seed ->
IO.puts "Game
Enum.reduce(52..2, {seed,@orig_deck}, fn len,{state,deck} ->
state = ((214013 * state) + 2531011) &&& 0x7fff_ffff
index = rem(state >>> 16, len)
last = len - 1
{a, b} = {Enum.at(deck, index), Enum.at(deck, last)}
{state, deck |> List.replace_at(index, b) |> List.replace_at(last, a)}
end)
|> elem(1)
|> Enum.reverse
|> Enum.chunk(8,8,[])
|> Enum.each(fn row -> Enum.join(row, " ") |> IO.puts end)
IO.puts ""
end)
end
end
System.argv |> Enum.map(&String.to_integer/1)
|> FreeCell.deal
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Write the same code in C++ as shown below in Elixir. | defmodule FreeCell do
import Bitwise
@suits ~w( C D H S )
@pips ~w( A 2 3 4 5 6 7 8 9 T J Q K )
@orig_deck for pip <- @pips, suit <- @suits, do: pip <> suit
def deal(games) do
games = if length(games) == 0, do: [Enum.random(1..32000)], else: games
Enum.each(games, fn seed ->
IO.puts "Game
Enum.reduce(52..2, {seed,@orig_deck}, fn len,{state,deck} ->
state = ((214013 * state) + 2531011) &&& 0x7fff_ffff
index = rem(state >>> 16, len)
last = len - 1
{a, b} = {Enum.at(deck, index), Enum.at(deck, last)}
{state, deck |> List.replace_at(index, b) |> List.replace_at(last, a)}
end)
|> elem(1)
|> Enum.reverse
|> Enum.chunk(8,8,[])
|> Enum.each(fn row -> Enum.join(row, " ") |> IO.puts end)
IO.puts ""
end)
end
end
System.argv |> Enum.map(&String.to_integer/1)
|> FreeCell.deal
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Produce a functionally identical Java code for the snippet given in Elixir. | defmodule FreeCell do
import Bitwise
@suits ~w( C D H S )
@pips ~w( A 2 3 4 5 6 7 8 9 T J Q K )
@orig_deck for pip <- @pips, suit <- @suits, do: pip <> suit
def deal(games) do
games = if length(games) == 0, do: [Enum.random(1..32000)], else: games
Enum.each(games, fn seed ->
IO.puts "Game
Enum.reduce(52..2, {seed,@orig_deck}, fn len,{state,deck} ->
state = ((214013 * state) + 2531011) &&& 0x7fff_ffff
index = rem(state >>> 16, len)
last = len - 1
{a, b} = {Enum.at(deck, index), Enum.at(deck, last)}
{state, deck |> List.replace_at(index, b) |> List.replace_at(last, a)}
end)
|> elem(1)
|> Enum.reverse
|> Enum.chunk(8,8,[])
|> Enum.each(fn row -> Enum.join(row, " ") |> IO.puts end)
IO.puts ""
end)
end
end
System.argv |> Enum.map(&String.to_integer/1)
|> FreeCell.deal
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Generate a Python translation of this Elixir snippet without changing its computational steps. | defmodule FreeCell do
import Bitwise
@suits ~w( C D H S )
@pips ~w( A 2 3 4 5 6 7 8 9 T J Q K )
@orig_deck for pip <- @pips, suit <- @suits, do: pip <> suit
def deal(games) do
games = if length(games) == 0, do: [Enum.random(1..32000)], else: games
Enum.each(games, fn seed ->
IO.puts "Game
Enum.reduce(52..2, {seed,@orig_deck}, fn len,{state,deck} ->
state = ((214013 * state) + 2531011) &&& 0x7fff_ffff
index = rem(state >>> 16, len)
last = len - 1
{a, b} = {Enum.at(deck, index), Enum.at(deck, last)}
{state, deck |> List.replace_at(index, b) |> List.replace_at(last, a)}
end)
|> elem(1)
|> Enum.reverse
|> Enum.chunk(8,8,[])
|> Enum.each(fn row -> Enum.join(row, " ") |> IO.puts end)
IO.puts ""
end)
end
end
System.argv |> Enum.map(&String.to_integer/1)
|> FreeCell.deal
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Change the following Elixir code into Go without altering its purpose. | defmodule FreeCell do
import Bitwise
@suits ~w( C D H S )
@pips ~w( A 2 3 4 5 6 7 8 9 T J Q K )
@orig_deck for pip <- @pips, suit <- @suits, do: pip <> suit
def deal(games) do
games = if length(games) == 0, do: [Enum.random(1..32000)], else: games
Enum.each(games, fn seed ->
IO.puts "Game
Enum.reduce(52..2, {seed,@orig_deck}, fn len,{state,deck} ->
state = ((214013 * state) + 2531011) &&& 0x7fff_ffff
index = rem(state >>> 16, len)
last = len - 1
{a, b} = {Enum.at(deck, index), Enum.at(deck, last)}
{state, deck |> List.replace_at(index, b) |> List.replace_at(last, a)}
end)
|> elem(1)
|> Enum.reverse
|> Enum.chunk(8,8,[])
|> Enum.each(fn row -> Enum.join(row, " ") |> IO.puts end)
IO.puts ""
end)
end
end
System.argv |> Enum.map(&String.to_integer/1)
|> FreeCell.deal
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Rewrite the snippet below in C so it works the same as the original F# code. | let msKindaRand seed =
let state = ref seed
(fun (_:unit) ->
state := (214013 * !state + 2531011) &&& System.Int32.MaxValue
!state / (1<<<16))
let unshuffledDeck = [0..51] |> List.map(fun n->sprintf "%c%c" "A23456789TJQK".[n / 4] "CDHS".[n % 4])
let deal boot idx =
let (last,rest) = boot |> List.rev |> fun xs->(List.head xs),(xs |> List.tail |> List.rev)
if idx=((List.length boot) - 1) then last, rest
else
rest
|> List.mapi (fun i x -> i,x)
|> List.partition (fst >> ((>) idx))
|> fun (xs,ys) -> (List.map snd xs),(List.map snd ys)
|> fun (xs,ys) -> (List.head ys),(xs @ last::(List.tail ys))
let game gameNo =
let rnd = msKindaRand gameNo
[52..-1..1]
|> List.map (fun i->rnd() % i)
|> List.fold (fun (dealt, boot) idx->deal boot idx |> fun (x,xs) -> (x::dealt, xs)) ([],unshuffledDeck)
|> fst |> List.rev
|> List.chunkBySize 8
|> List.map (String.concat " ")
|> String.concat "\n"
|> printfn "Game #%d\n%s\n" gameNo
[1; 617] |> List.iter game
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Rewrite the snippet below in C# so it works the same as the original F# code. | let msKindaRand seed =
let state = ref seed
(fun (_:unit) ->
state := (214013 * !state + 2531011) &&& System.Int32.MaxValue
!state / (1<<<16))
let unshuffledDeck = [0..51] |> List.map(fun n->sprintf "%c%c" "A23456789TJQK".[n / 4] "CDHS".[n % 4])
let deal boot idx =
let (last,rest) = boot |> List.rev |> fun xs->(List.head xs),(xs |> List.tail |> List.rev)
if idx=((List.length boot) - 1) then last, rest
else
rest
|> List.mapi (fun i x -> i,x)
|> List.partition (fst >> ((>) idx))
|> fun (xs,ys) -> (List.map snd xs),(List.map snd ys)
|> fun (xs,ys) -> (List.head ys),(xs @ last::(List.tail ys))
let game gameNo =
let rnd = msKindaRand gameNo
[52..-1..1]
|> List.map (fun i->rnd() % i)
|> List.fold (fun (dealt, boot) idx->deal boot idx |> fun (x,xs) -> (x::dealt, xs)) ([],unshuffledDeck)
|> fst |> List.rev
|> List.chunkBySize 8
|> List.map (String.concat " ")
|> String.concat "\n"
|> printfn "Game #%d\n%s\n" gameNo
[1; 617] |> List.iter game
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Rewrite the snippet below in C++ so it works the same as the original F# code. | let msKindaRand seed =
let state = ref seed
(fun (_:unit) ->
state := (214013 * !state + 2531011) &&& System.Int32.MaxValue
!state / (1<<<16))
let unshuffledDeck = [0..51] |> List.map(fun n->sprintf "%c%c" "A23456789TJQK".[n / 4] "CDHS".[n % 4])
let deal boot idx =
let (last,rest) = boot |> List.rev |> fun xs->(List.head xs),(xs |> List.tail |> List.rev)
if idx=((List.length boot) - 1) then last, rest
else
rest
|> List.mapi (fun i x -> i,x)
|> List.partition (fst >> ((>) idx))
|> fun (xs,ys) -> (List.map snd xs),(List.map snd ys)
|> fun (xs,ys) -> (List.head ys),(xs @ last::(List.tail ys))
let game gameNo =
let rnd = msKindaRand gameNo
[52..-1..1]
|> List.map (fun i->rnd() % i)
|> List.fold (fun (dealt, boot) idx->deal boot idx |> fun (x,xs) -> (x::dealt, xs)) ([],unshuffledDeck)
|> fst |> List.rev
|> List.chunkBySize 8
|> List.map (String.concat " ")
|> String.concat "\n"
|> printfn "Game #%d\n%s\n" gameNo
[1; 617] |> List.iter game
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Translate this program into Java but keep the logic exactly as in F#. | let msKindaRand seed =
let state = ref seed
(fun (_:unit) ->
state := (214013 * !state + 2531011) &&& System.Int32.MaxValue
!state / (1<<<16))
let unshuffledDeck = [0..51] |> List.map(fun n->sprintf "%c%c" "A23456789TJQK".[n / 4] "CDHS".[n % 4])
let deal boot idx =
let (last,rest) = boot |> List.rev |> fun xs->(List.head xs),(xs |> List.tail |> List.rev)
if idx=((List.length boot) - 1) then last, rest
else
rest
|> List.mapi (fun i x -> i,x)
|> List.partition (fst >> ((>) idx))
|> fun (xs,ys) -> (List.map snd xs),(List.map snd ys)
|> fun (xs,ys) -> (List.head ys),(xs @ last::(List.tail ys))
let game gameNo =
let rnd = msKindaRand gameNo
[52..-1..1]
|> List.map (fun i->rnd() % i)
|> List.fold (fun (dealt, boot) idx->deal boot idx |> fun (x,xs) -> (x::dealt, xs)) ([],unshuffledDeck)
|> fst |> List.rev
|> List.chunkBySize 8
|> List.map (String.concat " ")
|> String.concat "\n"
|> printfn "Game #%d\n%s\n" gameNo
[1; 617] |> List.iter game
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Convert this F# block to Python, preserving its control flow and logic. | let msKindaRand seed =
let state = ref seed
(fun (_:unit) ->
state := (214013 * !state + 2531011) &&& System.Int32.MaxValue
!state / (1<<<16))
let unshuffledDeck = [0..51] |> List.map(fun n->sprintf "%c%c" "A23456789TJQK".[n / 4] "CDHS".[n % 4])
let deal boot idx =
let (last,rest) = boot |> List.rev |> fun xs->(List.head xs),(xs |> List.tail |> List.rev)
if idx=((List.length boot) - 1) then last, rest
else
rest
|> List.mapi (fun i x -> i,x)
|> List.partition (fst >> ((>) idx))
|> fun (xs,ys) -> (List.map snd xs),(List.map snd ys)
|> fun (xs,ys) -> (List.head ys),(xs @ last::(List.tail ys))
let game gameNo =
let rnd = msKindaRand gameNo
[52..-1..1]
|> List.map (fun i->rnd() % i)
|> List.fold (fun (dealt, boot) idx->deal boot idx |> fun (x,xs) -> (x::dealt, xs)) ([],unshuffledDeck)
|> fst |> List.rev
|> List.chunkBySize 8
|> List.map (String.concat " ")
|> String.concat "\n"
|> printfn "Game #%d\n%s\n" gameNo
[1; 617] |> List.iter game
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Write the same code in Go as shown below in F#. | let msKindaRand seed =
let state = ref seed
(fun (_:unit) ->
state := (214013 * !state + 2531011) &&& System.Int32.MaxValue
!state / (1<<<16))
let unshuffledDeck = [0..51] |> List.map(fun n->sprintf "%c%c" "A23456789TJQK".[n / 4] "CDHS".[n % 4])
let deal boot idx =
let (last,rest) = boot |> List.rev |> fun xs->(List.head xs),(xs |> List.tail |> List.rev)
if idx=((List.length boot) - 1) then last, rest
else
rest
|> List.mapi (fun i x -> i,x)
|> List.partition (fst >> ((>) idx))
|> fun (xs,ys) -> (List.map snd xs),(List.map snd ys)
|> fun (xs,ys) -> (List.head ys),(xs @ last::(List.tail ys))
let game gameNo =
let rnd = msKindaRand gameNo
[52..-1..1]
|> List.map (fun i->rnd() % i)
|> List.fold (fun (dealt, boot) idx->deal boot idx |> fun (x,xs) -> (x::dealt, xs)) ([],unshuffledDeck)
|> fst |> List.rev
|> List.chunkBySize 8
|> List.map (String.concat " ")
|> String.concat "\n"
|> printfn "Game #%d\n%s\n" gameNo
[1; 617] |> List.iter game
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Write the same algorithm in C as shown in this Factor implementation. | USING: formatting grouping io kernel literals make math
math.functions namespaces qw sequences sequences.extras ;
IN: rosetta-code.freecell
CONSTANT: max-rand-ms $[ 1 15 shift 1 - ]
CONSTANT: suits qw{ C D H S }
CONSTANT: ranks qw{ A 2 3 4 5 6 7 8 9 T J Q K }
SYMBOL: seed
: (random) ( n1 n2 -- n3 ) seed get * + dup seed set ;
: rand-ms ( -- n )
max-rand-ms 2531011 214013 (random) -16 shift bitand ;
: init-deck ( -- seq )
ranks suits [ append ] cartesian-map concat V{ } like ;
: swap-cards ( seq -- seq' )
rand-ms over length [ mod ] [ 1 - ] bi pick exchange ;
: (deal) ( seq -- seq' )
[ [ swap-cards dup pop , ] until-empty ] { } make ;
: deal ( game# -- seq ) seed set init-deck (deal) ;
: .cards ( seq -- ) 8 group [ [ write bl ] each nl ] each nl ;
: .game ( game# -- ) dup "Game #%d\n" printf deal .cards ;
: freecell ( -- ) 1 617 [ .game ] bi@ ;
MAIN: freecell
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Write the same code in C# as shown below in Factor. | USING: formatting grouping io kernel literals make math
math.functions namespaces qw sequences sequences.extras ;
IN: rosetta-code.freecell
CONSTANT: max-rand-ms $[ 1 15 shift 1 - ]
CONSTANT: suits qw{ C D H S }
CONSTANT: ranks qw{ A 2 3 4 5 6 7 8 9 T J Q K }
SYMBOL: seed
: (random) ( n1 n2 -- n3 ) seed get * + dup seed set ;
: rand-ms ( -- n )
max-rand-ms 2531011 214013 (random) -16 shift bitand ;
: init-deck ( -- seq )
ranks suits [ append ] cartesian-map concat V{ } like ;
: swap-cards ( seq -- seq' )
rand-ms over length [ mod ] [ 1 - ] bi pick exchange ;
: (deal) ( seq -- seq' )
[ [ swap-cards dup pop , ] until-empty ] { } make ;
: deal ( game# -- seq ) seed set init-deck (deal) ;
: .cards ( seq -- ) 8 group [ [ write bl ] each nl ] each nl ;
: .game ( game# -- ) dup "Game #%d\n" printf deal .cards ;
: freecell ( -- ) 1 617 [ .game ] bi@ ;
MAIN: freecell
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Change the following Factor code into C++ without altering its purpose. | USING: formatting grouping io kernel literals make math
math.functions namespaces qw sequences sequences.extras ;
IN: rosetta-code.freecell
CONSTANT: max-rand-ms $[ 1 15 shift 1 - ]
CONSTANT: suits qw{ C D H S }
CONSTANT: ranks qw{ A 2 3 4 5 6 7 8 9 T J Q K }
SYMBOL: seed
: (random) ( n1 n2 -- n3 ) seed get * + dup seed set ;
: rand-ms ( -- n )
max-rand-ms 2531011 214013 (random) -16 shift bitand ;
: init-deck ( -- seq )
ranks suits [ append ] cartesian-map concat V{ } like ;
: swap-cards ( seq -- seq' )
rand-ms over length [ mod ] [ 1 - ] bi pick exchange ;
: (deal) ( seq -- seq' )
[ [ swap-cards dup pop , ] until-empty ] { } make ;
: deal ( game# -- seq ) seed set init-deck (deal) ;
: .cards ( seq -- ) 8 group [ [ write bl ] each nl ] each nl ;
: .game ( game# -- ) dup "Game #%d\n" printf deal .cards ;
: freecell ( -- ) 1 617 [ .game ] bi@ ;
MAIN: freecell
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Preserve the algorithm and functionality while converting the code from Factor to Java. | USING: formatting grouping io kernel literals make math
math.functions namespaces qw sequences sequences.extras ;
IN: rosetta-code.freecell
CONSTANT: max-rand-ms $[ 1 15 shift 1 - ]
CONSTANT: suits qw{ C D H S }
CONSTANT: ranks qw{ A 2 3 4 5 6 7 8 9 T J Q K }
SYMBOL: seed
: (random) ( n1 n2 -- n3 ) seed get * + dup seed set ;
: rand-ms ( -- n )
max-rand-ms 2531011 214013 (random) -16 shift bitand ;
: init-deck ( -- seq )
ranks suits [ append ] cartesian-map concat V{ } like ;
: swap-cards ( seq -- seq' )
rand-ms over length [ mod ] [ 1 - ] bi pick exchange ;
: (deal) ( seq -- seq' )
[ [ swap-cards dup pop , ] until-empty ] { } make ;
: deal ( game# -- seq ) seed set init-deck (deal) ;
: .cards ( seq -- ) 8 group [ [ write bl ] each nl ] each nl ;
: .game ( game# -- ) dup "Game #%d\n" printf deal .cards ;
: freecell ( -- ) 1 617 [ .game ] bi@ ;
MAIN: freecell
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Port the following code from Factor to Python with equivalent syntax and logic. | USING: formatting grouping io kernel literals make math
math.functions namespaces qw sequences sequences.extras ;
IN: rosetta-code.freecell
CONSTANT: max-rand-ms $[ 1 15 shift 1 - ]
CONSTANT: suits qw{ C D H S }
CONSTANT: ranks qw{ A 2 3 4 5 6 7 8 9 T J Q K }
SYMBOL: seed
: (random) ( n1 n2 -- n3 ) seed get * + dup seed set ;
: rand-ms ( -- n )
max-rand-ms 2531011 214013 (random) -16 shift bitand ;
: init-deck ( -- seq )
ranks suits [ append ] cartesian-map concat V{ } like ;
: swap-cards ( seq -- seq' )
rand-ms over length [ mod ] [ 1 - ] bi pick exchange ;
: (deal) ( seq -- seq' )
[ [ swap-cards dup pop , ] until-empty ] { } make ;
: deal ( game# -- seq ) seed set init-deck (deal) ;
: .cards ( seq -- ) 8 group [ [ write bl ] each nl ] each nl ;
: .game ( game# -- ) dup "Game #%d\n" printf deal .cards ;
: freecell ( -- ) 1 617 [ .game ] bi@ ;
MAIN: freecell
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Port the provided Factor code into Go while preserving the original functionality. | USING: formatting grouping io kernel literals make math
math.functions namespaces qw sequences sequences.extras ;
IN: rosetta-code.freecell
CONSTANT: max-rand-ms $[ 1 15 shift 1 - ]
CONSTANT: suits qw{ C D H S }
CONSTANT: ranks qw{ A 2 3 4 5 6 7 8 9 T J Q K }
SYMBOL: seed
: (random) ( n1 n2 -- n3 ) seed get * + dup seed set ;
: rand-ms ( -- n )
max-rand-ms 2531011 214013 (random) -16 shift bitand ;
: init-deck ( -- seq )
ranks suits [ append ] cartesian-map concat V{ } like ;
: swap-cards ( seq -- seq' )
rand-ms over length [ mod ] [ 1 - ] bi pick exchange ;
: (deal) ( seq -- seq' )
[ [ swap-cards dup pop , ] until-empty ] { } make ;
: deal ( game# -- seq ) seed set init-deck (deal) ;
: .cards ( seq -- ) 8 group [ [ write bl ] each nl ] each nl ;
: .game ( game# -- ) dup "Game #%d\n" printf deal .cards ;
: freecell ( -- ) 1 617 [ .game ] bi@ ;
MAIN: freecell
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Rewrite the snippet below in C# so it works the same as the original Fortran code. | module Freecell
use lcgs
implicit none
character(4) :: suit = "CDHS"
character(13) :: rank = "A23456789TJQK"
character(2) :: deck(0:51)
contains
subroutine Createdeck()
integer :: i, j, n
n = 0
do i = 1, 13
do j = 1, 4
deck(n) = rank(i:i) // suit(j:j)
n = n + 1
end do
end do
end subroutine
subroutine Freecelldeal(game)
integer, intent(in) :: game
integer(i64) :: rnum
integer :: i, n
character(2) :: tmp
call Createdeck()
rnum = msrand(game)
do i = 51, 1, -1
n = mod(rnum, i+1)
tmp = deck(n)
deck(n) = deck(i)
deck(i) = tmp
rnum = msrand()
end do
write(*, "(a, i0)") "Game #", game
write(*, "(8(a, tr1))") deck(51:0:-1)
write(*,*)
end subroutine
end module Freecell
program Freecell_test
use Freecell
implicit none
call Freecelldeal(1)
call Freecelldeal(617)
end program
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Ensure the translated C++ code behaves exactly like the original Fortran snippet. | module Freecell
use lcgs
implicit none
character(4) :: suit = "CDHS"
character(13) :: rank = "A23456789TJQK"
character(2) :: deck(0:51)
contains
subroutine Createdeck()
integer :: i, j, n
n = 0
do i = 1, 13
do j = 1, 4
deck(n) = rank(i:i) // suit(j:j)
n = n + 1
end do
end do
end subroutine
subroutine Freecelldeal(game)
integer, intent(in) :: game
integer(i64) :: rnum
integer :: i, n
character(2) :: tmp
call Createdeck()
rnum = msrand(game)
do i = 51, 1, -1
n = mod(rnum, i+1)
tmp = deck(n)
deck(n) = deck(i)
deck(i) = tmp
rnum = msrand()
end do
write(*, "(a, i0)") "Game #", game
write(*, "(8(a, tr1))") deck(51:0:-1)
write(*,*)
end subroutine
end module Freecell
program Freecell_test
use Freecell
implicit none
call Freecelldeal(1)
call Freecelldeal(617)
end program
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Produce a language-to-language conversion: from Fortran to C, same semantics. | module Freecell
use lcgs
implicit none
character(4) :: suit = "CDHS"
character(13) :: rank = "A23456789TJQK"
character(2) :: deck(0:51)
contains
subroutine Createdeck()
integer :: i, j, n
n = 0
do i = 1, 13
do j = 1, 4
deck(n) = rank(i:i) // suit(j:j)
n = n + 1
end do
end do
end subroutine
subroutine Freecelldeal(game)
integer, intent(in) :: game
integer(i64) :: rnum
integer :: i, n
character(2) :: tmp
call Createdeck()
rnum = msrand(game)
do i = 51, 1, -1
n = mod(rnum, i+1)
tmp = deck(n)
deck(n) = deck(i)
deck(i) = tmp
rnum = msrand()
end do
write(*, "(a, i0)") "Game #", game
write(*, "(8(a, tr1))") deck(51:0:-1)
write(*,*)
end subroutine
end module Freecell
program Freecell_test
use Freecell
implicit none
call Freecelldeal(1)
call Freecelldeal(617)
end program
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Generate a Go translation of this Fortran snippet without changing its computational steps. | module Freecell
use lcgs
implicit none
character(4) :: suit = "CDHS"
character(13) :: rank = "A23456789TJQK"
character(2) :: deck(0:51)
contains
subroutine Createdeck()
integer :: i, j, n
n = 0
do i = 1, 13
do j = 1, 4
deck(n) = rank(i:i) // suit(j:j)
n = n + 1
end do
end do
end subroutine
subroutine Freecelldeal(game)
integer, intent(in) :: game
integer(i64) :: rnum
integer :: i, n
character(2) :: tmp
call Createdeck()
rnum = msrand(game)
do i = 51, 1, -1
n = mod(rnum, i+1)
tmp = deck(n)
deck(n) = deck(i)
deck(i) = tmp
rnum = msrand()
end do
write(*, "(a, i0)") "Game #", game
write(*, "(8(a, tr1))") deck(51:0:-1)
write(*,*)
end subroutine
end module Freecell
program Freecell_test
use Freecell
implicit none
call Freecelldeal(1)
call Freecelldeal(617)
end program
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Produce a language-to-language conversion: from Fortran to Java, same semantics. | module Freecell
use lcgs
implicit none
character(4) :: suit = "CDHS"
character(13) :: rank = "A23456789TJQK"
character(2) :: deck(0:51)
contains
subroutine Createdeck()
integer :: i, j, n
n = 0
do i = 1, 13
do j = 1, 4
deck(n) = rank(i:i) // suit(j:j)
n = n + 1
end do
end do
end subroutine
subroutine Freecelldeal(game)
integer, intent(in) :: game
integer(i64) :: rnum
integer :: i, n
character(2) :: tmp
call Createdeck()
rnum = msrand(game)
do i = 51, 1, -1
n = mod(rnum, i+1)
tmp = deck(n)
deck(n) = deck(i)
deck(i) = tmp
rnum = msrand()
end do
write(*, "(a, i0)") "Game #", game
write(*, "(8(a, tr1))") deck(51:0:-1)
write(*,*)
end subroutine
end module Freecell
program Freecell_test
use Freecell
implicit none
call Freecelldeal(1)
call Freecelldeal(617)
end program
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Change the following Fortran code into Python without altering its purpose. | module Freecell
use lcgs
implicit none
character(4) :: suit = "CDHS"
character(13) :: rank = "A23456789TJQK"
character(2) :: deck(0:51)
contains
subroutine Createdeck()
integer :: i, j, n
n = 0
do i = 1, 13
do j = 1, 4
deck(n) = rank(i:i) // suit(j:j)
n = n + 1
end do
end do
end subroutine
subroutine Freecelldeal(game)
integer, intent(in) :: game
integer(i64) :: rnum
integer :: i, n
character(2) :: tmp
call Createdeck()
rnum = msrand(game)
do i = 51, 1, -1
n = mod(rnum, i+1)
tmp = deck(n)
deck(n) = deck(i)
deck(i) = tmp
rnum = msrand()
end do
write(*, "(a, i0)") "Game #", game
write(*, "(8(a, tr1))") deck(51:0:-1)
write(*,*)
end subroutine
end module Freecell
program Freecell_test
use Freecell
implicit none
call Freecelldeal(1)
call Freecelldeal(617)
end program
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Change the programming language of this snippet from Fortran to PHP without modifying what it does. | module Freecell
use lcgs
implicit none
character(4) :: suit = "CDHS"
character(13) :: rank = "A23456789TJQK"
character(2) :: deck(0:51)
contains
subroutine Createdeck()
integer :: i, j, n
n = 0
do i = 1, 13
do j = 1, 4
deck(n) = rank(i:i) // suit(j:j)
n = n + 1
end do
end do
end subroutine
subroutine Freecelldeal(game)
integer, intent(in) :: game
integer(i64) :: rnum
integer :: i, n
character(2) :: tmp
call Createdeck()
rnum = msrand(game)
do i = 51, 1, -1
n = mod(rnum, i+1)
tmp = deck(n)
deck(n) = deck(i)
deck(i) = tmp
rnum = msrand()
end do
write(*, "(a, i0)") "Game #", game
write(*, "(8(a, tr1))") deck(51:0:-1)
write(*,*)
end subroutine
end module Freecell
program Freecell_test
use Freecell
implicit none
call Freecelldeal(1)
call Freecelldeal(617)
end program
| class FreeCell_Deal {
protected $deck = array(
'AC', 'AD', 'AH', 'AS', '2C', '2D', '2H', '2S', '3C', '3D', '3H', '3S',
'4C', '4D', '4H', '4S', '5C', '5D', '5H', '5S', '6C', '6D', '6H', '6S',
'7C', '7D', '7H', '7S', '8C', '8D', '8H', '8S', '9C', '9D', '9H', '9S',
'TC', 'TD', 'TH', 'TS', 'JC', 'JD', 'JH', 'JS', 'QC', 'QD', 'QH', 'QS',
'KC', 'KD', 'KH', 'KS'
);
protected $game; // Freecell Game Number
protected $state; // Current state of the LCG
public $deal = array(); // Generated card sequence to deal
function __construct( $game ) {
$this->game = max( min( $game, 32000 ), 1 );
$this->state = $this->game;
while ( ! empty( $this->deck ) ) {
$i = $this->lcg_rnd() % count( $this->deck );
$this->deal[] = $this->deck[ $i ];
$this->deck[ $i ] = end( $this->deck );
array_pop( $this->deck );
}
}
protected function lcg_rnd() {
return ( $this->state = ( $this->state * 214013 + 2531011 ) % 2147483648 ) >> 16;
}
function print( $cols = 8 ) {
echo str_pad( " Game " . $this->game . " ", $cols * 3 - 1, '=', STR_PAD_BOTH ), PHP_EOL;
foreach ( array_chunk( $this->deal, $cols ) as $row ) {
echo implode( " ", $row ), PHP_EOL;
}
echo PHP_EOL;
}
}
$tests = array( 1, 617, 11982 );
foreach ( $tests as $game_num ) {
$deal = new FreeCell_Deal( $game_num );
$deal->print();
}
|
Can you help me rewrite this code in C instead of Groovy, keeping it the same logically? | class FreeCell{
int seed
List<String> createDeck(){
List<String> suits = ['♣','♦','♥','♠']
List<String> values = ['A','2','3','4','5','6','7','8','9','10','J','Q','K']
return [suits,values].combinations{suit,value -> "$suit$value"}
}
int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE
return seed >> 16
}
List<String> shuffledDeck(List<String> cards) {
List<String> deck = cards.clone()
(deck.size() - 1..1).each{index ->
int r = random() % (index + 1)
deck.swap(r, index)
}
return deck
}
List<String> dealGame(int seed = 1){
this.seed= seed
List<String> cards = shuffledDeck(createDeck())
(1..cards.size()).each{ number->
print "${cards.pop()}\t"
if(number % 8 == 0) println('')
}
println('\n')
}
}
def freecell = new FreeCell()
freecell.dealGame()
freecell.dealGame(617)
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Produce a functionally identical C# code for the snippet given in Groovy. | class FreeCell{
int seed
List<String> createDeck(){
List<String> suits = ['♣','♦','♥','♠']
List<String> values = ['A','2','3','4','5','6','7','8','9','10','J','Q','K']
return [suits,values].combinations{suit,value -> "$suit$value"}
}
int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE
return seed >> 16
}
List<String> shuffledDeck(List<String> cards) {
List<String> deck = cards.clone()
(deck.size() - 1..1).each{index ->
int r = random() % (index + 1)
deck.swap(r, index)
}
return deck
}
List<String> dealGame(int seed = 1){
this.seed= seed
List<String> cards = shuffledDeck(createDeck())
(1..cards.size()).each{ number->
print "${cards.pop()}\t"
if(number % 8 == 0) println('')
}
println('\n')
}
}
def freecell = new FreeCell()
freecell.dealGame()
freecell.dealGame(617)
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Translate this program into C++ but keep the logic exactly as in Groovy. | class FreeCell{
int seed
List<String> createDeck(){
List<String> suits = ['♣','♦','♥','♠']
List<String> values = ['A','2','3','4','5','6','7','8','9','10','J','Q','K']
return [suits,values].combinations{suit,value -> "$suit$value"}
}
int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE
return seed >> 16
}
List<String> shuffledDeck(List<String> cards) {
List<String> deck = cards.clone()
(deck.size() - 1..1).each{index ->
int r = random() % (index + 1)
deck.swap(r, index)
}
return deck
}
List<String> dealGame(int seed = 1){
this.seed= seed
List<String> cards = shuffledDeck(createDeck())
(1..cards.size()).each{ number->
print "${cards.pop()}\t"
if(number % 8 == 0) println('')
}
println('\n')
}
}
def freecell = new FreeCell()
freecell.dealGame()
freecell.dealGame(617)
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Rewrite the snippet below in Java so it works the same as the original Groovy code. | class FreeCell{
int seed
List<String> createDeck(){
List<String> suits = ['♣','♦','♥','♠']
List<String> values = ['A','2','3','4','5','6','7','8','9','10','J','Q','K']
return [suits,values].combinations{suit,value -> "$suit$value"}
}
int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE
return seed >> 16
}
List<String> shuffledDeck(List<String> cards) {
List<String> deck = cards.clone()
(deck.size() - 1..1).each{index ->
int r = random() % (index + 1)
deck.swap(r, index)
}
return deck
}
List<String> dealGame(int seed = 1){
this.seed= seed
List<String> cards = shuffledDeck(createDeck())
(1..cards.size()).each{ number->
print "${cards.pop()}\t"
if(number % 8 == 0) println('')
}
println('\n')
}
}
def freecell = new FreeCell()
freecell.dealGame()
freecell.dealGame(617)
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Change the programming language of this snippet from Groovy to Python without modifying what it does. | class FreeCell{
int seed
List<String> createDeck(){
List<String> suits = ['♣','♦','♥','♠']
List<String> values = ['A','2','3','4','5','6','7','8','9','10','J','Q','K']
return [suits,values].combinations{suit,value -> "$suit$value"}
}
int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE
return seed >> 16
}
List<String> shuffledDeck(List<String> cards) {
List<String> deck = cards.clone()
(deck.size() - 1..1).each{index ->
int r = random() % (index + 1)
deck.swap(r, index)
}
return deck
}
List<String> dealGame(int seed = 1){
this.seed= seed
List<String> cards = shuffledDeck(createDeck())
(1..cards.size()).each{ number->
print "${cards.pop()}\t"
if(number % 8 == 0) println('')
}
println('\n')
}
}
def freecell = new FreeCell()
freecell.dealGame()
freecell.dealGame(617)
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Convert the following code from Groovy to Go, ensuring the logic remains intact. | class FreeCell{
int seed
List<String> createDeck(){
List<String> suits = ['♣','♦','♥','♠']
List<String> values = ['A','2','3','4','5','6','7','8','9','10','J','Q','K']
return [suits,values].combinations{suit,value -> "$suit$value"}
}
int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE
return seed >> 16
}
List<String> shuffledDeck(List<String> cards) {
List<String> deck = cards.clone()
(deck.size() - 1..1).each{index ->
int r = random() % (index + 1)
deck.swap(r, index)
}
return deck
}
List<String> dealGame(int seed = 1){
this.seed= seed
List<String> cards = shuffledDeck(createDeck())
(1..cards.size()).each{ number->
print "${cards.pop()}\t"
if(number % 8 == 0) println('')
}
println('\n')
}
}
def freecell = new FreeCell()
freecell.dealGame()
freecell.dealGame(617)
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Maintain the same structure and functionality when rewriting this code in C. | import Data.Int
import Data.Bits
import Data.List
import Data.Array.ST
import Control.Monad
import Control.Monad.ST
import System.Environment
srnd :: Int32 -> [Int]
srnd = map (fromIntegral . flip shiftR 16) .
tail . iterate (\x -> (x * 214013 + 2531011) .&. maxBound)
deal :: Int32 -> [String]
deal s = runST (do
ar <- newListArray (0,51) $ sequence ["A23456789TJQK", "CDHS"]
:: ST s (STArray s Int String)
forM (zip [52,51..1] rnd) $ \(n, r) -> do
let j = r `mod` n
vj <- readArray ar j
vn <- readArray ar (n - 1)
writeArray ar j vn
return vj)
where rnd = srnd s
showCards :: [String] -> IO ()
showCards = mapM_ (putStrLn . unwords) .
takeWhile (not . null) .
unfoldr (Just . splitAt 8)
main :: IO ()
main = do
args <- getArgs
let s = read (head args) :: Int32
putStrLn $ "Deal " ++ show s ++ ":"
let cards = deal s
showCards cards
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Change the following Haskell code into C# without altering its purpose. | import Data.Int
import Data.Bits
import Data.List
import Data.Array.ST
import Control.Monad
import Control.Monad.ST
import System.Environment
srnd :: Int32 -> [Int]
srnd = map (fromIntegral . flip shiftR 16) .
tail . iterate (\x -> (x * 214013 + 2531011) .&. maxBound)
deal :: Int32 -> [String]
deal s = runST (do
ar <- newListArray (0,51) $ sequence ["A23456789TJQK", "CDHS"]
:: ST s (STArray s Int String)
forM (zip [52,51..1] rnd) $ \(n, r) -> do
let j = r `mod` n
vj <- readArray ar j
vn <- readArray ar (n - 1)
writeArray ar j vn
return vj)
where rnd = srnd s
showCards :: [String] -> IO ()
showCards = mapM_ (putStrLn . unwords) .
takeWhile (not . null) .
unfoldr (Just . splitAt 8)
main :: IO ()
main = do
args <- getArgs
let s = read (head args) :: Int32
putStrLn $ "Deal " ++ show s ++ ":"
let cards = deal s
showCards cards
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Write the same algorithm in C++ as shown in this Haskell implementation. | import Data.Int
import Data.Bits
import Data.List
import Data.Array.ST
import Control.Monad
import Control.Monad.ST
import System.Environment
srnd :: Int32 -> [Int]
srnd = map (fromIntegral . flip shiftR 16) .
tail . iterate (\x -> (x * 214013 + 2531011) .&. maxBound)
deal :: Int32 -> [String]
deal s = runST (do
ar <- newListArray (0,51) $ sequence ["A23456789TJQK", "CDHS"]
:: ST s (STArray s Int String)
forM (zip [52,51..1] rnd) $ \(n, r) -> do
let j = r `mod` n
vj <- readArray ar j
vn <- readArray ar (n - 1)
writeArray ar j vn
return vj)
where rnd = srnd s
showCards :: [String] -> IO ()
showCards = mapM_ (putStrLn . unwords) .
takeWhile (not . null) .
unfoldr (Just . splitAt 8)
main :: IO ()
main = do
args <- getArgs
let s = read (head args) :: Int32
putStrLn $ "Deal " ++ show s ++ ":"
let cards = deal s
showCards cards
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Generate an equivalent Java version of this Haskell code. | import Data.Int
import Data.Bits
import Data.List
import Data.Array.ST
import Control.Monad
import Control.Monad.ST
import System.Environment
srnd :: Int32 -> [Int]
srnd = map (fromIntegral . flip shiftR 16) .
tail . iterate (\x -> (x * 214013 + 2531011) .&. maxBound)
deal :: Int32 -> [String]
deal s = runST (do
ar <- newListArray (0,51) $ sequence ["A23456789TJQK", "CDHS"]
:: ST s (STArray s Int String)
forM (zip [52,51..1] rnd) $ \(n, r) -> do
let j = r `mod` n
vj <- readArray ar j
vn <- readArray ar (n - 1)
writeArray ar j vn
return vj)
where rnd = srnd s
showCards :: [String] -> IO ()
showCards = mapM_ (putStrLn . unwords) .
takeWhile (not . null) .
unfoldr (Just . splitAt 8)
main :: IO ()
main = do
args <- getArgs
let s = read (head args) :: Int32
putStrLn $ "Deal " ++ show s ++ ":"
let cards = deal s
showCards cards
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Port the following code from Haskell to Python with equivalent syntax and logic. | import Data.Int
import Data.Bits
import Data.List
import Data.Array.ST
import Control.Monad
import Control.Monad.ST
import System.Environment
srnd :: Int32 -> [Int]
srnd = map (fromIntegral . flip shiftR 16) .
tail . iterate (\x -> (x * 214013 + 2531011) .&. maxBound)
deal :: Int32 -> [String]
deal s = runST (do
ar <- newListArray (0,51) $ sequence ["A23456789TJQK", "CDHS"]
:: ST s (STArray s Int String)
forM (zip [52,51..1] rnd) $ \(n, r) -> do
let j = r `mod` n
vj <- readArray ar j
vn <- readArray ar (n - 1)
writeArray ar j vn
return vj)
where rnd = srnd s
showCards :: [String] -> IO ()
showCards = mapM_ (putStrLn . unwords) .
takeWhile (not . null) .
unfoldr (Just . splitAt 8)
main :: IO ()
main = do
args <- getArgs
let s = read (head args) :: Int32
putStrLn $ "Deal " ++ show s ++ ":"
let cards = deal s
showCards cards
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Convert this Haskell snippet to Go and keep its semantics consistent. | import Data.Int
import Data.Bits
import Data.List
import Data.Array.ST
import Control.Monad
import Control.Monad.ST
import System.Environment
srnd :: Int32 -> [Int]
srnd = map (fromIntegral . flip shiftR 16) .
tail . iterate (\x -> (x * 214013 + 2531011) .&. maxBound)
deal :: Int32 -> [String]
deal s = runST (do
ar <- newListArray (0,51) $ sequence ["A23456789TJQK", "CDHS"]
:: ST s (STArray s Int String)
forM (zip [52,51..1] rnd) $ \(n, r) -> do
let j = r `mod` n
vj <- readArray ar j
vn <- readArray ar (n - 1)
writeArray ar j vn
return vj)
where rnd = srnd s
showCards :: [String] -> IO ()
showCards = mapM_ (putStrLn . unwords) .
takeWhile (not . null) .
unfoldr (Just . splitAt 8)
main :: IO ()
main = do
args <- getArgs
let s = read (head args) :: Int32
putStrLn $ "Deal " ++ show s ++ ":"
let cards = deal s
showCards cards
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Change the programming language of this snippet from Icon to C without modifying what it does. | procedure main(A)
freecelldealer(\A[1] | &null)
end
procedure newDeck()
every D := list(52) & i := 0 & r := !"A23456789TJQK" & s := !"CDHS" do
D[i +:= 1] := r || s
return D
end
procedure freecelldealer(gamenum)
/gamenum := 11982
return showHand(freecellshuffle(newDeck(),gamenum))
end
procedure showHand(D)
write("Hand:\n")
every writes(" ",(1 to 8) | "\n")
every writes(" ",D[i := 1 to *D]) do
if i%8 = 0 then write()
write("\n")
return D
end
procedure freecellshuffle(D,gamenum)
srand_freecell(gamenum)
D2 := []
until *D = 0 do {
D[r := rand_freecell() % *D + 1] :=: D[*D]
put(D2,pull(D))
}
return D2
end
procedure srand_freecell(x)
static seed
return seed := \x | \seed | 0
end
procedure rand_freecell()
return ishift(srand_freecell((214013 * srand_freecell() + 2531011) % 2147483648),-16)
end
| #include <stdio.h>
#include <stdlib.h>
#include <locale.h>
wchar_t s_suits[] = L"♣♦♥♠", s_nums[] = L"A23456789TJQK";
#define RMAX32 ((1U << 31) - 1)
static int seed = 1;
int rnd(void) { return (seed = (seed * 214013 + 2531011) & RMAX32) >> 16; }
void srnd(int x) { seed = x; }
void show(const int *c)
{
int i;
for (i = 0; i < 52; c++) {
printf(" \033[%dm%lc\033[m%lc", 32 - (1 + *c) % 4 / 2,
s_suits[*c % 4], s_nums[*c / 4]);
if (!(++i % 8) || i == 52) putchar('\n');
}
}
void deal(int s, int *t)
{
int i, j;
srnd(s);
for (i = 0; i < 52; i++) t[i] = 51 - i;
for (i = 0; i < 51; i++) {
j = 51 - rnd() % (52 - i);
s = t[i], t[i] = t[j], t[j] = s;
}
}
int main(int c, char **v)
{
int s, card[52];
if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;
setlocale(LC_ALL, "");
deal(s, card);
printf("Hand %d\n", s);
show(card);
return 0;
}
|
Convert this Icon snippet to C# and keep its semantics consistent. | procedure main(A)
freecelldealer(\A[1] | &null)
end
procedure newDeck()
every D := list(52) & i := 0 & r := !"A23456789TJQK" & s := !"CDHS" do
D[i +:= 1] := r || s
return D
end
procedure freecelldealer(gamenum)
/gamenum := 11982
return showHand(freecellshuffle(newDeck(),gamenum))
end
procedure showHand(D)
write("Hand:\n")
every writes(" ",(1 to 8) | "\n")
every writes(" ",D[i := 1 to *D]) do
if i%8 = 0 then write()
write("\n")
return D
end
procedure freecellshuffle(D,gamenum)
srand_freecell(gamenum)
D2 := []
until *D = 0 do {
D[r := rand_freecell() % *D + 1] :=: D[*D]
put(D2,pull(D))
}
return D2
end
procedure srand_freecell(x)
static seed
return seed := \x | \seed | 0
end
procedure rand_freecell()
return ishift(srand_freecell((214013 * srand_freecell() + 2531011) % 2147483648),-16)
end
| using System;
using System.Collections.Generic;
using System.Text;
namespace FreeCellDeals
{
public class RNG
{
private int _state;
public RNG()
{
_state = (int)DateTime.Now.Ticks;
}
public RNG(int n)
{
_state = n;
}
public int Next()
{
return ((_state = 214013 * _state + 2531011) & int.MaxValue) >> 16;
}
}
public enum Rank
{
Ace,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten,
Jack,
Queen,
King
}
public enum Suit
{
Clubs,
Diamonds,
Hearts,
Spades
}
public class Card
{
private const string Ranks = "A23456789TJQK";
private const string Suits = "CDHS";
private Rank _rank;
public Rank Rank
{
get
{
return _rank;
}
set
{
if ((int)value < 0 || (int)value > 12)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_rank = value;
}
}
private Suit _suit;
public Suit Suit
{
get
{
return _suit;
}
set
{
if ((int)value < 0 || (int)value > 3)
{
throw new InvalidOperationException("Setting card rank out of range");
}
_suit = value;
}
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public int NRank()
{
return (int) Rank;
}
public int NSuit()
{
return (int) Suit;
}
public override string ToString()
{
return new string(new[] {Ranks[NRank()], Suits[NSuit()]});
}
}
public class FreeCellDeal
{
public List<Card> Deck { get; private set; }
public FreeCellDeal(int iDeal)
{
RNG rng = new RNG(iDeal);
List<Card> rDeck = new List<Card>();
Deck = new List<Card>();
for (int rank = 0; rank < 13; rank++)
{
for (int suit = 0; suit < 4; suit++)
{
rDeck.Add(new Card((Rank)rank, (Suit)suit));
}
}
for (int iCard = 51; iCard >= 0; iCard--)
{
int iSwap = rng.Next() % (iCard + 1);
Deck.Add(rDeck[iSwap]);
rDeck[iSwap] = rDeck[iCard];
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
for (int iRow = 0; iRow < 6; iRow++ )
{
for (int iCol = 0; iCol < 8; iCol++)
{
sb.AppendFormat("{0} ", Deck[iRow * 8 + iCol]);
}
sb.Append("\n");
}
for (int iCard = 48; iCard < 52; iCard++)
{
sb.AppendFormat("{0} ", Deck[iCard]);
}
return sb.ToString();
}
}
class Program
{
static void Main()
{
Console.WriteLine(new FreeCellDeal(1));
Console.WriteLine();
Console.WriteLine(new FreeCellDeal(617));
}
}
}
|
Write the same code in C++ as shown below in Icon. | procedure main(A)
freecelldealer(\A[1] | &null)
end
procedure newDeck()
every D := list(52) & i := 0 & r := !"A23456789TJQK" & s := !"CDHS" do
D[i +:= 1] := r || s
return D
end
procedure freecelldealer(gamenum)
/gamenum := 11982
return showHand(freecellshuffle(newDeck(),gamenum))
end
procedure showHand(D)
write("Hand:\n")
every writes(" ",(1 to 8) | "\n")
every writes(" ",D[i := 1 to *D]) do
if i%8 = 0 then write()
write("\n")
return D
end
procedure freecellshuffle(D,gamenum)
srand_freecell(gamenum)
D2 := []
until *D = 0 do {
D[r := rand_freecell() % *D + 1] :=: D[*D]
put(D2,pull(D))
}
return D2
end
procedure srand_freecell(x)
static seed
return seed := \x | \seed | 0
end
procedure rand_freecell()
return ishift(srand_freecell((214013 * srand_freecell() + 2531011) % 2147483648),-16)
end
| #include <windows.h>
#include <iostream>
using namespace std;
class fc_dealer
{
public:
void deal( int game )
{
_gn = game;
fillDeck();
shuffle();
display();
}
private:
void fillDeck()
{
int p = 0;
for( int c = 0; c < 13; c++ )
for( int s = 0; s < 4; s++ )
_cards[p++] = c | s << 4;
}
void shuffle()
{
srand( _gn );
int cc = 52, nc, lc;
while( cc )
{
nc = rand() % cc;
lc = _cards[--cc];
_cards[cc] = _cards[nc];
_cards[nc] = lc;
}
}
void display()
{
char* suit = "CDHS";
char* symb = "A23456789TJQK";
int z = 0;
cout << "GAME #" << _gn << endl << "=======================" << endl;
for( int c = 51; c >= 0; c-- )
{
cout << symb[_cards[c] & 15] << suit[_cards[c] >> 4] << " ";
if( ++z >= 8 )
{
cout << endl;
z = 0;
}
}
}
int _cards[52], _gn;
};
int main( int argc, char* argv[] )
{
fc_dealer dealer;
int gn;
while( true )
{
cout << endl << "Game number please ( 0 to QUIT ): "; cin >> gn;
if( !gn ) break;
system( "cls" );
dealer.deal( gn );
cout << endl << endl;
}
return 0;
}
|
Port the provided Icon code into Java while preserving the original functionality. | procedure main(A)
freecelldealer(\A[1] | &null)
end
procedure newDeck()
every D := list(52) & i := 0 & r := !"A23456789TJQK" & s := !"CDHS" do
D[i +:= 1] := r || s
return D
end
procedure freecelldealer(gamenum)
/gamenum := 11982
return showHand(freecellshuffle(newDeck(),gamenum))
end
procedure showHand(D)
write("Hand:\n")
every writes(" ",(1 to 8) | "\n")
every writes(" ",D[i := 1 to *D]) do
if i%8 = 0 then write()
write("\n")
return D
end
procedure freecellshuffle(D,gamenum)
srand_freecell(gamenum)
D2 := []
until *D = 0 do {
D[r := rand_freecell() % *D + 1] :=: D[*D]
put(D2,pull(D))
}
return D2
end
procedure srand_freecell(x)
static seed
return seed := \x | \seed | 0
end
procedure rand_freecell()
return ishift(srand_freecell((214013 * srand_freecell() + 2531011) % 2147483648),-16)
end
| import java.util.Arrays;
public class Shuffler {
private int seed;
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "2S",
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
"5C", "5D", "5H", "5S",
"6C", "6D", "6H", "6S",
"7C", "7D", "7H", "7S",
"8C", "8D", "8H", "8S",
"9C", "9D", "9H", "9S",
"TC", "TD", "TH", "TS",
"JC", "JD", "JH", "JS",
"QC", "QD", "QH", "QS",
"KC", "KD", "KH", "KS",
};
private int random() {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE;
return seed >> 16;
}
private String[] getShuffledDeck() {
String[] deck = Arrays.copyOf(this.deck, this.deck.length);
for(int i = deck.length - 1; i > 0; i--) {
int r = random() % (i + 1);
String card = deck[r];
deck[r] = deck[i];
deck[i] = card;
}
return deck;
}
public void dealGame(int seed) {
this.seed = seed;
String[] shuffledDeck = getShuffledDeck();
for(int count = 1, i = shuffledDeck.length - 1; i >= 0; count++, i--) {
System.out.print(shuffledDeck[i]);
if(count % 8 == 0) {
System.out.println();
} else {
System.out.print(" ");
}
}
System.out.println();
}
public static void main(String[] args) {
Shuffler s = new Shuffler();
s.dealGame(1);
System.out.println();
s.dealGame(617);
}
}
|
Transform the following Icon implementation into Python, maintaining the same output and logic. | procedure main(A)
freecelldealer(\A[1] | &null)
end
procedure newDeck()
every D := list(52) & i := 0 & r := !"A23456789TJQK" & s := !"CDHS" do
D[i +:= 1] := r || s
return D
end
procedure freecelldealer(gamenum)
/gamenum := 11982
return showHand(freecellshuffle(newDeck(),gamenum))
end
procedure showHand(D)
write("Hand:\n")
every writes(" ",(1 to 8) | "\n")
every writes(" ",D[i := 1 to *D]) do
if i%8 = 0 then write()
write("\n")
return D
end
procedure freecellshuffle(D,gamenum)
srand_freecell(gamenum)
D2 := []
until *D = 0 do {
D[r := rand_freecell() % *D + 1] :=: D[*D]
put(D2,pull(D))
}
return D2
end
procedure srand_freecell(x)
static seed
return seed := \x | \seed | 0
end
procedure rand_freecell()
return ishift(srand_freecell((214013 * srand_freecell() + 2531011) % 2147483648),-16)
end
| def randomGenerator(seed=1):
max_int32 = (1 << 31) - 1
seed = seed & max_int32
while True:
seed = (seed * 214013 + 2531011) & max_int32
yield seed >> 16
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
j = (nc - 1) - r % (nc - i)
cards[i], cards[j] = cards[j], cards[i]
return cards
def show(cards):
l = ["A23456789TJQK"[int(c/4)] + "CDHS"[c%4] for c in cards]
for i in range(0, len(cards), 8):
print(" ".join(l[i : i+8]))
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print("Hand {}".format(seed))
deck = deal(seed)
show(deck)
|
Port the following code from Icon to Go with equivalent syntax and logic. | procedure main(A)
freecelldealer(\A[1] | &null)
end
procedure newDeck()
every D := list(52) & i := 0 & r := !"A23456789TJQK" & s := !"CDHS" do
D[i +:= 1] := r || s
return D
end
procedure freecelldealer(gamenum)
/gamenum := 11982
return showHand(freecellshuffle(newDeck(),gamenum))
end
procedure showHand(D)
write("Hand:\n")
every writes(" ",(1 to 8) | "\n")
every writes(" ",D[i := 1 to *D]) do
if i%8 = 0 then write()
write("\n")
return D
end
procedure freecellshuffle(D,gamenum)
srand_freecell(gamenum)
D2 := []
until *D = 0 do {
D[r := rand_freecell() % *D + 1] :=: D[*D]
put(D2,pull(D))
}
return D2
end
procedure srand_freecell(x)
static seed
return seed := \x | \seed | 0
end
procedure rand_freecell()
return ishift(srand_freecell((214013 * srand_freecell() + 2531011) % 2147483648),-16)
end
| package main
import (
"fmt"
"math"
"math/rand"
"os"
"strconv"
"time"
)
const sSuits = "CDHS"
const sNums = "A23456789TJQK"
const rMax32 = math.MaxInt32
var seed = 1
func rnd() int {
seed = (seed*214013 + 2531011) & rMax32
return seed >> 16
}
func deal(s int) []int {
seed = s
t := make([]int, 52)
for i := 0; i < 52; i++ {
t[i] = 51 - i
}
for i := 0; i < 51; i++ {
j := 51 - rnd()%(52-i)
t[i], t[j] = t[j], t[i]
}
return t
}
func show(cs []int) {
for i, c := range cs {
fmt.Printf(" %c%c", sNums[c/4], sSuits[c%4])
if (i+1)%8 == 0 || i+1 == len(cs) {
fmt.Println()
}
}
}
func main() {
var game int
switch len(os.Args) {
case 1:
rand.Seed(time.Now().UnixNano())
game = 1 + rand.Intn(32000)
case 2:
var err error
game, err = strconv.Atoi(os.Args[1])
if err == nil && game >= 1 && game <= 32000 {
break
}
fallthrough
default:
fmt.Println("usage: deal [game]")
fmt.Println(" where game is a number in the range 1 to 32000")
return
}
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.