Sander L. wrote:
de-obfuscated it a bit to understand it
Here’s what I used:
o = “#”
f = " "
c = nil # copy of b
u = nil # alias for nil
b # main grid
b = ([nil] * 20).map { (0…20).map { (rand < 0.3) ? o : f } }
$> << “\e[2J” # this line is not strictly necessary (11 bytes)
until c == b
$> << “\e[H” << b.map {|x| x * f } * “\n”
c = b.map {|x| x.dup }
20.times {|i| # -4: b.each_index => 20.times
20.times {|e| # -7: b[i].each_index => 20.times
n = (
q, z = -1…1, []
q.map {|x| q.map {|y| z << [x, y] } }
(z - [[0, 0]]).map {|x| # -1: -= => -
c[i + x[0]][e + x[1]] rescue nil
} - [f, nil]
).size
b[i][e]=(n==2?b[i][e]:n==3?o:f) # -23
}
}
sleep 0.1
end
some ways i found to decrease the size:
remove “-[[0,0]]” and change the condition to (n>4||n<3) to account for
Good one. Can still do that to my result. -8
the +1
“rescue f” over “rescue ()”, and -[f] over -[f,nil]
-2
possible bug here though:
c[i+x[0]][e+x[1]]
take i=e=0 and x=[-1,-1], this results in c[-1][-1] which is
bottom-right, i don’t think this is what you want (unless i
misunderstood the ‘game’).
It’s sort of a feature - it’s half a wrap-rule. Here’s both halves and
minus another character:
< c[i+x[0]][e+x[1]] rescue f
c[(i+x[0])%s][(e+x[1])%s]
That’s assuming you put s=20 back in, which costs you that character
right back again, but is worth it, because that’s now 6 esses.
Cheers,
Dave