0495EasyArrayMatrixSimulation

Relaying the Contact Sheet

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 photo lab keeps a contact sheet as a grid sheet of m rows by n columns, where sheet[r][c] is the exposure reading of one frame.

The lab wants the very same frames pasted onto a fresh sheet with rows rows and cols columns. Frames come off the old sheet in reading order: the top row left to right, then the next row left to right, and so on. They go onto the new sheet in that same order and in the same reading pattern, filling the first row left to right before starting the second.

If the new layout does not hold exactly as many frames as the old sheet, the relay cannot be done and the original sheet is returned unchanged. Otherwise return the relaid sheet.

Examples

Example 1

Input: sheet = [[7, 2, 9], [4, 1, 6]], rows = 3, cols = 2
Output: [[7, 2], [9, 4], [1, 6]]

The frames come off in the order 7, 2, 9, 4, 1, 6 and go onto three rows of two, so the first new row reads 7 and 2.

Example 2

Input: sheet = [[7, 2, 9], [4, 1, 6]], rows = 4, cols = 2
Output: [[7, 2, 9], [4, 1, 6]]

Four rows of two would hold eight frames while the old sheet has six, so the sheet comes back as it was.

Example 3

Input: sheet = [[-1000, 1000], [0, -7]], rows = 1, cols = 4
Output: [[-1000, 1000, 0, -7]]

All four frames land on a single row in reading order.

Constraints

m == sheet.length
n == sheet[i].length
1 <= m, n <= 100
-1000 <= sheet[r][c] <= 1000
1 <= rows, cols <= 300

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 relay_sheet(sheet: list[list[int]], rows: int, cols: int) -> list[list[int]]:

Java

public int[][] relaySheet(int[][] sheet, int rows, int cols)

The intended approach

Time O(m * n)Space O(rows * cols) for the sheet handed back

Compare the two frame counts first and hand the sheet straight back when they differ. Otherwise allocate the new sheet and walk the old one in reading order, writing each frame at the current row and column of the new sheet, resetting the column and stepping the row whenever the column reaches the new width.

Pythonentry point: relay_sheet

def relay_sheet(sheet, rows, cols):
    # One sweep of the old sheet in reading order, dropping each frame into the
    # next slot of the new sheet and wrapping to the next row when a row fills up.
    # time O(m * n), space O(rows * cols) for the sheet handed back
    m = len(sheet)
    n = len(sheet[0])
    if m * n != rows * cols:
        return sheet
    out = [[0] * cols for _ in range(rows)]
    r = 0
    c = 0
    for line in sheet:
        for value in line:
            out[r][c] = value
            c += 1
            if c == cols:
                c = 0
                r += 1
    return out

The obvious version

Work the other way round: for every slot of the new sheet, turn its row and column into a position in reading order, then split that position by the old width to get the row and column it came from and copy the frame across.

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_relay_sheet(sheet, rows, cols):
    m = len(sheet)
    n = len(sheet[0])
    if rows * cols != m * n:
        return [list(line) for line in sheet]
    out = []
    for i in range(rows):
        line = []
        for j in range(cols):
            k = i * cols + j
            line.append(sheet[k // n][k % n])
        out.append(line)
    return out

How this problem was checked

Reference solution executed against 11 test cases — 11 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