```------art_9219_11345197.1186946995889
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: 7bit
Content-Disposition: inline

Here is my solution to this week's quiz.
I have created pasties for the full code:
Cellular Automata program: http://pastie.caboo.se/87013
RMagick Graphical Extention: http://pastie.caboo.se/87015

Here is a quick walk-though of the core logic. First, I included everything
in its own class:
class CellularAutomata

I created a method to compute a single iteration (Generation) of the
cellular automata. The method takes a State array and rule number, and
builds the next state (generation) of the cells:

def compute_generation(state, rule)
result  rray.new

# Pad front and back of state to compute boundaries
state.insert(0,state[0]).flatten!
state.push(state[-1])

# Find the 3 digit binary num at each index, and build a list of the
corresponding bits
# Uses built-in ruby functionality to index individual bits
(state.size - 2).times do |i|
result.push(rule[convert_to_dec(state.slice(i, 3), 2)])
end

result
end

This method preps the input and runs a series of generations:

def run(rule, steps, state)
# Pad state to width of board
(steps).times do
state.insert(0, 0)
state.push(0)
end

result  ].push(Array.new(state))

steps.times do
state  ompute_generation(state, rule)
result.push(Array.new(state))
end

result
end

Here is a boilerplate method to convert an array of numbers in the given
base (binary in this program) to a decimal number. There probably is a
better way to do this in ruby:

def convert_to_dec(num_array, base)
result, place  , 0
for digit in num_array.reverse
result  esult + digit * (base ** place)
place  lace + 1
end
result
end

And finally, here is the code to parse command line args and print
everything to console:
if ARGV.size 3
cell  ellularAutomata.new
for generation in cell.run(ARGV[0].to_i, ARGV[1].to_i,
ARGV[2].split("").map{|i| i.to_i })
print "\n", generation
end
else
print "Usage: Cellular_Automata.rb rule_number number_of_steps
initial_state"
end

Here is a sample run:
Cellular_Automata.rb 30 10 1

000000000010000000000
000000000111000000000
000000001100100000000
000000011011110000000
000000110010001000000
000001101111011100000
000011001000010010000
000110111100111111000
001100100011100000100
011011110110010001110
110010000101111011001

A few of the more interesting pictures generated by the RMagick class are
available online:

Thanks,

Justin

On 8/10/07, Ruby Quiz <james / grayproductions.net> wrote:
>
> The three rules of Ruby Quiz:
>
> 1.  Please do not post any solutions or spoiler discussion for this quiz
> until
> 48 hours have passed from the time on this message.
>
> 2.  Support Ruby Quiz by submitting ideas as often as you can:
>
> http://www.rubyquiz.com/
>
> 3.  Enjoy!
>
> Suggestion:  A [QUIZ] in the subject of emails about the problem helps
> everyone
> message,
> if you can.
>
>
> --------------------
>
> Most of us have probably heard of Conway's Game of Life, but there are
> other
> cellular automata that are equally interesting.  In fact, there is a group
> of
> 256 one-dimensional cellular automata that are quite easy to simulate but
> still
> fun to observe.
>
> To simulate these elementary cellular automata, you first need to
> construct a
> rule table.  This table is a description of the changes that happen in
> each
> discreet step of time.  Here's the table for the "rule 30" automaton:
>
>
>         +-----------------------------------------------------------------+
>         | Neighborhood    | 111 | 110 | 101 | 100 | 011 | 010 | 001 | 000
> |
>
>         +-----------------------------------------------------------------+
>         | New Center Cell
> |  0  |  0  |  0  |  1  |  1  |  1  |  1  |  0  |
>
>         +-----------------------------------------------------------------+
>
> The first row is the same for this whole family of automata.  It
> represents the
> "neighborhood" of the cell currently being examined, which includes the
> cell
> itself and one cell to either side of it.  The current values of those
> cells,
> ones being on and zeros being off, can be used to determine the new value
> for
> this cell in the next discreet step of time.
>
> That new value comes from the bottom row.  This row is generated by taking
> the
> rule number, 30 in this case, in binary form.  1110 is 30 in binary, so we
> just
> pad the right side with zeros and we have our table.
>
> Once you have the rules, you just apply them to a string of cells.  For
> example,
> given the cells:
>
>         11001
>
> The rule 30 table creates:
>
>         1101111
>
> Note that cells outside of what I had were off (zeros) for the purposes of
> calculating neighborhoods.
>
> This week's Ruby Quiz is to write a program that accepts up to three
> parameters:
> the rule as an integer in decimal, the number of steps to simulate, and
> the
> starting state of the cells as a String of ones and zeros.  Here's a
> sample run
> of my solution using all three options:
>
>         \$ ruby cellular_automaton.rb -r 110 -s 20 -c 1
>                             X
>                            XX
>                           XXX
>                          XX X
>                         XXXXX
>                        XX   X
>                       XXX  XX
>                      XX X XXX
>                     XXXXXXX X
>                    XX     XXX
>                   XXX    XX X
>                  XX X   XXXXX
>                 XXXXX  XX   X
>                XX   X XXX  XX
>               XXX  XXXX X XXX
>              XX X XX  XXXXX X
>             XXXXXXXX XX   XXX
>            XX      XXXX  XX X
>           XXX     XX  X XXXXX
>          XX X    XXX XXXX   X
>         XXXXX   XX XXX  X  XX
>
> To impress your friends, try adding in support for graphic output in