0153EasyArray

Turntable Weight Order

Tracked in this browser only

Trains the technique from

LeetCode 1752Check if Array Is Sorted and Rotated

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 pottery studio loads clay trays onto a circular turntable, one tray per station around the rim. House procedure says the loader picks any station to begin at and then works clockwise around the full circle, never putting on a tray lighter than the one just placed. Two trays of equal weight next to each other are perfectly fine.

An inspector arrives later and reads the weights off clockwise into the array weights, but the inspector begins at whichever station happens to face the doorway, which is not usually the station the loader began at. So the reading is the loader's ordering turned around the rim by some unknown number of stations.

Decide whether the reading is consistent with house procedure: return true when some station exists such that reading weights clockwise from it, all the way around, never steps down in weight, and false when no station does that. The inspector's own starting station counts, so a reading that never steps down as written is consistent.

Examples

Example 1

Input: weights = [7, 9, 4, 5, 6]
Output: true

Beginning at the station holding 4 and going clockwise gives 4, 5, 6, 7, 9, which never steps down, so the loader could have started there.

Example 2

Input: weights = [5, 3, 8, 6]
Output: false

Reading clockwise from each station in turn gives 5, 3, 8, 6 then 3, 8, 6, 5 then 8, 6, 5, 3 then 6, 5, 3, 8. Every one of those steps down somewhere, so no station is consistent with procedure.

Example 3

Input: weights = [4, 4, 4]
Output: true

Equal weights are allowed side by side, so the reading never steps down at all and any station works.

Constraints

1 <= weights.length <= 100
1 <= weights[i] <= 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 turntable_weight_order(weights: list[int]) -> bool:

Java

public boolean turntableWeightOrder(int[] weights)

The intended approach

Time O(n)Space O(1)

Going clockwise once around the rim, count the stations where the next weight is lighter than the current one, treating the last station as sitting next to the first. A loading that follows procedure has exactly one such step down, right at the seam where the loader began, or none at all when the reading happens to start at the seam. Two or more step downs cannot be produced by a single starting station, so the answer is simply whether that count stays at one or below.

Pythonentry point: turntable_weight_order

def turntable_weight_order(weights):
    # Time: O(n) -- a single lap around the rim.
    # Space: O(1) -- one counter.
    n = len(weights)
    drops = 0
    for i in range(n):
        if weights[i] > weights[(i + 1) % n]:
            drops += 1
    return drops <= 1

The obvious version

Try every station as the loader's starting point, spell out the whole clockwise reading from it, and check that reading front to back for any step down.

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_turntable_weight_order(weights):
    n = len(weights)
    for start in range(n):
        reading = [weights[(start + k) % n] for k in range(n)]
        fine = True
        for i in range(n - 1):
            if reading[i] > reading[i + 1]:
                fine = False
                break
        if fine:
            return True
    return False

How this problem was checked

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