0846EasyArrayMatrixSimulation

Rolling the Tile Board Forward

Tracked in this browser only

Trains the technique from

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A tile board is a grid of m rows by n columns of numbers, given as grid.

One roll moves every tile one place along, reading the board row by row from the top left: a tile moves to the next column of its own row, a tile in the last column moves to the first column of the row below, and the tile in the bottom right corner moves to the top left.

Return the board after k rolls.

Examples

Example 1

Input: grid = [[4, 7, 2], [8, 5, 9], [3, 6, 1]], k = 1
Output: [[1, 4, 7], [2, 8, 5], [9, 3, 6]]

Every tile moves one place along the row-by-row reading, and the 1 in the bottom right corner wraps round to the top left.

Example 2

Input: grid = [[4, 7, 2], [8, 5, 9], [3, 6, 1]], k = 9
Output: [[4, 7, 2], [8, 5, 9], [3, 6, 1]]

The board holds nine tiles, so nine rolls bring every tile back to where it started.

Example 3

Input: grid = [[6], [8]], k = 1
Output: [[8], [6]]

The board has a single column, so the 6 moves down into the second row and the 8 wraps round to the first.

Constraints

1 <= grid.length <= 50
1 <= grid[0].length <= 50
Every row of grid has the same length
-1000 <= grid[i][j] <= 1000
0 <= k <= 100

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def roll_board(grid: list[list[int]], k: int) -> list[list[int]]:

Java

public List<List<Integer>> rollBoard(int[][] grid, int k)

The intended approach

Time O(m * n): the board is flattened once and rebuilt once.Space O(m * n) for the returned board.

Reading the board row by row turns it into one long run of tiles, and a roll is a single shift along that run with the end wrapping to the start. So k rolls move the tile at position i to position (i + k) taken modulo the number of tiles, and the shift only has to be applied once rather than repeated k times. Cut the flattened run at the point that becomes the new start and lay it back out row by row.

Pythonentry point: roll_board

def roll_board(grid, k):
    rows = len(grid)
    cols = len(grid[0])
    total = rows * cols
    flat = []
    for row in grid:
        flat.extend(row)
    shift = k % total
    # the tile that ends up first is the one `shift` places before the end
    rolled = flat[total - shift:] + flat[:total - shift]
    return [rolled[r * cols:(r + 1) * cols] for r in range(rows)]

The obvious version

Apply one roll at a time, k times, each roll rebuilding the whole board by moving every tile to its next place. Repeats work the single shift avoids.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_roll_board(grid, k):
    rows = len(grid)
    cols = len(grid[0])
    board = [row[:] for row in grid]
    for _ in range(k):
        carry = board[rows - 1][cols - 1]
        for r in range(rows - 1, -1, -1):
            for c in range(cols - 1, -1, -1):
                if r == 0 and c == 0:
                    board[0][0] = carry
                elif c == 0:
                    board[r][0] = board[r - 1][cols - 1]
                else:
                    board[r][c] = board[r][c - 1]
        # the loop above walks backwards so each read happens before it is overwritten
    return board

How this problem was checked

Reference solution executed against 14 test cases — 14 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in