Design Spreadsheet

Design Spreadsheet - Problem

A spreadsheet is a grid with 26 columns (labeled from 'A' to 'Z') and a given number of rows. Each cell in the spreadsheet can hold an integer value between 0 and 10^5.

Implement the Spreadsheet class:

Spreadsheet(int rows) Initializes a spreadsheet with 26 columns (labeled 'A' to 'Z') and the specified number of rows. All cells are initially set to 0.
void setCell(String cell, int value) Sets the value of the specified cell. The cell reference is provided in the format "AX" (e.g., "A1", "B10"), where the letter represents the column (from 'A' to 'Z') and the number represents a 1-indexed row.
void resetCell(String cell) Resets the specified cell to 0.
int getValue(String formula) Evaluates a formula of the form "=X+Y", where X and Y are either cell references or non-negative integers, and returns the computed sum.

Note: If getValue references a cell that has not been explicitly set using setCell, its value is considered 0.

Input & Output

Example 1 — Basic Operations

$ Input: [["Spreadsheet",3],["setCell","A1",5],["setCell","B2",3],["getValue","=A1+B2"],["resetCell","A1"],["getValue","=A1+B2"]]

› Output: [null,null,null,8,null,3]

💡 Note: Create 3-row spreadsheet, set A1=5 and B2=3, A1+B2=8, reset A1 to 0, now A1+B2=3

Example 2 — Formula with Constants

$ Input: [["Spreadsheet",2],["setCell","A1",10],["getValue","=A1+5"],["getValue","=2+3"]]

› Output: [null,null,15,5]

💡 Note: Set A1=10, formula A1+5=10+5=15, formula 2+3=5

Example 3 — Unset Cell Reference

$ Input: [["Spreadsheet",1],["getValue","=A1+B1"]]

› Output: [null,0]

💡 Note: Both A1 and B1 are unset, so they default to 0: 0+0=0

Constraints

1 ≤ rows ≤ 1000
Cell references are valid format (A-Z)(1-rows)
0 ≤ cell values ≤ 10⁵
Formulas contain exactly 2 operands with '+' operator

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22 A Apple 18

The key insight is to efficiently store and retrieve cell values while parsing cell references and formulas. The hash map approach is optimal for sparse spreadsheets, storing only set cells. Time: O(1) per operation, Space: O(k) where k is the number of set cells.

Common Approaches

✓ 2D Array Storage

⏱️ Time: O(1) Space: O(rows)

Create a full 2D array to represent all possible cells. Parse cell references by converting column letter to index and row number to 0-based index.

Hash Map Storage

⏱️ Time: O(1) Space: O(k)

Use a hash map where keys are cell references (like "A1", "B10") and values are the cell values. This saves space by only storing cells that have been explicitly set.

2D Array Storage — Algorithm Steps

Create 26×rows 2D array initialized to 0
Parse cell references: column letter → 0-25, row → 0-based
For formulas, parse operands and sum values

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Grid

Create 26×rows array filled with zeros

Parse Cell Reference

Convert A1 → column 0, row 0

Direct Access

Set/get values using grid[row][col]

Code -

solution.c — C

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

typedef struct {
    int rows;
    int grid[100][26];  // max 100 rows, 26 columns
} Spreadsheet;

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

void setCell(Spreadsheet* s, const char* cell, int value) {
    int col = cell[0] - 'A';
    int row = atoi(cell + 1) - 1;
    s->grid[row][col] = value;
}

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

int getValue(Spreadsheet* s, const char* formula) {
    // Skip '=' and parse expression like "A1+B2" or "A1+5" or "2+3"
    const char* expr = formula + 1;
    char left[20], right[20];
    
    // Find the '+' operator
    const char* plus = strchr(expr, '+');
    if (!plus) return 0;
    
    // Extract left and right parts
    int leftLen = plus - expr;
    strncpy(left, expr, leftLen);
    left[leftLen] = '\0';
    strcpy(right, plus + 1);
    
    int total = 0;
    
    // Process left operand
    if (isdigit(left[0])) {
        total += atoi(left);
    } else {
        // Cell reference
        int col = left[0] - 'A';
        int row = atoi(left + 1) - 1;
        total += s->grid[row][col];
    }
    
    // Process right operand
    if (isdigit(right[0])) {
        total += atoi(right);
    } else {
        // Cell reference
        int col = right[0] - 'A';
        int row = atoi(right + 1) - 1;
        total += s->grid[row][col];
    }
    
    return total;
}

// Helper function to extract string from JSON
void extractString(const char* input, char* output) {
    const char* start = strchr(input, '"');
    if (start) {
        start++;
        const char* end = strchr(start, '"');
        if (end) {
            int len = end - start;
            strncpy(output, start, len);
            output[len] = '\0';
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    printf("[");
    
    Spreadsheet* spreadsheet = NULL;
    bool first = true;
    
    char* ptr = line;
    
    // Skip to first operation
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr) {
        // Skip to next operation
        while (*ptr && *ptr != '[') {
            if (*ptr == ']' && *(ptr-1) != '"') {
                goto done;
            }
            ptr++;
        }
        if (*ptr != '[') break;
        ptr++;
        
        if (!first) printf(",");
        first = false;
        
        // Parse operation type
        while (*ptr && *ptr != '"') ptr++;
        if (*ptr == '"') ptr++;
        
        if (strncmp(ptr, "Spreadsheet", 11) == 0) {
            // Find the number
            while (*ptr && !isdigit(*ptr)) ptr++;
            int rows = 0;
            while (*ptr && isdigit(*ptr)) {
                rows = rows * 10 + (*ptr - '0');
                ptr++;
            }
            spreadsheet = createSpreadsheet(rows);
            printf("null");
        }
        else if (strncmp(ptr, "setCell", 7) == 0) {
            // Extract cell reference
            char cell[10];
            while (*ptr && *ptr != '"') ptr++;
            if (*ptr == '"') ptr++;
            while (*ptr && *ptr != '"') ptr++;
            if (*ptr == '"') ptr++;
            int i = 0;
            while (*ptr && *ptr != '"') {
                cell[i++] = *ptr++;
            }
            cell[i] = '\0';
            
            // Extract value
            while (*ptr && !isdigit(*ptr)) ptr++;
            int value = 0;
            while (*ptr && isdigit(*ptr)) {
                value = value * 10 + (*ptr - '0');
                ptr++;
            }
            
            setCell(spreadsheet, cell, value);
            printf("null");
        }
        else if (strncmp(ptr, "resetCell", 9) == 0) {
            // Extract cell reference
            char cell[10];
            while (*ptr && *ptr != '"') ptr++;
            if (*ptr == '"') ptr++;
            while (*ptr && *ptr != '"') ptr++;
            if (*ptr == '"') ptr++;
            int i = 0;
            while (*ptr && *ptr != '"') {
                cell[i++] = *ptr++;
            }
            cell[i] = '\0';
            
            resetCell(spreadsheet, cell);
            printf("null");
        }
        else if (strncmp(ptr, "getValue", 8) == 0) {
            // Extract formula
            char formula[50];
            while (*ptr && *ptr != '"') ptr++;
            if (*ptr == '"') ptr++;
            while (*ptr && *ptr != '"') ptr++;
            if (*ptr == '"') ptr++;
            int i = 0;
            while (*ptr && *ptr != '"') {
                formula[i++] = *ptr++;
            }
            formula[i] = '\0';
            
            int result = getValue(spreadsheet, formula);
            printf("%d", result);
        }
        
        // Skip to end of current operation
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
    }
    
    done:
    printf("]\n");
    
    if (spreadsheet) {
        free(spreadsheet);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations are constant time array access

✓ Linear Growth

Space Complexity

O(rows)

2D array stores 26×rows cells regardless of usage

✓ Linear Space

25.0K Views

Medium Frequency

~25 min Avg. Time

890 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

2D Array Storage — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler