Ruby game to find cells with water [closed] - ruby

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 8 months ago.
Improve this question
How do I solve this question:
A rectangular grid is divided into regions called "aquariums" stacked
together in a Tetris manner. Each aquarium can be filled with water up
to a certain level or left empty. The water level in each aquarium is
the same across its full width. There can't be air bubble inside the
water.
Each region is defined by a letter.
Each cell is defined by a unique ID, from left to right, then from top
to bottom.
You have at your disposal the description of the grid as well as a
list of cell ids we know for sure that there is water in. According to
the following rules, implement the method find filled cells count that
returns the number of filled cells.
Rule N°1: Same water level Within a region, cells that are located in the same row are either all filled or all empty.
Rule N°2: No bubbles When, in a region, a row is filled, within the same region all cells below that row must be filled too.
INPUT:
gridRegions, an array of strings, the grid definition (regions) row
per row
filledCellIds, an array of integers, the cell ids where there is
water
OUTPUT:
an integer: the number of filled cells
CONSTRAINTS:
1 ≤ grid width ≤ 100
1 ≤ grid height ≤ 100
EXAMPLE:
Input
AAAABB, ACBABD, CCBBBD,
CCCBDD, CEFBDD, EEFBBB,
6, 16
Output
10
Write a below function:
def find_filled_cells_count(grid_regions, filled_cell_ids)
end
I've followed with the advice to use pen and paper to better understanding the algorithm, but nothing happens. I've started with the process the region data input and assign height to each cell. Then I look up which regions have any water in them and count their underwater cells. That's the theory, but how to code this? I doubted all my capabilities.

Answer 1

There are many ways to structure the data. But since the input is operating on absolute indices, I would create a Cell class with 3 attributes: aquarium (A-F), row (0-5) and a filled state (true or false).
class Cell
attr_accessor :aquarium
attr_accessor :row
attr_accessor :filled
def initialize(aquarium, row)
#aquarium = aquarium
#row = row
#filled = false
end
end
I would then convert the input grid definition into an array of 36 separate Cell instances:
grid = %w[AAAABB ACBABD CCBBBD CCCBDD CEFBDD EEFBBB]
cells = []
grid.each_with_index do |string, row|
string.each_char do |aquarium|
cells << Cell.new(aquarium, row)
end
end
Since the cells array was populated by appending new cells row-by-row and letter-by-letter, the indices correspond to the IDs in the description (3rd image), e.g.
cells[6] #=> #<Cell:0x00007fabea0dd7a0 #aquarium="A", #row=1, #filled=false>
cells[16] #=> #<Cell:0x00007fabea0dd458 #aquarium="B", #row=2, #filled=false>
Note that I didn't model the aquariums as separate objects or retained the grid as a 2D array. The cells array is just a flat sequence of 36 cells with 3 attributes each. But it's all that's needed.
Now, for each filled cell index (6 and 16) I would set the corresponding cell's filled state to true, traverse all other cells and for those with identical aquarium and an equal or greater row, also set their filled state to true:
filled_cell_indices = 6, 16
filled_cell_indices.each do |index|
filled_cell = cells[index]
filled_cell.filled = true
cells.each do |cell|
next unless cell.aquarium == filled_cell.aquarium
next unless cell.row >= filled_cell.row
cell.filled = true
end
end
Finally, I would count the cells with a filled state:
cells.count(&:filled) #=> 10

Answer 2

Here's one way that prioritizes speed and minimal memory usage:
def find_filled_cells_count(grid_regions, filled_cell_ids)
width = grid_regions.first.length
# Set minimums which map aquarium to minimum filled_cell_id
minimums = {}
filled_cell_ids.each do |cell_id|
row_idx, col_idx = cell_id.divmod width
char = grid_regions[row_idx][col_idx]
minimums[char] = cell_id if !minimums[char] || cell_id < minimums[char]
end
# Count filled cells based on minimums
minimums.to_a.inject(0) do |sum,(char,cell_id)|
row_idx = cell_id / width
sum + grid_regions[row_idx..-1].inject(0) do |count,row|
n = row.count(char)
break count if n.zero? # Assumes aquariums are connected
count + n
end
end
end
Basic idea is that for each cell_id in filled_cell_ids you first find its letter char and then simply count all occurrences of it in grid_regions starting at the row it is in.
However to avoid double-counting cells in case multiple ids are given for the same aquarium, use a hash minimums which only keeps the minimum filled_cell_id given for each aquarium. Then this can be iterated over without double-counting cells.
If we can assume aquariums are always connected, then this can be sped up by exiting the 2nd inject loop as soon as row.count(char) returns 0.