use strict; 
 
my $str = 'hello world'; 
my $newstr = $str; 
$newstr =~ s/o/u/g; 
print $newstr;

use strict; 
 
my $str = 'hello world'; 
( my $newstr = $str ) =~ s/o/u/g; 
print $newstr;

use strict; 
use warnings; 
use 5.14.0; 
my $str = 'hello world'; 
print $str =~ s/o/u/gr;

map(($r=$_,map(($y=$r-$_/3,$l[24-$r] 
.=(' ','@')[$y**2-20*$y+($_**2)/3<0]),(0..30)),),(0..24)); 
print join("\n", map(reverse($_).$_, @l)), "\n";

use strict; 
use warnings; 
use Readonly; 
Readonly::Scalar my $AT    => q(@); 
Readonly::Scalar my $SPACE => q( ); 
for my $row (0..24) { 
    my $curve = select_curve($row); 
    my $line; 
    $line .= $curve->($_) < 0  ?  $AT  :  $SPACE for (0..30) ; 
    print scalar reverse($line), $line, "\n"; 
} 
 
sub select_curve { 
    my ($row) = @_; 
    return sub { 
        my ($col) = @_; 
        my $x = 24 - $row - $col / 3; 
        return  $x**2 - 20 * $x + ( $col**2 ) / 3; 
    } 
}

my $x = 24 - $row - $col / 3;  
return  $x**2 - 20 * $x + ( $col**2 ) / 3;

use strict; 
use warnings;  
use Readonly;  
Readonly::Scalar my $AT    => q(@);  
Readonly::Scalar my $SPACE => q( ); 
 
for my $row (0..24) {  
    my $line;  
    $line .= select_curve($row, $_) < 0  ?  $AT  :  $SPACE  for (0..30) ; 
    print scalar reverse($line), $line, "\n";  
}  
  
sub select_curve {  
    my ($row, $col) = @_;  
    my $x = 24 - $row - $col / 3;  
    return  $x**2 - 20 * $x + $col**2 / 3;  
}

- The best hand of all is a Pontoon, which is 21 points in two cards - this can only consist of ace plus a picture card or ten. 
- Next best after a Pontoon is a Five Card Trick, which is a hand of five cards totaling 21 or less. 
- A hand of three or four cards worth 21 points beats everything else except a Pontoon or Five Card Trick. 
- Hands with 20 or fewer points and fewer than five cards rank in order of their point value - the nearer to 21 the better. 
- Hands with more than 21 points are bust and are worthless.

#!/usr/bin/perl 
use strict; 
use warnings FATAL => qw/all/; 
use Data::Dumper; 
 
our $deck =  
{ 
    '2H'  => [2]    , 
    '3H'  => [3]    , 
    '4H'  => [4]    , 
    '5H'  => [5]    , 
    '6H'  => [6]    , 
    '7H'  => [7]    , 
    '8H'  => [8]    , 
    '9H'  => [9]    , 
    '10H' => [10]   , 
    'JH'  => [10]   , 
    'QH'  => [10]   , 
    'KH'  => [10]   , 
    'AH'  => [1,11] , 
    '2D'  => [2]    , 
    '3D'  => [3]    , 
    '4D'  => [4]    , 
    '5D'  => [5]    , 
    '6D'  => [6]    , 
    '7D'  => [7]    , 
    '8D'  => [8]    , 
    '9D'  => [9]    , 
    '10D' => [10]   , 
    'JD'  => [10]   , 
    'QD'  => [10]   , 
    'KD'  => [10]   , 
    'AD'  => [1,11] , 
    '2S'  => [2]    , 
    '3S'  => [3]    , 
    '4S'  => [4]    , 
    '5S'  => [5]    , 
    '6S'  => [6]    , 
    '7S'  => [7]    , 
    '8S'  => [8]    , 
    '9S'  => [9]    , 
    '10S' => [10]   , 
    'JS'  => [10]   , 
    'QS'  => [10]   , 
    'KS'  => [10]   , 
    'AS'  => [1,11] , 
    '2C'  => [2]    , 
    '3C'  => [3]    , 
    '4C'  => [4]    , 
    '5C'  => [5]    , 
    '6C'  => [6]    , 
    '7C'  => [7]    , 
    '8C'  => [8]    , 
    '9C'  => [9]    , 
    '10C' => [10]   , 
    'JC'  => [10]   , 
    'QC'  => [10]   , 
    'KC'  => [10]   , 
    'AC'  => [1,11] ,  
}; 
 
my $total; 
print Dumper pontoon(['AH', 'KC'], \$total), $total; 
 
sub pontoon 
{ 
    my ($hand, $total) = @_; 
     
    return 'nohand'  if (!@$hand); 
   #return 'ok'      if (@$hand == 1); # can only be ok if 1 card in hand. No total here yet though. 
  
    ($$total) = sort { $b <=> $a      }                      # order highest total first 
                grep { $_ <= 21       }                      # filter totals less than 22 
                map  { list_total($_) } @{sequences($hand)}; # convert list to total of elements 
     
    return 'bust'      if (!$$total); 
    return 'fivecard'  if (@$hand > 4);     
    return 'pontoon'   if (@$hand == 2 && $$total == 21); 
    return 'twentyone' if ($$total == 21); 
    return 'ok'; 
} 
 
# sequences could be more efficient when no sequences yet and/or only 1 value. 
sub sequences 
{  
    my ($hand) = @_; 
     
    return () unless @$hand; 
 
    my @sequences = ([]); 
 
    foreach my $card (@$hand) 
    { 
        my $values = $deck->{$card}; 
         
        my @sequences_new; 
 
        foreach my $value (@$values) 
        {  
            my @sequences_copy = map { [@$_] } @sequences; # deep copy sequences 
 
            push @$_, $value foreach (@sequences_copy); 
 
            push @sequences_new, @sequences_copy; 
        } 
 
        @sequences = @sequences_new; 
    } 
     
    return \@sequences; 
} 
 
sub list_total 
{ 
    my ($list) = @_; 
 
    my $total; 
    $total += $_ foreach (@$list); 
 
    return $total; 
}

for my $suit ('H', 'S', 'C', 'D') {  
     $deck{"$_$suit"} = [$_] for 2..9;   
     $deck{"$_$suit"} = [10] for qw (K Q J);  
     $deck{"A$suit"} = [1, 10]}; 
}