Maximum Number of Pairs in Array - Practice Coding Problems

Maximum Number of Pairs in Array - Problem

You're given a 0-indexed integer array nums and need to form as many pairs as possible using identical elements. In each operation, you can:

Choose two identical integers from the array
Remove both integers and form a pair

Your goal is to repeat this process until no more pairs can be formed, then return the results as an array [pairs_formed, leftover_elements].

Example: Given [1,3,2,1,3,2,2], you can form pairs (1,1), (3,3), and (2,2), leaving one 2 unpaired. Result: [3, 1]

Input & Output

example_1.py — Basic Case

$ Input: [1,3,2,1,3,2,2]

› Output: [3,1]

💡 Note: We can pair (1,1), (3,3), and one (2,2), leaving one 2 unpaired. Result: 3 pairs, 1 leftover.

example_2.py — All Pairs

$ Input: [1,1]

› Output: [1,0]

💡 Note: Perfect pairing case: we can form exactly 1 pair from the two 1's with no leftovers.

example_3.py — No Pairs

$ Input: [0]

› Output: [0,1]

💡 Note: Single element edge case: no pairs can be formed, so 0 pairs and 1 leftover element.

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 100
Return array must have exactly 2 elements

Visualization

Tap to expand

Understanding the Visualization

Count sock types

Go through laundry basket and count how many of each sock type you have

Calculate pairs

For each sock type, pairs = count ÷ 2, singles = count % 2

Sum totals

Add up all pairs and all single socks across all types

Key Takeaway

🎯 Key Insight: Instead of searching for pairs element by element, count frequencies first and use the mathematical formula: pairs = count÷2, leftovers = count%2

Asked in

a Amazon 25 G Google 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a hash table to count element frequencies in O(n) time. For each unique element with count N, we can form N/2 pairs with N%2 leftovers. This mathematical approach is much more efficient than the brute force method of searching for pairs.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Count frequencies in single pass and calculate pairs mathematically
Brute Force (Nested Loops)	O(n²)	O(n)	For each element, search through remaining array to find its pair

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize hash map to count frequencies
Traverse array once, counting each element
For each unique element count N, add N//2 to pairs
For each unique element count N, add N%2 to leftovers
Return [total_pairs, total_leftovers]

Visualization

Tap to expand

Step-by-Step Walkthrough

Count frequencies

Single pass through array to count each element

Calculate pairs

For each count N, pairs = N÷2, leftovers = N%2

Sum results

Add up all pairs and leftovers

Code -

solution.c — C

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

#define MAX_VAL 101

int* numberOfPairs(int* nums, int numsSize, int* returnSize) {
    int* result = (int*)malloc(2 * sizeof(int));
    *returnSize = 2;
    
    // Count frequencies (assuming values 0-100 as per constraints)
    int freq[MAX_VAL] = {0};
    for (int i = 0; i < numsSize; i++) {
        freq[nums[i]]++;
    }
    
    int pairs = 0;
    int leftovers = 0;
    
    // Calculate pairs and leftovers
    for (int i = 0; i < MAX_VAL; i++) {
        if (freq[i] > 0) {
            pairs += freq[i] / 2;
            leftovers += freq[i] % 2;
        }
    }
    
    result[0] = pairs;
    result[1] = leftovers;
    return result;
}

int main() {
    int nums[1000];
    int size = 0;
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int returnSize;
    int* result = numberOfPairs(nums, size, &returnSize);
    printf("[%d,%d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to count frequencies, then single pass through unique elements

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n unique elements in worst case (all elements different)

⚡ Linearithmic Space

42.3K Views

Medium Frequency

~8 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler