0414EasyMathString

Seed Tray 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.

A seed bank stencils a label on every cold-storage tray. Labels use nothing but the 26 capital letters A through Z, and the bank hands them out in a fixed order: all the one-letter labels first, in alphabetical order, then all the two-letter labels in dictionary order, then all the three-letter labels, and so on without end.

So the first tray installed is stencilled "A", the twenty-sixth "Z", the twenty-seventh "AA", the twenty-eighth "AB", and after "AZ" comes "BA".

Given columnNumber, the position of a tray in that installation order, return the label stencilled on it.

Examples

Example 1

Input: columnNumber = 27
Output: "AA"

The 26 one-letter labels are used up by tray 26, so tray 27 gets the first two-letter label in dictionary order.

Example 2

Input: columnNumber = 26
Output: "Z"

Tray 26 is still inside the run of one-letter labels, and it takes the last letter of the alphabet.

Example 3

Input: columnNumber = 702
Output: "ZZ"

Every one-letter and two-letter label is spoken for by this point: 26 of the first kind and 676 of the second come to 702, and this tray takes the last of them.

Example 4

Input: columnNumber = 705
Output: "AAC"

This tray sits three past the end of the two-letter labels, so it carries a three-letter label.

Constraints

1 <= columnNumber <= 2^31 - 1

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 convert_to_title(columnNumber: int) -> str:

Java

public String convertToTitle(int columnNumber)

The intended approach

Time O(L) where L is the label length, at most 7 for the largest allowed input, since each loop turn emits one letter.Space O(L) for the collected letters, which is the returned label.

The scheme has no letter standing for an empty position, so it is not plain base 26: `Z` is the largest one-letter label and `AA` follows it rather than `BA` or `A0`. Dropping the running value by one before each remainder shifts the range 1..26 down onto 0..25, after which the remainder names the last letter and the quotient is the position of the label with that letter removed. Collect letters from the end and turn them round at the finish.

Pythonentry point: convert_to_title

def convert_to_title(columnNumber):
    # Peel one letter at a time off the low end. Shifting down by one before
    # the division makes the alphabet behave like digits 0..25 with no zero
    # digit available, which is exactly what "no empty position" means here.
    left = columnNumber
    letters = []
    while left > 0:
        left -= 1
        letters.append(chr(ord("A") + left % 26))
        left //= 26
    letters.reverse()
    return "".join(letters)

The obvious version

Work out the label length first by subtracting the count of one-letter labels, then two-letter labels, and so on until the position fits inside a block. What is left is the rank inside that block, which converts to fixed width letters by ordinary base-26 division with `A` standing for 0.

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_convert_to_title(columnNumber):
    remaining = columnNumber
    width = 1
    block = 26
    while remaining > block:
        remaining -= block
        width += 1
        block *= 26
    rank = remaining - 1
    slots = ["A"] * width
    pos = width - 1
    while pos >= 0:
        slots[pos] = chr(ord("A") + rank % 26)
        rank //= 26
        pos -= 1
    return "".join(slots)

How this problem was checked

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