Deal cards for FreeCell: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
(→{{header|Ruby}}: remove old code, optparse) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
| (70 intermediate revisions by 37 users not shown) | |||
Line 1:
{{task|Games}} [[Category:Cards]]
''Free Cell'' is the solitaire card game that Paul Alfille introduced to the PLATO system in 1978. Jim Horne, at Microsoft, changed the name to ''FreeCell'' and reimplemented the game for [[DOS]], then [[Windows]]. <br>
This version introduced 32000 numbered deals. (The [http://www.solitairelaboratory.com/fcfaq.html FreeCell FAQ] tells this history.)
Line 14 ⟶ 15:
* Rosetta Code has another task, [[linear congruential generator]], with code for this RNG in several languages.
<br>
The algorithm follows:
Line 25 ⟶ 27:
# Deal all 52 cards, face up, across 8 columns. The first 8 cards go in 8 columns, the next 8 cards go on the first 8 cards, and so on.
::::{| class="wikitable"
!| Order to deal cards
!| Game #1
Line 58 ⟶ 60:
Write a program to take a deal number and deal cards in the same order as this algorithm.
The program may display the cards with ASCII, with Unicode, by drawing graphics, or any other way.
Related tasks:
* [[Playing cards]]
* [[Card shuffles]]
* [[War Card_Game]]
* [[Poker hand_analyser]]
* [[Go Fish]]
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F randomGenerator(=seed, n)
[Int] r
-V max_int32 = 7FFF'FFFF
seed = seed [&] max_int32
L r.len < n
seed = (seed * 214013 + 2531011) [&] max_int32
r [+]= seed >> 16
R r
F deal(seed)
V nc = 52
V cards = Array((nc - 1 .< -1).step(-1))
V rnd = randomGenerator(seed, nc)
L(r) rnd
V j = (nc - 1) - r % (nc - L.index)
swap(&cards[L.index], &cards[j])
R cards
F show(cards)
V l = cards.map(c -> ‘A23456789TJQK’[Int(c / 4)]‘’‘CDHS’[c % 4])
L(i) (0 .< cards.len).step(8)
print((l[i .< i + 8]).join(‘ ’))
:start:
V seed = I :argv.len == 2 {Int(:argv[1])} E 11982
print(‘Hand #.’.format(seed))
V deck = deal(seed)
show(deck)</syntaxhighlight>
{{out}}
<pre>
Hand 11982
AH AS 4H AC 2D 6S TS JS
3D 3H QS QC 8S 7H AD KS
KD 6H 5S 4D 9H JH 9S 3C
JC 5D 5C 8C 9D TD KH 7C
6C 2C TH QH 6D TC 4S 7S
JD 7D 8H 9C 2H QD 4C 5H
KC 8D 2S 3S
</pre>
=={{header|Ada}}==
<
procedure FreeCell is
type State is mod 2**31;
Line 97 ⟶ 153:
New_Line;
Deal(617);
end FreeCell;</
{{out}}
<pre>JD 2D 9H JC 5D 7H 7C 5H
Line 116 ⟶ 172:
=={{header|AutoHotkey}}==
<
cards := "A23456789TJQK", suits := "♣♦♥♠", card := [], Counter := 0
loop, parse, cards
Line 139 ⟶ 195:
Seed := Mod(214013 * Seed + 2531011, 2147483648)
return, [Seed, Seed // 65536]
}</
MS() found at http://rosettacode.org/wiki/Linear_congruential_generator#AutoHotkey
Examples:<
Gui, add, edit, w320 r17 -VScroll, % "Game# 1`n" FreeCell(1) "`n`nGame#617`n" FreeCell(617)
Gui, show
Line 149 ⟶ 205:
GuiEscape:
ExitApp
return</
Outputs:<pre>Game# 1
J♦ 2♦ 9♥ J♣ 5♦ 7♥ 7♣ 5♥
Line 170 ⟶ 226:
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
hand% = 617
Line 214 ⟶ 270:
NEXT
ENDIF
= state >> 16</
{{out}}
[[File:freecell_BBC.gif]]
=={{header|Befunge}}==
<syntaxhighlight lang="befunge">vutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDC
>4$0" :rebmun emaG">:#,_$&>55+,>"O?+"**2+*"C4'' "**v
>8%!492*+*48*\-,1-:11p0g\0p11g#^_@A23456789TJQKCDHS*
^+3:g11,g2+"/"%4,g2+g14/4:-\"v"g0:%g11+*-/2-10-1*<>+
>8#8*#4*#::#%*#*/#*:#*0#:\#*`#:8#::#*:#8*#8:#2*#+^#<</syntaxhighlight>
{{out}}
<pre>Game number: 1
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H</pre>
=={{header|Bracmat}}==
<
= array rank ranks suit suits
. A 2 3 4 5 6 7 8 9 T J Q K:?ranks
Line 281 ⟶ 354:
& put$(deal$(!deck.617),"dealt.txt",APP)
&
)</
Content of <code>dealt.txt</code>:
<pre>Game #1
Line 303 ⟶ 376:
=={{header|C}}==
<
#include <stdlib.h>
#include <locale.h>
Line 348 ⟶ 421:
return 0;
}</
=={{header|C sharp|C#}}==
Longer than it absolutely needs to be because I split out several independently useful classes.
<
using System.Collections.Generic;
using System.Text;
Line 748 ⟶ 594:
}
}
}</
{{out}}
<pre>JD 2D 9H JC 5D 7H 7C 5H
Line 767 ⟶ 613:
</pre>
===Shorter version===
Shorter than the previous version. Adds a few classes, but stays closer to the gist of the C version.
<
using System;
using System.Text;
Line 829 ⟶ 675:
}
}
</syntaxhighlight>
{{out}}
<pre>Deck 1
Line 849 ⟶ 695:
J♦ K♠ K♣ 4♥
</pre>
=={{header|C++}}==
<syntaxhighlight lang="cpp">
#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;
}
//--------------------------------------------------------------------------------------------------
</syntaxhighlight>
Output:
<pre>
GAME #1
=======================
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
GAME #617
=======================
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H
</pre>
===OOP version===
This is written using a more object-oriented approach than the version above.
<syntaxhighlight lang="cpp">#include <string> // std::string
#include <iostream> // std::cout
#include <sstream> // std::stringstream
#include <vector> // std::vector
using namespace std;
//------------------------------------------------------------------------------
class Random {
public:
void init(uint32_t seed) { _seed = seed; }
int roll() { return (_seed = (_seed * MULT + INCR) & MASK) >> 16; }
private:
int _seed;
enum { MULT = 214013, INCR = 2531011, MASK = (1U << 31) - 1 };
};
//------------------------------------------------------------------------------
class Card {
public:
Card(int value) : _value(value) { }
int suit() const { return _value % 4; }
int rank() const { return _value / 4; }
string str() const {
stringstream s; s << _ranks[rank()] << _suits[suit()]; return s.str();
}
private:
int _value;
const char* _suits = "CDHS";
const char* _ranks = "A23456789TJQK";
};
//------------------------------------------------------------------------------
class Deck {
public:
Deck(int seed) {
_random.init(seed);
for (int i = 0; i < 52; i++)
_cards.push_back(Card(51 - i));
for (int i = 0; i < 51; i++) {
int j = 51 - _random.roll() % (52 - i);
swap(_cards[i], _cards[j]);
}
}
string str() const {
stringstream s;
for (int i = 0; i < _cards.size(); i++)
s << _cards[i].str() << (i % 8 == 7 || i == 51 ? "\n" : " ");
return s.str();
}
private:
vector<Card> _cards;
Random _random;
};
//------------------------------------------------------------------------------
int main(int argc, const char * argv[])
{
{
Deck deck(1);
cout << "Deck 1" << endl << deck.str() << endl;
}
{
Deck deck(617);
cout << "Deck 617" << endl << deck.str() << endl;
}
return 0;
}
</syntaxhighlight>
{{out}}
<pre>Deck 1
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
Deck 617
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H
</pre>
=={{header|Ceylon}}==
<syntaxhighlight lang="ceylon">shared void freeCellDeal() {
//a function that returns a random number generating function
function createRNG(variable Integer state) =>
() => (state = (214_013 * state + 2_531_011) % 2^31) / 2^16;
void deal(Integer num) {
// create an array with a list comprehension
variable value deck = Array {
for(rank in "A23456789TJQK")
for(suit in "CDHS")
"``rank````suit``"
};
value rng = createRNG(num);
for(i in 1..52) {
value index = rng() % deck.size;
assert(exists lastIndex = deck.lastIndex);
//swap the random card with the last one
deck.swap(index, lastIndex);
//print the last one
process.write("``deck.last else "missing card"`` " );
if(i % 8 == 0) {
print("");
}
//and shrink the array to remove the last card
deck = deck[...lastIndex - 1];
}
}
deal(1);
print("\n");
deal(617);
}</syntaxhighlight>
=={{header|Clojure}}==
<syntaxhighlight lang="clojure">(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)</syntaxhighlight>
=={{header|Common Lisp}}==
<syntaxhighlight lang="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)</syntaxhighlight>
=={{header|D}}==
{{trans|C}}
<
struct RandomGenerator {
Line 890 ⟶ 1,016:
cards.deal(seed);
cards.show;
}</
<pre>Hand 11982
AH AS 4H AC 2D 6S TS JS
Line 899 ⟶ 1,025:
JD 7D 8H 9C 2H QD 4C 5H
KC 8D 2S 3S</pre>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{Trans|C#}}
<syntaxhighlight lang="delphi">
program Deal_cards_for_FreeCell;
{$APPTYPE CONSOLE}
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;
{ TRandom }
function TRandom.Next: Integer;
begin
Seed := ((Seed * 214013 + 2531011) and Integer.MaxValue);
Result := Seed shr 16;
end;
{ TCard }
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;
{ TDeck }
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.</syntaxhighlight>
{{out}}
<pre>Deck 1
J♦ 2♦ 9♥ J♣ 5♦ 7♥ 7♣ 5♥
K♦ K♣ 9♠ 5♠ A♦ Q♣ K♥ 3♥
2♠ K♠ 9♦ Q♦ J♠ A♠ A♥ 3♣
4♣ 5♣ T♠ Q♥ 4♥ A♣ 4♦ 7♠
3♠ T♦ 4♠ T♥ 8♥ 2♣ J♥ 7♦
6♦ 8♠ 8♦ Q♠ 6♣ 3♦ 8♣ T♣
6♠ 9♣ 2♥ 6♥
Deck 617
7♦ A♦ 5♣ 3♠ 5♠ 8♣ 2♦ A♥
T♦ 7♠ Q♦ A♣ 6♦ 8♥ A♠ K♥
T♥ Q♣ 3♥ 9♦ 6♠ 8♦ 3♦ T♣
K♦ 5♥ 9♠ 3♣ 8♠ 7♥ 4♦ J♠
4♣ Q♠ 9♣ 9♥ 7♣ 6♥ 2♣ 2♠
4♠ T♠ 2♥ 5♦ J♣ 6♣ J♥ Q♥
J♦ K♠ K♣ 4♥</pre>
=={{header|EasyLang}}==
{{trans|Phix}}
<syntaxhighlight>
global seed .
func xrnd .
seed = (seed * 214013 + 2531011) mod 0x80000000
return seed div 0x10000
.
len cards[] 52
proc deal game_num . .
print "hand " & game_num
seed = game_num
for i = 1 to 52
cards[i] = 52 - i
.
for i = 1 to 51
j = 52 - xrnd mod (53 - i)
swap cards[i] cards[j]
.
.
suits$[] = strchars "CDHS"
ranks$[] = strchars "A23456789TJQK"
#
proc show . .
for idx = 1 to 52
rank = cards[idx] div 4 + 1
suit = cards[idx] mod 4 + 1
write ranks$[rank] & suits$[suit] & " "
if idx mod1 13 = 13
print ""
.
.
print ""
.
deal 1 ; show
deal 617 ; show
</syntaxhighlight>
=={{header|Elixir}}==
{{trans|Ruby}}
<syntaxhighlight lang="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 ##{seed}"
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</syntaxhighlight>
{{out}}
<pre>
C:\Elixir>elixir freecell.exs 1 617
Game #1
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
Game #617
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H
</pre>
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM FREECELL
Line 952 ⟶ 1,300:
SHOW(CARDS%[])
END PROGRAM
</syntaxhighlight>
{{out}}
<pre>
Line 973 ⟶ 1,321:
♠4 ♠T ♥2 ♦5 ♣J ♣6 ♥J ♥Q
♦J ♠K ♣K ♥4
</pre>
=={{header|F_sharp|F#}}==
The deal for this one is a little arduous, as we're using a list and maintain an immutable state. Of course, an array could be used, but what's the fun in that?
<syntaxhighlight lang="fsharp">
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
</syntaxhighlight>
{{out}}
<pre>
Game #1
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
Game #617
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H
</pre>
=={{header|Factor}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre>
Game #1
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
Game #617
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H
</pre>
Line 978 ⟶ 1,437:
{{works with|Fortran|95 and later}}
Using the lcgs module from [[Linear congruential generator#Fortran]]:
<
use lcgs
implicit none
Line 1,032 ⟶ 1,491:
call Freecelldeal(617)
end program</
{{out}}
<pre>Game #1
Line 1,051 ⟶ 1,510:
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' version 04-11-2016
' compile with: fbc -s console
' to seed ms_lcg(seed > -1)
' to get random number ms_lcg(-1) or ms_lcg() or just ms_lcg
Function ms_lcg(seed As Integer = -1) As UInteger
Static As UInteger ms_state
If seed <> -1 Then
ms_state = seed Mod 2 ^ 31
Else
ms_state = (214013 * ms_state + 2531011) Mod 2 ^ 31
End If
Return ms_state Shr 16
End Function
' ------=< MAIN >=------
Dim As UByte card(51)
Dim As String suit = "CDHS", value = "A23456789TJQK"
Dim As Long i, c, s, v, game = 1
Dim As ULong game_nr(1 To 2) = { 1, 617}
Do
ms_lcg(game_nr(game)) ' seed generator
Print "game #"; game_nr(game)
game = game + 1
For i = 0 To 51 ' set up the cards
card(i) = i
Next
For i = 51 To 0 Step -1 ' shuffle
c = ms_lcg Mod (i +1)
Swap card(i), card(c)
Next
c = 0
Do
For i = 0 To 7
s = card(51 - c) Mod 4
v = card(51 - c) \ 4
Print Chr(value[v]); Chr(suit[s]); " ";
c = c +1
If c > 51 Then Exit Do
Next
Print
Loop
Print : Print
Loop Until game > UBound(game_nr)
' empty keyboard buffer
While Inkey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End</syntaxhighlight>
{{out}}
<pre>game #1
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
game #617
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H</pre>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Deal_cards_for_FreeCell}}
'''Solution'''
There is no need to remove from a deal to be added to another one, it can be performed on a single array. It is and iteration from 52 to 1 indicating the end of the first array, and therefore the start of a second one after each swap. The only inconvenience is that second array contains the information in reversed order, but when it is shown it is also read in reversed order.
The number 127,185 is the decimal number of the 🃑 Unicode character.
In the Unicode playing cards characters, there is the Knight, between the Jack and Queen suits, which is not used, so it is skipped in the order.
[[File:Fōrmulæ - Deal cards for FreeCell 01.png]]
'''Test case.''' The —only— impossible deal #11982 in the original version of FreeCell for windows:
[[File:Fōrmulæ - Deal cards for FreeCell 02.png]]
[[File:Fōrmulæ - Deal cards for FreeCell 03.png]]
=={{header|Go}}==
{{trans|C}}
<
import (
Line 1,118 ⟶ 1,679:
fmt.Printf("\nGame #%d\n", game)
show(deal(game))
}</
{{out}}
<pre>
Line 1,138 ⟶ 1,699:
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H
</pre>
=={{header|Groovy}}==
<syntaxhighlight lang="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)
</syntaxhighlight>
{{out}}
<pre>
Game #1
♦J ♦2 ♥9 ♣J ♦5 ♥7 ♣7 ♥5
♦K ♣K ♠9 ♠5 ♦A ♣Q ♥K ♥3
♠2 ♠K ♦9 ♦Q ♠J ♠A ♥A ♣3
♣4 ♣5 ♠10 ♥Q ♥4 ♣A ♦4 ♠7
♠3 ♦10 ♠4 ♥10 ♥8 ♣2 ♥J ♦7
♦6 ♠8 ♦8 ♠Q ♣6 ♦3 ♣8 ♣10
♠6 ♣9 ♥2 ♥6
Game #617
♦7 ♦A ♣5 ♠3 ♠5 ♣8 ♦2 ♥A
♦10 ♠7 ♦Q ♣A ♦6 ♥8 ♠A ♥K
♥10 ♣Q ♥3 ♦9 ♠6 ♦8 ♦3 ♣10
♦K ♥5 ♠9 ♣3 ♠8 ♥7 ♦4 ♠J
♣4 ♠Q ♣9 ♥9 ♣7 ♥6 ♣2 ♠2
♠4 ♠10 ♥2 ♦5 ♣J ♣6 ♥J ♥Q
♦J ♠K ♣K ♥4
</pre>
=={{header|Haskell}}==
{{trans|C}}
<
import Data.Bits
import Data.List
Line 1,177 ⟶ 1,804:
putStrLn $ "Deal " ++ show s ++ ":"
let cards = deal s
showCards cards</
Execution:
Line 1,192 ⟶ 1,819:
=={{header|Icon}} and {{header|Unicon}}==
<
freecelldealer(\A[1] | &null) # seed from command line
end
Line 1,234 ⟶ 1,861:
procedure rand_freecell() #: lcrng
return ishift(srand_freecell((214013 * srand_freecell() + 2531011) % 2147483648),-16)
end</
{{out|Sample output for game 1}}
<pre>Hand:
Line 1,249 ⟶ 1,876:
=={{header|J}}==
Paraphrase of [[#C|C]]:
<
srnd=: 3 :'SEED=:{.y,11982'
Line 1,260 ⟶ 1,887:
deal=: |.@(swaps pairs) bind deck
show=: (,"2)@:(_8 ]\ ' '&,.)</
{{out|Example use}}
<
J♦ 2♦ 9♥ J♣ 5♦ 7♥ 7♣ 5♥
K♦ K♣ 9♠ 5♠ A♦ Q♣ K♥ 3♥
Line 1,277 ⟶ 1,904:
4♣ Q♠ 9♣ 9♥ 7♣ 6♥ 2♣ 2♠
4♠ T♠ 2♥ 5♦ J♣ 6♣ J♥ Q♥
J♦ K♠ K♣ 4♥ </
=={{header|Java}}==
<
import java.util.Arrays;
Line 1,289 ⟶ 1,916:
private String[] deck = {
"AC", "AD", "AH", "AS",
"2C", "2D", "2H", "
"3C", "3D", "3H", "3S",
"4C", "4D", "4H", "4S",
Line 1,343 ⟶ 1,970:
}
</syntaxhighlight>
{{out}}
<pre>
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
Line 1,358 ⟶ 1,985:
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H
Line 1,365 ⟶ 1,992:
=={{header|JavaScript}}==
<
/*
* Microsoft C Run-time-Library-compatible Random Number Generator
Line 1,452 ⟶ 2,079:
return columns.map(render_column).join("");
}
</syntaxhighlight>
=={{header|Julia}}==
{{trans|Lua}}
<syntaxhighlight lang="julia">const rank = split("A23456789TJQK", "")
const suit = split("♣♦♥♠", "")
const deck = Vector{String}()
const mslcg = [0]
rng() = (mslcg[1] = ((mslcg[1] * 214013 + 2531011) & 0x7fffffff)) >> 16
initdeck() = for r in rank, s in suit push!(deck, "$r$s") end
function deal(num = rand(UInt,1)[1] % 32000 + 1)
initdeck()
mslcg[1] = num
println("\nGame # ", num)
while length(deck) > 0
choice = rng() % length(deck) + 1
deck[choice], deck[end] = deck[end], deck[choice]
print(" ", pop!(deck), length(deck) % 8 == 4 ? "\n" : "")
end
end
deal(1)
deal(617)
deal()
</syntaxhighlight> {{output}} <pre>
Game # 1
J♦ 2♦ 9♥ J♣ 5♦ 7♥ 7♣ 5♥
K♦ K♣ 9♠ 5♠ A♦ Q♣ K♥ 3♥
2♠ K♠ 9♦ Q♦ J♠ A♠ A♥ 3♣
4♣ 5♣ T♠ Q♥ 4♥ A♣ 4♦ 7♠
3♠ T♦ 4♠ T♥ 8♥ 2♣ J♥ 7♦
6♦ 8♠ 8♦ Q♠ 6♣ 3♦ 8♣ T♣
6♠ 9♣ 2♥ 6♥
Game # 617
7♦ A♦ 5♣ 3♠ 5♠ 8♣ 2♦ A♥
T♦ 7♠ Q♦ A♣ 6♦ 8♥ A♠ K♥
T♥ Q♣ 3♥ 9♦ 6♠ 8♦ 3♦ T♣
K♦ 5♥ 9♠ 3♣ 8♠ 7♥ 4♦ J♠
4♣ Q♠ 9♣ 9♥ 7♣ 6♥ 2♣ 2♠
4♠ T♠ 2♥ 5♦ J♣ 6♣ J♥ Q♥
J♦ K♠ K♣ 4♥
Game # 20065
7♥ 8♠ T♣ 3♦ T♥ 2♥ 6♥ K♥
K♣ A♣ 4♣ 5♥ 9♠ K♠ K♦ J♦
8♦ 6♦ J♣ 6♠ T♠ 7♦ 7♠ Q♥
7♣ J♠ A♠ 4♦ 5♣ 2♠ A♥ T♦
A♦ 6♣ Q♣ 8♥ 3♣ 5♦ 3♠ 3♥
9♦ 2♦ Q♦ 4♠ 5♠ 9♥ 8♣ 4♥
9♣ 2♣ J♥ Q♠
</pre>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1.3
class Lcg(val a: Long, val c: Long, val m: Long, val d: Long, val s: Long) {
private var state = s
fun nextInt(): Long {
state = (a * state + c) % m
return state / d
}
}
const val CARDS = "A23456789TJQK"
const val SUITS = "♣♦♥♠"
fun deal(): Array<String?> {
val cards = arrayOfNulls<String>(52)
for (i in 0 until 52) {
val card = CARDS[i / 4]
val suit = SUITS[i % 4]
cards[i] = "$card$suit"
}
return cards
}
fun game(n: Int) {
require(n > 0)
println("Game #$n:")
val msc = Lcg(214013, 2531011, 1 shl 31, 1 shl 16, n.toLong())
val cards = deal()
for (m in 52 downTo 1) {
val index = (msc.nextInt() % m).toInt()
val temp = cards[index]
cards[index] = cards[m - 1]
print("$temp ")
if ((53 - m) % 8 == 0) println()
}
println("\n")
}
fun main(args: Array<String>) {
game(1)
game(617)
}</syntaxhighlight>
{{out}}
<pre>
Game #1:
J♦ 2♦ 9♥ J♣ 5♦ 7♥ 7♣ 5♥
K♦ K♣ 9♠ 5♠ A♦ Q♣ K♥ 3♥
2♠ K♠ 9♦ Q♦ J♠ A♠ A♥ 3♣
4♣ 5♣ T♠ Q♥ 4♥ A♣ 4♦ 7♠
3♠ T♦ 4♠ T♥ 8♥ 2♣ J♥ 7♦
6♦ 8♠ 8♦ Q♠ 6♣ 3♦ 8♣ T♣
6♠ 9♣ 2♥ 6♥
Game #617:
7♦ A♦ 5♣ 3♠ 5♠ 8♣ 2♦ A♥
T♦ 7♠ Q♦ A♣ 6♦ 8♥ A♠ K♥
T♥ Q♣ 3♥ 9♦ 6♠ 8♦ 3♦ T♣
K♦ 5♥ 9♠ 3♣ 8♠ 7♥ 4♦ J♠
4♣ Q♠ 9♣ 9♥ 7♣ 6♥ 2♣ 2♠
4♠ T♠ 2♥ 5♦ J♣ 6♣ J♥ Q♥
J♦ K♠ K♣ 4♥
</pre>
=={{header|Logo}}==
<syntaxhighlight lang="logo">; Linear congruential random number generator
make "_lcg_state 0
to seed_lcg :seed
make "_lcg_state :seed
end
to sample_lcg
make "_lcg_state modulo sum product 214013 :_lcg_state 2531011 2147483648
output int quotient :_lcg_state 65536
end
; FreeCell
to card_from_number :number
output word item sum 1 int quotient :number 4 "A23456789TJQK item sum 1 modulo :number 4 "CDHS
end
to generate_deal :number
(local "deck "size "index "deal)
seed_lcg :number
make "deck []
repeat 52 [
make "deck lput difference # 1 :deck
]
make "deck listtoarray :deck
make "deal []
repeat 52 [
make "size difference 53 #
make "index sum 1 modulo sample_lcg :size
make "deal lput item :index :deck :deal
setitem :index :deck item :size :deck
]
output :deal
end
to print_deal :number
(local "deal "i "j "index)
make "deal generate_deal :number
repeat 7 [
make "i difference # 1
repeat (ifelse [equal? :i 6] 4 8) [
make "j difference # 1
make "index (sum 1 product :i 8 :j)
type (word (card_from_number item :index :deal) "| |)
]
print "||
]
end
print [Game #1]
print_deal 1
print "||
print [Game #617]
print_deal 617
print "||
bye</syntaxhighlight>
{{Out}}
<pre>Game #1
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
Game #617
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H</pre>
=={{header|Lua}}==
Uses bit32 library added in Lua 5.2.
<
rank = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K"}
suit = {"C", "D", "H", "S"}
Line 1,491 ⟶ 2,312:
deal(1)
deal(617)</
{{out}}
<pre>Game #1
Line 1,509 ⟶ 2,330:
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">next[last_] := Mod[214013 last + 2531011, 2^31];
deal[n_] :=
Module[{last = n, idx,
deck = StringJoin /@
Tuples[{{"A", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J",
"Q", "K"}, {"C", "D", "H", "S"}}], res = {}},
While[deck != {}, last = next[last];
idx = Mod[BitShiftRight[last, 16], Length[deck]] + 1;
deck = ReplacePart[deck, {idx -> deck[[-1]], -1 -> deck[[idx]]}];
AppendTo[res, deck[[-1]]]; deck = deck[[;; -2]]]; res];
format[deal_] := Grid[Partition[deal, 8, 8, {1, 4}, Null]];
Print[format[deal[1]]];
Print[format[deal[617]]];</syntaxhighlight>
{{out}}
<pre>JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H</pre>
=={{header|Nim}}==
{{trans|Python}}
<
proc randomGenerator(seed: int): iterator: int =
var
return iterator: int =
while true:
yield
proc deal(seed: int): seq[int] =
const nc = 52
result = toSeq countdown(nc - 1, 0)
var rnd = randomGenerator seed
for i in 0 ..
let r = rnd()
let j = (nc - 1) - r mod (nc - i)
swap result[i], result[j]
proc show(cards: seq[int]) =
var l = newSeq[string]()
for c in cards:
Line 1,536 ⟶ 2,388:
for i in countup(0, cards.high, 8):
echo " ", l[i..min(i+7, l.high)].join(" ")
let seed = if paramCount() == 1: paramStr(1).parseInt else: 11982
echo "Hand ", seed
let deck = deal seed
show deck</
Output:
<pre>Hand 11982
Line 1,550 ⟶ 2,402:
JD 7D 8H 9C 2H QD 4C 5H
KC 8D 2S 3S</pre>
=={{header|Objeck}}==
{{trans|C#}}
<syntaxhighlight lang="objeck">class FreeCell {
function : Main(args : String[]) ~ Nil {
Deal(1)->PrintLine();
Deal(617)->PrintLine();
}
function : Deal(seed : Int) ~ String {
deck := Deck->New(seed)->ToString();
return "Game #{$seed}:\n{$deck}\n";
}
}
class Deck {
@cards : Card[];
New(seed : Int) {
r := Random->New(seed);
@cards := Card->New[52];
for(i := 0; i < 52; i+= 1;) {
@cards[i] := Card->New(51 - i);
};
for(i := 0; i < 51; i += 1;) {
j := 51 - r->Next() % (52 - i);
tmp := @cards[i]; @cards[i] := @cards[j]; @cards[j] := tmp;
};
}
method : public : ToString() ~ String {
buffer := "";
each(i : @cards) {
buffer += @cards[i]->ToString();
buffer += (i % 8 = 7 ? "\n" : " ");
};
return buffer;
}
}
class Random {
@seed : Int;
New(seed : Int) {
@seed := seed;
}
method : public : Next() ~ Int {
@seed := (@seed * 214013 + 2531011) and Int->MaxSize();
return @seed >> 16;
}
}
class Card {
@value : Int;
@suit : Int;
New(value : Int) {
@value := value / 4; @suit := value % 4;
}
method : public : ToString() ~ String {
suits := "♣♦♥♠"; values := "A23456789TJQK";
value := values->Get(@value); suit := suits->Get(@suit);
return "{$value}{$suit}";
}
}</syntaxhighlight>
Output:
<pre>
Game #1:
J♦ 2♦ 9♥ J♣ 5♦ 7♥ 7♣ 5♥
K♦ K♣ 9♠ 5♠ A♦ Q♣ K♥ 3♥
2♠ K♠ 9♦ Q♦ J♠ A♠ A♥ 3♣
4♣ 5♣ T♠ Q♥ 4♥ A♣ 4♦ 7♠
3♠ T♦ 4♠ T♥ 8♥ 2♣ J♥ 7♦
6♦ 8♠ 8♦ Q♠ 6♣ 3♦ 8♣ T♣
6♠ 9♣ 2♥ 6♥
Game #617:
7♦ A♦ 5♣ 3♠ 5♠ 8♣ 2♦ A♥
T♦ 7♠ Q♦ A♣ 6♦ 8♥ A♠ K♥
T♥ Q♣ 3♥ 9♦ 6♠ 8♦ 3♦ T♣
K♦ 5♥ 9♠ 3♣ 8♠ 7♥ 4♦ J♠
4♣ Q♠ 9♣ 9♥ 7♣ 6♥ 2♣ 2♠
4♠ T♠ 2♥ 5♦ J♣ 6♣ J♥ Q♥
J♦ K♠ K♣ 4♥
</pre>
=={{header|Objective-C}}==
Based on the shorter C# version. Objective-C can use the C code as-is, but this example uses some NS foundation classes. The [http://weblog.bignerdranch.com/398-objective-c-literals-part-1/ latest clang compiler] is assumed with [http://en.wikipedia.org/wiki/Automatic_Reference_Counting ARC] enabled. For the sake of clarity & simplicity, method prototypes have been omitted from @interface sections: they are not necessary if everything is in one file.
<
//--------------------------------------------------------------------
Line 1,641 ⟶ 2,587:
}
return 0;
}</
{{out}}
<pre>Deck 1
Line 1,664 ⟶ 2,610:
=={{header|OCaml}}==
{{trans|C}}
<
(* since OCaml's built-in int type is at least 31 (note: not 32) bits wide,
and this problem takes mod 2^31, it is just enough if we treat it as
Line 1,704 ⟶ 2,650:
Printf.printf "Deal %d:\n" s;
let cards = deal s in
show cards</
{{out|Execution}}
<pre>$ ocaml freecell.ml 617
Line 1,718 ⟶ 2,664:
=={{header|PARI/GP}}==
The use of <code>local</code> is critical here, so that <code>nextrand()</code> has access to the current state unaffected by whatever the user may have stored in the variable <code>'state</code>.
<
nextrand()={
(state=(214013*state+2531011)%2^31)>>16
Line 1,730 ⟶ 2,676:
deck[t]=deck[last]
)
};</
=={{header|Perl}}==
<
use strict;
Line 1,774 ⟶ 2,720:
binmode STDOUT, ':encoding(utf-8)';
print "Hand $hand_idx\n";
print $string;</
=={{header|
{{trans|ERRE}}
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">seed</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">xrnd</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">seed</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">seed</span><span style="color: #0000FF;">*</span><span style="color: #000000;">214013</span><span style="color: #0000FF;">+</span><span style="color: #000000;">2531011</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#7FFFFFFF</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">seed</span><span style="color: #0000FF;">/</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">16</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">cards</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">52</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">deal</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">game_num</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">seed</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">game_num</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">52</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">cards</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">52</span><span style="color: #0000FF;">-</span><span style="color: #000000;">i</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">51</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">j</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">52</span><span style="color: #0000FF;">-</span><span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">xrnd</span><span style="color: #0000FF;">(),</span><span style="color: #000000;">53</span><span style="color: #0000FF;">-</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">cards</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #000000;">cards</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">cards</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span>
<span style="color: #000000;">cards</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">s</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">suits</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"CDHS"</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">ranks</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"A23456789TJQK"</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">show</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">idx</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">52</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">rank</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cards</span><span style="color: #0000FF;">[</span><span style="color: #000000;">idx</span><span style="color: #0000FF;">]/</span><span style="color: #000000;">4</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">suit</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cards</span><span style="color: #0000FF;">[</span><span style="color: #000000;">idx</span><span style="color: #0000FF;">],</span><span style="color: #000000;">4</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">eol</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">idx</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">13</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">12</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%c%c%s"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">ranks</span><span style="color: #0000FF;">[</span><span style="color: #000000;">rank</span><span style="color: #0000FF;">],</span><span style="color: #000000;">suits</span><span style="color: #0000FF;">[</span><span style="color: #000000;">suit</span><span style="color: #0000FF;">],</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">eol</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">)})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">game_num</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
<span style="color: #000080;font-style:italic;">--integer game_num=617</span>
<span style="color: #000000;">deal</span><span style="color: #0000FF;">(</span><span style="color: #000000;">game_num</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"hand %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">game_num</span><span style="color: #0000FF;">})</span>
<span style="color: #000000;">show</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
hand 1
JD 2D 9H JC 5D 7H 7C 5H KD KC 9S 5S AD
QC KH 3H 2S KS 9D QD JS AS AH 3C 4C 5C
TS QH 4H AC 4D 7S 3S TD 4S TH 8H 2C JH
7D 6D 8S 8D QS 6C 3D 8C TC 6S 9C 2H 6H
hand 617
7D AD 5C 3S 5S 8C 2D AH TD 7S QD AC 6D
8H AS KH TH QC 3H 9D 6S 8D 3D TC KD 5H
9S 3C 8S 7H 4D JS 4C QS 9C 9H 7C 6H 2C
2S 4S TS 2H 5D JC 6C JH QH JD KS KC 4H
</pre>
=={{header|PHP}}==
<syntaxhighlight lang="php">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 );
// seed RNG with game number
$this->state = $this->game;
while ( ! empty( $this->deck ) ) {
// choose random card
$i = $this->lcg_rnd() % count( $this->deck );
// move random card to game deal pile
$this->deal[] = $this->deck[ $i ];
// move last card to random card spot
$this->deck[ $i ] = end( $this->deck );
// remove last card from 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();
}
</syntaxhighlight>
{{Out}}
<pre>
======= Game 1 ========
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
====== Game 617 =======
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H
===== Game 11982 ======
AH AS 4H AC 2D 6S TS JS
3D 3H QS QC 8S 7H AD KS
KD 6H 5S 4D 9H JH 9S 3C
JC 5D 5C 8C 9D TD KH 7C
6C 2C TH QH 6D TC 4S 7S
JD 7D 8H 9C 2H QD 4C 5H
KC 8D 2S 3S
</pre>
=={{header|PicoLisp}}==
Using the random generator from [[Linear congruential generator#PicoLisp]]:
<
(de msRand ()
Line 1,839 ⟶ 2,895:
(prin " ^[[" (cadr C) "m" (cddr C) "^[[m" (car C))
(at (0 . 8) (prinl)) )
(prinl) )</
=={{header|PureBasic}}==
<
Global deckSize
Global Dim cards(#MaxCardNum) ;card with highest index is at the top of deck
Line 1,888 ⟶ 2,944:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
{{out|Sample output}}
<pre>Hand #1
Line 1,917 ⟶ 2,973:
=={{header|Python}}==
{{trans|D}}
<syntaxhighlight lang
def randomGenerator(seed=1):
Line 1,929 ⟶ 2,985:
def deal(seed):
nc = 52
cards = list(range(nc - 1, -1, -1))
rnd = randomGenerator(seed)
for i, r in zip(range(nc), rnd):
Line 1,937 ⟶ 2,993:
def show(cards):
l = ["A23456789TJQK"[int(c
for i in range(0, len(cards), 8):
print
if __name__ == '__main__':
from sys import argv
seed = int(argv[1]) if len(argv) == 2 else 11982
print
deck = deal(seed)
show(deck)</
{{out}}
<pre>Hand 11982
=={{header|Quackery}}==
<code>MCR-seed</code> and <code>MCR-rand</code> are defined at [[Linear congruential generator#Quackery]].
<syntaxhighlight lang="Quackery"> [ [ [] 52 times
[ i^ join ] ]
constant ] is newpack ( --> n )
[ 2dup peek
dip [ over -1 peek ]
swap 2swap poke
-1 poke ] is to-end ( [ n --> [ )
[ [] swap
52 times
[ MCR-rand
over size mod
to-end
-1 split
swap dip join ]
drop ] is mixem ( [ --> [ )
[ 4 /mod
$ "A23456789TJQK"
rot peek emit
$ "CDHS"
swap peek emit ] is echocard ( n --> )
[ witheach
[ echocard
i^ 8 mod 7 =
iff cr else sp ] ] is echopack ( [ --> )
[ MCR-seed replace
newpack
mixem
echopack ] is deal ( n --> )
' [ 1 617 11982 ]
witheach
[ say "Deal #"
dup echo cr
deal cr cr ]</syntaxhighlight>
{{out}}
<pre>Deal #1
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
Deal #617
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H
Deal #11982
AH AS 4H AC 2D 6S TS JS
3D 3H QS QC 8S 7H AD KS
KD 6H 5S 4D 9H JH 9S 3C
JC 5D 5C 8C 9D TD KH 7C
6C 2C TH QH 6D TC 4S 7S
JD 7D 8H 9C 2H QD 4C 5H
KC 8D 2S 3S
</pre>
=={{header|R}}==
<syntaxhighlight lang="r">## Linear congruential generator code not original -
## copied from
## http://www.rosettacode.org/wiki/Linear_congruential_generator#R
## altered to allow seed as an argument
library(gmp) # for big integers
rand_MS <- function(n = 1, seed = 1) {
a <- as.bigz(214013)
c <- as.bigz(2531011)
m <- as.bigz(2^31)
x <- rep(as.bigz(0), n)
x[1] <- (a * as.bigz(seed) + c) %% m
i <- 1
while (i < n) {
x[i+1] <- (a * x[i] + c) %% m
i <- i + 1
}
as.integer(x / 2^16)
}
## =============================
## New code follows:
## =============================
dealFreeCell <- function(seedNum) {
deck <- paste(rep(c("A",2,3,4,5,6,7,8,9,10,"J","Q","K"), each = 4), c("C","D","H","S"), sep = "")
cards = rand_MS(52,seedNum)
for (i in 52:1) {
cardToPick <- (cards[53-i]%% i)+1 # R indexes from 1, not 0
deck[c(cardToPick,i)] <- deck[c(i, cardToPick)]
}
deck <- rev(deck) # flip the deck to deal
deal = matrix(c(deck,NA,NA,NA,NA),ncol = 8, byrow = TRUE)
# using a matrix for simple printing, but requires filling with NA
# if implementing as a game, a list for each pile would make more sense
print(paste("Hand numer:",seedNum), quote = FALSE)
print(deal, quote = FALSE, na.print = "")
}
</syntaxhighlight>
{{out}}
<pre>
> dealFreeCell(1)
[1] Hand numer: 1
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
[1,] JD 2D 9H JC 5D 7H 7C 5H
[2,] KD KC 9S 5S AD QC KH 3H
[3,] 2S KS 9D QD JS AS AH 3C
[4,] 4C 5C 10S QH 4H AC 4D 7S
[5,] 3S 10D 4S 10H 8H 2C JH 7D
[6,] 6D 8S 8D QS 6C 3D 8C 10C
[7,] 6S 9C 2H 6H
> dealFreeCell(617)
[1] Hand numer: 617
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
[1,] 7D AD 5C 3S 5S 8C 2D AH
[2,] 10D 7S QD AC 6D 8H AS KH
[3,] 10H QC 3H 9D 6S 8D 3D 10C
[4,] KD 5H 9S 3C 8S 7H 4D JS
[5,] 4C QS 9C 9H 7C 6H 2C 2S
[6,] 4S 10S 2H 5D JC 6C JH QH
[7,] JD KS KC 4H
</pre>
=={{header|Racket}}==
<
(module Linear_congruential_generator racket
Line 2,016 ⟶ 3,215:
(present-deal 1)
(newline)
(present-deal 617)</
{{out}}
Line 2,036 ⟶ 3,235:
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H</pre>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|rakudo|2016.05}}
<syntaxhighlight lang="raku" line>sub dealgame ($game-number = 1) {
sub ms-lcg-method($seed = $game-number) { ( 214013 * $seed + 2531011 ) % 2**31 }
# lazy list of the random sequence
my @ms-lcg = |(&ms-lcg-method ... *).map: * +> 16;
constant CardBlock = '🂠'.ord;
my @deck = gather for flat(1..11,13,14) X+ (48,32...0) -> $off {
take chr CardBlock + $off;
}
my @game = gather while @deck {
@deck[@ms-lcg.shift % @deck, @deck-1] .= reverse;
take @deck.pop;
}
say "Game #$game-number";
say @game.splice(0, 8 min +@game) while @game;
}
dealgame;
dealgame 617;</syntaxhighlight>
{{out}}
<big><big><pre>Game #1
🃋 🃂 🂹 🃛 🃅 🂷 🃗 🂵
🃎 🃞 🂩 🂥 🃁 🃝 🂾 🂳
🂢 🂮 🃉 🃍 🂫 🂡 🂱 🃓
🃔 🃕 🂪 🂽 🂴 🃑 🃄 🂧
🂣 🃊 🂤 🂺 🂸 🃒 🂻 🃇
🃆 🂨 🃈 🂭 🃖 🃃 🃘 🃚
🂦 🃙 🂲 🂶
Game #617
🃇 🃁 🃕 🂣 🂥 🃘 🃂 🂱
🃊 🂧 🃍 🃑 🃆 🂸 🂡 🂾
🂺 🃝 🂳 🃉 🂦 🃈 🃃 🃚
🃎 🂵 🂩 🃓 🂨 🂷 🃄 🂫
🃔 🂭 🃙 🂹 🃗 🂶 🃒 🂢
🂤 🂪 🂲 🃅 🃛 🃖 🂻 🂽
🃋 🂮 🃞 🂴</pre></big></big>
=={{header|REXX}}==
This REXX version supports EBCDIC and ASCII symbols (used for the cards).
It also supports any number for the number of columns (default is 8).
See the ''discussion'' page for support for '''game = ─1''' and '''game= ─2''' (minus one and minus two).
<syntaxhighlight lang="rexx">/*REXX program deals cards for a specific FreeCell solitaire card game (0 ──► 32767).*/
numeric digits 15 /*ensure enough digits for the random #*/
parse arg game cols . /*obtain optional arguments from the CL*/
if game=='' | game=="," then game=1 /*No game specified? Then use default.*/
if cols=='' | cols=="," then cols=8 /* " cols " " " " */
state=game /*seed random # generator with game num*/
if 8=='f8'x then suit= "cdhs" /*EBCDIC? Then use letters for suits.*/
else suit= "♣♦♥♠" /* ASCII? " " symbols " " */
rank= 'A23456789tJQK' /*t in the rank represents a ten (10).*/
pad=left('', 13) /*used for indentation for the tableau.*/
say center('tableau for FreeCell game' game, 50, "─") /*show title for FreeCell game #*/
say /* [↓] @ is an array of all 52 cards.*/
#=-1; do r=1 for length(rank) /*build the deck first by the rank. */
do s=1 for length(suit); #=#+1 /* " " " secondly " " suit. */
@.#=substr(rank, r,1)substr(suit, s,1) /*build the $ array one card at at time*/
end /*s*/ /* [↑] first card is number 0 (zero).*/
end /*r*/ /* [↑] build deck per FreeCell rules. */
$=pad /*@: cards to be dealt, eight at a time*/
do cards=51 by -1 for 52 /* [↓] deal the cards for the tableau.*/
?=rand() // (cards+1) /*get next rand#; card # is remainder.*/
$=$ @.?; @.?=@.cards /*swap two cards: use random and last.*/
if words($)==cols then do; say $; $=pad /*deal FreeCell cards for the tableau. */
end
end /*cards*/ /*normally, 8 cards are dealt to a row.*/
/* [↓] residual cards may exist. */
if $\='' then say $ /*Any residual cards in the tableau ? */
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
rand: state=(214013*state + 2531011) // 2**31; return state % 2**16 /*FreeCell rand#*/</syntaxhighlight>
'''output''' when using the default game number: <tt> 1 </tt>
<pre>
───────────tableau for FreeCell game 1────────────
J♦ 2♦ 9♥ J♣ 5♦ 7♥ 7♣ 5♥
K♦ K♣ 9♠ 5♠ A♦ Q♣ K♥ 3♥
2♠ K♠ 9♦ Q♦ J♠ A♠ A♥ 3♣
4♣ 5♣ t♠ Q♥ 4♥ A♣ 4♦ 7♠
3♠ t♦ 4♠ t♥ 8♥ 2♣ J♥ 7♦
6♦ 8♠ 8♦ Q♠ 6♣ 3♦ 8♣ t♣
6♠ 9♣ 2♥ 6♥
</pre>
'''output''' when using the game number: <tt> 617 </tt>
<pre>
──────────tableau for FreeCell game 617───────────
7♦ A♦ 5♣ 3♠ 5♠ 8♣ 2♦ A♥
t♦ 7♠ Q♦ A♣ 6♦ 8♥ A♠ K♥
t♥ Q♣ 3♥ 9♦ 6♠ 8♦ 3♦ t♣
K♦ 5♥ 9♠ 3♣ 8♠ 7♥ 4♦ J♠
4♣ Q♠ 9♣ 9♥ 7♣ 6♥ 2♣ 2♠
4♠ t♠ 2♥ 5♦ J♣ 6♣ J♥ Q♥
J♦ K♠ K♣ 4♥
</pre>
=={{header|Ruby}}==
<
# No arguments? Pick any of first 32000 games.
begin
Line 2,071 ⟶ 3,373:
deck.each_slice(8) {|row| puts " " + row.join(" ")}
puts
end</
{{out}}
<pre>
Line 2,095 ⟶ 3,397:
=={{header|Run BASIC}}==
<
imageDir$ = DefaultDir$ + "\projects\" + projectDir$ + "\image\" ' directory of deck images
imagePath$ = "../";projectDir$;"/image/" ' path of deck images
suite$ = "C,D,H,S" ' Club,Diamond,
card$ = "A,2,3,4,5,6,7,8,9,T,J,Q,K" ' Cards Ace to King
Line 2,127 ⟶ 3,429:
if card = 52 then end ' out of cards
next xx
next yy</
[[File:freeCell.png]]
Line 2,134 ⟶ 3,436:
Based on JavaScript.
<syntaxhighlight lang="rust">// Code available at https://rosettacode.org/wiki/Linear_congruential_generator#Rust
extern crate linear_congruential_generator;
use linear_congruential_generator::{MsLcg, Rng, SeedableRng};
// We can't use `rand::Rng::shuffle` because it uses the more uniform `rand::Rng::gen_range`
// (`% range` is subject to modulo bias). If an exact match of the old dealer is not needed,
// `rand::Rng::shuffle` should be used.
fn shuffle<T>(rng: &mut MsLcg, deck: &mut [T]) {
let len = deck.len() as u32;
for i in (1..len).rev() {
deck.swap(i as usize, j as usize);
}
}
fn gen_deck() -> Vec<String> {
const RANKS: [char; 13] = ['A','2','3','4','5','6','7','8','9','T','J','Q','K'];
const SUITS: [char; 4] = ['C', 'D', 'H', 'S'];
let render_card = |card: usize| {
let (suit, rank) = (card % 4, card / 4);
format!("{}{}", RANKS[rank], SUITS[suit])
};
(0..52).map(render_card).collect()
}
fn deal_ms_fc_board(seed: u32) -> Vec<String> {
let mut
let mut deck = gen_deck();
shuffle(&mut rng, &mut deck);
deck.reverse();
deck.chunks(8).map(|row| row.join(" ")).collect::<Vec<_>>()
}
fn main() {
let seed = std::env::args()
.nth(1)
.and_then(|n| n.parse().ok())
.expect("A 32-bit seed is required");
for
}
}
</syntaxhighlight>
=={{header|Scala}}==
<syntaxhighlight lang="scala">object Shuffler extends App {
private val suits = Array("C", "D", "H", "S")
private val values = Array("A", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K")
private val deck = values.flatMap(v => suits.map(s => s"$v$s"))
private var seed: Int = _
private def random() = {
seed = (214013 * seed + 2531011) & Integer.MAX_VALUE
seed >> 16
}
private def getShuffledDeck = {
for(i <- deck.length - 1 until 0 by -1) {
val r = random() % (i + 1)
val
d(i) = card
}
d.reverse
}
def deal(seed: Int): Unit = {
this.seed = seed
getShuffledDeck.grouped(8).foreach(e => println(e.mkString(" ")))
}
deal(1)
println
deal(617)
}</syntaxhighlight>
{{out}}
<pre>
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
</pre>
<pre>
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H
</pre>
=={{header|Seed7}}==
<
include "console.s7i";
Line 2,286 ⟶ 3,606:
writeln("Hand " <& gameNum);
show(cards);
end func;</
{{out}}
Line 2,308 ⟶ 3,628:
♠4 ♠T ♥2 ♦5 ♣J ♣6 ♥J ♥Q
♦J ♠K ♣K ♥4
</pre>
=={{header|Swift}}==
Swift 4.2. Largely based on the Objective-C example.
<syntaxhighlight lang="swift">enum Suit : String, CustomStringConvertible, CaseIterable {
case clubs = "C", diamonds = "D", hearts = "H", spades = "S"
var description: String {
return self.rawValue
}
}
enum Rank : Int, CustomStringConvertible, CaseIterable {
case ace=1, two, three, four, five, six, seven
case eight, nine, ten, jack, queen, king
var description: String {
let d : [Rank:String] = [.ace:"A", .king:"K", .queen:"Q", .jack:"J", .ten:"T"]
return d[self] ?? String(self.rawValue)
}
}
struct Card : CustomStringConvertible {
let rank : Rank, suit : Suit
var description : String {
return String(describing:self.rank) + String(describing:self.suit)
}
init(rank:Rank, suit:Suit) {
self.rank = rank; self.suit = suit
}
init(sequence n:Int) {
self.init(rank:Rank.allCases[n/4], suit:Suit.allCases[n%4])
}
}
struct Deck : CustomStringConvertible {
var cards = [Card]()
init(seed:Int) {
for i in (0..<52).reversed() {
self.cards.append(Card(sequence:i))
}
struct MicrosoftLinearCongruentialGenerator {
var seed : Int
mutating func next() -> Int {
self.seed = (self.seed * 214013 + 2531011) % (Int(Int32.max)+1)
return self.seed >> 16
}
}
var r = MicrosoftLinearCongruentialGenerator(seed: seed)
for i in 0..<51 {
self.cards.swapAt(i, 51-r.next()%(52-i))
}
}
var description : String {
var s = ""
for (ix,c) in self.cards.enumerated() {
s.write(String(describing:c))
s.write(ix % 8 == 7 ? "\n" : " ")
}
return s
}
}
let d1 = Deck(seed: 1)
print(d1)
let d617 = Deck(seed: 617)
print(d617)
</syntaxhighlight>
{{out}}
<pre>
JD 2D 9H JC 5D 7H 7C 5H
KD KC 9S 5S AD QC KH 3H
2S KS 9D QD JS AS AH 3C
4C 5C TS QH 4H AC 4D 7S
3S TD 4S TH 8H 2C JH 7D
6D 8S 8D QS 6C 3D 8C TC
6S 9C 2H 6H
</pre>
<pre>
7D AD 5C 3S 5S 8C 2D AH
TD 7S QD AC 6D 8H AS KH
TH QC 3H 9D 6S 8D 3D TC
KD 5H 9S 3C 8S 7H 4D JS
4C QS 9C 9H 7C 6H 2C 2S
4S TS 2H 5D JC 6C JH QH
JD KS KC 4H
</pre>
=={{header|Tcl}}==
{{trans|C}}
<
upvar 1 ${*r} r
expr {[set r [expr {($r * 214013 + 2531011) & 0x7fffffff}]] >> 16}
Line 2,342 ⟶ 3,743:
set cards [deal $s]
puts "Hand $s"
show $cards</
=={{header|UNIX Shell}}==
{{works with|zsh}}
<
for seed; do
print Game $seed:
Line 2,367 ⟶ 3,768:
done
print
done</
{{out}}
<pre>$ zsh freecell.sh 80388
Line 2,378 ⟶ 3,779:
KS AC KD 9C 9H 6C JC 2D
4C 8H TS 6S</pre>
=={{header|Wren}}==
{{trans|Kotlin}}
<syntaxhighlight lang="wren">class Lcg {
construct new(a, c, m, d, s) {
_a = a
_c = c
_m = m
_d = d
_s = s
}
nextInt() {
_s = (_a * _s + _c) % _m
return _s / _d
}
}
var CARDS = "A23456789TJQK"
var SUITS = "♣♦♥♠".toList
var deal = Fn.new {
var cards = List.filled(52, null)
for (i in 0...52) {
var card = CARDS[(i/4).floor]
var suit = SUITS[i%4]
cards[i] = card + suit
}
return cards
}
var game = Fn.new { |n|
if (n.type != Num || !n.isInteger || n <= 0) {
Fiber.abort("Game number must be a positive integer.")
}
System.print("Game #%(n):")
var msc = Lcg.new(214013, 2531011, 1<<31, 1<<16, n)
var cards = deal.call()
for (m in 52..1) {
var index = (msc.nextInt() % m).floor
var temp = cards[index]
cards[index] = cards[m - 1]
System.write("%(temp) ")
if ((53 - m) % 8 == 0) System.print()
}
System.print("\n")
}
game.call(1)
game.call(617)</syntaxhighlight>
{{out}}
<pre>
Game #1:
J♦ 2♦ 9♥ J♣ 5♦ 7♥ 7♣ 5♥
K♦ K♣ 9♠ 5♠ A♦ Q♣ K♥ 3♥
2♠ K♠ 9♦ Q♦ J♠ A♠ A♥ 3♣
4♣ 5♣ T♠ Q♥ 4♥ A♣ 4♦ 7♠
3♠ T♦ 4♠ T♥ 8♥ 2♣ J♥ 7♦
6♦ 8♠ 8♦ Q♠ 6♣ 3♦ 8♣ T♣
6♠ 9♣ 2♥ 6♥
Game #617:
7♦ A♦ 5♣ 3♠ 5♠ 8♣ 2♦ A♥
T♦ 7♠ Q♦ A♣ 6♦ 8♥ A♠ K♥
T♥ Q♣ 3♥ 9♦ 6♠ 8♦ 3♦ T♣
K♦ 5♥ 9♠ 3♣ 8♠ 7♥ 4♦ J♠
4♣ Q♠ 9♣ 9♥ 7♣ 6♥ 2♣ 2♠
4♠ T♠ 2♥ 5♦ J♣ 6♣ J♥ Q♥
J♦ K♠ K♣ 4♥
</pre>
=={{header|XPL0}}==
<
string 0; \use zero-terminated string convention
int RandState;
Line 2,403 ⟶ 3,875:
Deck(Card):= Deck(Size); \replace dealt card with last card
until Size = 0; \all cards have been dealt
]</
Output:
Line 2,418 ⟶ 3,890:
=={{header|zkl}}==
<
var seed=1; const RMAX32=(1).shiftLeft(31) - 1;
Line 2,435 ⟶ 3,907:
game(1);
game(617);
</syntaxhighlight>
{{out}}
<pre>
Line 2,455 ⟶ 3,927:
🃋 🂮 🃞 🂴
</pre>
{{omit from|ZX Spectrum Basic|Cannot calculate high numbers for the generator accurately enough}}
| |||