; concatenate n n times

(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 (digits n . args)
  (let ((b (if (null? args) 10 (car args))))
    (let loop ((n n) (d '()))
      (if (zero? n) d
          (loop (quotient n b)
                (cons (modulo n b) d))))))

(define (undigits ds . args)
  (let ((b (if (null? args) 10 (car args))))
    (let loop ((ds ds) (n 0))
      (if (null? ds) n
          (loop (cdr ds) (+ (* n b) (car ds)))))))

(define (f n)
  (undigits (flatten (iterate n append (digits n)))))

(display (f 12)) (newline)


(define (d n) ; number of digits in n
  (let loop ((n n) (k 0))
    (if (zero? n) k
      (loop (quotient n 10) (+ k 1)))))

(define (f n) ; concatenate n n times
  (quotient
    (* n (- (expt 10 (* n (d n))) 1))
    (- (expt 10 (d n)) 1)))

(display (d 12)) (newline)
(display (f 12)) (newline)