I was waiting to clean up my solution, but it's Thursday, so here it 
is.  It's too late for the summary, I'm just looking to get my first 
successful RubyQuiz up.  I also used this as my first TDD "project," 
which explains why it's so verbose in places.  I've also included the 
tests, can't hurt. 

class String
  def each_char
    for i in 0...length
      yield(self[i,1])
    end
  end
end

class Array
  alias_method :old_eq, :==
  def ==(arg)
    return arg == self if arg.kind_of?(Grid)
    old_eq(arg)
  end
end

class Range
  def middle
    (first+last)/2
  end

  def flip(i)
    last-1-(i-first)
  end

  def flip_doubled(i)
    (last*2)-1-(i-first)
  end
end

module DiscreteMethod
  def make_disc_meth(sym)
    define_method(sym) do |*args|
      temp_var = clone
      temp_var.send(sym.to_s + "!",*args)
      temp_var
    end
  end
end  

class Grid
  extend DiscreteMethod
  attr_accessor :size, :rows, :cols, :vert, :cells
  def initialize(n = 0)
    @size = n
    @rows = 0...n
    @cols = 0...n
    @vert = 0...1
    @cells = {}
    init_cells if n > 0
  end

  def init_cells
    num = 1
    for r in 0...size
      for c in 0...size
        @cells[[r,c,0]] = num; num += 1;
      end
    end
  end

  def [](r,c,v)
    @cells[[r,c,v]]
  end

  make_disc_meth "fold"
  def fold!(str)
    if str.length > 1
      str.each_char { |c| fold!(c) }
      return
    end
    raise "bad attempted fold" unless ["R","T","L","B"].include?(str)
    raise "bad attempted fold" if (str == "R" or str == "L") and 
cols.first == cols.last-1
    raise "bad attempted fold" if (str == "B" or str == "T") and 
rows.first == rows.last-1
    @cells.keys.find_all { |k| k[1] >= cols.middle }.each { |k| 
self[k[0],cols.flip(k[1]),vert.flip_doubled(k[2])] = @cells[k]; 
@cells.delete(k) } if str == "R"
    @cells.keys.find_all { |k| k[1] < cols.middle }.each { |k| 
self[k[0],cols.flip(k[1]),vert.flip_doubled(k[2])] = @cells[k]; 
@cells.delete(k) } if str == "L"
    @cells.keys.find_all { |k| k[0] >= rows.middle }.each { |k| 
self[rows.flip(k[0]),k[1],vert.flip_doubled(k[2])] = @cells[k]; 
@cells.delete(k)  } if str == "B"
    @cells.keys.find_all { |k| k[0] < rows.middle }.each { |k| 
self[rows.flip(k[0]),k[1],vert.flip_doubled(k[2])] = @cells[k]; 
@cells.delete(k) } if str == "T"
    update_boundaries!(str)
  end

  make_disc_meth "update_boundaries"
  def update_boundaries!(d)
     @vert = (0...vert.last*2)
     @rows = (rows.first...rows.middle) if d == "B"
     @rows = (rows.middle...rows.last) if d == "T"
     @cols = (cols.first...cols.middle) if d == "R"
     @cols = (cols.middle...cols.last) if d == "L"
  end

  def []=(r,c,v,n)
    @cells[[r,c,v]] = n
  end

  def clone
    g = Grid.new
    g.rows,g.cols,g.vert = rows.clone,cols.clone,vert.clone
    @cells.each_key do |k|
      g[k[0],k[1],k[2]] = @cells[k]
    end
    g
  end

  def ==(g)
    return to_a == g if g.kind_of? Array
    return false if @cells.keys.size != g.cells.keys.size
    return false if size != g.size or cols != g.cols or rows != g.rows 
or vert != g.vert
    @cells.keys.each { |k| return false if @cells[k] != g.cells[k] }
    true
  end

  def sorted_keys
    @cells.keys.sort { |a,b| x = b[2] <=> a[2]; (x = a[0] <=> b[0]) if 
x==0; (x = a[1] <=> b[1]) if x==0; x }
  end

  def to_a
    a = []
    sorted_keys.each { |k| a << @cells[k] }
    a
  end
end

def fold(r,c,str)
  raise "Bad Input Dimensions" if r != c or 
![1,2,4,8,16,32,64,128].include?(r)
  g = Grid.new(r)
  g.fold!(str)
  g.to_a
end

-----------

require 'test/unit'
require '../grid.rb'

class TestGridFold < Test::Unit::TestCase
  def setup
    @two = Grid.new(2)
    @two_folded_rb = Grid.new
    @two_folded_rb.rows = (0...1)
    @two_folded_rb.cols = (0...1)
    @two_folded_rb.vert = (0...4)
    @two_folded_rb[0,0,3] = 3
    @two_folded_rb[0,0,2] = 4
    @two_folded_rb[0,0,1] = 2
    @two_folded_rb[0,0,0] = 1
    @st = Grid.new(16)
  end

  def test_size
    assert @two.size == 2
  end

  def test_get
    assert @two[0,0,0] == 1
    assert @two[0,1,0] == 2
    assert @two[1,0,0] == 3
    assert @two[1,1,0] == 4
  end

  def test_out_bounds
    assert @two[2,2,2].nil?
  end

  def test_full_fold
    g = @two.fold("RB")
    assert g == @two_folded_rb,g.to_a
    #assert @two.fold("TL") == [3,1,2,4]
  end

  def test_one_fold
    g = @two.fold("R")
    assert g == [2,4,1,3],g.to_a
    g = g.fold("B")
    assert g == @two_folded_rb
  end

  def test_fold_not_modify
    @two.fold("R")
    test_get
  end

  def test_fold_exc
    assert @two.fold("RB") == @two_folded_rb
  end

  def test_init_boundaries
    assert @two.rows == (0...2)
    assert @two.cols == (0...2)
    assert @two.vert == (0...1)
  end

  def test_boundaries_after_fold
    assert @two.fold("R").cols == (0...1)
    assert @two.fold("L").cols == (1...2)
    assert @two.fold("R").rows == (0...2)
    assert @two.fold("L").rows == (0...2)
  end

  def test_update_boundaries_r
    g = @two.update_boundaries("R")
    assert g.rows == (0...2)
    assert g.cols == (0...1),g.cols
    assert g.vert == (0...2)
  end

  def test_update_boundaries_t
    assert @two.update_boundaries("T").rows == (1...2)
    assert @two.update_boundaries("T").cols == (0...2)
    assert @two.update_boundaries("T").vert == (0...2)
  end

  def test_update_boundaries_l
    g = @two.update_boundaries("L")
    assert g.rows == (0...2)
    assert g.cols == (1...2),g.cols
    assert g.vert == (0...2)
  end

  def test_update_boundaries_ll
    g = @st.update_boundaries("L").update_boundaries("L")
    assert g.rows == (0...16)
    assert g.cols == (12...16),g.cols
    assert g.vert == (0...4)
  end

  def test_update_boundaries_llrbt
    g = 
@st.update_boundaries("L").update_boundaries("L").update_boundaries("R").update_boundaries("B").update_boundaries("T")
    assert g.rows == (4...8)
    assert g.cols == (12...14),g.cols
    assert g.vert == (0...32)
  end

  def test_update_boundaries_no_update
    @two.update_boundaries("R")
    assert @two.cols == (0...2)
  end

  def test_update_boundaries_exc_update
    @two.update_boundaries!("R")
    assert @two.cols == (0...1)
  end

  def test_clone
    g = @two.clone
    assert g[0,0,0] == 1
    assert g[1,1,0] == 4
    g[0,0,0] = 9
    assert g[0,0,0] == 9
    assert @two[0,0,0] == 1
  end

  def test_set
    @two[0,0,0] = 9
    assert @two[0,0,0] == 9
  end

  def test_equality_grid
    assert @two == Grid.new(2)
    assert Grid.new(2).fold("R") == Grid.new(2).fold("R")
    assert Grid.new(2).fold("RB") == Grid.new(2).fold("RB")
  end

  def test_equality_array
    assert @two_folded_rb == [3,4,2,1]
  end

  def test_to_a
    a = @two_folded_rb.to_a
    assert a == [3,4,2,1],a
  end
   

end