Certainly from an infrastructure perspective a little bit of Windows NT (even OS/2 or LAN Manager) would have set me up far better than any of the stuff we were doing! And how many times were we told in our OS internals module that the PowerPC would kill off the 80×86 line of CPUs…

Those were the days.

I don’t know about your experience, but for me I think if we’d have learnt C and a dynamic language of the time (like Smalltalk) it would have been more valuable than what we did learn. To me at least.

A little arithmetic gives that the difference between the sum of squares and square of sum of 1,…,n is
(3n^4 + 2n^3 – 3n^2 – 2n)/12

Plug in n=100 and get 25164150

Seems like the it worked although formating got lost!

The idea here is that the function doing the real work is hidden inside and take an additional parameter (helper). “Labels” is used so the locally defined function can recurse. The original function name is now only use to jumpstart the helper!

Now I’d like to suggest another way to do this exercise, it is less performan in strict language than with lazy language but it has some value to learn functional programming IMO.

If you take the problem more literally it’s about working on the “list of natural”. So let’s first make a small function to get such a list (I’m more of and Haskeller so bear with me on CL )

(defun make-range (start end)
(labels ((helper (cur sofar)
(if (&lt cur start)
sofar
(helper (1- cur) (cons cur sofar)))))
(helper end ())))

Once we have that the rest of of the problem get’s even simpler and even more generic!
(setq nats (make-range 1 100))

What is the list of the 100 first natural squared?
(mapcar (lambda (x) (expt x 2)) nats)
Let’s generalize this to any list
(defun square-list (l)
(mapcar (lambda (x) (expt x 2)) l))

What about doing a summation?
(defun sum (l)
(reduce #’+ l))

If we put it all together:
(let ((nats (make-range 1 100)))
(- (expt (sum nats) 2)
(sum (square-list nats))))

Finally a last level of candy:
(defun square (x)
(flet ((sq (n) (* n n)))
(cond ((numberp x) (sq x))
((listp x) (mapcar #’sq x))
(1 (error “unsupported type”)))))

which afford us:
(let ((nats (make-range 1 100)))
(- (square (sum nats))
(sum (square nats))))

You have a nicer solution, which read almost like the problem and utilities to get range of numbers, sums & square

P.S. In Haskell all of this is simply
nats = [1..100] in (sum nats)^2 – (sum (map (^2) nats))
and assuming I am not using sum, which is part standard library, and rather use the Haskell equivalent of reduce here’s what I would get:
let nats = [1..100] in (foldl1 (+) nats)^2 – (foldl1 (+) (map (^2) nats))

Out of curiosity how do I escape the “less than” and “greater than” sign ?

WordPress, I think, truncates after unescaped < and >. Not sure though I’ll take a look.

I think I understand what you mean though. Even though my code looks like the sum-of-series is the last item it’s actuall part of a + statement and that’s the problem, it’s simply not tail recursive because there’s a summation that happens at the tail, not a recursive call. Doh! Thanks for pointing that out I’ll give it a try!

Steve