Excel Sheet Column Title - Practice Coding Problems

Excel Sheet Column Title - Problem

Math String Easy

Ever wondered how Excel generates those column headers? A, B, C... Z, AA, AB... This problem asks you to reverse-engineer Excel's column naming system!

Given an integer columnNumber, return its corresponding column title as it appears in an Excel sheet.

The mapping works like this:

A → 1
B → 2
C → 3
...
Z → 26
AA → 27
AB → 28
...

This is essentially a base-26 numeral system using letters A-Z, but with a twist - there's no zero! It's like counting with a bijective base-26 system.

Input & Output

example_1.py — Single Letter

$ Input: columnNumber = 1

› Output: "A"

💡 Note: The first column in Excel is labeled 'A', corresponding to number 1.

example_2.py — Double Letter Start

$ Input: columnNumber = 28

› Output: "AB"

💡 Note: After Z (26), we have AA (27), then AB (28). This follows the bijective base-26 pattern.

example_3.py — Large Number

$ Input: columnNumber = 701

› Output: "ZY"

💡 Note: 701 converts to ZY in Excel's column system. This demonstrates the mathematical conversion: (701-1) gives us the right digits in base-26.

Constraints

1 ≤ columnNumber ≤ 2³¹ - 1
The result will always be a valid Excel column title
No leading zeros - this is bijective base-26

Visualization

Tap to expand

Understanding the Visualization

Single Letters (1-26)

A through Z represent columns 1 through 26

Double Letters Start

After Z, we get AA (27), AB (28), etc.

Mathematical Pattern

This is bijective base-26: no zero, direct mapping

Conversion Algorithm

Subtract 1, divide by 26, use remainder for character

Key Takeaway

🎯 Key Insight: Excel columns use bijective base-26 - subtract 1 to convert from 1-indexed to 0-indexed, then use standard base conversion with A-Z representing digits 0-25.

Asked in

⊞ Microsoft 35 G Google 28 a Amazon 22 f Meta 15

The optimal solution uses bijective base-26 conversion with the key insight of subtracting 1 before each operation to handle the absence of a zero character. This achieves O(log n) time complexity by directly computing each character through division and modulo operations.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Conversion (Optimal)	O(log n)	O(log n)	Convert number to bijective base-26 using division and modulo operations
Brute Force (Sequential Counting)	O(n)	O(1)	Count from 1 to columnNumber, generating each column title sequentially

Mathematical Conversion (Optimal) — Algorithm Steps

Initialize empty result string
While columnNumber > 0:
Subtract 1 from columnNumber (to handle 1-indexed system)
Get remainder when dividing by 26, convert to character (A-Z)
Prepend character to result string
Update columnNumber = columnNumber / 26
Return the result string

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with number

Begin with the input column number

Subtract 1

Handle 1-indexed system (no zero character)

Get remainder mod 26

Maps to A-Z (0-25)

Divide by 26

Move to next digit position

Repeat until 0

Continue until number becomes 0

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* convertToTitle(int columnNumber) {
    char* result = malloc(10 * sizeof(char)); // Max length for int range
    int index = 0;
    char temp[10];
    
    while (columnNumber > 0) {
        // Subtract 1 to handle 1-indexed system
        columnNumber--;
        // Get the character for current position
        temp[index++] = 'A' + (columnNumber % 26);
        // Move to next position
        columnNumber /= 26;
    }
    
    // Reverse the string
    for (int i = 0; i < index; i++) {
        result[i] = temp[index - 1 - i];
    }
    result[index] = '\0';
    
    return result;
}

int main() {
    int columnNumber;
    scanf("%d", &columnNumber);
    char* result = convertToTitle(columnNumber);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We divide by 26 each iteration, so we have log₂₆(n) iterations

⚡ Linearithmic

Space Complexity

O(log n)

The result string length is proportional to log₂₆(n)

⚡ Linearithmic Space

89.3K Views

Medium Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Mathematical Conversion (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler