phase 0 unit 2 week 1 boggle class challenge

0.2.1-boggle_class_from_methods.rb

class BoggleBoard

  def initialize(board)
    @boggle_board = board
  end

  def create_word(*coords)
    coords.map { |coord| @boggle_board[coord.first][coord.last]}.join("")
  end

  def get_row(row)
    @boggle_board[row]
  end

  def get_col(col)
    @boggle_board.map do |row|
      row[col]
    end
  end

  def get_diagonal(*coords)
    if valid_diagonal_coords?(*coords)
      create_word(*coords)
    else
      "Please enter a proper diagonal."
    end
  end

  private

  # The calculations for the left to right diagonals. See lns

  # Compares coords to see if they increment in diagonally based on left to right pattern.
  # Ex. [0,0], [1,1]  Each element increase by one.
  def proper_left_to_right_diagonal?(*coords)
    coords = coords.sort
    coord_comparison = coords.first
    proper_diagonal = false

    
    coords.each do |coord|
      if coord == coord_comparison
        next
      elsif convert_coord_to_string(coord) == increment_lr_prev_coord(coord_comparison)
        coord_comparison = coord
        proper_diagonal = true
      else
        proper_diagonal = false
      end
    end
    proper_diagonal
  end

  def convert_coord_to_string(coord)
    coord[0].to_s + coord[1].to_s 
  end

  # Increment prev lr coord 
  def increment_lr_prev_coord(coord_comparison)
    (coord_comparison[0] + 1).to_s + (coord_comparison[1] + 1).to_s
  end

  #####################################################################################

  # The calculations for the right to bottom left diagonals. See lns

  # Compares coords to see if they increment in diagonally based on right to left pattern.
  # Ex. [0,3], [1,2]  Coord[0] increases by one while Coord[1] decreases by one.
  def proper_right_to_left_diagonal?(*coords)
    coords = coords.sort
    coord_comparison = coords.first
    proper_diagonal = false

    
    coords.each do |coord|
      if coord == coord_comparison
        next
      elsif convert_coord_to_string(coord) == increment_rl_prev_coord(coord_comparison)
        coord_comparison = coord
        proper_diagonal = true
      else
        proper_diagonal = false
      end
    end
    proper_diagonal
  end

  # Increment prev rl coord 
  def increment_rl_prev_coord(coord_comparison)
    (coord_comparison[0] + 1).to_s + (coord_comparison[1] - 1).to_s
  end

  # Confirms if the coords are either type of diagonal.
  def valid_diagonal_coords?(*coords)
    proper_left_to_right_diagonal?(*coords) || proper_right_to_left_diagonal?(*coords)
  end

end


dice_grid = [["b", "r", "a", "e"],
             ["i", "o", "d", "t"],
             ["e", "c", "l", "r"],
             ["t", "a", "k", "e"]]

boggle_board = BoggleBoard.new(dice_grid)
#puts boggle_board.create_word([2,1], [1,1], [1,2], [0,3])  #=> returns "code"
# puts boggle_board.create_word([0,0], [1,1], [0,2], [0,1])  #=> boar

# puts boggle_board.get_row(1) #=>  ["i", "o", "d", "t"]

# puts boggle_board.get_col(1)  #=>  ["r", "o", "c", "a"]

puts boggle_board.get_diagonal([0,3],[1,2],[2,1],[3,0])
puts boggle_board.get_diagonal([0,0],[1,1],[2,2],[3,3])
puts boggle_board.get_diagonal([0,2],[1,1],[2,0])