phase 0 unit 2 week 1 boggle class challenge

0.2.1-boggle_class_from_methods.rb

class BoggleBoard
  attr_accessor :board

  def initialize(board)
  	@board = board
  end

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

  def get_row(row)
    whole_row = []
    (@board[row].length).times { |letter| whole_row.push(@board[row][letter]) }
    whole_row
    #whole_row.map {|letter| "#{letter}"}.join('')=> if want to print as string turn on
  end

  def get_col(col)
    column = []
    (@board.length).times { |letter| column.push(@board[letter][col]) }
    column
    #column.map {|letter| "#{letter}"}.join('')=>if want to print as string turn on
  end

  def get_diagonal(coord1, coord2)
    if coord1.first + coord2.first == (@board.length - 1)
	    diagonal = []
	    if coord1.last < coord2.last
		  i = 0
		  @board.each {|letter| diagonal << @board[coord1.first + i][coord1.last + i]; i +=1}
		else
		  y = 0	
		  i = 0
		  @board.each {|letter| diagonal << @board[coord1.first + y][coord1.last + i]; i -= 1; y += 1}
		end
	    diagonal
	else
	  raise ArgumentError.new("Danger!! Not a diagonal!!")
	end
  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)

# implement tests for each of the methods here:

boggle_board = BoggleBoard.new(dice_grid) #initialize instance object of BoggleBoard

puts boggle_board.create_word([2,1], [1,1], [1,2], [0,3]) == 'code' #=> return true 
puts boggle_board.create_word([1,2], [1,1], [2,1], [3,2]) == 'dock' #=> return true

puts boggle_board.get_col(0) != ["b", "i", "e", "p"] #=> return true
puts boggle_board.get_col(3) == ["e", "t", "r", "e"] #=> return true

puts boggle_board.get_row(0) == ["b", "r", "a", "e"] #=> return true
puts boggle_board.get_row(3) != ["b", "r", "a", "e"] #=> return true

# print out all rows and columns of boggle_board, see comments in methods if want to print as strings

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


p boggle_board.get_row(0) #=> return ["b", "r", "a", "e"]
p boggle_board.get_row(1) #=> return ["i", "o", "d", "t"]
p boggle_board.get_row(2) #=> return ["e", "c", "l", "r"]
p boggle_board.get_row(3) #=> return ["t", "a", "k", "e"] -- this is a word!!

puts boggle_board.get_diagonal([0,0],[3,3]) == ["b", "o", "l", "e"] #=> return true
puts boggle_board.get_diagonal([0,3],[3,0]) == ["e", "d", "c", "t"] #=> return true
puts boggle_board.get_diagonal([2,1],[3,3]) #=> return ArgumentError.New("Danger!! Not a diagonal!!")

# create driver test code to retrieve a value at a coordinate here:

puts boggle_board.create_word([3,2]) #=> return 'k'

#Review

# Using object orientated programming we are capable of abstracting out concepts, keeping the code that
# defines our specific objects (e.g. classes) separate from the program interfaces that may be using them.
# Rather than having to maintain code in multiple points, if something breaks we have abstracted our concepts 
# into a design that lets us know what code base we need to pinpoint for debugging. Object orientated programming
# lets us encapsulate our code and make more robust designs that keeps things separate when making more complex
# programs.

# Object orientated programming then is built on the practice of encapsulation and separation of concerns, all 
# which are used in defining our objects and their associated behaviors. This keeps our maintanence more robust 
# and succinct.