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|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; }

{

int i;

}

}

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|Common Lisp}}==

#'(lambda ()

(ash (setf seed (mod (+ (* 214013 seed) 2531011) (expt 2 31))) -16)))

(let ((hand (make-array 52 :fill-pointer 0))

(rng (make-rng seed)))

(vector-push (concatenate 'string d s) hand)))

(dotimes (i 52)

 

(show-deck 1)

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

 

1 2 3 4 5 6 7 8

 

=={{header|J}}==

 

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

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

 

 

 

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

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

6♦ 8♠ 8♦ Q♠ 6♣ 3♦ 8♣ T♣

6♠ 9♣ 2♥ 6♥

7♦ A♦ 5♣ 3♠ 5♠ 8♣ 2♦ A♥

T♦ 7♠ Q♦ A♣ 6♦ 8♥ A♠ K♥

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

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

 

=={{header|OCaml}}==

{{trans|C}}

 

let deal s =

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

let cards = deal s in

<pre>$ ocaml freecell.ml 617

Deal 617:

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

JD KS KC 4H</pre>

 

=={{header|Perl}}==

sub deal {

 

 

}

 

 

 

 

 

 

}

 

 

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

<pre>Hand #1

JD 2D 9H JC 5D 7H 7C 5H

=={{header|Python}}==

{{trans|D}}

 

 

 

def deal(seed):

nc = 52

cards[i], cards[j] = cards[j], cards[i]

return cards

 

def show(cards):

 

if __name__ == '__main__':

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

deck = deal(seed)

<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(" ")}

 

 

=={{header|Tcl}}==

{{trans|C}}

upvar 1 ${*r} r

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

set cards [deal $s]

puts "Hand $s"