0029MediumArrayMatrixSimulation

Clockwise Panel Readout

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 thermal camera keeps a per-pixel calibration offset for every cell of its sensor, stored as a grid panel of m rows and n columns. Offsets may be negative, since a pixel can read cold as well as hot.

The firmware ships these offsets over a serial link on an inward clockwise track. Starting at the top-left cell it sweeps the first row rightwards, drops down the final column, sweeps the last row back to the left, climbs the first column, and then applies the same track to the rectangle still untouched inside. It stops once every cell has gone out on the wire.

Return the offsets in the exact order the firmware ships them.

Examples

Example 1

Input: panel = [[3, -1, 4], [0, 7, -6], [8, 2, 5]]
Output: [3, -1, 4, -6, 5, 2, 8, 0, 7]

The outer ring goes out first, ending at the offset 0 on the left edge, and the lone inner cell 7 is shipped last.

Example 2

Input: panel = [[9, -2, 3, 6], [4, 0, -8, 1], [7, 5, 2, -3]]
Output: [9, -2, 3, 6, 1, -3, 2, 5, 7, 4, 0, -8]

After the outer ring, the leftover rectangle is the single row `[0, -8]`, which is swept rightwards.

Example 3

Input: panel = [[5], [-2], [0], [8]]
Output: [5, -2, 0, 8]

A one-column sensor gives a track that only ever heads downwards.

Constraints

m == panel.length
n == panel[i].length
1 <= m, n <= 10
-100 <= panel[i][j] <= 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 readout_order(panel: list[list[int]]) -> list[int]:

Java

public List<Integer> readoutOrder(int[][] panel)

The intended approach

Time O(m * n)Space O(1) beyond the returned list

Hold four live boundaries — first and last remaining row, first and last remaining column — and peel one ring per iteration, shrinking all four afterwards. The bottom sweep and the left climb must be skipped when the leftover rectangle has collapsed to a single row or a single column, otherwise those cells would go out twice.

Pythonentry point: readout_order

def readout_order(panel):
    top = 0
    bottom = len(panel) - 1
    left = 0
    right = len(panel[0]) - 1
    wire = []
    while top <= bottom and left <= right:
        for col in range(left, right + 1):
            wire.append(panel[top][col])
        for row in range(top + 1, bottom + 1):
            wire.append(panel[row][right])
        if top < bottom and left < right:
            for col in range(right - 1, left - 1, -1):
                wire.append(panel[bottom][col])
            for row in range(bottom - 1, top, -1):
                wire.append(panel[row][left])
        top += 1
        bottom -= 1
        left += 1
        right -= 1
    return wire

The obvious version

Walk one cell at a time with a heading vector and a grid of already-shipped flags, rotating the heading whenever the next cell is off the panel or already shipped, for exactly m * n steps.

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_readout_order(panel):
    rows = len(panel)
    cols = len(panel[0])
    shipped = [[False] * cols for _ in range(rows)]
    headings = [(0, 1), (1, 0), (0, -1), (-1, 0)]
    r = 0
    c = 0
    h = 0
    wire = []
    for _ in range(rows * cols):
        wire.append(panel[r][c])
        shipped[r][c] = True
        dr, dc = headings[h]
        nr = r + dr
        nc = c + dc
        if not (0 <= nr < rows and 0 <= nc < cols and not shipped[nr][nc]):
            h = (h + 1) % 4
            dr, dc = headings[h]
            nr = r + dr
            nc = c + dc
        r = nr
        c = nc
    return wire

How this problem was checked

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