 Open in App
Not now

# Check if elements of an array can be arranged satisfying the given condition

• Difficulty Level : Easy
• Last Updated : 12 Sep, 2022

Given an array arr of N (even) integer elements. The task is to check if it is possible to reorder the elements of the array such that:

```arr[2*i + 1] = 2 * A[2 * i]

for i = 0 ... N-1. ```

Print True if it is possible, otherwise print False.

Examples:

Input: arr[] = {4, -2, 2, -4}
Output: True
{-2, -4, 2, 4} is a valid arrangement, -2 * 2 = -4 and 2 * 2 = 4

Input: arr[] = {1, 2, 4, 16, 8, 4}
Output: False

Approach: The idea is that, if k is current minimum element in the array then it must pair with 2 * k as there does not exist any other element k / 2 to pair it with.

We check elements in ascending order. When we check an element k and it isn’t used, it must pair with 2 * k. We will attempt to arrange k followed by 2 * k however if we can’t, then the answer is False. In the end, if all the operations are successful, then print True

We will store a count of each element to keep track of what we have not yet considered.

Below is the implementation of above approach:

## C++

 `// C++ implementation of the approach``#include``using` `namespace` `std;` `// Function to return true if the elements``// can be arranged in the desired order``string canReorder(``int` `A[],``int` `n)``{``    ``map<``int``,``int``> m;``    ` `    ``for``(``int` `i=0;i

## Java

 `// Java implementation of the approach``import` `java.util.HashMap;``import` `java.util.Map;``import` `java.util.Arrays;` `class` `GfG``{``    ` `    ``// Function to return true if the elements``    ``// can be arranged in the desired order``    ``static` `String canReorder(``int` `A[],``int` `n)``    ``{``        ``HashMap m = ``new` `HashMap<>();``        ` `        ``for``(``int` `i = ``0``; i < n; i++)``        ``{``            ` `            ``if` `(m.containsKey(A[i]))``                ``m.put(A[i], m.get(A[i]) + ``1``);``            ``else``                ``m.put(A[i], ``1``);``        ``}``        ` `        ``Arrays.sort(A);``        ``int` `count = ``0``;``    ` `        ``for``(``int` `i = ``0``; i < n; i++)``        ``{``            ``if` `(m.get(A[i]) == ``0``)``                ``continue``;``    ` `            ``// If 2 * x is not found to pair``            ``if` `(m.containsKey(``2` `* A[i]))``            ``{``                ` `                ``count += ``2``;``                ` `                ``// Remove an occurrence of x``                ``// and an occurrence of 2 * x``                ``m.put(A[i], m.get(A[i]) - ``1``);``                ``m.put(``2` `* A[i], m.get(``2` `* A[i]) - ``1``);``            ``}``        ``}``        ` `        ``if``(count == n)``            ``return` `"true"``;``        ``else``            ``return` `"false"``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String []args)``    ``{``        ` `        ``int` `A[] = {``4``, -``2``, ``2``, -``4``};``        ``int` `n = A.length;``        ` `        ``// Function call to print required answer``        ``System.out.println(canReorder(A,n));``    ``}``}` `// This code is contributed by Rituraj Jain`

## Python

 `# Python implementation of the approach``import` `collections` `# Function to return true if the elements``# can be arranged in the desired order``def` `canReorder(A):` `    ``count ``=` `collections.Counter(A)` `    ``for` `x ``in` `sorted``(A, key ``=` `abs``):``        ``if` `count[x] ``=``=` `0``:``            ``continue` `        ``# If 2 * x is not found to pair``        ``if` `count[``2` `*` `x] ``=``=` `0``:``            ``return` `False` `        ``# Remove an occurrence of x``        ``# and an occurrence of 2 * x``        ``count[x] ``-``=` `1``        ``count[``2` `*` `x] ``-``=` `1` `    ``return` `True`  `# Driver Code``A ``=` `[``4``, ``-``2``, ``2``, ``-``4``]` `# Function call to print required answer``print``(canReorder(A))`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``    ` `// Function to return true if the elements``// can be arranged in the desired order``static` `String canReorder(``int` `[]A,``int` `n)``{``    ``Dictionary<``int``,``               ``int``> m = ``new` `Dictionary<``int``,``                                       ``int``>();``    ` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``if` `(m.ContainsKey(A[i]))``            ``m[A[i]]= m[A[i]] + 1;``        ``else``            ``m.Add(A[i], 1);``    ``}``    ` `    ``Array.Sort(A);``    ``int` `count = 0;` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``if` `(m[A[i]] == 0)``            ``continue``;` `        ``// If 2 * x is not found to pair``        ``if` `(m.ContainsKey(2 * A[i]))``        ``{``            ``count += 2;``            ` `            ``// Remove an occurrence of x``            ``// and an occurrence of 2 * x``            ``m[A[i]]= m[A[i]] - 1;``            ``if` `(m.ContainsKey(2 * A[i]))``                ``m[2 * A[i]]= m[2 * A[i]] - 1;``            ``else``                ``m.Add(2 * A[i], m[2 * A[i]] - 1);``        ``}``    ``}``    ``if``(count == n)``        ``return` `"True"``;``    ``else``        ``return` `"False"``;``}` `// Driver code``public` `static` `void` `Main(String []args)``{``    ``int` `[]A = {4, -2, 2, -4};``    ``int` `n = A.Length;``    ` `    ``// Function call to print required answer``    ``Console.WriteLine(canReorder(A,n));``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

`true`

Complexity Analysis:

• Time Complexity: O(n * log n)
• Auxiliary Space: O(n)

My Personal Notes arrow_drop_up