Finding Pairs With a Certain Sum - Practice Coding Problems

Finding Pairs With a Certain Sum - Problem

Design a Dynamic Pair Sum Finder

You're tasked with building a smart data structure that can efficiently handle two types of operations on a pair of integer arrays:

📊 Array Management: You have two integer arrays nums1 and nums2. While nums1 remains static, nums2 can be modified by adding values to specific indices.

🔍 Pair Counting: For any given target sum, you need to quickly count how many pairs (i, j) exist such that nums1[i] + nums2[j] = target.

The Challenge: Since nums2 can be frequently updated, your solution must efficiently handle both modifications and queries without recalculating everything from scratch each time.

Operations to implement:
• FindSumPairs(nums1, nums2) - Initialize with the two arrays
• add(index, val) - Add val to nums2[index]
• count(tot) - Count pairs that sum to tot

Input & Output

basic_operations.py — Python

$ Input: nums1 = [1, 1, 2, 2, 2, 3], nums2 = [1, 4, 5, 2, 5, 4] operations: count(7), add(3, 2), count(8), count(4), add(0, 1), add(1, 1), count(7)

› Output: [null, 8, null, 2, 1, null, null, 11]

💡 Note: Initial: count(7) finds 8 pairs. After add(3,2), nums2=[1,4,5,4,5,4]. count(8) finds 2 pairs, count(4) finds 1 pair. After more adds, count(7) finds 11 pairs.

edge_case_empty.py — Python

$ Input: nums1 = [1], nums2 = [1] operations: count(2), add(0, 1), count(3)

› Output: [null, 1, null, 1]

💡 Note: Single element arrays. Initially nums1[0] + nums2[0] = 1+1 = 2, so count(2)=1. After add(0,1), nums2=[2], so nums1[0] + nums2[0] = 1+2 = 3, count(3)=1.

no_pairs_found.py — Python

$ Input: nums1 = [1, 1], nums2 = [1, 1] operations: count(5), add(0, 3), count(5)

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

💡 Note: Initially max possible sum is 1+1=2, so count(5)=0. After add(0,3), nums2=[4,1], now we have sums 1+4=5 and 1+4=5, so count(5)=2.

Visualization

Tap to expand

Understanding the Visualization

Setup Menu System

Store fixed appetizer prices and create a frequency chart of main course prices

Customer Budget Query

For each appetizer price, quickly lookup how many main courses fit the remaining budget

Price Update

When main course prices change, efficiently update the frequency chart

Instant Response

Serve customers instantly with updated combo counts using the optimized system

Key Takeaway

🎯 Key Insight: Use a frequency map for the changing array (nums2) while keeping the static array (nums1) simple. This allows O(1) updates and O(n) queries instead of O(n×m) brute force.

Time & Space Complexity

Time Complexity

⏱️

O(n) per count query, O(1) per add

Count queries iterate through nums1 (size n) with O(1) hash lookups. Add operations just update hash map.

✓ Linear Growth

Space Complexity

O(m)

Need to store frequency map of nums2 values, which has at most m unique values

✓ Linear Space

Constraints

1 ≤ nums1.length ≤ 1000
1 ≤ nums2.length ≤ 10⁵
1 ≤ nums1[i] ≤ 10⁹
1 ≤ nums2[i] ≤ 10⁶
At most 1000 calls will be made to add and count

Asked in

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

The optimal approach uses a frequency hash map to track nums2 values while keeping nums1 as a simple array. This enables O(n) count queries and O(1) add operations by leveraging the fact that nums1 is read-only while nums2 changes frequently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n*m) per count query, O(1) per add	O(1)	For each query, check all possible pairs by iterating through both arrays
Optimized Hash Map (Optimal)	O(n) per count query, O(1) per add	O(m)	Maintain frequency map of nums2 for O(n) count queries

Brute Force (Nested Loops) — Algorithm Steps

Store both arrays as instance variables
For add(index, val): simply do nums2[index] += val
For count(tot): use nested loops to check every pair (i,j)
Count pairs where nums1[i] + nums2[j] == tot
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Arrays

Store nums1=[1,1,2,2] and nums2=[1,4,5,6]

Count Query (target=7)

Check every pair: (1,6), (1,6), (2,5), (2,5) = 4 pairs

Add Operation

add(3,1) changes nums2[3] from 6 to 7

Recount

Check all pairs again with updated nums2

Code -

solution.c — C

typedef struct {
    int* nums1;
    int nums1Size;
    int* nums2;
    int nums2Size;
} FindSumPairs;

FindSumPairs* findSumPairsCreate(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    FindSumPairs* obj = (FindSumPairs*)malloc(sizeof(FindSumPairs));
    obj->nums1 = nums1;
    obj->nums1Size = nums1Size;
    obj->nums2 = nums2;
    obj->nums2Size = nums2Size;
    return obj;
}

void findSumPairsAdd(FindSumPairs* obj, int index, int val) {
    obj->nums2[index] += val;
}

int findSumPairsCount(FindSumPairs* obj, int tot) {
    int count = 0;
    for (int i = 0; i < obj->nums1Size; i++) {
        for (int j = 0; j < obj->nums2Size; j++) {
            if (obj->nums1[i] + obj->nums2[j] == tot) {
                count++;
            }
        }
    }
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m) per count query, O(1) per add

Each count query requires checking all n*m pairs where n=len(nums1) and m=len(nums2)

✓ Linear Growth

Space Complexity

O(1)

Only storing the input arrays, no additional data structures

✓ Linear Space

Constraints

1 ≤ nums1.length ≤ 1000
1 ≤ nums2.length ≤ 10⁵
1 ≤ nums1[i] ≤ 10⁹
1 ≤ nums2[i] ≤ 10⁶
At most 1000 calls will be made to add and count

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler