Array of Doubled Pairs

Array of Doubled Pairs - Problem

Given an integer array arr of even length, return true if it is possible to reorder arr such that arr[2 * i + 1] = 2 * arr[2 * i] for every 0 <= i < len(arr) / 2, or false otherwise.

In other words, we need to check if we can pair up all elements such that each pair contains a number and its double.

Input & Output

Example 1 — Basic Valid Case

$ Input: arr = [1,2,4,16,8,4]

› Output: true

💡 Note: We can reorder as [1,2,4,8,4,16] where arr[1]=2×arr[0], arr[3]=2×arr[2], arr[5]=2×arr[4]

Example 2 — Impossible Case

$ Input: arr = [2,1,2,6]

› Output: false

💡 Note: We have two 2s but only one 1 and one 6. We can pair (1,2) but the remaining 2 cannot pair with 6 since 6≠2×2

Example 3 — Zeros

$ Input: arr = [4,-2,2,-4]

› Output: true

💡 Note: We can pair (-2,-4) since -4 = 2×(-2) and (2,4) since 4 = 2×2

Constraints

1 ≤ arr.length ≤ 1000
arr.length is even
-1000 ≤ arr[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 42 f Facebook 28 a Amazon 35

The key insight is to count frequencies of each number and greedily match each with its double. Best approach is frequency counting which handles zeros and negatives correctly. Time: O(n), Space: O(n)

Common Approaches

✓ Frequency Count and Greedy Matching

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

Count how many times each number appears, then for each number try to pair it with its double. Handle zero as a special case since 0 × 2 = 0.

Sort and Greedy Pairing

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

Sort the array by absolute value, then use two pointers to greedily match each element with its double. This ensures we process smaller elements first.

Try All Pairings

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

This approach tries every possible way to divide the array into pairs and checks if each pair satisfies the doubling condition. We use backtracking to explore all combinations.

Frequency Count and Greedy Matching — Algorithm Steps

Count frequency of each number in a hash map
For each unique number, try to pair it with its double
Handle zero specially since 0 × 2 = 0
Return true if all numbers can be paired

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many times each number appears

Match Pairs

For each number, try to pair with its double

Verify Success

Check if all numbers can be paired successfully

Code -

solution.c — C

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

#define MAX_SIZE 1000

struct Pair {
    int num;
    int count;
};

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int compare(const void* a, const void* b) {
    struct Pair* pa = (struct Pair*)a;
    struct Pair* pb = (struct Pair*)b;
    return abs_val(pa->num) - abs_val(pb->num);
}

bool solution(int* arr, int size) {
    struct Pair pairs[MAX_SIZE];
    int unique_count = 0;
    
    // Count frequencies
    for (int i = 0; i < size; i++) {
        int found = -1;
        for (int j = 0; j < unique_count; j++) {
            if (pairs[j].num == arr[i]) {
                found = j;
                break;
            }
        }
        
        if (found == -1) {
            pairs[unique_count].num = arr[i];
            pairs[unique_count].count = 1;
            unique_count++;
        } else {
            pairs[found].count++;
        }
    }
    
    // Sort by absolute value
    qsort(pairs, unique_count, sizeof(struct Pair), compare);
    
    // Process each number
    for (int i = 0; i < unique_count; i++) {
        if (pairs[i].count == 0) continue;
        
        if (pairs[i].num == 0) {
            if (pairs[i].count % 2 != 0) {
                return false;
            }
        } else {
            int double_num = 2 * pairs[i].num;
            int double_idx = -1;
            
            for (int j = 0; j < unique_count; j++) {
                if (pairs[j].num == double_num) {
                    double_idx = j;
                    break;
                }
            }
            
            if (double_idx == -1 || pairs[double_idx].count < pairs[i].count) {
                return false;
            }
            
            pairs[double_idx].count -= pairs[i].count;
        }
        
        pairs[i].count = 0;
    }
    
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[MAX_SIZE];
    int size = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    bool result = solution(arr, size);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count frequencies, then iterate through unique numbers

⚡ Linearithmic

Space Complexity

O(n)

Hash map stores frequency of each unique number

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Frequency Count and Greedy Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler