Maximum Number of Pairs in Array

Maximum Number of Pairs in Array - Problem

You are given a 0-indexed integer array nums. In one operation, you may do the following:

Choose two integers in nums that are equal.
Remove both integers from nums, forming a pair.

The operation is done on nums as many times as possible.

Return a 0-indexed integer array answer of size 2 where answer[0] is the number of pairs that are formed and answer[1] is the number of leftover integers in nums after doing the operation as many times as possible.

Input & Output

Example 1 — Basic Case

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

› Output: [3,1]

💡 Note: Form pairs: (1,1), (3,3), (2,2). This gives us 3 pairs. One element 2 is left over, so leftovers = 1.

Example 2 — All Pairs

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

› Output: [3,0]

💡 Note: Form pairs: (1,1), (2,2), (3,3). All elements are paired, so 3 pairs and 0 leftovers.

Example 3 — No Pairs Possible

$ Input: nums = [0]

› Output: [0,1]

💡 Note: Single element cannot form a pair. Result: 0 pairs, 1 leftover.

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8 🍎 Apple 6

The key insight is that for any element appearing f times, we can form f÷2 pairs with f%2 leftovers. Best approach is frequency counting using a hash map. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Nested Loop Pairing

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

Use nested loops to find matching pairs. For each element, scan the remaining array to find a matching element, then remove both elements when found.

Frequency Counting - Hash Map

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

Use a hash map to count the frequency of each element in the array. For each unique element with frequency f, we can form f÷2 pairs and have f%2 leftover elements.

Single Pass Optimization

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

Instead of building the complete frequency map first, we can update pair and leftover counts as we encounter each element. This is still O(n) time but with better constant factors.

Brute Force - Nested Loop Pairing — Algorithm Steps

Iterate through each element in the array
For each element, search for its pair in remaining elements
Remove both elements when pair found, increment pair count
Count remaining elements as leftovers

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Take first element and search for its pair

Find matching pair

Scan remaining array for matching element

Remove both elements

Remove both elements and increment pair count

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    int pairs = 0;
    
    // Create a copy to work with
    int* arr = (int*)malloc(numsSize * sizeof(int));
    for (int k = 0; k < numsSize; k++) {
        arr[k] = nums[k];
    }
    int size = numsSize;
    
    int i = 0;
    while (i < size) {
        int foundPair = 0;
        for (int j = i + 1; j < size; j++) {
            if (arr[i] == arr[j]) {
                // Found a pair, remove both elements
                // Remove j first (higher index)
                for (int k = j; k < size - 1; k++) {
                    arr[k] = arr[k + 1];
                }
                size--;
                // Remove i
                for (int k = i; k < size - 1; k++) {
                    arr[k] = arr[k + 1];
                }
                size--;
                pairs++;
                foundPair = 1;
                break;
            }
        }
        
        if (!foundPair) {
            i++;
        }
    }
    
    result[0] = pairs;
    result[1] = size;
    free(arr);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Nested loops O(n²) with array removal operations O(n) for each pair

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

⚡ Linearithmic Space

30.0K Views

Medium Frequency

~8 min Avg. Time

856 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

Brute Force - Nested Loop Pairing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler