Loop to queue a list n times in scheme - queue

Question

I'm trying to write a function that takes two parameters, a list and the number of times to loop, n. I've been trying to implement a let loop to call the helper function, save the result to a variable, then decrement n by 1 each loop and then stop when n reaches 0, but I'm not sure how exactly to do it..
Here's my code:
; helper function to queue it once
(define (queue lst)
(if (empty? lst)
'()
(append (cdr lst) (list (car lst)))))
;main function that calls helper function
(define (queueLoop n lst)
(if (empty? lst)
'()
(let loop ((res (queue lst))
(lst (queue lst)))
(cond
[(> n 0)
((- n 1) (loop (queue res) (rest lst)))]
(else
(loop (queue res) (rest lst)))))))

Answer 1

Here is what I would have done:
(define (rotate-left-inc lst n)
(let-values ([(tail head) (split-at lst n)])
(append head tail)))
As for a roll your own, using the fact that cons is O(1) and append is O(n) I'd do:
;; rotate once in O(n) time
(define (rotate-left-once lst)
(append (cdr lst) (list (car lst))))
;; rotate n times in O(n) time
(define (rotate-left-on lst n)
(let loop ([head lst] [rtail '()] [n n])
(if (<= n 0)
(append head (reverse rtail))
(loop (cdr head) (cons (car head) rtail) (sub1 n)))))
While there is no way to repeat rotate-once and get a efficient procedure:
;; rotate n times in O(n^2) time
(define (rotate-left lst n)
(let loop ([n n] [lst lst])
(if (<= n 0)
lst
(loop (sub1 n) (rotate-left-once lst)))))
This get quite slow the longer the number you rotate when using the naive version, while the one using append once is much faster:
(define lst1 (make-list 200 198))
(define lst2 (make-list 20000 19998))
(define lst3 (make-list 2000000 1999998))
(for-each (lambda (lst)
(display (car lst))
(newline)
(display "O(n) inc")
(time (rotate-left-inc lst (car lst)))
(display "O(n) roll")
(time (rotate-left-on lst (car lst)))
(display "O(n^2)")
(time (rotate-left lst (car lst))))
(list lst1 lst2 lst3))
Output on my computer clearly shows the exponential time takes a lot of time:
198
O(n) inccpu time: 1 real time: 0 gc time: 0
O(n) rollcpu time: 0 real time: 0 gc time: 0
O(n^2)cpu time: 0 real time: 1 gc time: 0
19998
O(n) inccpu time: 1 real time: 0 gc time: 0
O(n) rollcpu time: 0 real time: 1 gc time: 0
O(n^2)cpu time: 4846 real time: 4884 gc time: 1295
1999998
O(n) inccpu time: 207 real time: 209 gc time: 160
O(n) rollcpu time: 279 real time: 282 gc time: 234
O(n^2) (didn't wait for it. Gave up after 5 minutes)

Answer 2

Remember that in Scheme most operations don't mutate variables, instead they return a new value with the modification. Take this, for instance:
(- n 1)
The above line is not modifying the value of n, it's returning a new value that is equal to n minus 1, and unless you store it somewhere or pass it as a parameter to a function call, the value will be lost (that's what's happening, in fact).
UPDATE: Now that you've posted a sample input/output, it's clear what you intended to do. Here's another simple way to write a solution using built-in procedures, which handles corner cases:
(define (queueLoop n lst)
(let ((x (min n (length lst))))
(append (drop lst x)
(take lst x))))
For example:
(queueLoop 1 '())
=> '()
(queueLoop 0 '(1 2 3 4))
=> '(1 2 3 4)
(queueLoop 3 '(1 2 3 4))
=> '(4 1 2 3)
(queueLoop 5 '(1 2 3 4))
=> '(1 2 3 4)