Creating a list of n elements in Scheme/lisp?

Question

I am trying to create a list of n elements. It must produce this output:

(my-list 5)
 >> 0 1 2 3 4

I have the function below:

 (define (my-list n)
    (cond
          ((<= n 0) '())

    (else  (reverse-list   (cons (- n 1) 
                           (my-list(- n 1)))))
    )
 )

and this is producing

(my-list 10)
>>(8 6 4 2 0 1 3 5 7 9)

I understand this is due to reversing the list at every recursive call, but I am not sure what is the correct way. Also my reverse-list is working fine.

Thanks in advance!

If I call the function and input a list, it is reversed correctly — Kattie.S, Jan 31 '18 at 00:06
@Kattie.S your code is unreadable, can you please reformat it? — rsm, Jan 31 '18 at 00:18

bipll · Answer 1 · 2018-01-31T00:32:54.707

A standard idiom in Scheme 'build-and-reverse' suggests you only reverse the list once, at the very end, when its reverse has been completely built (thus reducing the complexity down to O(N) from quadratic.)

So yes, you end up in a tail call to reverse but the list should be built without doing it. Scheme has plenty of local recursive binding constructs.

But.

If you build a range starting with the largest value (that should be one greater than the last element to the list) you don't need to reverse it in the end, at each iteration step you decrease a counter and prepend its new value to those already accumulated:

(define (range n)
   (let rng ((m (- n 1)) (ret-val '())) ; named-let is very useful for small local recursive closures
      (if (< m 0)                       ; that original (<= n 0) check is also handled here
         ret-val                        ; here, the result is returned; note we don't need to reverse it
         (rng (- m 1) (cons m ret-val))))))

(display (range 10))
(newline)

prints

(0 1 2 3 4 5 6 7 8 9)

Or, to demonstrate the build-and-reverse, we can start with the lowest value:

(define (range-asc n)
   (let rng ((m 0) (ret-val '()))
      (if (= m n)
         (reverse ret-val) ; since we started from zero, we need to reverse it
         (rng (+ m 1) (cons m ret-val)))))

^{(Looks like I still remember/can recover some Scheme. :-O)}

Thank you! I was also wondering if there is a way to build the list completely using recursion then reversing it using the reverse-list helper function? — Kattie.S, Jan 31 '18 at 00:27
after playing around with this code, it seems that it doesn't run at "(rng (- m 1) (cons m ret-val))" because it doesn't interpret (rng... as a function. — Kattie.S, Feb 01 '18 at 03:06
What revision of Report and what implementation are you using? Named let has been described as early as in R5RS, and probably much before that: http://schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-7.html#%_sec_4.2.4 — bipll, Feb 01 '18 at 06:16

score 2 · Accepted Answer · edited Jan 31 '18 at 07:06

First of all, your code. Properly formatted it should look something like:

(define (my-list n)
    (cond ((<= n 0) '())
          (else (reverse-list (cons (- n 1) 
                                    (my-list (- n 1)))))))

Problem you have, is reverse-list call. It happens every time you add new element to the list. You can fix it in many ways, but simple solution is to wrap your recursive code into local function, and do some additional operations (reverse in your case) when it returns.

(define (my-list n)
    (define (build-list m)
        (cond ((<= m 0) '())
              (else (cons (- m 1)
                          (build-list (- m 1))))))
    (reverse-list (build-list n)))

So, inside my-list function, first we define recursive part as a local function build-list. This is exactly your code, but with call to reverse-list removed. This part will build your list, but as you know, in reverse order. But that is no longer a problem, since we can reverse it when local function returns.

Creating a list of n elements in Scheme/lisp?

2 Answers2