The following runs in a fraction of second. I haven't looked at the other code contributions so I won't try to compare code complexity. (:

Interesting puzzle, and a nice challenge. Thanks for the diversion. :-)

I don't know if my solution is any more elegant, readable, or speedy*, but here it is:

ggry
ypgr
rypp
pryg
[download]

use strict;
use warnings;

# cube strings are the colors for the left, front, right, back, top
# and bottom faces, respectively
my @cubes = ( 'pgpygr', 'rprrgy', 'ppryyg', 'rrygpy' );
my ( $num_solutions, @opts );

foreach my $cube ( @cubes )
{
    push( @opts, get_all_opts( $cube ) );
}

foreach my $cube0str ( @{ $opts[0] } )
{
    foreach my $cube1str ( @{ $opts[1] } )
    {
        next if has_duplicate_faces( $cube0str, $cube1str );

        foreach my $cube2str ( @{ $opts[2] } )
        {
            next if has_duplicate_faces( $cube0str, $cube2str );
            next if has_duplicate_faces( $cube1str, $cube2str );

            foreach my $cube3str ( @{ $opts[3] } )
            {
                next if has_duplicate_faces( $cube0str, $cube3str );
                next if has_duplicate_faces( $cube1str, $cube3str );
                next if has_duplicate_faces( $cube2str, $cube3str );

                # we have a winner
                print "**********\n";
                print join( "\n", $cube0str, $cube1str,
                                  $cube2str, $cube3str ), "\n";

                $num_solutions++;
            }
        }
    }
}

printf "\n\nFound $num_solutions %s (%d unique %s),\n",
      $num_solutions == 1 ? 'solution' : 'solutions',
      $num_solutions / 8,
      $num_solutions / 8 == 1 ? 'solution' : 'solutions';
print "but by permuting the block order this total can be ",
      "increased by a factor of 24\n";

sub get_all_opts
{
    my ( $cubestr ) = @_;

    my @opts;

    # generate all 8 options for the rings around the
    # X, Y, and Z axes of the cube
    my @faces = split( //, $cubestr );
    push( @opts, permute_ring( @faces[ 0,1,2,3 ] ) );
    push( @opts, permute_ring( @faces[ 4,1,5,3 ] ) );
    push( @opts, permute_ring( @faces[ 0,4,2,5 ] ) );

    return( \@opts );
}

sub permute_ring
{
    my ( @faces ) = @_;

    # rotate and reverse the 4 faces
    my @opts;
    for ( 1 .. 4 )
    {
        push( @opts, join( '', @faces ) );
        push( @opts, scalar reverse join( '', @faces ) );
        push( @faces, shift( @faces ) );
    }

    return( @opts );
}

sub has_duplicate_faces
{
    my ( $cube1, $cube2 ) = @_;

    for( 0 .. 3 )
    {
        if( substr( $cube1, $_, 1 ) eq substr( $cube2, $_, 1 ) )
        {
            return 1;
        }
    }

    return 0;
}
[download]

*Update: After downloading and running your code, my solution appears to be a bit faster. The short-circuiting that I used meant that I only checked 12,480 4-block combinations for the given input data, whereas your solution checks 331,776 combinations. I didn't run extensive benchmarks (which might be more interesting once other solutions are posted), but on my box your code took about 50 sec to run and mine took less than 1 sec. Your code has more error checking and output capability, though, so speed isn't everything. :-)

The solution posted 5 days ago wasn't a solution at all :)
I just realised that it solved a bit another puzzle :)

The updated pure rexep-based version is here:</p

Update (2006-07-06):
Here is a smarter brute-force approach. It reduces the number of loops from 331,776 to 65,536:

Final Update (2006-07-06):
This is an even smarter brute-force approach. The number of total loops is less than 8,048 and It is quite fast.

The total number of iterations needed to find all unique solutions is ((3*4)^4)/8 == 2592, as the unique solution does not depend on the cubes' order :) And all 8 solutions can be built using simple permutation of an array representing the unique one.

My regexp solution really uses the smallest possible number of loops, i think. Be stricter, it does not use loops at all to find the solution — only during the pre-processing :)))

It's difficult to make a good benchmark, as all presented scripts print their output directly to STDOUT and need to be a bit modified to become comparable by cmpthese(). But i'll try to do it today, if i have enough time.

Ieronim,
I told liverpole in the CB that I didn't really have time to play with this but since he indicated I was the reason he posted it as a Challenge (see some of my previous posts), I felt obligated to do so. Without thinking about it too much, I decided just to brute-force it and then see if there were any obvious optimizations on that. I do not expect it to be the fastest but it is fast enough.

With regards to benchmarking, it is almost never a good idea to include IO. Basically, the routines should be verified to produce essentially the same results first and then the output should be omitted. In other words, doing any preparation IO work before the bench, run the bench, and omit any IO output.

Update: Depending on how you count, the following only loops 1,152 times and still finds duplicates.

<Reveal this spoiler or all spoilers in this node or all in this thread>

And the following performs even fewer (< 500):

<Reveal this spoiler>

Cheers - L~R

Here's my solution in the J programming language. The cubes in the example are defined near the beginning, but you can use any other cube colorings you wish. My solution uses brute force and is unoptimized, but on a modern machine it still runs within a few seconds so I don't care.

The output lists all the solutions and then gives the number of solutions just in case there are so many they scrolled out of the screen. Each solution is the list of four rotated cubes each given as six colors like in the input. The output is in spoiler tags.

Update: Let's compare the output with that of some of the other solutions posted in this thread.

Update: I cross-posted a description of the puzzle and my solution to the J wiki: Essays/InsanityCube.

Update 2010-11-29: has anyone linked to the description of this puzzle (called Instant Insanity there) on Jaap's puzzle page?

See also http://www.jsoftware.com/jwiki/Doc/Articles/Play173.