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

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 `

Output:

```True
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.