README.md

Game of Life

An implementation of Conway's Game of Life in 140 characters of Ruby.

Author

Created by Simon Ernst (@sier).

Thanks to @aemkei for feedback and inspiration!

conway.rb

life=->g,s{(0..s*s-1).map{|i|->n{n==3||(g[i]&&n==2)||nil}[[g[i-s-1],g[i-s],g[i-s+1],g[i-1],g[i+1],g[i+s-1],g[i+s],g[i+s+1]].compact.count]}}

demonstration.rb

# The code with some animation logic for demonstration.
#
life=->g,s{(0..s*s-1).map{|i|->n{n==3||(g[i]&&n==2)||nil}[[g[i-s-1],g[i-s],g[i-s+1],g[i-1],g[i+1],g[i+s-1],g[i+s],g[i+s+1]].compact.count]}}

size = 20
grid = (1..size*size).map { rand(0..1)==1 ? 1 : nil }

while true do
  system 'clear'
  grid = life[grid, size]
  (0..size-1).each do |y|
    (0..size-1).each do |x|
      print "#{(grid[x+(y*size)] ? 'O' : '.')}"
    end
    puts
  end
  sleep 0.1
end

expanded.rb

# Expanded version for better readability.
#
life = lambda do |grid, size|
  (0..size*size-1).map do |i|
    lambda do |neighbours|
      neighbours == 3 || ( grid[i] && neighbours == 2 )|| nil
    end.call (
      [
        grid[i-size-1], grid[i-size], grid[i-size+1],
        grid[i-1],                    grid[i+1],
        grid[i+size-1], grid[i+size], grid[i+size+1]
      ].compact.count
    )
  end
end

experimentation.rb

# Small rewrite of the original code to support independent x and y values.
# Doesn't fit in 140 chars anymore thought.
#
life = lambda do |grid, x, y|
  (0..x*y-1).map do |i|
    lambda do |neighbours|
      neighbours == 3 || ( grid[i] && neighbours == 2 )|| nil
    end.call (
      [
        grid[i-x-1], grid[i-x], grid[i-x+1],
        grid[i-1],              grid[i+1],
        grid[i+x-1], grid[i+x], grid[i+x+1]
      ].compact.count
    )
  end
end

x = 80
y = 20
grid = (1..x*y).map { rand(0..1)==1 ? 1 : nil }

while true do
  system 'clear'
  grid = life[grid, x, y]
  (0..y-1).each do |yi|
    (0..x-1).each do |xi|
      print "#{(grid[xi+(yi*x)] ? 'O' : '.')}"
    end
    puts
  end
  sleep 0.1
end