Playing cards: Difference between revisions

 

The deck should contain 52 unique cards.

 

 

Each card must have a pip value and a suit value which constitute the unique value of the card.

 

=={{header|ACL2}}==

(if (or (zp i) (endp (rest xs)))

(rest xs)

(defun draw-from-deck (deck)

(mv (first deck) (rest deck)))

 

Example (first 4 cards of a shuffled deck):

4 of DIAMONDS

(NIL <state>)</pre>

 

=={{header|Ada}}==

* [http://www.csail.mit.edu/timeline/timeline.php?query=event&id=93 LOC was essential; Algol 68's REF was a mistake.]

 

 

# class members & attributes #

(init OF class deck)(deck);

(shuffle OF class deck)(deck);

 

{{Out|Example output}}

<pre>((King OF Clubs), (6 OF Hearts), (7 OF Diamonds), (Ace OF Hearts), (9 OF Spades), (10 OF Clubs), (Ace OF Spades), (8 OF Clubs), (4 OF Spades), (8 OF Hearts), (Jack OF Hearts), (3 OF Clubs), (7 OF Hearts), (10 OF Hearts), (Jack OF Clubs), (Ace OF Clubs), (King OF Spades), (9 OF Clubs), (7 OF Spades), (5 OF Spades), (7 OF Clubs), (Queen OF Clubs), (9 OF Diamonds), (2 OF Spades), (6 OF Diamonds), (Ace OF Diamonds), (Queen OF Diamonds), (5 OF Hearts), (4 OF Clubs), (5 OF Clubs), (4 OF Hearts), (3 OF Diamonds), (4 OF Diamonds), (3 OF Hearts), (King OF Diamonds), (2 OF Clubs), (Jack OF Spades), (2 OF Diamonds), (5 OF Diamonds), (Queen OF Spades), (10 OF Diamonds), (King OF Hearts), (Jack OF Diamonds), (Queen OF Hearts), (8 OF Spades), (2 OF Hearts), (8 OF Diamonds), (10 OF Spades), (9 OF Hearts), (6 OF Clubs), (3 OF Spades), (6 OF Spades))</pre>

 

=={{header|AutoHotkey}}==

{

}

GuiClose:

ExitApp

 

{

}

 

 

=={{header|BASIC}}==

{{works with|QuickBASIC|QBX 7.1}}

 

Most BASICs aren't object-oriented (or anything even resembling such) and can't do a deck of cards as a single cohesive unit -- but we can fake it.

 

DECLARE SUB shuffle (deck() AS STRING * 2)

DECLARE SUB showDeck (deck() AS STRING * 2)

deck(L0) = shuffled(L0)

NEXT

 

Sample output:

Dealt: 7D

Dealt: 6D

AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH AC

2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC AD 2D 3D 4D 5D 6D 7D 8D 9D TD JD QD KD

 

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

{{works with|BBC BASIC for Windows}}

Suit$() = "Clubs", "Diamonds", "Hearts", "Spades"

Rank$() = "Ace", "Two", "Three", "Four", "Five", "Six", "Seven", \

REM Return the name of a card:

DEF FNcardname(card&)

Output:

<pre>Creating a new deck...

 

=={{header|C}}==

#include <stdlib.h>

#include <locale.h>

//free(d);

return 0;

<pre>

New deck, 52 cards: ♠A ♠2 ♠3 ♠4 ♠5 ♠6 ♠7 ♠8 ♠9 ♠10 ♠J ♠Q ♠K ♥A ♥2 ...

See also [[Playing Cards/C]]

 

 

 

#include <algorithm>

#include <ostream>

namespace cards

{

enum pip_type { two, three, four, five, six, seven, eight, nine, ten,

 

 

 

 

 

unsigned char value;

 

{ "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",

"jack", "queen", "king", "ace" };

 

return os << pip_names[pip];

 

{ "hearts", "spades", "diamonds", "clubs" };

 

return os << suite_names[suite];

 

return os << c.pip() << " of " << c.suite();

 

deck()

{

}

 

void shuffle() { std::random_shuffle(cards.begin(), cards.end()); }

 

card deal() { card c = cards.front(); cards.pop_front(); return c; }

 

typedef std::deque<card>::const_iterator const_iterator;

std::deque<card> cards;

 

std::copy(d.begin(), d.end(), std::ostream_iterator<card>(os, "\n"));

return os;

}

 

 

 

 

 

 

}

 

}

}

 

 

}

}

 

 

 

 

 

 

 

 

 

 

class Card

constructor: (@pip, @suit) ->

@cards[i] = @cards.splice(randomCard, 1, card)[0]

 

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

A card is a cons of a suit and a pip. A deck is a list of cards, and so dealing is simply popping off of a deck. Shuffling is naïve, just a sort with a random predicate. Printing is built in.

 

'(club diamond heart spade)

"Card suits are the symbols club, diamond, heart, and spade.")

(sort list #'(lambda (x y)

(declare (ignore x y))

=={{header|D}}==

std.range, std.random;

 

alias Card = Tuple!(Pip, Suit);

 

return cartesianProduct([EnumMembers!Pip], [EnumMembers!Suit]);

}

}

 

writefln("Deck:\n%(%s\n%)\n", deck);

}

 

auto d = newDeck.array;

d.show;

while (!d.empty)

d.dealCard.writeln;

{{out}}

<pre>Deck:

 

===More Refined Version===

 

struct Card {

g.sortDeck.showDeck;

}

{{out}}

<pre>Host

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

 

Readln;

 

=={{header|E}}==

See [[Playing Cards/E]]

 

=={{header|Erlang}}==

 

This module is used by [[Go_Fish]].

-module( playing_cards ).

 

 

suites() -> ["Clubs", "Hearts", "Spades", "Diamonds"].

{{out}}

<pre>

{card,"6","Hearts"} {card,"3","Diamonds"} {card,"Queen","Spades"}

{card,"10","Hearts"} {card,"2","Hearts"} {card,"6","Diamonds"}

</pre>

 

=={{header|Fantom}}==

enum class Suit { clubs, diamonds, hearts, spades }

enum class Pips { ace, two, three, four, five,

}

}

 

=={{header|Forth}}==

{{works with|GNU Forth}}

 

create pips s" A23456789TJQK" mem,

new-deck shuffle .deck

5 .hand

 

=={{header|Fortran}}==

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

 

IMPLICIT NONE

END SUBROUTINE Print_deck

 

Example use:

USE Cards

CALL Print_deck

This creates a new deck, shuffles it, deals five cards to hand, prints the cards in hand and then prints the cards remaining in the deck.

=={{header|Go}}==

 

import (

}

return hands, true

Example use:

 

import (

fmt.Println("\nReturning the cards to the deck")

fmt.Println(d)

Output:

<pre>

 

=={{header|Groovy}}==

 

enum Pip {

 

String toString() { cards.isEmpty() ? "Empty Deck" : "Deck $cards" }

Test Code

deck.shuffle()

Output:

<pre>TWO of DIAMONDS

 

Straightforward implementation with explicit names for pips and suits. A deck is just a list of cards. Dealing consists of splitting off cards from the beginning of the list by the usual pattern matching (not shown). Printing is automatic. Purely functional shuffling is a bit tricky, so here we just do the naive quadratic version. This also works for other than full decks.

 

data Pip = Two | Three | Four | Five | Six | Seven | Eight | Nine | Ten |

shuffle' g [] _ ys = ys

shuffle' g (x:xs) n ys = shuffle' g' xs (n+1) (insertAt k x ys) where

 

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

 

cards := 2 # cards per hand

procedure card2string(x) #: return a string version of a card

return x.pip || x.suit

Sample output:

<pre>New deck : 2H 3H 4H 5H 6H 7H 8H 9H 10H JH QH KH AH 2S 3S 4S 5S 6S 7S 8S 9S 10S JS QS KS AS 2D 3D 4D 5D 6D 7D 8D 9D 10D JD QD KD AD 2C 3C 4C 5C 6C 7C 8C 9C 10C JC QC KC AC

=={{header|J}}==

'''Solution:'''<br>

NB. Defines a Rosetta Code playing cards class

NB. Multiple decks may be used, one for each instance of this class.

)

 

 

'''Example use:'''

coinsert 'rcpc' NB. insert rcpc class in the path of current locale

pc=: newDeck ''

42 2

destroy__pc ''

 

=={{header|Java}}==

{{works with|Java|1.5+}}

 

 

The card:

private final Suit suit;

private final Pip value;

return value + " of " + suit;

}

The deck:

import java.util.LinkedList;

 

return deck.toString();

}

 

=={{header|JavaScript}}==

this.pip = pip;

this.suit = suit;

return this.deck.shift();

};

 

=={{header|K}}==

 

Create the deck.

s:"SHCD" / suites

 

/ create a new deck

newdeck:{deck::,/s,'\:v}

 

Show the deck.

 

show()

 

Shuffle the deck.

 

shuffle();show()

 

Deal: Get the N top cards and remove them from the deck.

Deal 5 cards.

deal:{c:deal1[x];deck::(deck _dvl c);c}

 

 

#deck / 5 cards are removed

 

Deal 3 more hands.

(("D6"

"DJ"

"H3"

"S6"

 

We now have 32 cards left.

32

show()

 

=={{header|Liberty BASIC}}==

Dim holdCards(1, 1)

Print "The Sorted Deck"

pipLabel$ = "Ace Deuce Three Four Five Six Seven Eight Nine Ten Jack Queen King"

pip$ = Word$(pipLabel$, faceValue)

 

=={{header|Logo}}==

{{works with|UCB Logo}}

make "pips {Ace Two Three Four Five Six Seven Eight Nine Ten Jack Queen King}

 

new.deck

shuffle.deck

 

=={{header|Lua}}==

suits = {"Clubs", "Diamonds", "Hearts", "Spades"}

faces = {2,3,4,5,6,7,8,9,10,"Jack","Queen","King","Ace"}

print(d - 4 .. "")

print(-b .. "")

 

=={{header|M4}}==

define(`setRand',

`define(`randSeed',ifelse(eval($1<10000),1,`eval(20000-$1)',`$1'))')dnl

deal deal(`b')

deal deal(`b')

 

DeckShuffle[deck_] := RandomSample[deck, Length@deck]

Example usage:

<pre>deck = DeckShuffle@MakeDeck[]; Print[deck]

{8,♥},{Jack,♠},{5,♥},{7,♣},{8,♠},{King,♣},{Queen,♦},{9,♥},{Ace ,♥},{3,♦},{7,♥},{Queen,♣},{10,♣},

{3,♥},{2,♥},{Jack,♥},{7,♦},{6,♠},{6,♥},{Ace ,♠},{9,♣}}</pre>

 

=={{header|MUMPS}}==

See [[Playing Cards/MUMPS]]

 

 

type

 

 

 

 

 

for suit in Suit:

 

 

 

 

 

=={{header|OCaml}}==

Straightforward implementation with algebraic types for the pips and suits, and lists of their values. A deck is an array of cards.

Jack | Queen | King | Ace

let pips = [Two; Three; Four; Five; Six; Seven; Eight; Nine; Ten;

Jack; Queen; King; Ace]

type suit = Diamonds | Spades | Hearts | Clubs

let suits = [Diamonds; Spades; Hearts; Clubs]

type card = pip * suit

let full_deck = Array.of_list (List.concat (List.map (fun pip -> List.map (fun suit -> (pip, suit)) suits) pips))

let shuffle deck =

for i = Array.length deck - 1 downto 1 do

let j = Random.int (i+1) in

let temp = deck.(i) in

deck.(i) <- deck.(j);

deck.(j) <- temp

 

=={{header|PARI/GP}}==

Uses a global variable v to pass around the remaining cards in the deck. If used inside a function this would be a good case for a dynamically-scoped variable (<code>local</code>) rather than the typically-preferred lexical scoping of <code>my</code>.

newdeck()={

v=vector(52,i,i);

);

v

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

 

use strict;

 

@Playing_Card_Deck::suits = qw

{my $invocant = shift;

my $class = ref($invocant) || $invocant;

foreach my $suit (@Playing_Card_Deck::suits)

{foreach my $pip (@Playing_Card_Deck::pips)

# Removes the top card of the given deck and returns it as a hash

# with the keys "suit" and "pip".

 

sub shuffle

sub print_cards

# Prints out a description of every card in the deck, in order.

Some examples of use:

$deck->shuffle;

my %card = $deck->deal;

print uc("$card{pip} OF $card{suit}\n");

This creates a new deck, shuffles it, removes the top card, prints out that card's name in all caps, and then prints the rest of the deck.

 

{{out}}

 

=={{header|PHP}}==

{{works with|PHP|5.3+}}

Implementation:

{

// if unable to save as UTF-8, use other, non-UTF-8, symbols here

return $result[ 0 ];

}

 

Usage:

header( 'Content-Type: text/plain; charset=utf-8' );

 

 

// show the remaining cards in the deck

 

This will output something like:

24 cards remaining in the deck:

♥A ♥6 ♦2 ♦5 ♥J ♣T ♦3 ♠5 ♠A ♣8 ♥8 ♥7 ♥K ♦7 ♥T ♦6 ♦T ♣6 ♣3 ♣A ♦4 ♥4 ♠6 ♣9</pre>

 

=={{header|PicoLisp}}==

{{trans|Common Lisp}}

Club Diamond Heart Spade )

 

 

(de shuffle (Lst)