Recursive method to find matching rows on grid - ruby

Question

I have a grid object which is populated by space objects each containing a value. What I want to do is write a method which takes a space, and a number representing the amount of equal spaces I would like to find, to see if there is anywhere on the grid with x-number of equal spaces in the same direction.
In psuedo-code, the steps I planned are:
Begin at the top-left corner of the grid.
Check each direction (N,S,E,W,NE,NW,SE,SW) for 2 conditions
The space in that direction exists
The value in that space matches the value in the current space
If these conditions all fail I want call the method again, but with the current space as the next space (increasing left >> right & top >> bottom)
If these conditions are satisfied I want to store this value in a list and call the method again to check the matching space only in the direction the current space was found
If the next space finds that its adjacent space does not match, I want to
Quit searching
Return to the first space the method was called with
Check the remaining directions to satify the 2 conditions
Call the method again with the next space if no spaces satisfy (increasing left >> right & top >> bottom)
The function returns when the current space is the bottom right space or the list of matching values is the same length as the value specified
If this were implemented on a tic-tac-toe board like below, I would start at the top left "O". I would check North, fail, check North-East, fail, check East, pass. Once it passes I would move to the next "O" and check only to its East since the current "O" was found to the east of its previous space, which would give me the expected result of finding 3 "O"s.
The other case I want to handle is, if the South-East were checked the space would move to the center, where the center space would check its South-East, notice that "X" does not equal "O", return back to the top-left space, check the remaining directions, then move to the next space down the line and repeat until all spaces are checked or a match is found
My non-recursive implementation of this method is as follows. It loops through each space, and for each space loops through each compass direction and assigns the value repeated 'num' times to the found variable which will return nil if nothing was found, or the value which was repeated 'num' times
def check_for_row_of(num)
found = nil
each_space do |space|
COMPASS.each do |direction|
if num_spaces_in_direction(space.pos, direction) == num
values = get_spaces_by_pattern(space.pos, direction)
found = values.uniq[0] if values.uniq.length == 1 && values.uniq[0] != " "
end
end
end
found
end

Answer 1

If I understood you correctly, I believe the following code answers your question. Please, tell me if it isn't quite what you were thinking.
For ease of reading, I kept the recursive search function separate from the (somewhat clunky) logic that iterates over each cell and direction.
Also, it is worth mentioning that I am calling transpose and reverse on the Array of Arrays so that the grid is easier for humans to read. Lower left is (0, 0) and top right is (2, 2).
def search(grid, x, y, direction, length_to_find, value_to_find=nil)
return true if length_to_find == 0
value_at_location = grid.transpose[x].reverse[y] if grid.transpose[x]
value_to_find ||= value_at_location
return false if value_at_location != value_to_find
y += 1 if direction =~ /N/i
y -= 1 if direction =~ /S/i
x += 1 if direction =~ /E/i
x -= 1 if direction =~ /W/i
search(grid, x, y, direction, length_to_find - 1, value_to_find)
end
def row_of?(grid, length_to_find)
grid.length.times do |row|
grid[0].length.times do |col|
%w[N NE E SE S SW W NW].each do |direction|
if search(grid, row, col, direction, length_to_find)
return true
end
end
end
end
false
end
grid = [
[ "O", "O", "O"],
[ " ", "O", "X"],
[ " ", "X", "X"]
]
puts row_of?(grid, 3)