phase 0 unit 2 week 1 boggle class challenge

0.2.1-boggle_class_from_methods.rb

class BoggleBoard

  #your code here

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 = [["b", "r", "a", "e"],
                ["i", "o", "d", "t"],
                ["e", "c", "l", "r"],
                ["t", "a", "k", "e"]]

puts boggle_board[0][1] == "r"   # returns boggle_board[row_number][column_number]
puts boggle_board[2][1] == "c" #=> should be true
puts boggle_board[3][3] == "e" #=> should be true
puts boggle_board[2][3] == "x" #=> should be false

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

puts create_word(boggle_board, [2,1], [1,1], [1,2], [0,3])  #=> returns "code"  
puts create_word(boggle_board, [0,1], [0,2], [1,2])  #=> creates what california slang word? rad

puts create_word(boggle_board, [0,1], [1,1], [0,2], [1,2]) #=> returns "road"
puts create_word(boggle_board, [0,0], [1,0], [0,1], [1,2]) #=> returns ""

def get_row(board, row)
    board[row]
end

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

def get_col(boggle_board, col)
  column = []
  boggle_board.each do |row|
    column << row[col]
  end
  return column
end

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


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

class BoggleBoard

def initialize(dice_grid)
  @dice_grid = dice_grid
end

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


def get_row(row)
    @dice_grid[row]
end

def get_col(col)
  column = []
  @dice_grid.each do |row|
    column << row[col]
  end
  return column
end

def get_diag(c1, c2) #get_diag([0, 3], [3, 0])
  if (c1[0] - c2[0]).abs != (c1[1] - c2[1]).abs 
    raise(ArgumentError, "That's not diagonal")
  end

  if c1[1] > c2[1]
    c1, c2 = c2, c1
  end    
  final_array = []
  c3 = c1
  if c1[0] < c2[0]
    final_array << @dice_grid[c1[0]][c1[1]]
    while c3 != c2
      c3 = [c3[0] + 1, c3[1] + 1]
      final_array.push(@dice_grid[c3[0]][c3[1]])
    end
    final_array
  else
    final_array << @dice_grid[c1[0]][c1[1]]
    while c3 != c2
      c3 = [c3[0] - 1, c3[1] + 1]
      final_array.push(@dice_grid[c3[0]][c3[1]])
    end
    final_array
  end


  
end
end 
  
  #if c1[0] < c2[0]
  #  add_num = 1
  #else
    #add_num = -1
  #end
  
 
 
  
  # psuedocode
  # return an array of diag letters given two coords
  # check to see if the given coords are diag
  # get the letters between the two given endpoints, diagonally.
    #sort to make sure we start from the leftmost coord
    #will either go up or down
      #if down, add 1,1
      #if up, add -1,1
  # make array to hold the letters, return it
  
  
  

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([0,1], [1,1], [0,2], [1,2]) #=> returns "road"
p boggle_board.get_row(1) #=>  ["i", "o", "d", "t"]
p boggle_board.get_row(2) #=>  ["e", "c", "l", "r"]
p boggle_board.get_row(3) #=>  ["t", "a", "k", "e"]

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

#get a particle coordinate
p boggle_board.get_row(3)[2] == "k"

p boggle_board.get_diag([0,0], [3,3]) == ["b", "o", "l", "e"]
p boggle_board.get_diag([3,0], [0,3]) == ["t", "c", "d", "e"]
p boggle_board.get_diag([3,3], [0,0]) == ["b", "o", "l", "e"]




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