1157EasyMathString

The Position of a Shelf Label

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.

Shelves are labelled A, B, on to Z, then AA, AB and onwards, so the labels run through every string of uppercase letters, shorter labels first and alphabetically within a length.

Return the position of the shelf labelled label, counting from 1.

Examples

Example 1

Input: label = "Z"
Output: 26

The last of the single-letter labels sits at position 26.

Example 2

Input: label = "AA"
Output: 27

After the twenty-six single letters come the two-letter labels, and this is the first of them.

Example 3

Input: label = "XYZ"
Output: 16900

Reading the three letters as a base twenty-six number with the first letter worth one gives 16900.

Constraints

1 <= label.length <= 7
label holds only uppercase English letters
label lies between A and FXSHRXW

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 title_to_number(label: str) -> int:

Java

public int titleToNumber(String label)

The intended approach

Time O(n) over the label.Space O(1).

The labelling is counting in base twenty-six, except that the digits run from one to twenty-six rather than zero to twenty-five: `A` is worth one and `Z` is worth twenty-six, and there is no digit worth nothing. That means the ordinary reading of a number works: start at nothing and, for each letter from the front, multiply what is held so far by twenty-six and add the letter's worth. Every earlier letter is thereby multiplied once more for each letter that follows it, which is exactly what place value asks for. Because the digits start at one rather than nothing, shorter labels are automatically counted before longer ones without any extra allowance.

Pythonentry point: title_to_number

def title_to_number(label):
    total = 0
    for ch in label:
        total = total * 26 + (ord(ch) - ord("A") + 1)
    return total

The obvious version

Work out each letter's place from the back, raise twenty-six to that power, multiply by the letter's worth and add it in. Costs a power for every letter rather than one running total.

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_title_to_number(label):
    n = len(label)
    total = 0
    for i in range(n):
        digit = ord(label[i]) - ord("A") + 1
        total += digit * (26 ** (n - 1 - i))
    return total

How this problem was checked

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