By: FalconNL

FalconNL — Thu, 16 Apr 2009 22:23:08 +0000

In Haskell: [sourcecode lang='css'] import Data.List import Data.Numbers.Primes main = print $ test [541,41,17,7,1] consecutivePrimes n = map (sum . take n) $ tails primes test = head . foldl1 (\a b -> filter (\x -> elem x $ takeWhile (<= x) b) a) . map consecutivePrimes[/sourcecode]

By: jcs

jcs — Thu, 16 Apr 2009 19:45:22 +0000

Here is a solution that makes no assumptions about the size of the solution and does not compute unnecessary sums. The primes module provides a stream (as in SICP) of primes and the primitive prime?; push, pop, and dotimes are Scheme implementations of the like-named Common Lisp macros.

(use-modules (private primes)) ;for stream-of-primes, prime?


;;; Queue object that holds n consecutive primes and sums them

(define make-summing-queue

  (lambda (n)

    (let ((front '()) (back '()) (primes stream-of-primes))

      (define popq    ;just throw away the head of queue

        (lambda ()

          (unless (pop front)

            (set! front (reverse back))

            (set! back '())

            (pop front))))

      (define popp    ;return the next prime

        (lambda ()

          (let ((p (str-car primes)))

            (set! primes (str-cdr primes))

            p)))

      (dotimes (i n)

        (push (popp) back))

      (lambda (cmd)

        (case cmd

          ((next) (push (popp) back) (popq))   ;shift sum

          ((fb) (format #t "front: ~s, back: ~s\n" front back))

          ((show) (princ (append front (reverse back))))

          ((sum) (apply + (append front back))))))))
;;; Find sums of primes
(define queues (list (make-summing-queue 541)

                     (make-summing-queue 41)

                     (make-summing-queue 17)

                     (make-summing-queue 7)))
(define run

  (lambda (queues)

    (let ((first (car queues)))

      (while (not (prime? (first 'sum)))

        (first 'next))

      (let iter ((goal (first 'sum)) (rest (cdr queues)))

        (cond ((null? rest) (first 'sum))

              ((= goal ((car rest) 'sum)) (iter goal (cdr rest)))

              ((< goal ((car rest) 'sum)) (first 'next) (run queues))

              (else ((car rest) 'next) (iter goal rest)))))))

;; (for-each (lambda (q) (q 'show)) queues) ;; to see lists of primes

Comments on: Google Treasure Hunt 2008 Puzzle 4

By: FalconNL

By: jcs