In the course of my math class in the engineering program I'm currently in it's often convenient to write up little programs that perform some calculation based on a function or algorithm. However, oftentimes a reasonable program makes calculations in a different way than humans might, and it becomes a challenge to parse the print statements I insert into the code to "show my work."

Well I finally decided to get around this problem after reading about inlining eval's in regular expressions while reading the Camel in a compromising position recently and faced with a particularly laborious exercise in my latest assignment:

Find the number of partitions of 7 and 8 using the formula for the number of partitions of a number (all possible combinations of adding smaller positive integers):

P(m,n) = {
   1                    if m or n = 1,
   P(m,m)               if m < n,
   1 + P(m,m-1)         if m = n > 1,
   P(m,n-1) + P(m-n,n)  if m > n > 1
}
[download]

My first attempt was straightforward:

sub partition {
    my ( $m, $n ) = @_;
    die "bad inputs" if $m <= 0 or $n <= 0;
    print "P($m,$n) = ";
    if ( $m == 1 or $n == 1 ) {
        say 1;
        return 1;
    }
    if ( $m < $n ) {
        say "P($m,$m)";
        return partition( $m, $m );
    }
    if ( $m == $n ) {
        say "1 + P($m,", $m - 1, ")";
        return 1 + partition( $m, $m - 1 );
    }
    if ( $m > $n ) {
        say "P($m,", $n - 1, ") + P(", $m - $n, ",$n)";
        return partition( $m, $n - 1 ) + partition( $m - $n, $n );
    }
    die "impossible!";
}

MAIN: {
    my ( $m, $n ) = @ARGV;
    $n ||= $m;
    say partition( $m, $n );
}
[download]

The output to this program though is actually harder to put together than doing the problem manually! The recursion is depth-first and so the program goes straight to the bottom of each branch, and yet it's more natural to evaluate one level at a time and combine. Fortunately, Perl rocks my world:

sub P {
    # Returns strings!
    my ( $m, $n ) = @_;
    if ( $m == 1 or $n == 1 ) {
        return 1;
    }
    if ( $m < $n ) {
        return "P($m,$m)";
    }
    if ( $m == $n ) {
        return sprintf( "1 + P(%i,%i)", $m, $m - 1 );
    }
    if ( $m > $n ) {
        return sprintf( "P(%i,%i) + P(%i,%i)", $m, $n - 1, $m - $n, $n
+ );
    }
    die "impossible!";
}

MAIN: {
    local $_ = "P($m,$n)";
    print;
    while ( /\D/ ) {
        # Put ints up front
        1 while s/^(.+\)) \+ (\d+)/$2 + $1/;
        # Add the ints
        1 while s/(\d+) \+ (\d+)/$1 + $2/eg;
        # Evaluate *one* level at a time
        s/(P\(\d+,\d+\))/$1/eeg;
        printf( "\n = %s", $_ );   
    }
}
[download]

And the output looks like:

$ partition.pl 7
P(7,7)
 = 1 + P(7,6)
 = 1 + P(7,5) + P(1,6)
 = 1 + P(7,4) + P(2,5) + 1
 = 2 + P(7,3) + P(3,4) + P(2,2)
 = 2 + P(7,2) + P(4,3) + P(3,3) + 1 + P(2,1)
 = 3 + P(7,1) + P(5,2) + P(4,2) + P(1,3) + 1 + P(3,2) + 1
 = 5 + 1 + P(5,1) + P(3,2) + P(4,1) + P(2,2) + 1 + P(3,1) + P(1,2)
 = 7 + 1 + P(3,1) + P(1,2) + 1 + 1 + P(2,1) + 1 + 1
 = 12 + 1 + 1 + 1
 = 15
[download]

Beautiful! Copied straight to the notebook.

Update: For those interested in efficient solutions to this and other integer partition problems, Limbic~Region has this post.