Design Spreadsheet - Practice Coding Problems

Design Spreadsheet - Problem

Imagine building your own version of Microsoft Excel or Google Sheets! In this problem, you'll design a simplified spreadsheet system that can store values in cells and evaluate basic formulas.

Your spreadsheet has 26 columns labeled from 'A' to 'Z' and a specified number of rows. Each cell can hold an integer value between 0 and 10⁵.

Key Features to Implement:

setCell(cell, value) - Set a cell's value (e.g., "A1", "B10")
resetCell(cell) - Reset a cell back to 0
getValue(formula) - Evaluate formulas like "=A1+B2" or "=5+A3"

Example Usage:

spreadsheet.setCell("A1", 10);
spreadsheet.setCell("B2", 20);
result = spreadsheet.getValue("=A1+B2"); // Returns 30

The challenge lies in efficiently parsing cell references, storing the data, and evaluating formulas that can mix cell references with literal integers.

Input & Output

example_1.py — Basic Operations

$ Input: spreadsheet = Spreadsheet(5) spreadsheet.setCell("A1", 10) spreadsheet.setCell("B2", 20) result = spreadsheet.getValue("=A1+B2")

› Output: 30

💡 Note: We set A1 to 10 and B2 to 20, then evaluate the formula =A1+B2 which gives us 10+20=30

example_2.py — Mixed Formula

$ Input: spreadsheet = Spreadsheet(3) spreadsheet.setCell("C1", 5) result = spreadsheet.getValue("=C1+25")

› Output: 30

💡 Note: We can mix cell references (C1=5) with literal integers (25) in formulas: 5+25=30

example_3.py — Reset and Unset Cells

$ Input: spreadsheet = Spreadsheet(2) spreadsheet.setCell("A1", 15) spreadsheet.resetCell("A1") result = spreadsheet.getValue("=A1+B1+10")

› Output: 10

💡 Note: After resetting A1 to 0 and with B1 never being set (defaults to 0), the formula =A1+B1+10 evaluates to 0+0+10=10

Constraints

1 ≤ rows ≤ 10³
Cell values are integers between 0 and 10⁵
Cell references follow format "[A-Z][1-rows]"
Formulas are always in format "=X+Y" where X,Y are cell references or integers
At most 10⁴ operations will be performed

Visualization

Tap to expand

Understanding the Visualization

Smart Storage

Use a hash map as our 'catalog' - only record cells that have values

Instant Access

When we need a cell value, check our catalog. If it's not there, it's zero

Formula Magic

Parse formulas by splitting on '+' and looking up each part in our catalog

Key Takeaway

🎯 Key Insight: Use a hash map to create a 'smart catalog' that only stores what you need, achieving optimal space and time complexity for spreadsheet operations.

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal solution uses a hash map to store only non-zero cell values, achieving O(1) time complexity for all operations and O(k) space complexity where k is the number of set cells. This approach is perfect for sparse spreadsheets where most cells remain empty, providing significant memory savings over a 2D array implementation.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (2D Array Storage)	O(1) per operation, O(n) for formula parsing	O(rows × 26)	Store all cells in a 2D array and parse formulas naively
Hash Map Storage (Optimal)	O(1) per operation	O(k) where k is number of non-zero cells	Use hash map to store only non-zero cells for optimal space efficiency

Brute Force (2D Array Storage) — Algorithm Steps

Create a 2D array of size [rows][26] initialized to 0
For setCell: convert column letter to index (A=0, B=1, etc.) and store value
For resetCell: set the corresponding array position to 0
For getValue: parse the formula string, extract operands, and compute sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Grid

Create a 2D array with all cells initialized to 0

Set Cell Values

Convert cell references to array indices and store values

Evaluate Formula

Parse formula string and sum up cell values and literals

Code -

solution.c — C

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

typedef struct {
    int rows;
    int** grid;
} Spreadsheet;

Spreadsheet* createSpreadsheet(int rows) {
    Spreadsheet* s = malloc(sizeof(Spreadsheet));
    s->rows = rows;
    s->grid = malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        s->grid[i] = calloc(26, sizeof(int));
    }
    return s;
}

void parseCell(const char* cell, int* row, int* col) {
    *col = cell[0] - 'A';
    *row = atoi(cell + 1) - 1;
}

void setCell(Spreadsheet* s, const char* cell, int value) {
    int row, col;
    parseCell(cell, &row, &col);
    s->grid[row][col] = value;
}

void resetCell(Spreadsheet* s, const char* cell) {
    int row, col;
    parseCell(cell, &row, &col);
    s->grid[row][col] = 0;
}

int getValue(Spreadsheet* s, const char* formula) {
    char* expression = strdup(formula + 1);
    char* token = strtok(expression, "+");
    int total = 0;
    
    while (token != NULL) {
        if (isdigit(token[0])) {
            total += atoi(token);
        } else {
            int row, col;
            parseCell(token, &row, &col);
            total += s->grid[row][col];
        }
        token = strtok(NULL, "+");
    }
    
    free(expression);
    return total;
}

Time & Space Complexity

Time Complexity

⏱️

O(1) per operation, O(n) for formula parsing

Array access is constant time, but string parsing for formulas is linear in formula length

✓ Linear Growth

Space Complexity

O(rows × 26)

Must allocate space for entire grid regardless of how many cells are actually used

✓ Linear Space

38.4K Views

Medium Frequency

~25 min Avg. Time

1.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

Brute Force (2D Array Storage) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler