(define (memoize func)
 (let ((known (make-table)))
   (lambda args
     (let ((remembered (table-ref known args #f)))
       (if remembered
           (car remembered)
           (let ((learned (apply func args)))
             (table-set! known args (list learned))
             learned))))))

(define-macro (memoize! f)
 `(set! ,f (memoize ,f)))

(define (steve days off-by l)
 (if (zero? days)
     (list off-by)
     (if (null? l)
         #f
         (let ((first-try (steve (- days 1) (+ off-by (car l)) (cdr l)))
               (second-try (steve days off-by (cdr l))))
           (if (not first-try)
               second-try
               (let ((first-fixed (cons (car first-try)
                                        (cons (car l)
                                              (cdr first-try)))))
                 (if (or (not second-try)
                         (< (abs (car first-try)) (abs (car second-try))))
                     first-fixed
                     second-try)))))))

(memoize! steve)

(define (answer days list-of-days)
 (cdr (steve days 0 list-of-days)))

(time (answer 9 '(-50 -21 13 171 14 -42 -58 109 4 7 -23 -44 -98 -121
101 33 87 -121 -40 -65 43 54 -45 -12 -12 38 25 3 7 8)))
   3167 ms real time
   1829 ms cpu time (1703 user, 126 system)
   8 collections accounting for 912 ms real time (450 user, 31 system)
   25226416 bytes allocated
   no minor faults
   no major faults
(87 -40 -65 54 -45 -12 -12 25 8)