Back in the Cretaceous era I worked at the University of Oklahoma as a student assistant at Remote 1. OU was a [shudder] IBM big iron shop at the time, and beginning students typically got a job class that limited CPU time to thirty seconds, lest a beginner submit a program with an endless loop and chew up serious resources. (And when the computer everyone's sharing is a 370 of mid-1970s vintage, it doesn't take much to be considered serious resources. According to the

Hercules FAQ, a Celeron 300 can

*emulate* a 370 at speeds greater than a 3033, which was at least twice as fast as what OU had at the time.)

One day one of the instructors assigned his charges the following problem: count the number of ways to make change for a dollar assuming you have a generous supply of half dollars, quarters, dimes, nickels, and pennies. (The language is a bit loose; there wasn't any buying going on, just figuring out how to get coinage adding up to a dollar.) They all headed off to punch their FORTRAN programs to run using

WATFIV, successor to

WATFOR, the University of Waterloo FORTRAN compiler designed to give good error messages rather than worrying about optimization.

The student assistants were getting swamped with students coming in and wanting to know how to get more computer time; their change-making programs were running thirty seconds and getting killed. Every one of them had written something like this, modulo the length of that logical IF; I'm not going to bother to churn out the appropriate "continuation card"):

** IWAYS = 0**
** DO 100 ICENTS = 0,100**
** DO 200 INICKELS = 0,20**
** DO 300 IDIMES = 0,10**
** DO 400 IQUARTERS = 0,4**
** DO 500 IHALFS = 0,2**
** IF (ICENTS + 5 * INICKELS + 10 * IDIMES + 25 * IQUARTERS + 50 * IHALFS .EQ. 100) IWAYS = IWAYS + 1**
** 500 CONTINUE**
** 400 CONTINUE**
** 300 CONTINUE**
** 200 CONTINUE**
** 100 CONTINUE**
** WRITE(6,600) IWAYS**
** 600 FORMAT(I8,' WAYS')**
** STOP**
** END**
so that no attention was paid to how much you'd accumulated in outer loops--no matter whether ICENTS was 0 or 99, it would doggedly try counts of other coins sure to push the total far over a dollar.

I wrote a recursive program in Algol W, my then language of choice, with a function that took an arbitrary array of coin denominations and amount and a main program passing the particular values for the problem the instructor set. It ran in 0.01 seconds. A friend and coworker, Raymond Schlecht (alevasholem), wrote a FORTRAN version that took less than 0.01 seconds, so from the output, which only gave run time to two decimal places, it looked like it took no time at all. We handed the listings and output to our boss, who had a chat with the instructor. I like to think the discussion was educational.

Nowadays, of course, just about everyone has computers so much faster than that 370/158 that the above brute force code would run to completion in no time at all. The old fogey in me hopes that the up and coming programmers serve time with low-end hardware, and indeed systems like Arduino mean that does happen at least some of the time. OTOH, another way to do it is to crank the input size so you still can't get away with an inefficient method,

*vide* the small and large inputs for Code Jam problems... and we'll see that shortly as I get my comeuppance.

So, how to do it in Haskell?

**waysToMakeChange :: [Int] -> Int -> Int**
Obviously there's exactly one way to make change for 0.

**waysToMakeChange _ 0 = 1**
For a nonzero amount, you need at least one denomination!

**waysToMakeChange [] _ = 0**

With just one denomination, either you can do or do not, as Yoda would say.

**waysToMakeChange [denom] amount**
** | amount `mod` denom == 0 = 1**
** | otherwise = 0**
With more than one, consider the first one. The number should be the sum of the ways to make change for the amount minus 0, 1, 2, ... of the coins of that denomination using the remaining denominations as long as the difference is non-negative.

**waysToMakeChange (denom:denoms) amount**
** = sum $ map (waysToMakeChange denoms) [amount, amount - denom .. 0]**
That should do the trick... shouldn't it?

***Main> waysToMakeChange [50, 25, 10, 5, 1] 100**
**292**
Do we believe that? Turns out that Rosetta Code has

the same problem, only their example doesn't bother with half-dollars. The result they get for that variation is 242, and sure enough, that's what we get as well.

For completeness's sake, the Rosetta Code page shows an example with considerably larger amounts, for us it would be

**waysToMakeChange [100, 50, 25, 10, 5, 1] 100000**
Let's try it. (Given the output shown on Rosetta Code, we have to switch over to

**Integer** for the result.) Now we're in the same boat as the engineering students! Even compiled, ten minutes isn't enough given the above implementation.

We need a better method. Why? This version of the code is doing a lot of recalculation. For example, if we have a half-dollar and a quarter, or three quarters, or two quarters, two dimes, and a nickel, or... we will keep evaluating, among other things, the number of ways to make change for 25 cents just using pennies. So while we have a nice recursive function that is pretty clearly correct, it's inefficient. We tried one dollar, ten dollars, and one hundred dollars, running time on the compiled program, and looking at the user line of the time output, we see

one dollar: 0.002 s

ten dollars: 0.009 s

one hundred dollars: 6.794 s

Definitely the larger problem isn't practical this way... but this is already long enough and has been sitting for months waiting to be published, so let's make this Part One. Stay tuned.