I'm proud of it, so give a nonexpert a break. That said, any constructive feedback would be most welcome.

For a non-expert it's pretty good. There are a few inconsistencies but I'm sure you can spot those and polish them out in due course. The only bit which really grates is this:

# GENERATE THE BOARD

my @board;
my $inversions;
GEN:
@board = (0, shuffle(1..15));
# @board = (1,0,2..15); # for testing
$inversions = 0;
for my $a(1..15) {
  for my $b(1..15) {
    ++$inversions if($a<$b and $board[$a]>$board[$b])
  }
}
goto GEN if $inversions % 2;
[download]

There's really no need for a goto in here. You are clearly aware of conditional loops in Perl as you've used them elsewhere in this script. Let's re-write this to avoid the goto, avoid the special variables $a and $b and make it marginally more efficient by only checking the triangle rather than the square.

my @board;
my $inversions = 1;
while ($inversions % 2) {
    @board = (0, shuffle(1..15));
    $inversions = 0;
    for my $x (1 .. 15) {
        for my $y ($x + 1 .. 15) {
            $inversions++ if $board[$x] > $board[$y];
        }
    }
}
[download]

Hopefully I have not altered the logic of your board construction at all, just tweaked the code to do the same thing but in a slightly more Perlish way. For completeness I would probably put this in its own subroutine and just call my @board = setup_board() in the main script as the setup is entirely independent of the rest of the script.

Your

my $inversions = 1;
while ($inversions % 2) {
    @board = (0, shuffle(1..15));
    $inversions = 0;
    for my $x (1 .. 15) {
        for my $y ($x + 1 .. 15) {
            $inversions++ if $board[$x] > $board[$y];
        }
    }
}
[download]

bothers me a little, because the code is asserting we have one inversion, and then that we have none, and then counting them. It seems… wrong, somehow, to assert at the start that we have one inversion, beginning counting them — especially because that assertion is followed immediately by a contradictory one. So I switched it to

my $inversions;
do {
  $inversions = 0;
  @board = (0, shuffle(1..15));
  # @board = (1,0,2..15); # for testing
  for my $x(1..15) {
    for my $y($x+1..15) {
      ++$inversions if $board[$x]>$board[$y]
    }
  }
} while $inversions % 2;
[download]

I'd appreciate your letting me know what you think.

$_="msh210";$"=$\;@_=@{[split//,uc]}[2,0];$_="@_$\1";$\=$/;++$_[0]for$...1;print lc substr crypt($_,"@_"),1,6

Both versions of the loop are effectively the same as far as the algorithm goes. By moving the conditional to the end you have avoided the need for the initial flag value. I just picked 1 as it makes $inversions % 2 a true value but it could equally have been -1 or -9999 or any other (odd) value if that were to make it seem less wrong. You could even go so far as to set up a constant called INITIAL_INVERSIONS and set that to have the arbitrary flag value - TIMTOWTDI.

It's best to code in a way that's right for you. If the semantics of the variables are most important to you then that's clearly the way to go. There's no computational penalty for this and anything that makes the code easier to maintain, whether objectively or for the specific maintainer, has to be beneficial.

Just the process of analysing this and re-working the loop will have been, I hope, a worthwhile exercise. Thanks for taking the time to do so.

Thanks!

$_="msh210";$"=$\;@_=@{[split//,uc]}[2,0];$_="@_$\1";$\=$/;++$_[0]for$...1;print lc substr crypt($_,"@_"),1,6

NICE! A big PLUS to you. The generation of the board can go into an endless loop, and can be done much simpler directly:

# GENERATE THE BOARD
my @board = shuffle 1 .. 15;
splice @board, int rand 16, 0, 0;
[download]

I've added my version here, which is how I would re-write yours (TIMTOWTDI):

Thanks.

Note that not all configurations of the puzzle are solvable. My check for  $inversions % 2 == 0 makes sure we get a solvable configuration. I don't see anything comparable in your code, though it could be I'm just not seeing it.

$_="msh210";$"=$\;@_=@{[split//,uc]}[2,0];$_="@_$\1";$\=$/;++$_[0]for$...1;print lc substr crypt($_,"@_"),1,6

not all configurations of the puzzle are solvable

This Numberphile video explains the math behind.

Alexander

--
Today I will gladly share my knowledge and experience, for there are no sweeter words than "I told you so". ;-)

print for(
  '',
  'Welcome to the 15 puzzle!',
  '',
  'Use an arrow key to move a block into the empty position.',
  "You're trying to reach the position:",
  '   01 02 03',
  '04 05 06 07',
  '08 09 10 11',
  '12 13 14 15',
  '',
  '^C to kill.',
  ''
);
[download]

That would probably be better as a here doc (a single string) than a list of strings:

print <<TEXT;

Welcome to the 15 puzzle!

Use an arrow key to move a block into the empty position.
You're trying to reach the position:
   01 02 03
04 05 06 07
08 09 10 11
12 13 14 15

^C to kill.

TEXT
[download]

Thank you!

$_="msh210";$"=$\;@_=@{[split//,uc]}[2,0];$_="@_$\1";$\=$/;++$_[0]for$...1;print lc substr crypt($_,"@_"),1,6

++ For your code. It's quite readable as well despite being dense IMHO.

About the number of permutations, rather than a loop wouldn't it be simpler to just have: @board[1,2] = @board[2,1] if $inversions %2; ?

Good idea; thanks!

$_="msh210";$"=$\;@_=@{[split//,uc]}[2,0];$_="@_$\1";$\=$/;++$_[0]for$...1;print lc substr crypt($_,"@_"),1,6

Version 1.01 is available from BackPAN. It appears to be fairly platform independent.