Skip to content

Instantly share code, notes, and snippets.

Show Gist options
  • Save lorenanicole/7529054 to your computer and use it in GitHub Desktop.
Save lorenanicole/7529054 to your computer and use it in GitHub Desktop.
phase 0 unit 2 week 1 boggle class challenge
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.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment