Home/ Questions/Q 80967
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-10T21:23:08+00:00

I’m a Lisp beginner. I’m trying to memoize a recursive function for calculating the

  • 0

I’m a Lisp beginner. I’m trying to memoize a recursive function for calculating the number of terms in a Collatz sequence (for problem 14 in Project Euler). My code as of yet is:

(defun collatz-steps (n)   (if (= 1 n) 0        (if (evenp n)             (1+ (collatz-steps (/ n 2)))            (1+ (collatz-steps (1+ (* 3 n)))))))  (defun p14 ()   (defvar m-collatz-steps (memoize #'collatz-steps))   (let        ((maxsteps (funcall m-collatz-steps 2))        (n 2)        (steps))     (loop for i from 1 to 1000000           do            (setq steps (funcall m-collatz-steps i))           (cond              ((> steps maxsteps)               (setq maxsteps steps)              (setq n i))             (t ())))     n))   (defun memoize (fn)   (let ((cache (make-hash-table :test #'equal)))     #'(lambda (&rest args)         (multiple-value-bind                (result exists)             (gethash args cache)           (if exists               result               (setf (gethash args cache)                     (apply fn args)))))))

The memoize function is the same as the one given in the On Lisp book.

This code doesn’t actually give any speedup compared to the non-memoized version. I believe it’s due to the recursive calls calling the non-memoized version of the function, which sort of defeats the purpose. In that case, what is the correct way to do the memoization here? Is there any way to have all calls to the original function call the memoized version itself, removing the need for the special m-collatz-steps symbol?

EDIT: Corrected the code to have 

(defvar m-collatz-steps (memoize #'collatz-steps))

which is what I had in my code. Before the edit I had erroneously put:

(defvar collatz-steps (memoize #'collatz-steps))

Seeing that error gave me another idea, and I tried using this last defvar itself and changing the recursive calls to 

       (1+ (funcall collatz-steps (/ n 2)))        (1+ (funcall collatz-steps (1+ (* 3 n))))

This does seem to perform the memoization (speedup from about 60 seconds to 1.5 seconds), but requires changing the original function. Is there a cleaner solution which doesn’t involve changing the original function?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. I assume you’re using Common-Lisp, which has separate namespaces for variable and function names. In order to memoize the function named by a symbol, you need to change its function binding, through the accessor `fdefinition’:

    (setf (fdefinition 'collatz-steps) (memoize #'collatz-steps))  (defun p14 ()   (let ((mx 0) (my 0))     (loop for x from 1 to 1000000           for y = (collatz-steps x)           when (< my y) do (setf my y mx x))     mx))
    • 0