codepad

Language:

; cellular automata

(define (rule->bits rule)
  (let loop ((rule rule) (k 8) (bits '()))
    (cond ((zero? k) (list->vector (reverse bits)))
          ((odd? rule) (loop (quotient rule 2) (- k 1) (cons 1 bits)))
          (else (loop (quotient rule 2) (- k 1) (cons 0 bits))))))

(define (display-row row)
  (let ((len (- (vector-length row) 2)))
    (do ((i 1 (+ i 1))) ((> i len) (newline))
      (if (zero? (vector-ref row i))
          (display #\space)
          (display #\X))
      (if (< i len) (display #\space)))))

(define (next-row row bits)
  (let* ((len (- (vector-length row) 2))
         (next (make-vector (+ len 2) 0)))
    (do ((i 1 (+ i 1)))
        ((> i len)
          (vector-set! next 0 (vector-ref next 1))
          (vector-set! next (+ len 1) (vector-ref next len))
          next)
      (let ((neighbors (+ (* (vector-ref row (- i 1)) 4)
                          (* (vector-ref row i) 2)
                          (vector-ref row (+ i 1)))))
        (vector-set! next i (vector-ref bits neighbors))))))

(define (cells rule ticks)
  (let* ((row (make-vector (+ ticks ticks 3) 0))
         (bits (rule->bits rule)))
    (vector-set! row (+ ticks 1) 1)
    (do ((tick 0 (+ tick 1))
         (row row (next-row row bits)))
        ((> tick ticks))
      (display-row row))))

(cells 79 12)

Private [?]

Run code