In the Ghost Hunt program, there are six functions that are used to handle the grid (a list of lists of Tiles). These functions were either mutable or immutable, depending on whether they changed the grid or not. Note that just because a function returns a new grid does not mean it is mutable; a function is only mutable if it modifies the grid that was passed into it.

Which of the following grid functions were mutable in that they modified the actual grid that was passed into the function?

Select every one that applies, then check.

• make_ghost_grid
  Not mutable. make_ghost_grid doesn't even take a grid as a parameter: it builds one from scratch with make_empty_grid and returns it.
• make_empty_grid
  Not mutable. It doesn't take a grid as a parameter either; it builds and returns a brand new one.
• add_treat_if_empty
  Correct. add_treat_if_empty sets grid[y][x].text = TREAT directly on the grid it was given.
• choose_ghost_spots
  Not mutable. It only reads len(grid) to know the size; it never assigns into the grid, only returns a list of positions.
• fill_in_board
  Correct. fill_in_board assigns grid[y][x].text = GHOST and calls add_treat_if_empty on the grid it was given.
• draw_grid
  Not mutable. draw_grid only reads the grid's tiles to build a separate display list; it never assigns into the grid.

The choose_ghost_spots function returns a list of list of integers. Which of the following is the best explanation of that data?

Select one answer, then check.

• The outer list contains one element for each ghost, and each inner list contains two integers representing the row and column of that ghost's position on the grid.
  Correct. Each call to positions.append([xs.pop(), ys.pop()]) adds one [x, y] pair for one ghost, so there is one two-element inner list per ghost.
• The outer list contains one element for each row of the grid, and each inner list contains one integer for each column in that row, with a 1 representing a ghost and a 0 representing an empty space.
  Not quite. That would describe a full grid of 0s and 1s, but choose_ghost_spots only builds a short list of [x, y] positions, one per ghost.
• The outer list contains one element for each column of the grid, and each inner list contains one integer for each row in that column, with a 1 representing a ghost and a 0 representing an empty space.
  Not quite, for the same reason: there's no full grid of 0s and 1s here, only one short [x, y] list per ghost.
• The outer list contains two elements, one for the row positions of all ghosts and one for the column positions of all ghosts, and each inner list contains integers representing those positions.
  Not quite. That would be two long lists (all the xs, then all the ys), but the code pairs one x with one y per ghost instead: [xs.pop(), ys.pop()].

Look up the shuffle function in the Python standard library. Which of the following best describes what it does?

Select one answer, then check.

• It takes in a list and immutably returns a new list with the elements in random order.
  Not quite. shuffle returns None; it doesn't build and return a new list.
• It takes in a list and mutably modifies that list to have its elements in random order.
  Correct. random.shuffle reorders the list it is given in place and returns None, which is exactly why the code calls it as a statement, shuffle(xs), rather than assigning its result.
• It takes in a list and returns a new list with the elements sorted in ascending order
  Not quite. That describes sorted, not shuffle. Shuffling randomizes order; it doesn't sort.
• It takes in a list and returns a new list with the elements sorted in descending order.
  Not quite. That describes sorted(..., reverse=True), not shuffle.
• It returns a random element from a list without modifying the list.
  Not quite. That describes random.choice, which the program also imports but doesn't use for this part.
• It returns a random element from a list and removes that element from the list.
  Not quite. Popping a random element isn't what shuffle does; the code gets that removal effect separately, with .pop().

The grid in this project is represented as a list of list of Tile objects. In some places, we access the grid using expressions like grid[y][x] (e.g., in fill_in_board and flip_tile). Why do we use grid[y][x] instead of grid[x][y]?

Select one answer, then check.

• The outer list represents rows (y-coordinates), and the inner lists represent columns (x-coordinates) within those rows.
  Correct. make_empty_grid builds the grid by looping for y in range(size) on the outside and for x in range(size) on the inside, appending each row before appending it to the grid, so the first index picks a row (y) and the second picks a column within it (x).
• The outer list represents columns (x-coordinates), and the inner lists represent rows (y-coordinates) within those columns.
  Not quite. It's the other way around: make_empty_grid loops over y for the outer list and x for the inner one.
• The outer list represents the x-coordinates of all tiles, and the inner lists represent the y-coordinates of all tiles.
  Not quite. There's no separate list of all x-coordinates and all y-coordinates here; each row is a list of Tile objects, not raw coordinates.
• The outer list represents the y-coordinates of all tiles, and the inner lists represent the x-coordinates of all tiles.
  Not quite, for the same reason as the previous option; there's no such split into two flat coordinate lists.
• It does not matter whether we use grid[y][x] or grid[x][y]; both are equivalent.
  Not quite. The grid isn't square-symmetric in how it's built; the order the loops run in fixes which index is the row and which is the column.
• We use grid[y][x] because Python lists are indexed starting from 0, not 1.
  Not quite. Zero-based indexing applies to both orders equally; it doesn't explain why y comes first specifically.

In the State of this application, we have a field named score that keeps track of the player's score. Which of these best describes how the score field is updated during the game?

Select one answer, then check.

• The score field is incremented by 1 each time the player flips a tile, regardless of whether the player found a ghost.
  Not quite. flip_tile only increments score inside the if tile.text == GHOST: check, not on every flip.
• The score field is decremented by 1 each time the player flips a tile, regardless of whether the player found a ghost.
  Not quite. score only ever goes up, via state.score += 1.
• The score field is incremented by 1 each time the player finds a ghost.
  Correct. flip_tile runs if tile.text == GHOST: state.score += 1, so only flipping a ghost tile raises the score.
• The score field is decremented by 1 each time the player finds an empty tile.
  Not quite. Flipping an empty or treat tile leaves score unchanged; it never decreases.
• The score field is based on how much time has elapsed since the start of the game.
  Not quite. There's no timer anywhere in State or in the routes; the game has no time component.