Cells in a Range on an Excel Sheet

Cells in a Range on an Excel Sheet - Problem

String Easy

A cell (r, c) of an excel sheet is represented as a string <col><row> where:

<col> denotes the column number c of the cell. It is represented by alphabetical letters.
- For example, the 1st column is denoted by 'A', the 2nd by 'B', the 3rd by 'C', and so on.
<row> is the row number r of the cell. The rth row is represented by the integer r.

You are given a string s in the format <col1><row1>:<col2><row2>, where <col1> represents the column c1, <row1> represents the row r1, <col2> represents the column c2, and <row2> represents the row r2, such that r1 ≤ r2 and c1 ≤ c2.

Return the list of cells (x, y) such that r1 ≤ x ≤ r2 and c1 ≤ y ≤ c2. The cells should be represented as strings in the format mentioned above and be sorted in non-decreasing order first by columns and then by rows.

Input & Output

Example 1 — Basic Range

$ Input: s = "K1:L2"

› Output: ["K1","K2","L1","L2"]

💡 Note: Start at K1, end at L2. First process column K (rows 1-2): K1, K2. Then column L (rows 1-2): L1, L2.

Example 2 — Single Cell

$ Input: s = "A1:F1"

› Output: ["A1","B1","C1","D1","E1","F1"]

💡 Note: Single row across multiple columns A through F, all at row 1.

Example 3 — Single Column

$ Input: s = "A1:A3"

› Output: ["A1","A2","A3"]

💡 Note: Single column A with multiple rows 1 through 3.

Constraints

s.length == 5
'A' ≤ s[0] ≤ s[3] ≤ 'Z'
'1' ≤ s[1], s[2], s[4] ≤ '9'
s[2] == ':'
s[1] ≤ s[4]

Visualization

Tap to expand

Asked in

M Microsoft 25 G Google 15

The key insight is to parse the range string to extract start and end coordinates, then systematically iterate through all columns and rows in the specified range. The optimal approach is to use nested loops - outer loop for columns, inner loop for rows. Time: O(m × n), Space: O(m × n) where m and n are the dimensions of the range.

Common Approaches

✓ Parse and Iterate

⏱️ Time: O(m × n) Space: O(m × n)

Split the input string to extract start and end coordinates, then use nested loops to generate all cell combinations in the specified range.

Parse and Iterate — Algorithm Steps

Step 1: Parse start and end coordinates from input string
Step 2: Iterate through columns from start to end
Step 3: For each column, iterate through rows from start to end

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Input

Extract start cell 'A1' and end cell 'B3' from 'A1:B3'

Iterate Columns

For each column A to B, iterate through rows 1 to 3

Generate Cells

Create cell strings: A1, A2, A3, B1, B2, B3

Code -

solution.c — C

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

char** solution(char* s, int* returnSize) {
    // Parse the range string
    char* colon = strchr(s, ':');
    *colon = '\0';
    char* startCell = s;
    char* endCell = colon + 1;
    
    // Extract start coordinates
    char startCol = startCell[0];
    int startRow = atoi(startCell + 1);
    
    // Extract end coordinates
    char endCol = endCell[0];
    int endRow = atoi(endCell + 1);
    
    // Calculate result size
    int numCols = endCol - startCol + 1;
    int numRows = endRow - startRow + 1;
    *returnSize = numCols * numRows;
    
    char** result = (char**)malloc(*returnSize * sizeof(char*));
    int index = 0;
    
    // Iterate through columns
    for (char col = startCol; col <= endCol; col++) {
        // Iterate through rows for current column
        for (int row = startRow; row <= endRow; row++) {
            result[index] = (char*)malloc(10 * sizeof(char));
            sprintf(result[index], "%c%d", col, row);
            index++;
        }
    }
    
    return result;
}

int main() {
    char s[100];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int returnSize;
    char** result = solution(s, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Where m is number of columns and n is number of rows in the range

✓ Linear Growth

Space Complexity

O(m × n)

To store all cells in the result list

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~8 min Avg. Time

543 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

Parse and Iterate — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler