I've read, since then, that up to around that point Brendan Eich had been working on a Scheme-based extension language for Netscape Navigator. Such was the power of the hegemony of the high level folks at Sun that the word came down on Mr. Eich: "Get it done. And make it look like Java." Staying true to his sense of Self, he quickly knocked out the first implementation of Mocha, later renamed Javascript.

Explains a lot. And shows what an under-appreciated genius Brendan Eich is.

But I'm not complaining; everything looks like it's working out well.

Going back to Scheme, the next Project Euler problem is:

The prime factors of 13195 are 5, 7, 13 and 29. What is the largest prime factor of the number 600851475143 ?

And straightforwardly:

(define gpf ; greatest prime factor
  (lambda (n try) ; n is the number to find the factor of; try is the lowest number to try
    (cond
      ((> try (sqrt n)) n) ; no need to try a factor higher than the square root; if we get here, n is prime
      ((divides try n) (gpf (/ n try) try)) ; divide out the current trial factor and try again
      (else (gpf n (+ try 1))))))
(define euler3
  (lambda (n) (gpf n 2)))

(euler3 600851475143) gives us the answer 6857 pretty quickly.

But this is getting boring; I'm not using the interesting parts of Scheme. This sort of problem cries out for a prime number generator, and that cries out for call-with-current-continuation, and that cries out for some more playing and learning. I'll see what I can do.

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be: 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ... Find the sum of all the even-valued terms in the sequence which do not exceed four million.

Brute force Fibonacci generator:

(define fibo
  (lambda (n)
    (cond
      ((= n 1)
       1)
      ((= n 2)
       2)
      (else (+ (fibo (- n 1)) (fibo (- n 2)))))))

But that takes exponential time, and the problem requires generating all of the numbers anyway, so we can use something like:

(define fibo-sum
  (lambda (a b lim)
    (let* ((c (+ a b)))
      (cond
        ((< lim c) 0)
        (else (+ c (fibo-sum b c lim)))))))

to get the sum of all the fibonacci numbers less than lim (use (fibo-sum 1 2 4000000)). I could add a test for even numbers to solve the problem, but more elegantly we notice that the pattern of the fibonacci numbers has to be odd-odd-even-odd-odd-even, so we have:

(define euler2
  (lambda (a b lim)
    (let* ((c (+ a b))
           (d (+ b c))
           (e (+ c d)))
      (cond
        ((< lim e) 0)
        (else (+ e (euler2 d e lim)))))))
(euler2 1 0 4000000)

We start the fibonacci sequence with 1 0 so that the 2 is part of our sum. And we get the correct answer, 4613732, imperceptibly fast.

One bug that took me forever to find was a mistyped line:

(let* ((c (+ a b))
  (d (+ b c))
   (e (+ d e)))

Where e was defined in terms of d and e, so it used the global value of e. If it hadn't been defined, it would have given me an error immediately, but unfortunately, DrScheme has it pre-defined as #i2.718281828459045 so my code went happily along giving me the wrong answers.

Problem 1:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000.

Translating Javascript to Scheme means function(x, y) {foo;bar;} becomes (lambda (x y) (foo) (bar)) and var x = y; becomes (define x y) and realizing that all loops have to be made into tail-recursive function calls gives us this pretty easily:

(define divides
  (lambda (a b)
    (= 0 (remainder b a))))

(define euler1
  (lambda (n)
    (cond
      ((= n 1) 
        0)
      ((or (divides 5 n) (divides 3 n))
        (+ n (euler1 (- n 1))))
      (else (euler1 (- n 1))))))

(euler1 999)

And the correct answer is 233168. Not bad for my first Scheme program! (Certainly more interesting than (display "hello, world")).

Addendum: I just looked at the forum at Project Euler and I see that there's a much better solution; just add the series 3+6+9....999, which is simply 3*(1+2+3+...333) or 3* 333 * (333+1)/2, to the series 5+10+15+...995, or 5 * 199 * (199+1)/2 and subtract the series 15+30+45... which is counted twice. No loops! Less interesting for learning to program, though.