A Common Lisp variant of an excercise found in the Seasoned Schemer:

  (defun sum-of-prefixes (tup)
   (let ((sonssf 0))
     (loop for n in tup
           do (setf sonssf (+ sonssf n))
           collect sonssf)))

The variable 'sonssf' is an acronym for "sum of numbers seen so far;" this function creates a list of sums of all numbers it visits as it traverses the input list.

ie:

  (sum-of-prefixes '(1 1 1)) 
  => (1, 2, 3)

  (sum-of-prefixes '(1 2 3 4 5))
  => (1, 3, 6, 10, 15)

It's a simple bit of code that I go into in more detail with an example in Python and Scheme: http://agentultra.com/?p=670

The reason why I think Lisp is a great language is that I haven't yet needed to use any "patterns" in any of my (admittedly small) projects. Patterns, IMO, are boilerplate code to work around the limitations of a language. I haven't encountered a need for that in Lisp yet. It's a good sign to me.

I also have dynamically scoped variables, generic functions, parametric dispatch (or multimethods or whatever you call it), macros, and a very powerful OO system if I need it. Best of all is that all of it is unified by a small amount of syntax, backed by a small set of axioms, and surrounded by a wonderful (but small) community.

edit: Fixed the example output