CODEWITHSUNDEEP
listrecursionschemelispracket
Kattie.S
Kattie.S

Reputation: 117

Creating a list of n elements in Scheme/lisp?

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!

Upvotes: 3

Views: 3937

Answers (2)

rsm
rsm

Reputation: 2560

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.

Upvotes: 2

bipll
bipll

Reputation: 11940

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)

Upvotes: 4

Related Questions