Phase 0, Week 4: Boogle Class Solo Challenge boggle class challenge

phase0_week4_boggle_class_solo.rb

#STEPS: create BoggleBoard class, move methods from previous challenge
#into class and update arguments to accomplish change from procedural
#to object-oriented design.


class BoggleBoard

  def initialize(board)
    @board = board
  end

  #iterate over each given coord using the first value as the arguemnt
  #board's "row", and last (second value) as the board's column. 
  #Then join the resulting characters and return the word. 
  def create_word(*coords)
    coords.map { |coord| @board[coord.first][coord.last]}.join("")
  end


  #show every letter in given row
  def get_row(row)
    @board[row]
  end


  #iterate through each row to return letters in given column position
  def get_col(col)
    @board.map { |row| row[col] }
  end

  def access_board(row,col)
    @board[row][col]
  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)



# #-----------------TEST CODE--------------------#

#create_word
puts boggle_board.create_word([2,1], [1,1], [1,2], [0,3])  #=> returns "code"  
puts boggle_board.create_word([0,1], [0,2], [1,2])  #=> returns "rad"
puts boggle_board.create_word([3,0], [3,1], [3,2], [3,3])  #=> returns "take"
puts boggle_board.create_word([0,1], [1,1], [1,2])  #=> returns "rod"
puts boggle_board.create_word([1,2], [1,1], [2,1], [3,2]) # => "dock"

#get_row
puts boggle_board.get_row(0).inspect #=>  ["b", "r", "a", "e"]
puts boggle_board.get_row(1).inspect #=>  ["i", "o", "d", "t"]
puts boggle_board.get_row(2).inspect #=>  ["e", "c", "l", "r"]
puts boggle_board.get_row(3).inspect #=>  ["t", "a", "k", "e"]

#gel_col
puts boggle_board.get_col(0).inspect  #=>  ["b", "i", "e", "t"]
puts boggle_board.get_col(1).inspect  #=>  ["r", "o", "c", "a"]
puts boggle_board.get_col(2).inspect  #=>  ["a", "d", "l", "k"]
puts boggle_board.get_col(3).inspect  #=>  ["e", "t", "r", "e"]

puts boggle_board.access_board(0,1) == "r" #=> should be true
puts boggle_board.access_board(2,1) == "c" #=> should be true
puts boggle_board.access_board(3,3) == "e" #=> should be true
puts boggle_board.access_board(2,3) != "x" #=> should be true

#----------------------------------------------#



#PRINT WORDS

puts boggle_board.get_row(0).join("") #=>  brae
puts boggle_board.get_row(1).join("") #=>  iocdt
puts boggle_board.get_row(2).join("") #=>  eclr
puts boggle_board.get_row(3).join("") #=>  take

#gel_col
puts boggle_board.get_col(0).join("")  #=>  biet
puts boggle_board.get_col(1).join("")  #=>  roca
puts boggle_board.get_col(2).join("")  #=>  adlk
puts boggle_board.get_col(3).join("")  #=>  etre



#REFLECT
#The major benefit of object-oriented programming is it's easy to 
#change code because everything is "self-contained". In procedural
#programming, changes can effect the entire program, which makes
#it much more difficult to debug.