Deal cards for FreeCell: Difference between revisions

# 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

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.

 

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

 

=={{header|AutoHotkey}}==

cards := "A23456789TJQK", suits := "♣♦♥♠", card := [], Counter := 0

loop, parse, cards

Seed := Mod(214013 * Seed + 2531011, 2147483648)

return, [Seed, Seed // 65536]

MS() found at http://rosettacode.org/wiki/Linear_congruential_generator#AutoHotkey

Gui, add, edit, w320 r17 -VScroll, % "Game# 1`n" FreeCell(1) "`n`nGame#617`n" FreeCell(617)

Gui, show

GuiEscape:

ExitApp

Outputs:<pre>Game# 1

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

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

{{works with|BBC BASIC for Windows}}

hand% = 617

NEXT

ENDIF

{{out}}

[[File:freecell_BBC.gif]]

 

=={{header|Befunge}}==

>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*<>+

{{out}}

<pre>Game number: 1

 

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

 

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

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

}

}

{{out}}

<pre>Deck 1

 

=={{header|C++}}==

#include <windows.h>

#include <iostream>

}

//--------------------------------------------------------------------------------------------------

Output:

<pre>

This is written using a more object-oriented approach than the version above.

 

#include <iostream> // std::cout

#include <sstream> // std::stringstream

return 0;

}

{{out}}

<pre>Deck 1

 

=={{header|Ceylon}}==

 

//a function that returns a random number generating function

print("\n");

deal(617);

 

=={{header|Clojure}}==

 

(defn lcg [seed]

(reverse (reduce xchg deck (gen seed))))))

 

 

=={{header|Common Lisp}}==

#'(lambda ()

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

 

(show-deck 1)

 

=={{header|D}}==

{{trans|C}}

 

struct RandomGenerator {

cards.deal(seed);

cards.show;

<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|Elixir}}==

{{trans|Ruby}}

import Bitwise

 

System.argv |> Enum.map(&String.to_integer/1)

 

{{out}}

 

=={{header|ERRE}}==

PROGRAM FREECELL

 

SHOW(CARDS%[])

END PROGRAM

{{out}}

<pre>

</pre>

 

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?

let msKindaRand seed =

let state = ref seed

 

[1; 617] |> List.iter game

 

{{out}}

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

JD KS KC 4H

</pre>

 

{{works with|Fortran|95 and later}}

Using the lcgs module from [[Linear congruential generator#Fortran]]:

use lcgs

implicit none

call Freecelldeal(617)

{{out}}

<pre>Game #1

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>game #1

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

JD KS KC 4H</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|Java}}==

import java.util.Arrays;

 

}

{{out}}

<pre>

=={{header|JavaScript}}==

 

/*

* Microsoft C Run-time-Library-compatible Random Number Generator

return columns.map(render_column).join("");

}

 

=={{header|Kotlin}}==

 

class Lcg(val a: Long, val c: Long, val m: Long, val d: Long, val s: Long) {

game(1)

game(617)

 

{{out}}

 

=={{header|Logo}}==

make "_lcg_state 0

 

print_deal 617

print "||

{{Out}}

<pre>Game #1

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

 

deal(1)

{{out}}

<pre>Game #1

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

deal[n_] :=

Module[{last = n, idx,

format[deal_] := Grid[Partition[deal, 8, 8, {1, 4}, Null]];

Print[format[deal[1]]];

{{out}}

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

=={{header|Nim}}==

{{trans|Python}}

proc randomGenerator(seed: int): iterator: int =

return iterator: int =

while true:

const nc = 52

result = toSeq countdown(nc - 1, 0)

var rnd = randomGenerator seed

let r = rnd()

let j = (nc - 1) - r mod (nc - i)

swap result[i], result[j]

var l = newSeq[string]()

for c in cards:

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

Output:

<pre>Hand 11982

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

KC 8D 2S 3S</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.

 

//--------------------------------------------------------------------

}

return 0;

{{out}}

<pre>Deck 1

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

{{trans|ERRE}}

{{out}}

<pre>

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

 

=={{header|Racket}}==

 

 

(module Linear_congruential_generator racket

(present-deal 1)

(newline)

 

{{out}}

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

JD KS KC 4H</pre>

 

=={{header|REXX}}==

 

It also supports any number for the number of columns &nbsp; (default is 8).

numeric digits 15 /*ensure enough digits for the random #*/

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).*/

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. */

end /*s*/ /* [↑] first card is number 0 (zero).*/

end /*r*/ /* [↑] build deck per FreeCell rules. */

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.*/

end /*cards*/ /*normally, 8 cards are dealt to a row.*/

/* [↓] residual cards may exist. */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output''' &nbsp; when using the default game number: &nbsp; <tt> 1 </tt>

<pre>

 

=={{header|Ruby}}==

# No arguments? Pick any of first 32000 games.

begin

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

puts

{{out}}

<pre>

 

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

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

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

if card = 52 then end ' out of cards

next xx

[[File:freeCell.png]]

 

Based on JavaScript.

 

 

}

}

 

 

 

 

 

deck.reverse();

 

}

 

 

 

 

 

=={{header|Seed7}}==

include "console.s7i";

 

writeln("Hand " <& gameNum);

show(cards);

 

{{out}}

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

♦J ♠K ♣K ♥4

</pre>

 

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

 

=={{header|XPL0}}==

string 0; \use zero-terminated string convention

int RandState;

Deck(Card):= Deck(Size); \replace dealt card with last card

until Size = 0; \all cards have been dealt

 

Output:

 

=={{header|zkl}}==

 

var seed=1; const RMAX32=(1).shiftLeft(31) - 1;

game(1);

game(617);

{{out}}

<pre>

🃋 🂮 🃞 🂴

</pre>