; 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)
programmingpraxis
-
Scheme,
pasted
on May 9: