Pair Sum Finder - Problem

Given an array of integers nums and an integer target, return all pairs of indices where the two numbers add up to the target sum.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Return the answer as a 2D array where each sub-array contains two indices [i, j] such that nums[i] + nums[j] = target.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,7,11,15], target = 9

› Output: [0,1]

💡 Note: nums[0] + nums[1] = 2 + 7 = 9, so we return indices [0,1]

Example 2 — Different Position

$ Input: nums = [3,2,4], target = 6

› Output: [1,2]

💡 Note: nums[1] + nums[2] = 2 + 4 = 6, so indices are [1,2]

Example 3 — Same Values

$ Input: nums = [3,3], target = 6

› Output: [0,1]

💡 Note: Both elements have same value: 3 + 3 = 6, return [0,1]

Constraints

2 ≤ nums.length ≤ 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
-10⁹ ≤ target ≤ 10⁹
Only one valid answer exists

Visualization

Tap to expand

Asked in

G Google 45 A Amazon 38 f Facebook 31 M Microsoft 28 Apple 22

The key insight is using a hash map to store previously seen numbers, allowing us to find the complement in O(1) time instead of O(n). The optimal hash map approach solves this in a single pass through the array. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Check All Pairs

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

Use two nested loops to examine every possible pair of indices. For each pair (i,j), check if nums[i] + nums[j] equals the target. Return the indices when found.

Hash Map - Single Pass

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

Iterate through the array once. For each number, calculate its complement (target - current number). If the complement exists in our hash map, we found our pair. Otherwise, store the current number and its index.

Brute Force - Check All Pairs — Algorithm Steps

Iterate through each element with index i
For each i, iterate through remaining elements with index j
Check if nums[i] + nums[j] equals target
Return [i,j] when match is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Outer Loop

Pick first element (index i)

Inner Loop

Check against all remaining elements (index j)

Compare

Test if nums[i] + nums[j] = target

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int target, int* returnSize) {
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[i] + nums[j] == target) {
                int* result = (int*)malloc(2 * sizeof(int));
                result[0] = i;
                result[1] = j;
                *returnSize = 2;
                return result;
            }
        }
    }
    *returnSize = 0;
    return NULL;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int target;
    scanf("%d", &target);
    
    int returnSize;
    int* result = solution(nums, numsSize, target, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    if (result) free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops iterate through n×n combinations in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

89.4K Views

Very High Frequency

~15 min Avg. Time

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

Pair Sum Finder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler