Deal cards for FreeCell: Difference between revisions

 

 

The algorithm uses this [[linear congruential generator]] from Microsoft C:

* Rosetta Code has another task, [[linear congruential generator]], with code for this RNG in several languages.

 

The algorithm follows:

 

# 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.

 

!| Order to deal cards

!| Game #1

|}

 

 

 

=={{header|Ada}}==

procedure FreeCell is

type State is mod 2**31;

New_Line;

Deal(617);

{{out}}

<pre>JD 2D 9H JC 5D 7H 7C 5H

4S TS 2H 5D JC 6C JH QH

JD KS KC 4H</pre>

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

hand% = 617

NEXT

ENDIF

{{out}}

[[File:freecell_BBC.gif]]

 

=={{header|Bracmat}}==

= array rank ranks suit suits

. A 2 3 4 5 6 7 8 9 T J Q K:?ranks

& put$(deal$(!deck.617),"dealt.txt",APP)

&

Content of <code>dealt.txt</code>:

<pre>Game #1

 

=={{header|C}}==

#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)

{

}

}

void deal(int s, int *t)

{

}

}

int main(int c, char **v)

{

int s, card[52];

if (c < 2 || (s = atoi(v[1])) <= 0) s = 11982;

setlocale(LC_ALL, "");

 

 

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;

}

}

{{out}}

<pre>JD 2D 9H JC 5D 7H 7C 5H

JD KS KC 4H

</pre>

 

=={{header|D}}==

{{trans|C}}

 

struct RandomGenerator {

uint seed = 1;

 

seed = (seed * 214_013 + 2_531_011) & int.max;

return seed >> 16;

int[52] cards;

 

enum int nc = cards.length; // Must be signed for iota.

 

auto rnd = RandomGenerator(seed);

}

 

}

}

 

writeln("Hand ", seed);

Deck cards;

cards.deal(seed);

<pre>Hand 11982

AH AS 4H AC 2D 6S TS JS

JD 7D 8H 9C 2H QD 4C 5H

KC 8D 2S 3S</pre>

 

=={{header|Go}}==

{{trans|C}}

 

import (

fmt.Printf("\nGame #%d\n", game)

show(deal(game))

{{out}}

<pre>

4S TS 2H 5D JC 6C JH QH

JD KS KC 4H

</pre>

 

=={{header|Haskell}}==

{{trans|C}}

import Data.Bits

import Data.List

putStrLn $ "Deal " ++ show s ++ ":"

let cards = deal s

 

Execution:

 

=={{header|Icon}} and {{header|Unicon}}==

freecelldealer(\A[1] | &null) # seed from command line

end

procedure rand_freecell() #: lcrng

return ishift(srand_freecell((214013 * srand_freecell() + 2531011) % 2147483648),-16)

{{out|Sample output for game 1}}

<pre>Hand:

=={{header|J}}==

Paraphrase of [[#C|C]]:

 

srnd=: 3 :'SEED=:{.y,11982'

deal=: |.@(swaps pairs) bind deck

 

{{out|Example use}}

J♦ 2♦ 9♥ J♣ 5♦ 7♥ 7♣ 5♥

K♦ K♣ 9♠ 5♠ A♦ Q♣ K♥ 3♥

4♣ Q♠ 9♣ 9♥ 7♣ 6♥ 2♣ 2♠

4♠ T♠ 2♥ 5♦ J♣ 6♣ J♥ Q♥

 

=={{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

Printf.printf "Deal %d:\n" s;

let cards = deal s in

{{out|Execution}}

<pre>$ ocaml freecell.ml 617

=={{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

deck[t]=deck[last]

)

 

=={{header|Perl}}==

 

use strict;

binmode STDOUT, ':encoding(utf-8)';

print "Hand $hand_idx\n";

 

 

 

 

 

}

 

 

=={{header|PicoLisp}}==

Using the random generator from [[Linear congruential generator#PicoLisp]]:

 

(de msRand ()

(prin " ^[[" (cadr C) "m" (cddr C) "^[[m" (car C))

(at (0 . 8) (prinl)) )

 

=={{header|PureBasic}}==

Global deckSize

Global Dim cards(#MaxCardNum) ;card with highest index is at the top of deck

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out|Sample output}}

<pre>Hand #1

=={{header|Python}}==

{{trans|D}}

 

def randomGenerator(seed=1):

def deal(seed):

nc = 52

rnd = randomGenerator(seed)

for i, r in zip(range(nc), rnd):

 

def show(cards):

for i in range(0, len(cards), 8):

 

if __name__ == '__main__':

seed = int(argv[1]) if len(argv) == 2 else 11982

deck = deal(seed)

{{out}}

<pre>Hand 11982

 

 

 

 

 

end

 

# Create original deck of 52 cards, not yet shuffled.

 

games.each do |seed|

deck = orig_deck.dup

# Shuffle deck with random index from linear congruential

# generator like Microsoft.

deck[index], deck[last] = deck[last], deck[index]

end

deck.reverse! # Shuffle did reverse deck. Do reverse again.

# Deal cards.

puts "Game ##{seed}"

deck.each_slice(8) {|row| puts " " + row.join(" ")}

{{out}}

 

=={{header|Run BASIC}}==

imageDir$ = DefaultDir$ + "\projects\" + projectDir$ + "\image\" ' directory of deck images

imagePath$ = "../";projectDir$;"/image/" ' path of deck images

 

card$ = "A,2,3,4,5,6,7,8,9,T,J,Q,K" ' Cards Ace to King

 

if card = 52 then end ' out of cards

next xx

[[File:freeCell.png]]

 

=={{header|Tcl}}==

{{trans|C}}

upvar 1 ${*r} r

expr {[set r [expr {($r * 214013 + 2531011) & 0x7fffffff}]] >> 16}

set cards [deal $s]

puts "Hand $s"

 

=={{header|UNIX Shell}}==

{{works with|zsh}}

for seed; do

print Game $seed:

done

print

{{out}}

<pre>$ zsh freecell.sh 80388

KS AC KD 9C 9H 6C JC 2D

4C 8H TS 6S</pre>