netmute · May 10, 2025 11:03 · maettig · Feb 9, 2012 · ghost · Feb 11, 2012
diff --git a/README.md b/README.md
diff --git a/conway.rb b/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]}}
diff --git a/demonstration.rb b/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
diff --git a/expanded.rb b/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
diff --git a/experimentation.rb b/experimentation.rb
 # Small rewrite of the original code to support independent x and y values.
 # Doesn't fit in 140 chars anymore, though.
 #
 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
	# 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 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
	# Small rewrite of the original code to support independent x and y values.
	# Doesn't fit in 140 chars anymore, though.
	#
	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