-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

The three rules of Ruby Quiz:

1.  Please do not post any solutions or spoiler discussion for this
quiz until 48 hours have elapsed from the time this message was
sent.

2.  Support Ruby Quiz by submitting ideas and responses
as often as you can!
Visit: http://rubyquiz.strd6.com/suggestions

3.  Enjoy!

Suggestion:  A [QUIZ] in the subject of emails about the problem
helps everyone on Ruby Talk follow the discussion.  Please reply to
the original quiz message, if you can.

RSS Feed: http://rubyquiz.strd6.com/quizzes.rss

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

## Matrix Rotator (#209)

Здравствуйте Rubyists,

This week's quiz is write ruby method that will rotate a matrix 90
degrees counter-clockwise (or π/2 radians).

Ex:
    0 0 0 0
    0 X 0 0
    X X X 0
    0 0 0 0

    0 0 0 0
    0 0 X 0
    0 X X 0
    0 0 X 0

I have attached the following test suite for your convenience:

    require 'test/unit'
    require 'solution'

    class RotationTest < Test::Unit::TestCase
      def test_square_rotation
        square = [
          [0, 1, 0, 0],
          [0, 1, 1, 0],
          [0, 0, 1, 0],
          [0, 0, 0, 0]
        ]

        square_rotated = [
          [0, 0, 0, 0],
          [0, 1, 1, 0],
          [1, 1, 0, 0],
          [0, 0, 0, 0]
        ]

        assert_equal Matrix.rotate(square), square_rotated
      end

      def test_rectangular_rotation
        rectangle = [
          [0, 1, 0],
          [1, 1, 1]
        ]

        rectangle_rotated = [
          [0, 1],
          [1, 1],
          [0, 1]
        ]

        assert_equal Matrix.rotate(rectangle), rectangle_rotated
      end
    end

Have Fun!

--
-Daniel
http://rubyquiz.strd6.com

P. S. This may come in handy on a future quiz.

On Fri, Jun 12, 2009 at 11:06 AM, <brabuhr@gmail.com> wrote:
> :-)
>

That's what I thought at first, and how I originally had it, but the
docs on TestUnit specify:

    assert_equal(expected, actual, message=nil)

In this situation square_rotated is the expected result and
Matrix.rotate(square) is the actual result that the quiz solution
generates.

Thanks for bringing this up, each testing framework has its own order
conventions as well, I know QUnit has actual first and expected
second.

Have fun on the quiz!

On Fri, Jun 12, 2009 at 4:03 PM, Robert Dober<robert.dober@gmail.com>
wrote:
>>> assert_equal rectangle_rotated, Matrix.rotate(rectangle)
> But as all my tests pass it does not matter ;).
>
> This somehow coincides with the specs I have attached, with Daniel's
> kind permission. It is interesting to
> notice how each of the three test tools avoids that kind of confusion
> in three different ways.
>
> Cheers
> Robert
>

Brahbur and Robert are right on the order of the test arguments, my
mistake.

Daniel X Moore wrote:
> -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
> ## Matrix Rotator (#209)
>
> Здравствуйте Rubyists,
>
> This week's quiz is write ruby method that will rotate a matrix 90
> degrees counter-clockwise (or π/2 radians).
>
> Ex:
>     0 0 0 0
>     0 X 0 0
>     X X X 0
>     0 0 0 0
>
>     0 0 0 0
>     0 0 X 0
>     0 X X 0
>     0 0 X 0
>
>
> --
> -Daniel
> http://rubyquiz.strd6.com
>
> P. S. This may come in handy on a future quiz.

Here's my solution; not too savvy but I guess kinda OK given that I've
recently started with Ruby. :-)

http://pastie.org/511668

I just happened to have done this in a side project I was working on..
Here's my rotate method.  It accepts negative and positive numbers..

  def rotate(n=1)
    (n%4).times {self.replace(self.reverse.transpose)}
  end

  Which supports grid.rotate(-2) for left twice,  or 1 for right.. or
whatever really..

Here's the Grid class:

#!/usr/bin/env ruby -W0
SAMPLE_DATA = %w[
0       0       7       0       5       0       0       0       0
0       0       0       0       6       4       0       0       1
4       0       0       0       0       0       2       0       9
0       8       9       0       0       0       4       0       3
6       0       3       0       0       4       0       9       0
0       0       2       4       0       0       8       0       6
0       0       0       9       1       0       6       0       0
0       0       0       0       0       0       0       0       0
2       0       4       0       0       0       0       0       0
].collect {|i| i.to_i}

class Array
  def /len
    a = []
    self.each_with_index do |x,i|
      a << [] if i % len == 0
      a.last << x
    end
    a
  end
end

class Grid < Array
  attr_accessor :set
  def initialize(set=SAMPLE_DATA)
    @set = set
    self.replace(set/Math.sqrt(set.size))
  end

  def rotate(n=1)
    (n%4).times {self.replace(self.reverse.transpose)}
  end

  def flip(direction=:right)
    case direction
    when :right then self.replace(self.transpose.rotate(1))
    when :left then self.replace(self.transpose.rotate(-1))
    end
  end

  def children ## returns array of new Grids(3x3), ordered from left to
right
    return self.collect {|i| i/3}.transpose.collect {|i|
i/3}.transpose.collect {|i| i.collect {|j| Grid.new(j.flatten.compact)}}
  end

  def sum
    Array.new(self.flatten.compact).sum
  end

  def columns
    self.transpose
  end

  def rows
    self
  end

  def inspect
    self.to_s
  end

  def to_s
    "\n" + self.collect {|i| i.inspect}.join("\n")
  end

end

grid = Grid.new
grid.rotate(1) #right cw 90deg
p grid
grid.rotate(-2)  #left ccw 180deg
p grid

My solution:

  def self.rotate(rect)
    rotated = []
    rect.each_with_index do |row, irow|
      row.reverse.each_with_index do |col, icol|
        rotated[icol] ||= []
        rotated[icol][irow] = col
      end
    end
    rotated
  end

It works by reversing the elements in the row and then swapping elements
in the x & y  axis.

Luke

The goal for this week's quiz was to rotate a two dimensional matrix
counter-clockwise. I provided a simple test suite to make the process
easier. Robert Dober and brabuhr straightened out my mix-up about the
order of arguments for `assert_equal`. For the record, it's
<expected>, then <actual>.

Robert also shared three alternative test suites using RSpec[1],
testy[2], and Verify[3]. They are included in the quiz attachment.
Check them out if you are interested in alternatives to Test::Unit.
Another alternative is shoulda[4].

I find the primary advantage of testing, aside from knowing when your
code is correct, is that it frees you up to refactor your code,
knowing that at each step of the way you haven't broken anything.

Now, on to the solutions submitted for this week's quiz.

brabuhr's solution creates and returns a new matrix by transposing the
row and column index, and populating the elements in reversed order.

    module Matrix
      def self.rotate(o)
        rows, cols = o.size, o[0].size
        Array.new(cols){|i| Array.new(rows){|j| o[j][cols - i - 1]}}
      end
    end

The secret is knowing that a counterclockwise rotation is equivalent
to transposing, then reversing the matrix.

Robert showed a simple way to accomplish this using the standard Ruby
API.

    matrix.transpose.reverse

list had an interesting solution: it can rotate a matrix any number of
times, even a negative number. This is accomplished by using the mod
operator, since four rotations would leave you back where you started.

    def rotate(n=1)
      (n%4).times {self.replace(self.reverse.transpose)}
    end

One note about list's solution is that it rotates clockwise. It is
interesting that changing the order in which the operations are called
changes the direction that the rotation occurs in, but it makes sense
because most matrix operations are non-commutative. The 'direction' in
which the operations are performed determines the direction of the
rotation.

Thank you everyone for your solutions!

[1]: http://rspec.info/
[2]: http://github.com/ahoward/testy/tree/master
[3]: http://www.ruby-forum.com/topic/183354
[4]: http://thoughtbot.com/projects/shoulda