#!/usr/bin/perl
use strict;
use warnings;

my %digit_letters = (
    2 => [qw(a b c)],
    3 => [qw(d e f)],
    4 => [qw(g h i)],
    5 => [qw(j k l)],
    6 => [qw(m n o)],
    7 => [qw(p r s)],
    8 => [qw(t u v)],
    9 => [qw(w x y)],
);

my @letter_combinations;

my $letterchooser = choose([0 .. 2], 4);
while (my $letters = $letterchooser->()) {
    push @letter_combinations, $letters;
}

my $digitchooser = choose([2 .. 9], 4);
while (my $digits = $digitchooser->()) {
    for my $letters (@letter_combinations) {
        my @digits  = split //, $digits;
        my @letters = split //, $letters;

        my @word = map { $digit_letters{$digits[$_]}[$letters[$_]] }
                   0 .. $#digits;

        print "$digits: ", @word, "\n";
    }
}

sub basen {
    my ($base, $num) = @_;

    my $q = int($num / $base);
    my $r =     $num % $base;

    return $r if $q == 0;
    return basen($base, $q), $r;
}

sub choose {
    my ($list, $number) = @_;

    my $listcount = @$list;
    my $combcount = @$list**$number;

    my $curr = 0;

    sub {
        return if $curr >= $combcount;

        my @choice = basen($listcount, $curr++);
        unshift @choice, 0 while @choice < $number;

        return join "", map $list->[$_], @choice;
    }
}

##</code><code>##

#!/usr/bin/python

def basen (base, num):
    q = num / base
    r = num % base

    if q == 0:
        return [r]
    else:
        return basen(base, q) + [r]

def choose (list, number):
    iterations = len(list)**number

    for i in range(0, iterations):
        choice = basen(len(list), i)

        while len(choice) < number:
            choice.insert(0, 0)

        yield [ list[x] for x in choice ]

digit_letters = { 2: [ 'a', 'b', 'c' ],
                  3: [ 'd', 'e', 'f' ],
                  4: [ 'g', 'h', 'i' ],
                  5: [ 'j', 'k', 'l' ],
                  6: [ 'm', 'n', 'o' ],
                  7: [ 'p', 'r', 's' ],
                  8: [ 't', 'u', 'v' ],
                  9: [ 'w', 'x', 'y' ] }

letter_choices = []

for letters in choose([0,1,2], 4):
    letter_choices.append(letters)

for digits in choose(range(2,10), 4):
    for letters in letter_choices:
        word = []

        for i in range(0, len(digits)):
            digit    = digits[i]
            letter_i = letters[i]
            letter   = digit_letters[digit][letter_i]

            word.append(letter)

        print digits, ":", ''.join(word)

##</code><code>##

#!/usr/bin/pugs

my %digit_letters = (
    2 => [qw(a b c)],
    3 => [qw(d e f)],
    4 => [qw(g h i)],
    5 => [qw(j k l)],
    6 => [qw(m n o)],
    7 => [qw(p r s)],
    8 => [qw(t u v)],
    9 => [qw(w x y)],
);

my @letterchoices;

my $letters;
my $letterchooser = choose([0 .. 2], 4);
while $letters = $letterchooser() {
    push @letterchoices, $letters;
}

my $digits;
my $digitchooser = choose([2 .. 9], 4);
while $digits = $digitchooser() {
    my $letters;
    for @letterchoices -> $letters {
        my @digits  = split '', $digits;
        my @letters = split '', $letters;

        my @word;

        for zip(@digits, @letters) -> $digit, $letter {
            push @word, %digit_letters{$digit}[$letter];
        }

        say "$digits: ", @word;
    }
}

sub basen ($base, $num) {
    my $q = int($num / $base);
    my $r =     $num % $base;

    return $r if $q == 0;
    return basen($base, $q), $r;
}

sub choose ($list, $number) {
    my $iterations = $list.elems ** $number;
    my $current = 0;

    return sub {
        return if $current >= $iterations;

        my @choice = basen($list.elems, $current++);
        unshift @choice, 0 while @choice.elems < $number;

        return @choice.map({$list[$_]}).join("");
    };
}