Task: Playing cards






PHP: class Card
{

    protected static $suits = array( '♠', '♥', '♦', '♣' );

    protected static $pips = array( '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A' );

    protected $suit;

    protected $suitOrder;

    protected $pip;

    protected $pipOrder;

    protected $order;

    public function __construct( $suit, $pip )
    {
        if( !in_array( $suit, self::$suits ) )
        {
            throw new InvalidArgumentException( 'Invalid suit' );
        }
        if( !in_array( $pip, self::$pips ) )
        {
            throw new InvalidArgumentException( 'Invalid pip' );
        }

        $this->suit = $suit;
        $this->pip = $pip;
    }

    public function getSuit()
    {
        return $this->suit;
    }

    public function getPip()
    {
        return $this->pip;
    }

    public function getSuitOrder()
    {

        if( !isset( $this->suitOrder ) )
        {

            $this->suitOrder = array_search( $this->suit, self::$suits );
        }

        return $this->suitOrder;
    }

    public function getPipOrder()
    {

        if( !isset( $this->pipOrder ) )
        {

            $this->pipOrder = array_search( $this->pip, self::$pips );
        }

        return $this->pipOrder;
    }

    public function getOrder()
    {

        if( !isset( $this->order ) )
        {
            $suitOrder = $this->getSuitOrder();
            $pipOrder = $this->getPipOrder();

            $this->order = $pipOrder * count( self::$suits ) + $suitOrder;
        }

        return $this->order;
    }

    public function compareSuit( Card $other )
    {
        return $this->getSuitOrder() - $other->getSuitOrder();
    }

    public function comparePip( Card $other )
    {
        return $this->getPipOrder() - $other->getPipOrder();
    }

    public function compare( Card $other )
    {
        return $this->getOrder() - $other->getOrder();
    }

    public function __toString()
    {
        return $this->suit . $this->pip;
    }

    public static function getSuits()
    {
        return self::$suits;
    }

    public static function getPips()
    {
        return self::$pips;
    }
}

class CardCollection
    implements Countable, Iterator
{
    protected $cards = array();

    protected function __construct( array $cards = array() )
    {
        foreach( $cards as $card )
        {
            $this->addCard( $card );
        }
    }

    
    public function count()
    {
        return count( $this->cards );
    }

    
    public function key()
    {
        return key( $this->cards );
    }

    
    public function valid()
    {
        return null !== $this->key();
    }

    
    public function next()
    {
        next( $this->cards );
    }

    
    public function current()
    {
        return current( $this->cards );
    }

    
    public function rewind()
    {
        reset( $this->cards );
    }

    public function sort( $comparer = null )
    {
        $comparer = $comparer ?: function( $a, $b ) {
            return $a->compare( $b );
        };

        if( !is_callable( $comparer ) )
        {
            throw new InvalidArgumentException( 'Invalid comparer; comparer should be callable' );
        }

        usort( $this->cards, $comparer );
        return $this;
    }

    public function toString()
    {
        return implode( ' ', $this->cards );
    }

    public function __toString()
    {
        return $this->toString();
    }

    protected function addCard( Card $card )
    {
        if( in_array( $card, $this->cards ) )
        {
            throw new DomainException( 'Card is already present in this collection' );
        }

        $this->cards[] = $card;
    }
}

class Deck
    extends CardCollection
{
    public function __construct( $shuffled = false )
    {
        foreach( Card::getSuits() as $suit )
        {
            foreach( Card::getPips() as $pip )
            {
                $this->addCard( new Card( $suit, $pip ) );
            }
        }

        if( $shuffled )
        {
            $this->shuffle();
        }
    }

    public function deal( $amount = 1, CardCollection $cardCollection = null )
    {
        if( !is_int( $amount ) || $amount < 1 )
        {
            throw new InvalidArgumentException( 'Invalid amount; amount should be an integer, larger than 0' );
        }

        if( $amount > count( $this->cards ) )
        {
            throw new RangeException( 'Invalid amount; requested amount is larger than the amount of available cards' );
        }

        $cards = array_splice( $this->cards, 0, $amount );

        $cardCollection = $cardCollection ?: new CardCollection;

        foreach( $cards as $card )
        {
            $cardCollection->addCard( $card );
        }

        return $cardCollection;
    }

    public function shuffle()
    {
        shuffle( $this->cards );
    }
}

class Hand
    extends CardCollection
{



    public function __construct() {}

    public function play( $position )
    {
        if( !isset( $this->cards[ $position ] ) )
        {
            throw new OutOfBoundsException( 'Invalid position; position is not present in this hand' );
        }

        $result = array_splice( $this->cards, $position, 1 );
        return $result[ 0 ];
    }
}



VB: suite$ = "CDHS"                 #Club, Diamond, Heart, Spade
card$  = "A23456789TJQK"        #Cards Ace to King
card   = 0

dim n(55)                       #make ordered deck
for i = 1 to 52                 # of 52 cards
    n[i] = i
next i

for i = 1 to 52 * 3             #shuffle deck 3 times
    i1    = int(rand * 52) + 1
    i2    = int(rand * 52) + 1
    h2    = n[i1]
    n[i1] = n[i2]
    n[i2] = h2
next i

for hand = 1 to 4               #4 hands
    for deal = 1 to 13            #deal each 13 cards
        card += 1               #next card in deck
        s = (n[card] mod 4)  + 1    #determine suite
        c = (n[card] mod 13) + 1    #determine card
        print mid(card$,c,1);mid(suite$,s,1);" ";  #show the card
    next deal
    print
next hand
end

function word$(sr$, wn, delim$)
    j = wn
    if j = 0 then j += 1
    res$ = "" : s$ = sr$ : d$ = delim$
    if d$ = "" then d$ = " "
    sd = length(d$) : sl = length(s$)
    while true
        n = instr(s$,d$) : j -= 1
        if j = 0 then
            if n=0 then res$=s$ else res$=mid(s$,1,n-1)
            return res$
        end if
        if n = 0 then return res$
        if n = sl - sd then res$ = "" : return res$
        sl2 = sl-n : s$ = mid(s$,n+1,sl2) : sl = sl2
    end while
    return res$
end function