Problem 4 ver. 2: optimization
Find the largest palindrome made from the product of two 3digit numbers.
Last time we had a straightforward algo with complexity and at least O(n) memory use. Now let's enhance that. Instead of iterating over multipliers it's reasonable to iterate over palindromes, starting from the largest. I.e. over sequence 999999, 998899, 997799, and so on.
Remark. The largest product of two 3digit numbers is 999 * 999 = 998001. So, in principle, we could start from the palindrome 997799. But this saves just 2 iterations.
Having a palindrome m, we factorize it and look at all the subsets of the factorization. Assume, we have one subset already. Let's name the product of those factors as p. If this number p has k digits (k = 3 for now) and the number m/p has k digits, than we found the palindrome, which is a product of two kdigit numbers.
In Scheme that will be written as:

(define (findlargestpalindromeviafactorization k)

(define (correctlength? m) (= (length (digits m)) k))

(define (iter l) (let* ([n (makenumberfromdigits (append (reverse l) l))]

[factors (map mullist (subsets (factorize n minimalfactorsqrtcomplexity)))]

[factors (filter correctlength? factors)]

[factors (filter (lambda (m) (correctlength? (/ n m))) factors)])

(if (null? factors) (iter (digits ( (makenumberfromdigits l) 1))) n)))

;(display (list n '= (car factors) '* (/ n (car factors)))))))

(iter (onenumbermultipletimes 9 k)))
Here I used a few new util functions:

(define (makenumberfromradix list k)

(define (iter l f) (if (null? l) 0 (+ (* (car l) f) (iter (cdr l) (* f k)))))

(iter list 1))

(define (makenumberfromdigits list) (makenumberfromradix list 10))
which make numbers out of their basek representation.
Complexity now is hard to calculate. The worst case scenario gives quite a bad upper boundary. However, the worst case will never be realized.
Looking at what it gives out (9009, 906609, 99000099, 9966006699, 999000000999, ...), I could guess that the required palindrome is found after roughly iterations. So, in total I hope for less than complexity.
The memory use depends on factorizations  we store one whenever a palindrome is taken and lose it when proceed with the next palindrome.