0065MediumArrayHash TableMatrix

Depot Rack Audit

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 depot keeps crates on a storage rack shaped as a 9 x 9 grid of slots, handed to you as rack. Every slot holds either one crate, written as a single character from '1' to '9' naming its hazard class, or nothing at all, written as '.'.

Safety policy forbids two crates of the same hazard class from sharing:

a rack row,
a rack column,
or a bay. The rack is cut into three horizontal strips and three vertical strips, which carves it into nine 3 x 3 bays.

Only slots that currently hold a crate are subject to the policy; empty slots never conflict with anything. You are auditing the layout as it stands and not planning the rest of the load, so a layout passes the audit even when there is no legal way to fill the remaining empty slots.

Return true when the current layout breaks none of the three rules, and false otherwise.

Examples

Example 1

Input: rack = [["1",".",".",".",".",".",".",".","."],[".",".",".",".","5",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".","3",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","9"]]
Output: true

Four crates sit on the rack and no two of them share a row, a column or a bay, so the audit passes.

Example 2

Input: rack = [["6",".",".",".",".",".",".",".","."],[".","6",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".",".","."]]
Output: false

The two class 6 crates sit in different rows and different columns, but both land in the top-left bay, which the policy forbids.

Constraints

rack.length == 9
rack[i].length == 9
rack[i][j] is a character '1' through '9', or '.' for an empty slot

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 audit_rack(rack: list[list[str]]) -> bool:

Java

public boolean auditRack(char[][] rack)

The intended approach

Time O(1) (a fixed 81 slots, each visited once)Space O(1)

Each crate belongs to exactly one row, one column and one bay, and the bay is identified by the pair of strip indices `(r // 3, c // 3)`, which flattens to `(r // 3) * 3 + c // 3`. Sweep the slots once while holding nine row sets, nine column sets and nine bay sets of hazard classes already placed, and reject the layout the first time a class is already recorded in any of the three sets that the current slot belongs to.

Pythonentry point: audit_rack

def audit_rack(rack):
    row_seen = [set() for _ in range(9)]
    col_seen = [set() for _ in range(9)]
    bay_seen = [set() for _ in range(9)]
    for r in range(9):
        for c in range(9):
            label = rack[r][c]
            if label == '.':
                continue
            bay = (r // 3) * 3 + c // 3
            if label in row_seen[r] or label in col_seen[c] or label in bay_seen[bay]:
                return False
            row_seen[r].add(label)
            col_seen[c].add(label)
            bay_seen[bay].add(label)
    return True

The obvious version

Collect the occupied slots and compare every pair of them directly, rejecting any pair that shares a hazard class and also shares a row, a column or a bay.

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_audit_rack(rack):
    filled = []
    for r in range(9):
        for c in range(9):
            if rack[r][c] != '.':
                filled.append((r, c, rack[r][c]))
    for i in range(len(filled)):
        for j in range(i + 1, len(filled)):
            r1, c1, first = filled[i]
            r2, c2, second = filled[j]
            if first != second:
                continue
            same_bay = (r1 // 3 == r2 // 3) and (c1 // 3 == c2 // 3)
            if r1 == r2 or c1 == c2 or same_bay:
                return False
    return True

How this problem was checked

Reference solution executed against 9 test cases — 9 passed
2 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

Depot Rack Audit

Examples

Constraints

The signature

Create a free account to unlock the solution

More on the same topics