Two Sum III - Data structure design - Practice Coding Problems

Two Sum III - Data structure design - Problem

Array Hash Table Two Pointers Design Data Stream Easy

Design a dynamic data structure that can efficiently handle a stream of integers and quickly determine if any pair of stored numbers sum to a target value.

You need to implement the TwoSum class with the following operations:

TwoSum() - Initializes an empty TwoSum object
void add(int number) - Adds a number to the data structure
boolean find(int value) - Returns true if there exists any pair of numbers whose sum equals value, false otherwise

The challenge: Since numbers are added dynamically and searches happen frequently, you need to balance the efficiency of both operations. Consider the trade-offs between optimizing add vs find operations based on expected usage patterns.

Example:

TwoSum twoSum = new TwoSum();
twoSum.add(1);   // [] becomes [1]
twoSum.add(3);   // [1] becomes [1,3]
twoSum.add(5);   // [1,3] becomes [1,3,5]
twoSum.find(4);  // return true (1 + 3 = 4)
twoSum.find(7);  // return false (no pair sums to 7)

Input & Output

example_1.py — Basic Operations

$ Input: ["TwoSum", "add", "add", "add", "find", "find"] [[], [1], [3], [5], [4], [7]]

› Output: [null, null, null, null, true, false]

💡 Note: TwoSum twoSum = new TwoSum(); twoSum.add(1); twoSum.add(3); twoSum.add(5); twoSum.find(4); // 1 + 3 = 4, return true; twoSum.find(7); // No pair sums to 7, return false

example_2.py — Duplicate Numbers

$ Input: ["TwoSum", "add", "add", "add", "find", "find"] [[], [3], [1], [3], [6], [3]]

› Output: [null, null, null, null, true, false]

💡 Note: After adding [3, 1, 3]: find(6) returns true (3 + 3 = 6 using two different 3's); find(3) returns false (would need 1.5 + 1.5, but we don't have 1.5)

example_3.py — Edge Case with Same Number

$ Input: ["TwoSum", "add", "find", "add", "find"] [[], [0], [0], [0], [0]]

› Output: [null, null, false, null, true]

💡 Note: With one 0, find(0) is false (need two 0's to sum to 0). After adding second 0, find(0) returns true (0 + 0 = 0)

Visualization

Tap to expand

Understanding the Visualization

Add Numbers

Store each number with its frequency in a hash map

Find Complement

For each stored number, check if its complement exists

Handle Duplicates

If complement equals the number, ensure we have at least 2 copies

Key Takeaway

🎯 Key Insight: Hash map with frequencies provides the optimal balance - O(1) additions and O(n) lookups, while correctly handling duplicate numbers for same-value pairs.

Time & Space Complexity

Time Complexity

⏱️

O(1) add, O(n) find

Add is constant time hash insertion, find checks each unique number once

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n unique numbers with their frequencies

⚡ Linearithmic Space

Constraints

-10⁵ ≤ number ≤ 10⁵
-2³¹ ≤ value ≤ 2³¹ - 1
At most 10⁴ calls to add and find
Each number can be added multiple times

Asked in

in LinkedIn 35 G Google 28 a Amazon 22 f Facebook 18

The optimal solution uses a hash map to store number frequencies, providing O(1) add operations and O(n) find operations where n is the number of unique values. The key insight is handling duplicates correctly by checking if complement equals the current number (requiring count > 1) versus different numbers (requiring both to exist).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(1) add, O(n²) find	O(n)	Store numbers in a list, check all pairs for each find operation
Hash Map with Frequencies (Optimal)	O(1) add, O(n) find	O(n)	Use hash map to store number frequencies, enabling O(1) complement lookups

Brute Force (Nested Loops) — Algorithm Steps

Store all added numbers in a simple list/array
For find operation, use nested loops to check all pairs
Return true if any pair sums to target value
Handle duplicate numbers correctly

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Numbers

Numbers are added to a simple array: [1, 3, 5]

Nested Loop Search

For find(4), check pairs: (1,3)=4 ✓, (1,5)=6, (3,5)=8

Return Result

Found pair (1,3) that sums to 4, return true

Code -

solution.c — C

typedef struct {
    int* numbers;
    int size;
    int capacity;
} TwoSum;

TwoSum* twoSumCreate() {
    TwoSum* obj = (TwoSum*)malloc(sizeof(TwoSum));
    obj->capacity = 10;
    obj->numbers = (int*)malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    return obj;
}

void twoSumAdd(TwoSum* obj, int number) {
    if (obj->size >= obj->capacity) {
        obj->capacity *= 2;
        obj->numbers = (int*)realloc(obj->numbers, obj->capacity * sizeof(int));
    }
    obj->numbers[obj->size++] = number;
}

bool twoSumFind(TwoSum* obj, int value) {
    for (int i = 0; i < obj->size; i++) {
        for (int j = i + 1; j < obj->size; j++) {
            if (obj->numbers[i] + obj->numbers[j] == value) {
                return true;
            }
        }
    }
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(1) add, O(n²) find

Adding is constant time, but finding requires checking all n*(n-1)/2 pairs

⚠ Quadratic Growth

Space Complexity

O(n)

Only need to store the n numbers that were added

⚡ Linearithmic Space

Constraints

-10⁵ ≤ number ≤ 10⁵
-2³¹ ≤ value ≤ 2³¹ - 1
At most 10⁴ calls to add and find
Each number can be added multiple times

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler