Map Sum Pairs

Map Sum Pairs - Problem

Design a map that allows you to do the following:

Maps a string key to a given value
Returns the sum of the values that have a key with a prefix equal to a given string

Implement the MapSum class:

MapSum() Initializes the MapSum object
void insert(String key, int val) Inserts the key-val pair into the map. If the key already existed, the original key-value pair will be overridden to the new one
int sum(string prefix) Returns the sum of all the pairs' value whose key starts with the prefix

Input & Output

Example 1 — Basic Operations

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

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

💡 Note: MapSum() creates object, insert("apple",3) adds key, sum("ap") returns 3, insert("app",2) adds another key, sum("ap") returns 3+2=5

Example 2 — Key Override

$ Input: operations = ["MapSum", "insert", "sum", "insert", "sum"], values = [[], ["apple",3], ["app"], ["apple",2], ["app"]]

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

💡 Note: After inserting apple=3, sum("app") returns 3. After updating apple=2, sum("app") returns 2 (original value overridden)

Example 3 — No Matching Prefix

$ Input: operations = ["MapSum", "insert", "sum", "sum"], values = [[], ["apple",3], ["app"], ["xyz"]]

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

💡 Note: sum("app") finds "apple" with prefix match, returns 3. sum("xyz") finds no keys with this prefix, returns 0

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

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 35 M Microsoft 25

Brief HTML summary: The key insight is using a trie data structure where each node stores the sum of all values in its subtree. Best approach is the trie with prefix sums for O(m) query time where m is prefix length. Time: O(m), Space: O(ALPHABET_SIZE × N × M)

Common Approaches

✓ Optimized Trie with Prefix Sums

⏱️ Time: O(m) Space: O(ALPHABET_SIZE × N × M)

Build a trie where each node maintains the sum of all key-value pairs that pass through it. This allows O(prefix length) queries instead of O(n).

Brute Force with Hash Map

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

Use a simple hash map to store key-value pairs. For each sum query, iterate through all keys to find those with matching prefix and sum their values.

Optimized Trie with Prefix Sums — Algorithm Steps

Build trie with nodes storing prefix sums
For insert, update sums along path
For sum query, traverse to prefix end
Return sum stored at that node

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie

Create trie with sum at each node

Navigate Path

Follow prefix characters

Return Sum

Get precomputed sum at node

Code -

solution.c — C

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

#define ALPHABET_SIZE 26
#define MAX_KEYS 1000
#define MAX_LEN 100
#define MAX_LINE 10000
#define MAX_OPS 100

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

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

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

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

void mapSumInsert(MapSum* obj, char* key, int val) {
    int delta = val;
    for (int i = 0; i < obj->size; i++) {
        if (strcmp(obj->keys[i], key) == 0) {
            delta = val - obj->values[i];
            obj->values[i] = val;
            break;
        }
    }
    if (delta == val) {
        strcpy(obj->keys[obj->size], key);
        obj->values[obj->size] = val;
        obj->size++;
    }
    
    TrieNode* node = obj->root;
    for (int i = 0; key[i]; i++) {
        int idx = key[i] - 'a';
        if (!node->children[idx]) {
            node->children[idx] = createNode();
        }
        node = node->children[idx];
        node->sum += delta;
    }
}

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

char* extractString(char* str, int* pos) {
    while (str[*pos] && str[*pos] != '"') (*pos)++;
    if (!str[*pos]) return NULL;
    (*pos)++; // skip opening quote
    
    int start = *pos;
    while (str[*pos] && str[*pos] != '"') (*pos)++;
    if (!str[*pos]) return NULL;
    
    int len = *pos - start;
    char* result = malloc(len + 1);
    strncpy(result, str + start, len);
    result[len] = '\0';
    (*pos)++; // skip closing quote
    return result;
}

int extractNumber(char* str, int* pos) {
    while (str[*pos] && !isdigit(str[*pos]) && str[*pos] != '-') (*pos)++;
    if (!str[*pos]) return 0;
    
    int result = 0;
    int sign = 1;
    if (str[*pos] == '-') {
        sign = -1;
        (*pos)++;
    }
    
    while (str[*pos] && isdigit(str[*pos])) {
        result = result * 10 + (str[*pos] - '0');
        (*pos)++;
    }
    return result * sign;
}

int main() {
    char opsLine[MAX_LINE], valsLine[MAX_LINE];
    fgets(opsLine, sizeof(opsLine), stdin);
    fgets(valsLine, sizeof(valsLine), stdin);
    
    // Remove newlines
    opsLine[strcspn(opsLine, "\n")] = 0;
    valsLine[strcspn(valsLine, "\n")] = 0;
    
    // Parse operations
    char operations[MAX_OPS][20];
    int opCount = 0;
    int pos = 0;
    while (opsLine[pos]) {
        char* op = extractString(opsLine, &pos);
        if (op) {
            strcpy(operations[opCount], op);
            opCount++;
            free(op);
        } else {
            pos++;
        }
    }
    
    MapSum* obj = NULL;
    int results[MAX_OPS];
    int isNull[MAX_OPS];
    int resultCount = 0;
    
    pos = 0;
    
    for (int i = 0; i < opCount; i++) {
        if (strcmp(operations[i], "MapSum") == 0) {
            obj = mapSumCreate();
            isNull[resultCount] = 1;
            resultCount++;
        } else if (strcmp(operations[i], "insert") == 0) {
            // Find next string and number in values
            char* key = extractString(valsLine, &pos);
            int val = extractNumber(valsLine, &pos);
            if (key) {
                mapSumInsert(obj, key, val);
                free(key);
            }
            isNull[resultCount] = 1;
            resultCount++;
        } else if (strcmp(operations[i], "sum") == 0) {
            // Find next string in values
            char* prefix = extractString(valsLine, &pos);
            if (prefix) {
                results[resultCount] = mapSumSum(obj, prefix);
                free(prefix);
            }
            isNull[resultCount] = 0;
            resultCount++;
        }
    }
    
    // Print results
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        if (i > 0) printf(",");
        if (isNull[i]) {
            printf("null");
        } else {
            printf("%d", results[i]);
        }
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m)

Sum query traverses m characters of prefix in trie

✓ Linear Growth

Space Complexity

O(ALPHABET_SIZE × N × M)

Trie nodes for all prefixes of all keys

✓ Linear Space

38.0K Views

Medium Frequency

~25 min Avg. Time

950 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

Optimized Trie with Prefix Sums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler