Codestin Search App

Array of Doubled Pairs - Problem

Array of Doubled Pairs asks you to determine if an array can be rearranged into a specific pattern where every pair consists of a number and its double.

Given an integer array arr of even length, return true if it's possible to reorder the array such that for every valid index i: arr[2*i + 1] = 2 * arr[2*i].

In other words, can you arrange the array so that at positions (0,1), (2,3), (4,5), etc., each pair follows the pattern where the second element is exactly double the first?

Example: [3,1,3,6] can be rearranged to [1,2,3,6] where 2=2*1 and 6=2*3, so return true.

Input & Output

example_1.py — Basic valid case

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

› Output: true

💡 Note: We can arrange as [1,2,3,6] where arr[1]=2=2×arr[0]=2×1 and arr[3]=6=2×arr[2]=2×3

example_2.py — Invalid case

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

› Output: false

💡 Note: We have two 3s but only one 6, so we cannot pair both 3s with their doubles

example_3.py — Negative numbers

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

› Output: true

💡 Note: We can arrange as [-2,-4,2,4] where -4=2×(-2) and 4=2×2

Constraints

2 ≤ arr.length ≤ 3 × 10⁴
arr.length is even
-10⁵ ≤ arr[i] ≤ 10⁵
Note: Zero can pair with itself since 0 = 2 × 0

Visualization

Tap to expand

Understanding the Visualization

Count Heights

Count how many dancers we have at each height

Sort by Height

Process dancers from shortest to tallest

Find Partners

For each height h, pair with dancers of height 2h

Check Success

Return true if everyone finds a partner

Key Takeaway

🎯 Key Insight: The greedy approach of pairing from smallest absolute values first guarantees that we find a valid arrangement if one exists, making this an optimal O(n log n) solution.

Asked in

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

The optimal solution uses a frequency counter and greedy pairing strategy. By processing numbers in order of absolute value, we ensure each number is optimally assigned as either the smaller or larger element in a doubled pair, achieving O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Hash Table (Optimal)	O(n log n)	O(n)	Count frequencies and process in single optimal pass
Two-Pass Hash Table	O(n log n)	O(n)	Count frequencies first, then match pairs greedily
Brute Force (All Permutations)	O(n! × n)	O(n)	Generate all possible arrangements and check each one

Optimized Hash Table (Optimal) — Algorithm Steps

Create a frequency counter for all numbers in the array
Sort numbers by absolute value to process systematically
For each number x with count[x] occurrences, try to pair with 2x
If count[2x] >= count[x], pair them by reducing count[2x] by count[x]
If any number cannot be fully paired, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Count & Sort

Count frequencies and sort by absolute value

Greedy Pairing

Pair each number x with 2x, updating counts

Validation

Return false if any number cannot be paired

Code -

solution.c — C

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

struct CountPair {
    int value;
    int count;
};

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

int compare_abs(const void* a, const void* b) {
    struct CountPair* pa = (struct CountPair*)a;
    struct CountPair* pb = (struct CountPair*)b;
    return abs_value(pa->value) - abs_value(pb->value);
}

bool canReorderDoubled(int* arr, int arrSize) {
    struct CountPair counts[1000];
    int uniqueCount = 0;
    
    // Count frequencies
    for (int i = 0; i < arrSize; i++) {
        bool found = false;
        for (int j = 0; j < uniqueCount; j++) {
            if (counts[j].value == arr[i]) {
                counts[j].count++;
                found = true;
                break;
            }
        }
        if (!found) {
            counts[uniqueCount].value = arr[i];
            counts[uniqueCount].count = 1;
            uniqueCount++;
        }
    }
    
    // Sort by absolute value
    qsort(counts, uniqueCount, sizeof(struct CountPair), compare_abs);
    
    // Process each unique number
    for (int i = 0; i < uniqueCount; i++) {
        int x = counts[i].value;
        int needed = counts[i].count;
        int target = 2 * x;
        int available = 0;
        
        // Find count of 2*x
        for (int j = 0; j < uniqueCount; j++) {
            if (counts[j].value == target) {
                available = counts[j].count;
                if (needed > available) {
                    return false;
                }
                counts[j].count -= needed;
                break;
            }
        }
        
        if (available == 0 && needed > 0) {
            return false;
        }
    }
    
    return true;
}

int main() {
    int arr[] = {1, 2, 3, 6};
    printf("%s\n", canReorderDoubled(arr, 4) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to count frequencies + O(n log n) to sort unique values + O(n) to process pairs

⚡ Linearithmic

Space Complexity

O(n)

Hash map stores at most n unique values with their frequencies

⚡ Linearithmic Space

42.3K Views

Medium Frequency

~25 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

Optimized Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler