Map Sum Pairs - Practice Coding Problems

Map Sum Pairs - Problem

Design a MapSum data structure that supports efficient key-value storage and prefix-based sum queries. This is a common system design problem that combines the functionality of a hash map with prefix matching capabilities.

Your task: Implement the MapSum class with the following operations:

MapSum() - Initialize an empty MapSum object
insert(key, val) - Insert or update a key-value pair. If the key already exists, override the old value
sum(prefix) - Return the sum of all values whose keys start with the given prefix

Example scenario: Imagine a word frequency counter where you can query the total frequency of all words starting with a certain prefix - like finding the sum of frequencies for all words starting with "app" (apple, application, approach, etc.).

The challenge is to balance the efficiency of both insertion and prefix sum operations.

Input & Output

example_1.py — Basic Operations

$ Input: ["MapSum", "insert", "sum", "insert", "sum"] [[], ["apple", 3], ["ap"], ["app", 2], ["ap"]]

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

💡 Note: Initially empty MapSum. Insert "apple" with value 3. Query sum("ap") returns 3 (only "apple" matches). Insert "app" with value 2. Query sum("ap") returns 5 ("apple" + "app" = 3 + 2 = 5).

example_2.py — Key Override

$ Input: ["MapSum", "insert", "insert", "sum", "insert", "sum"] [[], ["aa", 3], ["aa", 2], ["a"], ["aaa", 4], ["aa"]]

› Output: [null, null, null, 2, null, 6]

💡 Note: Insert "aa" with value 3, then override it with value 2. sum("a") returns 2. Insert "aaa" with value 4. sum("aa") returns 6 ("aa" + "aaa" = 2 + 4 = 6).

example_3.py — No Matching Prefix

$ Input: ["MapSum", "insert", "insert", "sum", "sum"] [[], ["apple", 3], ["banana", 5], ["app"], ["xyz"]]

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

💡 Note: Insert "apple"=3 and "banana"=5. sum("app") returns 3 (only "apple" starts with "app"). sum("xyz") returns 0 (no keys start with "xyz").

Visualization

Tap to expand

Understanding the Visualization

Build the Catalog Tree

Create a tree structure where each path represents a book title

Maintain Running Totals

Each node tracks the sum of all books in its section

Handle Book Updates

When replacing a book, update all nodes along its path with the difference

Instant Prefix Queries

Follow the prefix path and return the sum at the final node

Key Takeaway

🎯 Key Insight: By storing prefix sums at each Trie node, we transform expensive O(n) prefix searches into lightning-fast O(m) path traversals, where m is just the prefix length!

Time & Space Complexity

Time Complexity

⏱️

O(m) per operation

Both insert and sum operations traverse the Trie depth equal to key/prefix length

✓ Linear Growth

Space Complexity

O(ALPHABET_SIZE * N * M)

Trie can have up to ALPHABET_SIZE children per node, with N keys of average length M

✓ Linear Space

Constraints

1 ≤ key.length, prefix.length ≤ 50
key and prefix consist of only lowercase English letters
1 ≤ val ≤ 1000
At most 50 calls will be made to insert and sum

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a Trie (prefix tree) where each node maintains the sum of all values in its subtree. This achieves O(m) time complexity for both insertions and sum queries, where m is the key/prefix length. The key insight is handling key overwrites by calculating the difference between old and new values and propagating this delta through the Trie path.

Common Approaches

Approach	Time	Space	Notes
✓ Trie with Prefix Sums (Optimal)	O(m) per operation	O(ALPHABET_SIZE * N * M)	Use a Trie where each node maintains the sum of all values in its subtree
Brute Force (Hash Map + Linear Search)	O(n*m) per sum query, O(1) per insert	O(n*m)	Store key-value pairs in hash map, iterate through all keys for each sum query

Trie with Prefix Sums (Optimal) — Algorithm Steps

Create a Trie where each node has a 'sum' field tracking total values in subtree
For insert: traverse the Trie creating nodes as needed, update sum values along the path
Handle overwrites by calculating the difference and updating sums accordingly
For sum query: traverse the Trie following the prefix path, return the sum at the final node

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie Structure

Insert keys creating nodes with running sums

Update Node Sums

Each node tracks sum of all keys passing through it

Fast Prefix Query

Follow prefix path and return sum at final node

Code -

solution.c — C

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

#define ALPHABET_SIZE 26
#define MAX_KEYS 1000

typedef struct TrieNode {
    struct TrieNode* children[ALPHABET_SIZE];
    int sum;
} TrieNode;

typedef struct {
    TrieNode* root;
    char keys[MAX_KEYS][101];
    int values[MAX_KEYS];
    int size;
} MapSum;

TrieNode* createTrieNode() {
    TrieNode* node = (TrieNode*)calloc(1, sizeof(TrieNode));
    return node;
}

MapSum* mapSumCreate() {
    MapSum* obj = (MapSum*)malloc(sizeof(MapSum));
    obj->root = createTrieNode();
    obj->size = 0;
    return obj;
}

int findKeyValue(MapSum* obj, char* key) {
    for (int i = 0; i < obj->size; i++) {
        if (strcmp(obj->keys[i], key) == 0) {
            return obj->values[i];
        }
    }
    return 0;
}

void updateKeyValue(MapSum* obj, char* key, int val) {
    for (int i = 0; i < obj->size; i++) {
        if (strcmp(obj->keys[i], key) == 0) {
            obj->values[i] = val;
            return;
        }
    }
    strcpy(obj->keys[obj->size], key);
    obj->values[obj->size] = val;
    obj->size++;
}

void mapSumInsert(MapSum* obj, char* key, int val) {
    int delta = val - findKeyValue(obj, key);
    updateKeyValue(obj, key, val);
    
    TrieNode* node = obj->root;
    for (int i = 0; key[i]; i++) {
        int index = key[i] - 'a';
        if (!node->children[index]) {
            node->children[index] = createTrieNode();
        }
        node = node->children[index];
        node->sum += delta;
    }
}

int mapSumSum(MapSum* obj, char* prefix) {
    TrieNode* node = obj->root;
    for (int i = 0; prefix[i]; i++) {
        int index = prefix[i] - 'a';
        if (!node->children[index]) {
            return 0;
        }
        node = node->children[index];
    }
    return node->sum;
}

void mapSumFree(MapSum* obj) {
    // Note: Complete cleanup would require recursive Trie traversal
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(m) per operation

Both insert and sum operations traverse the Trie depth equal to key/prefix length

✓ Linear Growth

Space Complexity

O(ALPHABET_SIZE * N * M)

Trie can have up to ALPHABET_SIZE children per node, with N keys of average length M

✓ Linear Space

Constraints

1 ≤ key.length, prefix.length ≤ 50
key and prefix consist of only lowercase English letters
1 ≤ val ≤ 1000
At most 50 calls will be made to insert and sum

42.0K Views

Medium Frequency

~25 min Avg. Time

1.6K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Trie with Prefix Sums (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler