phase 0 unit 2 week 1boggle class challenge

0.2.1-boggle_class_from_methods.rb

#[0,0], [1,1], [2,2], [3,3]  == true [0,0], [3,3]
#[0,3], [1,2], [2,1], [3,0] ==true 
#[0,1], [1,2], [2,3] == true
# Roughly 12029640 possible boggle words in a 4x4 board

class BoggleBoard
  def initialize(new_board)
    @board = self.random_board(4) if new_board == nil
    @board = new_board if new_board != nil
    @max_value = @board.length
  end

  def random_board(size)
    @board = Array.new(size) { 
    Array.new(size){('a'..'z').to_a[rand(0..25)]} 
    }
  end
  
  def show_board
    @board.each{|row| puts "#{row} \n"}
  end
  
  def puts_coords(first_coord, last_coord)
    p "#{first_coord} #{last_coord}"
  end
  
  def get_coord(*coords)
    coords.map { |coord| @board[coord.first][coord.last]}
  end
  
  def create_word(*coords)
   coords.map { |coord| @board[coord.first][coord.last]}.join("")
  end

  def get_diagonal(first_coord, last_coord)
      coords = first_coord.last > last_coord.last ? right_to_left_coords(first_coord, last_coord) :  left_to_right_coords(first_coord, last_coord) 
      validate_coords(coords, first_coord,last_coord)
  end

  def get_row(row)
    @board[row]
  end
  
  def get_col(col)
    # consider @board.transpose[col]
    @board.map {|row| row[col]}
  end

  def left_to_right_coords(first_coord, last_coord) # left to right
    coords = []
    for i in (0..@max_value) 
      first_coord.each {|x|coords << x+i}
    end
    coords.each_slice(2).to_a
  end
  
  def right_to_left_coords(first_coord, last_coord) # right to left
    coords = []
    for i in (0..@max_value) 
      first_coord.each_slice(2) {|x, y| coords << x + i ;coords << y - i }
    end
    coords.each_slice(2).to_a
  end

  def validate_coords(coords, first_coord, last_coord)
    diagonal = []
    return "Needs two different coordinates" if first_coord == last_coord
    return "Not a valid diagonal" unless coords.include?(last_coord)
    coords.each {|pair| diagonal << get_coord(pair); break if pair == last_coord}    
    return diagonal.flatten
  end

end

# Random Board Test
test_board = BoggleBoard.new(nil)       
test_board.random_board(4)
test_board.show_board
puts " "
p test_board.get_diagonal([0,0], [3,3])
p test_board.get_row(1)
p test_board.get_coord([0,0])
p test_board.create_word([0,1], [0,2])
p "------NEW TEST-------"
# Main Driver Code
dice_grid = [["b", "r", "a", "e"],
             ["i", "o", "d", "t"],
             ["e", "c", "l", "r"],
             ["t", "a", "k", "e"]]

boggle_board = BoggleBoard.new(dice_grid)
boggle_board.show_board
p boggle_board.get_row(1) == ["i", "o", "d", "t"]
p boggle_board.get_col(1) == ["r", "o", "c", "a"]
p boggle_board.create_word([0,1], [0,2]) == "ra"
p boggle_board.get_coord([1,1]) == ["o"]
#   left to right
p boggle_board.get_diagonal([0,0], [3,3]) == ["b", "o", "l", "e"]
p boggle_board.get_diagonal([1,0], [3,2]) == ["i", "c", "k"]
p boggle_board.get_diagonal([0,1], [2,3]) == ["r", "d", "r"]
# not valid diagonals
p boggle_board.get_diagonal([0,1], [1,7]) == "Not a valid diagonal"
p boggle_board.get_diagonal([0,5], [1,5]) == "Not a valid diagonal"
p boggle_board.get_diagonal([1,1], [1,1]) == "Needs two different coordinates"

#  right to left
p boggle_board.get_diagonal([2,0], [3,1]) == ["e", "a"]
p boggle_board.get_diagonal([0,3], [3,0]) == ["e", "d", "c", "t"]
p boggle_board.get_diagonal([1,3], [3,1]) == ["t", "l", "a"]
p boggle_board.get_diagonal([0,0], [1,1])

# Reflection
# Using this object Oriented approach you don't have to pass the board 
# in each time you apply a method to it since you can use instance variables
# I also felt like I was able to break my methods down smaller and smaller
# so that I could test each part