Lets review the first 3 problems to support this claim. A few things are common to the answers below. First is that there is no code to deal with representation of numbers in the computer. This is taken care of by the language for arbitrarily large numbers. Second is the use of the map reduce paradigm which removes most of the need to think about how to iterate. Instead, simply map a function to all values and then reduce all of the results.

Problem 1

"Add all the natural numbers below one thousand that are multiples of 3 or 5."

First we create nums-list which creates a sequential list of natural numbers as large as you want. We then make 3or5 which returns the number if it is divisible by 3 or 5 and otherwise 0. Then we use the magic of mapping and reducing. We map 3or5 to all numbers from 1 to 999 and reduce the list with addition.

(defun nums-list (n limit lst)
  (if (<= n limit)
      (cons n (nums-list (1+ n) limit lst))
    lst))
(defun 3or5 (n)
  (if (or (= (mod n 3) 0)
          (= (mod n 5) 0))
      n
    0))
(reduce #'+ (mapcar #'3or5 (nums-list 1 999 nil)))

Problem 2

"By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms."

First we create fib which returns the nth Fibonacci number. We then make evenret which returns the number if it is even or 0 otherwise. Then we use the magic of mapping and reducing. I used quick guess and check to determine that (fib 33) is the first fib over 4 million in value. So we map fib from 0 to 33, map that to evenret and reduce with addition.

(defun fib (n)
  (cond ((= n 0) 1)
        ((= n 1) 1)
        (t (+ (fib (- n 1)) (fib (- n 2))))))

(defun evenret (n)
  (if (evenp n) n 0))

; guess and check, (fib 33) is 5702887
(reduce #'+ (mapcar #'evenret (mapcar #'fib (nums-list 0 33 nil))))

Problem 3

"What is the largest prime factor of the number 600851475143?"

This one is a bit more involved. The basic approach is to generate all primes that could be factors, find the actual factors and finally find the largest. The primes are generated in order and use all previous primes to test if subsequent numbers are primes. Almost all of the code is for generating primes.

(defvar *primes* (list 2))

; true if b does not go evenly into a
(defun not-divisable (a b)
  (not (divisable a b)))

(defun divisable (a b)
  (= (mod a b) 0))

; prime? based on primes we already have
; p should be bigger than (last primes)
(defun primep (p primes)
  (cond ((null (car primes)) t)
        ((divisable p (car primes)) nil)
        (t (primep p (cdr primes)))))

(defun next-prime ()
  (let ((p (1+ (car (last *primes*)))))
    (do ()
        ((primep p *primes*))
      (setf p (1+ p)))
    (setf *primes* (append *primes* (list p)))))

(defun gen-primes (lessthan)
  (setf *primes* (list 2))
  (do ()
      ((>= (car (last *primes*)) lessthan))
    (next-prime))
  *primes*)

; filter out nil cruft
(defun just-numbers (lst acc)
  (if (not (consp lst))
      (if (numberp lst) (cons (list lst) acc)
          acc)
      (if (numberp (car lst))
          (just-numbers (cdr lst) (cons (car lst) acc))
          (just-numbers (cdr lst) acc))))

; (sqrt 600851475143) is 775147
(gen-primes 775147)
(car (just-numbers (mapcar (lambda (n) (if (divisable 600851475143 n) n nil)) *primes*) nil))