Max Number of K-Sum Pairs - Practice Coding Problems

Max Number of K-Sum Pairs - Problem

You have an integer array nums and a target value k. Your goal is to maximize the number of operations you can perform on the array.

In each operation, you can:

Pick any two numbers from the array whose sum equals k
Remove both numbers from the array
Count this as one operation

Return the maximum number of operations you can perform until no more valid pairs exist.

Example: If nums = [1,2,3,4] and k = 5, you can pair (1,4) and (2,3) for a total of 2 operations.

Input & Output

example_1.py — Basic case

$ Input: nums = [1,2,3,4], k = 5

› Output: 2

💡 Note: We can form pairs (1,4) and (2,3), both summing to 5. This gives us 2 operations total.

example_2.py — Multiple duplicates

$ Input: nums = [3,1,3,4,3], k = 6

› Output: 1

💡 Note: Only one pair (3,3) can be formed that sums to 6. Even though there are three 3's, we can only use two of them for one operation.

example_3.py — No valid pairs

$ Input: nums = [1,1,1,1], k = 3

› Output: 0

💡 Note: No two elements can sum to 3 since all elements are 1, and 1+1=2 ≠ 3.

Visualization

Tap to expand

Understanding the Visualization

Dancers Arrive

As each dancer arrives, we check our waiting list for their perfect height complement

Perfect Match Found

If the complement exists, we immediately pair them up and they start dancing

Join Waiting List

If no perfect partner is waiting, the dancer joins our waiting list

Maximize Pairs

This process ensures we form pairs as quickly as possible, maximizing the total number of dancing pairs

Key Takeaway

🎯 Key Insight: Instead of checking all possible pairs (O(n²)), we use a hash table to instantly find perfect partners in O(1) time, achieving optimal O(n) performance.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(n)

Hash map can store up to n unique elements in worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 10⁹
Follow-up: Can you solve this in O(n) time?

Asked in

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

The optimal solution uses a hash table with one-pass processing in O(n) time. For each number, we check if its complement (k - number) exists in our hash map. If found, we form a pair and increment operations; otherwise, we store the current number. The two-pointers approach on a sorted array is also efficient at O(n log n) and uses less space.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Build hash map and search simultaneously in one pass
Two Pointers (Sorted Array)	O(n log n)	O(1)	Sort array and use two pointers from both ends
Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible pair of numbers in the array

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize a hash map to store number frequencies
Iterate through each number in the array once
Calculate complement = k - current_number
If complement exists in hash map with count > 0, form a pair
Decrement complement count and increment operations
Otherwise, add current number to hash map
Return total operations count

Visualization

Tap to expand

Step-by-Step Walkthrough

Check for complement

For each number, check if its complement exists in hash map

Form pair if found

If complement exists, increment operations and decrement its count

Store if not found

If complement not found, add current number to hash map

Continue processing

Move to next number and repeat the process

Code -

solution.c — C

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

#define HASH_SIZE 100003

typedef struct HashNode {
    int key;
    int count;
    struct HashNode* next;
} HashNode;

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

void insert(HashNode** table, int key) {
    int index = hash(key);
    HashNode* node = table[index];
    
    while (node) {
        if (node->key == key) {
            node->count++;
            return;
        }
        node = node->next;
    }
    
    node = (HashNode*)malloc(sizeof(HashNode));
    node->key = key;
    node->count = 1;
    node->next = table[index];
    table[index] = node;
}

int getCount(HashNode** table, int key) {
    int index = hash(key);
    HashNode* node = table[index];
    
    while (node) {
        if (node->key == key) {
            return node->count;
        }
        node = node->next;
    }
    return 0;
}

void decrement(HashNode** table, int key) {
    int index = hash(key);
    HashNode* node = table[index];
    
    while (node) {
        if (node->key == key) {
            node->count--;
            return;
        }
        node = node->next;
    }
}

int maxOperations(int* nums, int numsSize, int k) {
    HashNode* table[HASH_SIZE] = {NULL};
    int operations = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int complement = k - nums[i];
        
        if (getCount(table, complement) > 0) {
            operations++;
            decrement(table, complement);
        } else {
            insert(table, nums[i]);
        }
    }
    
    return operations;
}

int main() {
    int nums[1000];
    int numsSize = 0;
    int num;
    
    while (scanf("%d", &num) == 1) {
        nums[numsSize++] = num;
        if (getchar() == '\n') break;
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", maxOperations(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(n)

Hash map can store up to n unique elements in worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 10⁹
Follow-up: Can you solve this in O(n) time?

89.6K Views

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler