Find the 10001st prime.
The problem of finding primes is the most famous computational task in the number theory.
At first, let's update the (generatelistiteratively) function. It now includes i  the parameter, which denotes number of eligible elements up to this moment. We use it in the stopping condition.

(define (generatelistiteratively seed filter map step stop)

(define (iterate current i) (if (stop current i) '()

(let* ([ok (filter current)] [next (if ok (+ i 1) i)] [rest (iterate (step current) next)])

(if ok (cons (map current) rest) rest))))

(iterate seed 0))
Dependant functions are rewritten also. I refactored the factorization functions and added primality tests (usual straightforward ones):

(define (minimalfactorbruteforce n)

(define (iterate n x) (if (> x n) n (if (divides? n x) x (iterate n (+ x 1)))))

(iterate n 2))

(define (minimalfactorsqrtcomplexity n)

(define (iterate n x) (if (> x (sqrt n)) n (if (divides? n x) x (iterate n (+ x 1)))))

(iterate n 2))

(define (factorize n minimalfactor) (let ([p (minimalfactor n)]) (if (= p n) (list p) (cons p (factorize (/ n p) minimalfactor)))))

(define (prime?bruteforce n) (= (minimalfactorbruteforce n) n))

(define (prime?sqrtcomplexity n) (= (minimalfactorsqrtcomplexity n) n))

(define (primeslist n prime?) (generatelistiteratively 2 prime? (lambda (x) x) (lambda (x) (+ x 1)) (lambda (x i) (= i n))))
Now, having an extra function that returns the last element in a list, we can easily solve the 7th problem:

(define (last list) (if (null? (cdr list)) (car list) (last (cdr list))))

(define (solution7bruteforce n) (last (primeslist n prime?bruteforce)))

(define (solution7optimized1 n) (last (primeslist n prime?sqrtcomplexity)))
The complexity in memory is O(n), as we store n primes. It could be O(1), of course, but I prefer this way for now. The performance complexity of the algorithm is hard to determine. Probably, I need to overlook some literature for that.
What is the difference between the sum of the squares and the square of the sums?
No problems with bruteforce here.

(define (square n) (* n n))

(define (solution6bruteforce n) (let ([ns (numbers 1 n)]) ( (square (sumlist ns)) (sumlist (map square ns)))))
The number of operations (additions and multiplications) here is 3*n + 2. The complexity is O(n), and the algo is O(n) in memory as well (of course, can be done with O(1) in memory).
What is the smallest number divisible by each of the numbers 1 to 20?
This is also quite known problem  finding a least common multiple (LCM).
As usual, let's start with the bruteforce solution.

(define (leastcommonmultiplebruteforce divisors)

(define (iterate x) (if (alldivide? x divisors) x (iterate (+ x 1))))

(iterate (maxlist divisors)))

(define (solution5bruteforce n) (leastcommonmultiplebruteforce (numbers 2 n)))
This is the most inefficient way we can invent for the task of finding LCM. The complexity in the worst case is something like O(p^n), when n divisors out there are prime numbers, each is p at the average (but different, of course, then their LCM is just their product). More strictly, the number of divisions is up to n*p^n in the worst case (would be that if not shorcutted logical operations in (alldivide?) function).
Find the largest palindrome made from the product of two 3digit numbers.
An additional function that filters out empty lists from a list of lists:

(define (filteremptylists lists) (filter (lambda (list) (not (null? list))) lists))
The function that represents a number in arbitrary number system and the function that returns 10base digits for a number (starting from the rightmost digit):

(define (representinradix n k) (if (= n 0) '() (cons (mod n k) (representinradix (div n k) k))))

(define (digits n) (representinradix n 10))
(digits) function could use standard (number>string), but this generalized solution I like more. Now a solution to the problem looks as easy as:

(define (palindromenumber? n) (let ([d (digits n)]) (equal? d (reverse d))))

(define (findpalindromesamongproducts n) (map (lambda (x) (map (lambda (y) (* x y)) (numbersfiltered x n (lambda (y) (palindromenumber? (* x y)))))) (numbers 1 n)))


(define (solution4bruteforce n) (maxlist (map maxlist (filteremptylists (findpalindromesamongproducts n)))))
Notice, for comparing lists we use (equal?), not (eq?) and not (eqv?)  they would return just #f. However, we could use (eq?) instead of (null?) in (filteremptylists) to compare a list to the empty one. As regards number of operations, we have n^2 / 2 multiplications, as many (palindromenumber?) calls that create digits lists (up to 6 divmod per each) and compare them (up to 6 comparisons per each). So, the complexity is O(n^2), and memory use is proportional to the palindrome numbers density in the n by n matrix (half of which we actually iterate over to find an answer).
Problem 3
Find the largest prime factor of a composite number.
is a very well known problem called factorization. The fundamental theorem of arithmetics comes in handy.
Bruteforce in this case is just iterating from 2 upwards, searching for factors:

(define (factorizebruteforce n)

(define (iterate n x) (if (> x n) (list n) (if (divides? n x) (cons x (iterate (/ n x) x)) (iterate n (+ x 1)))))

(iterate n 2))
If a factor is found, we divide the number by it, and continue with searching factors of a quotient. We don't need to start from 2 again (see the theorem).
The complexity for finding one factor is O(n) in the worst case. Let us optimize at once, stopping the iteration at sqrt(n). Indeed, a number cannot have a factor greater than its square root. This improves the worst case complexity drastically to O(\sqrt(n)) and this is the classical factorization algo.

(define (factorizesqrtcomplexity n)

(define (iterate n x) (if (> x (sqrt n)) (list n) (if (divides? n x) (cons x (iterate (/ n x) x)) (iterate n (+ x 1)))))

(iterate n 2))
Now, having written additional function (maxlist) for finding maximums through lists, we can solve the third problem:

(define (maxlist list) (foldleft max (car list) list))

(define (solution3bruteforce n) (maxlist (factorizebruteforce n)))

(define (solution3optimized1 n) (maxlist (factorizesqrtcomplexity n)))
I've written the generic procedure to generate lists iteratively:

(define (generatelistiteratively seed filter map step stop)

(define (iterate current) (if (stop current) '()

(let ([rest (iterate (step current))])

(if (filter current) (cons (map current) rest) rest))))

(iterate seed))
I've refactored (createfilterednumberslist from to filter) function into (numbersfilters) and added also (numbers) for future use:

(define (numbersfiltered from to filter) (generatelistiteratively from filter (lambda (x) x) (lambda (x) (+ x 1)) (lambda (x) (> x to))))

(define (numbers from to) (numbersfiltered from to (lambda (x) #t)))
Now the bruteforce solution for the problem 2
Find the sum of all the evenvalued terms in the Fibonacci sequence which do not exceed four million
looks like this:

(define (fibonacci to) (generatelistiteratively (cons 1 1) (lambda (pair) #t) (lambda (pair) (car pair)) (lambda (pair) (cons (cdr pair) (+ (car pair) (cdr pair)))) (lambda (pair) (> (car pair) to))))


(define (solution2bruteforce n) (sumnumbers (filter even? (fibonacci n))))
The complexity is O(n). I decided not to generate a filtered list, but rather first generate, then filter, (fibonacci) function goes to the library for future use (for future functions I will not mention placing into my library). This is an optimal algorithm for generating a Fibonacci sequence, unlike computing the nth member of it, which can be done more efficiently. However, for computing a sum of members, perhaps, there is a better solution, I will think about it later.
I refactored the previous solution and extracted such library functions, they could be useful in future:

(define (somedivides? n divisors) (exists (lambda (x) (divides? n x)) divisors))

(define (sumnumbers numbers) (foldleft + 0 numbers))

(define (createfilterednumberslist from to filter)

(define (iterate current) (if (> current to) '()

(let ([rest (iterate (+ current 1))])

(if (filter current) (cons current rest) rest))))

(iterate from))
I think for these algoritms, where we have to iterate through large lists of numbers, the laziness (e.g. in Haskell) would give slightly more elegant code at certain places.
The first problem solution now becomes:

(define (sumofmultiplesbruteforce upton divisors)

(let ([multiples (createfilterednumberslist 1 upton (lambda (x) (somedivides? x divisors)))])

(sumnumbers multiples)))


(define (solution1bruteforce n) (sumofmultiplesbruteforce ( n 1) '(3 5)))
For a list of divisors with length k the number of operations will be k*n. Actually, less than that because of shortcut (exists). Assuming k fixed and small, the complexity is still O(n). We could make use of the not yet written (createnumberslist) function and filter that afterwards instead of the (createfilterednumberslist) function, but let us take less space in memory at once.
It took me quite a while to understand. Today I'm using a laptop with Windows, so here is solution for the windowsversion of the PLT Scheme implementation. Under Linux it will not differ much. By the way, to use R6RS in PLT DrScheme you need to choose Module language (Ctrl+L) and write #!r6rs in the beginning of each program.
First, write your own library. I separated the function (divides?) from the previous program:

#!r6rs

(library (projecteulerlib)

(export divides?)

(import (rnrs))


(define (divides? n x) (= (mod n x) 0))

)
Second, save it under the path, for example, C:\Projects\projecteulersolutions\projecteulerlib.scm and, as it is explained in "C:\Program Files\PLT\doc\r6rs\Installing_Libraries.html", compile and install the library into collections folder by running the command (the first way explained there seems not to be working):
"C:\Program Files\PLT\pltr6rs.exe" install C:\Projects\projecteulersolutions\projecteulerlib.scm
Some files drop into the directory "C:\Users\User\AppData\Roaming\PLT Scheme\4.1.4\collects\projecteulerlib"
Third, you connect it to the program by replacing (import (rnrs)) clause with (import (rnrs) (projecteulerlib)). And, of course, delete (divides?) function form the toplevel program body.
Fourth, before recompiling a library, don't forget to clean the folder:
rmdir /s /q "C:\Users\User\AppData\Roaming\PLT Scheme\4.1.4\collects\projecteulerlib"
Let us start with solutions to Project Euler problems. I will always start with bruteforce solutions if those are possible and later on post optimized solutions. Every solution will be given in Scheme (R6RS) along with quick estimate of complexity. The reason for solving those problems is training myself in Scheme and, of course, fun.
Find the sum of all the multiples of 3 or 5 below 1000.
Solution:

#!r6rs

(import (rnrs))


(define n 1000)


(define (divides? n x) (= (mod n x) 0))


(define (dividedby3or5? n) (or (divides? n 3) (divides? n 5)))


(define (adddividends n sum) (if (< n 1) sum (adddividends ( n 1) (if (dividedby3or5? n) (+ sum n) sum))))


(display (adddividends ( n 1) 0))
This is the simplest straightforward approach. Backwardrecursion is used, with tailrecursion optimization, which is obligatory for all Scheme implementations, will be transformed into iteration. Backward direction is to simplify a function signature (otherwise an extra parameter is needed).
The complexity is O(n), assuming the (mod) operation is atomic. More strictly, the number of operations is 2*n. By the way, in R5RS (mod) is called (remainder).
The most easytouse Scheme compiler/interpreter is PLT, simple IDE is included. Emerging the latest ebuild gives errors under O3 optimization flag, I confirmed it at the bugtracker. The solution is to switch temporarily to O2.