Bryce Bockman wrote:

How would you guys memoize the following code.

simpleCalc :: (Int,Int) -> (Int,Int) simpleCalc (1,l) = (1,l+1) simpleCalc (x,l) | (odd x) = simpleCalc (((3*x) + 1), 1 + l) | otherwise = simpleCalc ((x `div` 2), 1 + l)

sCalc x = simpleCalc (x,0)

sCalcListRange a b = map sCalc [a..b]

sCalcListLengthRange a b = map snd (sCalcListRange a b)

The key is I need to calculate maximum (sCalcListLengthRange 1 1000000).

One observation is that `l' is merely `an iteration counter'. Therefore, the code can be simplified. The other observation is that memoizing all intermediate results may be expensive: the memoization table (a list, for example) will be big and sparsely populated. The cost of indexing in such a list can be significant. Here's a solution that seems to be balancing both costs. One can change the balance by modifying sc_upb.

module Foo where

import Data.Array

sc_upb = 100 sc = listArray (1,sc_upb) $ map sc_calc [1..]

sc_get i | i <= sc_upb = sc ! i sc_get i = sc_calc i

sc_calc :: Int -> (Int,Int) sc_calc 0 = (0,0) sc_calc 1 = (1,1) sc_calc x | odd x = let (r,c) = sc_get (3*x + 1) in (r, c+1) sc_calc x = let (r,c) = sc_get (x `div` 2) in (r, c+1)

sCalcListLengthRange' a b = map (snd . sc_calc) [a..b]

*Foo> maximum $ sCalcListLengthRange 1 10000 262 (1.57 secs, 82200088 bytes) *Foo> maximum $ sCalcListLengthRange' 1 10000 262 (1.18 secs, 61043084 bytes) there seems to be a benefit.