```--------------090508050402060304030007
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit

Greetings all,

Attached is my solution.  It uses nested arrays to simulate the 3-d
grid cells, and adds methods to Array to effect this.  It handles
arbitrary rectangles of 2**n by 2**m.  The unit tests provided earlier pass.

I can't help feeling there should be a direct numerical way to
calculate this sequence.  To study the sequence, I wrote a second
script, also attached, that prints the bits of the resulting sequence
from any given rectangle dimensions and list of folds.  (I subtract one
from the sequence to make it zero-based.)  However, even with a fair
amount of studying lists of bit patterns I haven't cracked the code.

Luke Blanshard

--------------090508050402060304030007
Content-Type: text/plain;
nameold.rb"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filenameold.rb"

#!/usr/bin/ruby -w
#
# Ruby Quiz #63, Grid Folding

require "strscan"

# Creates the grid, applies the folds to it
def fold( v, h, folds )
grid  rray.new(v){|i|Array.new(h){|j|[j*v+i+1]}}
s, c  tringScanner.new(folds), ""
grid.send("fold_"+c+"!") while cgetch
raise "Too few folds" if grid.size !  or grid[0].size !
grid[0][0]
end

class Array
# Slices self in half, yields removed and retained elements
def fold!(forward)
raise "Can't fold odd-sized array" if size[0] 1
start  f forward then 0 else size/2 end
a  lice! start, size/2
zip(a.reverse!){|e|yield e[1], e[0]}
end

# Vertical fold, top to bottom or vice versa
def fold_v!(down)
each{|c|c.fold!(down){|a,b|b.unshift(*a.reverse!)}}
end

# Horizontal fold, left to right or vice versa
def fold_h!(left)
fold!(left){|a,b|a.each_index{|i|b[i].unshift(*a[i].reverse!)}}
end

def fold_T!; fold_v! true;  end
def fold_B!; fold_v! false; end
def fold_L!; fold_h! true;  end
def fold_R!; fold_h! false; end
end

# Parses ARGV, returns v, h, folds
def get_args
def usage
puts "Usage: #{File.basename(\$0)} [<size>] <folds>\n"+
"  where <size> is a power of 2 or a pair thereof separated by 'x', like 4x8\n"+
"  and <folds> is a string of fold directions from T, L, R, B\n"
exit
end
usage unless (1..2)  ARGV.size
size, folds  16, 16], ARGV[-1]
usage unless folds /^[TLRB]+\$/
if ARGV.size 2
size  RGV[0].split('x').map{|s|s.to_i}
usage unless (1..2)  size.size
size  rray.new(2, size[0]) if size.size 1
size.each{|i|raise "%d not a power of 2"%i unless i>0 and i&(i-1)}
end
v, h  size
return v, h, folds
end

# Main program
if \$0 __FILE__
p fold( *get_args )
end

--------------090508050402060304030007
Content-Type: text/plain;
nameoldbits.rb"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filenameoldbits.rb"

#!/usr/bin/ruby -w

require 'fold.rb'

class Integer
def bits
return 0 if self <
return 1+(self/2).bits
end
end

if \$0 __FILE__
v, h, folds  et_args
bits  .bits + h.bits
puts fold(v, h, folds).map{|i|sprintf "%0*b", bits, i-1}
end

--------------090508050402060304030007--

```