; a triangular sequence
 
(define (iterate n f . bs)
  (let loop ((n n) (b (car bs)) (bs (cdr bs)) (xs '()))
    (if (zero? n) (reverse xs)
      (let ((new-bs (append bs (list (apply f b bs)))))
        (loop (- n 1) (car new-bs) (cdr new-bs) (cons b xs))))))
 
(define (flatten xs)
  (cond ((null? xs) xs)
        ((pair? xs)
          (append (flatten (car xs))
                  (flatten (cdr xs))))
        (else (list xs))))
 
(define (range . args)
  (case (length args)
    ((1) (range 0 (car args) (if (negative? (car args)) -1 1)))
    ((2) (range (car args) (cadr args) (if (< (car args) (cadr args)) 1 -1)))
    ((3) (let ((le? (if (negative? (caddr args)) >= <=)))
           (let loop ((x(car args)) (xs '()))
             (if (le? (cadr args) x)
                 (reverse xs)
                 (loop (+ x (caddr args)) (cons x xs))))))
    (else (error 'range "unrecognized arguments"))))
 
(define (seq nrows)
  (flatten (iterate nrows (lambda (xs) (map add1 (cons 0 xs))) '(1))))
 
(display (seq 5)) (newline)
 
(define (nth n)
  (let ((m (inexact->exact (floor (/ (- (sqrt (+ (* 8 n) 1)) 1) 2)))))
    (inexact->exact (- n (* m (+ m 1) 1/2) -1))))
 
(display (map nth (range 15))) (newline)