sub pick_a_card {
    my $deck = shift;

    return pop @$deck;
}

pick_a_card(\@deck);
[download]

Hmm.. so it`s just a C-like error of mine. Sorry, I am still learning Perl, so I didn`t know that a special reference will be needed in the case. Well, thanks a lot, I`ll keep in mind that for the future.

I`ll look into references ( pointers ) asap when I finish the regexp part of perl, which I find a bit confusing. I guess pointers are as powerful as they were in C... I just had no idea there are any since Perl is garbage collected and, dunno... maybe I am a bit noob to this :)

Well, I would say that references are kind of a step up in terms of abstraction from pointers. For example, in C, you can point a pointer at pretty much any arbitrary space in memory; I don't think you can do that with references in Perl. I also don't think you could perform arithmetic on references (not that this is a great idea in C anyways).

In my mind, Perl references are much simpler. They always point to a thing, and you just have to remember to dereference it to use the thing it's pointing to.

First step is a better shuffle algorithm, which is right there in Recipe 14.7, the fisher-yates algorithm. I don't see the need to keep the suits separate, generate an array (or just type it in manually) with all 52 cards, shuffle and away you go!

#!/usr/bin/perl -w
use strict;

use Data::Dumper;
 
my @deck = make_deck();           
fisher_yates_shuffle(\@deck); #in place shuffle
print Dumper \@deck;

# use pop or shift of @deck to deal a single card
# or perhaps use splice to deal out multiple cards
# the cards are already randomized so it doesn't matter
# how you deal 'em.

my @deal4 = splice(@deck,0,4);
print "4 cards: @deal4\n"; #4 cards: 6_heart 9_heart J_heart Q_spade

# From Perl Cookbook  Recipe 14.7    
#    Randomizing an Array with fisher_yates_shuffle

sub fisher_yates_shuffle 
{
    my $array = shift;
    my $i;
    for ($i = @$array; --$i; ) 
    {
        my $j = int rand ($i+1);
        next if $i == $j;
        @$array[$i,$j] = @$array[$j,$i];
    }
}

sub make_deck   #or just use a fixed array with 52 cards
{
   my @cards = ( 2,3,4,5,6,7,8,9,10,'J','Q','K','A');
   my @deck;
   foreach my $suit qw(spade diamond heart club)
   {
      push @deck, map{"$_"."_$suit"}@cards;
   }
   return @deck;
}
[download]

I know about that algorithm, better say 'heard' than 'know', actually, but really I think that it`s a bit complex for a simple task like mine, not that is bad or good, it`s just another way to do it. Maybe I would have used it if I know how to implement it, but since I don`t have that cookbook, I just made my own ( simple as it is ). However, thanx for the recipe, if I am going to make a real game ( sallable ) will consider Yates shuffle algorithm

Riales is spot-on; using Data::Dumper to dump out @deck at several places will show this quickly enough.

As an aside, I spotted another issue when I was looking at this, and couldn't run it as-shown. There's some needless complexity in sub deck_maker, which I simplified to this:

#DECK MAKER
sub deck_maker {
    my @deck = (); #the deck for returning
    my @types = ('spades', 'hearts', 'diamonds', 'clubs');
    my @cards = ( 2,3,4,5,6,7,8,9,10,'J','Q','K','A');
    for ( my $i=0; $i < 4; $i++) {
        for ( my $j=0; $j < 13; $j++) {
            my $newcard = $cards[$j] . " of " . $types[$i];
            push(@deck, $newcard);
        }
    }
    return @deck; #return the new deck
}
[download]

Perhaps a little bit easier using some perl idioms...

#DECK MAKER
sub deck_maker {
    my @deck = (); #the deck for returning
    my @suits = qw( spades hearts diamonds clubs );
    my @cards = ( 2..10, qw(J Q K A) );
    for my $suit ( @suits ) {
        for my $card ( @cards ) {
            my $newcard = "$card of $suit";
            push(@deck, $newcard);
        }
    }
    return @deck; #return the new deck
}
[download]

--MidLifeXis

Can go simpler...

sub deck_maker {
    map {
        my $suit = $_;
        map { "$_ of $suit" } 2..10, qw(J Q K A)
    } qw(spades hearts diamonds clubs);
}
[download]

perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'

Yes, it is, but I prefer to really be more verbose about my code.

You'll also need to dereference that reference, inside sub pick_a_card, of course:

#PICK A CARD
sub pick_a_card {
    my $deckref = shift;
    my $card=pop(@{$deckref});
    return $card;
}
[download]

use List::Util;

# ... snip ...

@deck = List::Util::shuffle @deck;
[download]

This is slightly different that the fisher_yates_shuffle algorithm.

At the root of the matter, rand() is not random and has a odd,even,odd,even bias - or at least common implementations do. There are better "pseudo random number generators" than rand(). They are much more computationally expensive and I think outside of the scope of this thread.

The shuffle is "buggy" only in the sense that it isn't fair. (Not every permutation will happen with equal probability). Replacing it with a fair algorithm doesn't make the OPs problem go away.

Well, I may not agree here. "Buggy" if it messes some elements in the deck by either copy them in the swap process. However I`ve tested it, and it`s OK, yes I am missing the srand(seed) but my algorithm is working since it never goes out of range and in worst case it can just swap two similar elements like card2 with card2 but it`s no error at all and it`s quite possible in real life shuffle too.

The awkward moment you shuffle and you get 3 times the same cards to piss everybody out on the table... well it`s no algorithm for a lame shuffler, better never gave him/her to pass cards again!

Not sure if this has been mentioned yet, but the warning in your screenshot comes from:

            my $newcard = pop(@cards[$i]) . " of " . $types[$i];
[download]

I'm not sure that is supposed to work (no idea how pop handles array slices), but you meant pop(@{$cards[$i]})

Interestingly, if I pass pop a slice, it seems to operate on the last element in the slice, popping the last element from the array to which that element is a reference. If I pass it a slice of ordinary scalars (not array references) it errors. All this is since version 5.14, by the way; prior to that pop simply demands an array as the first argument. Also, perldoc -f pop says this is experimental behavior, so it'd probably be best to keep dereferencing for now and not count on this.

#!/usr/bin/env perl
use Modern::Perl;
use Data::Dumper;

my @cards = ([qw[0 1 2 3]],
             [qw[4 5 6 7]],
             [qw[8 9 A B]],
             [qw[C D E F]],
             );
say pop @cards;       # pop the last array element [C D E F]
say pop @cards[0,1];  # pop from a two-element slice, gets 7 from @$ca
+rds[1];
say pop @cards[0];    # pop from a one-element slice, gets 3 from @$ca
+rds[0], throws warning
say pop $cards[0];    # pop from a scalar array reference, gets 2 from
+ @$cards[0]
say Dumper @cards;    # see what's left in the array

my @list = (0..15);
say pop @list[3..5];  # error, not an ARRAY reference
[download]

Aaron B.
My Woefully Neglected Blog, where I occasionally mention Perl.

My only vision of the things here ( and I am a Perl noob) is that pop @ar0,1 is possible by poping index1 and index0 sequentially, the problem with pop @ar0..3 is that you try to pop a list probably, that`s my assumption tho, it may be completely wrong. The problem with pop is more verbal than system, it`s hard for us humans to read than the compiler to turn to 0s and 1s, when I say:

pop($storage[0]);
[download]

I actually want a scalar variable, but I have to know that $storage[0] is a index to an array from which I`ll pop something. It`s tricky and definitely not a noob-friendly, so noobs like me should read Perl books 2 times more cautiously.

That`s some trick I am not quite good at... Yes the point is good but I want to pop an element from an array it can be written like @cards->$i but there is still a warning ( not an error which can be omitted for now ). I don`t pop a slice actually, I just pop last element from N row of the 2D array and that was my solution, for good or bad Doing it the way:

pop($cards[$i]...)
[download]

solves the warning but I am not sure why since I want to pop an array variable not a scalar one... Guess I need more Perls to eat :)