Array of Doubled Pairs - Practice Coding Problems

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
✓ Brute Force (All Permutations)	O(n! × n)	O(n)	Generate all possible arrangements and check each one
Two-Pass Hash Table	O(n log n)	O(n)	Count frequencies first, then match pairs greedily
Optimized Hash Table (Optimal)	O(n log n)	O(n)	Count frequencies and process in single optimal pass

Brute Force (All Permutations) — Algorithm Steps

Generate all permutations of the input array
For each permutation, check if arr[2*i+1] = 2*arr[2*i] for all valid i
Return true if any permutation satisfies the condition
Return false if no permutation works

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orderings of the array

Check Each

For each permutation, verify the doubled pairs condition

Return Result

Return true if any permutation satisfies the condition

Code -

solution.c — C

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

bool isValid(int* arr, int size) {
    for (int i = 0; i < size; i += 2) {
        if (arr[i + 1] != 2 * arr[i]) return false;
    }
    return true;
}

bool backtrack(int* arr, int size, int* current, bool* used, int pos) {
    if (pos == size) {
        return isValid(current, size);
    }
    
    for (int i = 0; i < size; i++) {
        if (used[i]) continue;
        used[i] = true;
        current[pos] = arr[i];
        if (backtrack(arr, size, current, used, pos + 1)) {
            return true;
        }
        used[i] = false;
    }
    return false;
}

bool canReorderDoubled(int* arr, int size) {
    int* current = malloc(size * sizeof(int));
    bool* used = calloc(size, sizeof(bool));
    bool result = backtrack(arr, size, current, used, 0);
    free(current);
    free(used);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth for generating permutations

⚡ 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

Brute Force (All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler