user
There are four types of common coins in   US   currency:

:   :   :   1. quarters   (25 cents)
            2. dimes   (10 cents)
            3. nickels   (5 cents),   and
            4. pennies   (1 cent)

There are six ways to make change for 15 cents:

:   :   :   1. A dime and a nickel
            2. A dime and 5 pennies
            3. 3 nickels
            4. 2 nickels and 5 pennies
            5. A nickel and 10 pennies
            6. 15 pennies

Task

How many ways are there to make change for a dollar using these common coins?     (1 dollar = 100 cents).

Optional

Less common are dollar coins (100 cents);   and very rare are half dollars (50 cents).   With the addition of these two coins, how many ways are there to make change for $1000?

(Note:   the answer is larger than   232).

References

* an algorithm from the book *Structure and Interpretation of Computer Programs*.
* an article in the algorithmist.
* Change-making problem on Wikipedia.
assistant
(formerly Perl 6)

**Works with**: rakudo version 2018.10

**Translation of**: Ruby

```
# Recursive (cached)
sub change-r($amount, @coins) {
    my @cache = [1 xx @coins], |([] xx $amount);

    multi ways($n where $n >= 0, @now [$coin,*@later]) {
        @cache[$n;+@later] //= ways($n - $coin, @now) + ways($n, @later);
    }
    multi ways($,@) { 0 }

    # more efficient to start with coins sorted in descending order
    ways($amount, @coins.sort(-*).list);
}

# Iterative
sub change-i(\n, @coins) {
    my @table = [1 xx @coins], [0 xx @coins] xx n;
    (1..n).map: -> \i {
        for ^@coins -> \j {
        my \c = @coins[j];
        @table[i;j] = [+]
            @table[i - c;j] // 0,
            @table[i;j - 1] // 0;
        }
    }
    @table[*-1][*-1];
}

say "Iterative:";
say change-i    1_00, [1,5,10,25];
say change-i 1000_00, [1,5,10,25,50,100];

say "\nRecursive:";
say change-r    1_00, [1,5,10,25];
say change-r 1000_00, [1,5,10,25,50,100];

```

Output:

```
Iterative:
242
13398445413854501

Recursive:
242
13398445413854501
```