Open in App
Not now

# Rearrange array elements such that Bitwise AND of first N – 1 elements is equal to last element

• Difficulty Level : Medium
• Last Updated : 09 Nov, 2021

Given an array arr[] of N positive integers, the task is to find an arrangement such that Bitwise AND of the first N – 1 elements is equal to the last element. If no such arrangement is possible then output will be -1.
Examples:

Input: arr[] = {1, 5, 3, 3}
Output: 3 5 3 1
(3 & 5 & 3) = 1 which is equal to the last element.
Input: arr[] = {2, 3, 7}
Output: -1
No such arrangement is possible.

Approach:

• Let p = x & y then p â‰¤ min(x, y) which means Bitwise AND is a non-increasing function. If bitwise AND is performed on some elements then the value will be decreasing or remain the same.
• So, it is obvious to put the smallest element at the last index and then check if the last element is equal to the bitwise AND of the first N – 1 elements or not. If yes, then print the required arrangement otherwise print -1.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ` `using` `namespace` `std;`   `// Utility function to print` `// the elements of an array` `void` `printArr(``int` `arr[], ``int` `n)` `{` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``cout << arr[i] << ``" "``;` `}`   `// Function to find the required arrangement` `void` `findArrangement(``int` `arr[], ``int` `n)` `{`   `    ``// There has to be atleast 2 elements` `    ``if` `(n < 2) {` `        ``cout << ``"-1"``;` `        ``return``;` `    ``}`   `    ``// Minimum element from the array` `    ``int` `minVal = *min_element(arr, arr + n);`   `    ``// Swap any occurrence of the minimum` `    ``// element with the last element` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(arr[i] == minVal) {` `            ``swap(arr[i], arr[n - 1]);` `            ``break``;` `        ``}` `    ``}`   `    ``// Find the bitwise AND of the` `    ``// first (n - 1) elements` `    ``int` `andVal = arr[0];` `    ``for` `(``int` `i = 1; i < n - 1; i++) {` `        ``andVal &= arr[i];` `    ``}`   `    ``// If the bitwise AND is equal` `    ``// to the last element then` `    ``// print the arrangement` `    ``if` `(andVal == arr[n - 1])` `        ``printArr(arr, n);` `    ``else` `        ``cout << ``"-1"``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 5, 3, 3 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``);`   `    ``findArrangement(arr, n);`   `    ``return` `0;` `}`

## Java

 `// Java implementation of the approach` `import` `java.util.*;`   `class` `GFG ` `{`   `// Utility function to print` `// the elements of an array` `static` `void` `printArr(``int` `[]arr, ``int` `n)` `{` `    ``for` `(``int` `i = ``0``; i < n; i++)` `        ``System.out.print(arr[i] + ``" "``);` `}`   `// Function to find the required arrangement` `static` `void` `findArrangement(``int` `arr[], ``int` `n)` `{`   `    ``// There has to be atleast 2 elements` `    ``if` `(n < ``2``)` `    ``{` `        ``System.out.print(``"-1"``);` `        ``return``;` `    ``}`   `    ``// Minimum element from the array` `    ``int` `minVal = Arrays.stream(arr).min().getAsInt();`   `    ``// Swap any occurrence of the minimum` `    ``// element with the last element` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{` `        ``if` `(arr[i] == minVal) ` `        ``{` `            ``swap(arr, i, n - ``1``);` `            ``break``;` `        ``}` `    ``}`   `    ``// Find the bitwise AND of the` `    ``// first (n - 1) elements` `    ``int` `andVal = arr[``0``];` `    ``for` `(``int` `i = ``1``; i < n - ``1``; i++) ` `    ``{` `        ``andVal &= arr[i];` `    ``}`   `    ``// If the bitwise AND is equal` `    ``// to the last element then` `    ``// print the arrangement` `    ``if` `(andVal == arr[n - ``1``])` `        ``printArr(arr, n);` `    ``else` `        ``System.out.print(``"-1"``);` `}`   `static` `int``[] swap(``int` `[]arr, ``int` `i, ``int` `j)` `{` `    ``int` `temp = arr[i];` `    ``arr[i] = arr[j];` `    ``arr[j] = temp;` `    ``return` `arr;` `}`   `// Driver code` `public` `static` `void` `main(String []args)` `{` `    ``int` `arr[] = { ``1``, ``5``, ``3``, ``3` `};` `    ``int` `n = arr.length;`   `    ``findArrangement(arr, n);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the approach `   `# Utility function to print ` `# the elements of an array ` `def` `printArr(arr, n) :`   `    ``for` `i ``in` `range``(n) :` `        ``print``(arr[i], end ``=` `" "``); `   `# Function to find the required arrangement ` `def` `findArrangement(arr, n) : `   `    ``# There has to be atleast 2 elements ` `    ``if` `(n < ``2``) :` `        ``print``(``"-1"``, end ``=` `""); ` `        ``return``; `   `    ``# Minimum element from the array ` `    ``minVal ``=` `min``(arr); `   `    ``# Swap any occurrence of the minimum ` `    ``# element with the last element ` `    ``for` `i ``in` `range``(n) :` `        ``if` `(arr[i] ``=``=` `minVal) :` `            ``arr[i], arr[n ``-` `1``] ``=` `arr[n ``-` `1``], arr[i]; ` `            ``break``; ` `            `  `    ``# Find the bitwise AND of the ` `    ``# first (n - 1) elements ` `    ``andVal ``=` `arr[``0``]; ` `    ``for` `i ``in` `range``(``1``, n ``-` `1``) :` `        ``andVal &``=` `arr[i]; `   `    ``# If the bitwise AND is equal ` `    ``# to the last element then ` `    ``# print the arrangement ` `    ``if` `(andVal ``=``=` `arr[n ``-` `1``]) :` `        ``printArr(arr, n); ` `    ``else` `:` `        ``print``(``"-1"``); `   `# Driver code ` `if` `__name__ ``=``=` `"__main__"` `: `   `    ``arr ``=` `[ ``1``, ``5``, ``3``, ``3` `]; ` `    ``n ``=` `len``(arr); `   `    ``findArrangement(arr, n); `   `# This code is contributed by AnkitRai01`

## C#

 `// C# implementation of the approach` `using` `System;    ` `using` `System.Linq;`   `class` `GFG` `{` ` `  `// Utility function to print` `// the elements of an array` `static` `void` `printArr(``int` `[]arr, ``int` `n)` `{` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``Console.Write(arr[i] + ``" "``);` `}` ` `  `// Function to find the required arrangement` `static` `void` `findArrangement(``int` `[]arr, ``int` `n)` `{` ` `  `    ``// There has to be atleast 2 elements` `    ``if` `(n < 2)` `    ``{` `        ``Console.Write(``"-1"``);` `        ``return``;` `    ``}` ` `  `    ``// Minimum element from the array` `    ``int` `minVal = arr.Min();` ` `  `    ``// Swap any occurrence of the minimum` `    ``// element with the last element` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{` `        ``if` `(arr[i] == minVal) ` `        ``{` `            ``swap(arr, i, n - 1);` `            ``break``;` `        ``}` `    ``}` ` `  `    ``// Find the bitwise AND of the` `    ``// first (n - 1) elements` `    ``int` `andVal = arr[0];` `    ``for` `(``int` `i = 1; i < n - 1; i++) ` `    ``{` `        ``andVal &= arr[i];` `    ``}` ` `  `    ``// If the bitwise AND is equal` `    ``// to the last element then` `    ``// print the arrangement` `    ``if` `(andVal == arr[n - 1])` `        ``printArr(arr, n);` `    ``else` `        ``Console.Write(``"-1"``);` `}` ` `  `static` `int``[] swap(``int` `[]arr, ``int` `i, ``int` `j)` `{` `    ``int` `temp = arr[i];` `    ``arr[i] = arr[j];` `    ``arr[j] = temp;` `    ``return` `arr;` `}` ` `  `// Driver code` `public` `static` `void` `Main(String []args)` `{` `    ``int` `[]arr = { 1, 5, 3, 3 };` `    ``int` `n = arr.Length;` ` `  `    ``findArrangement(arr, n);` `}` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output:

`3 5 3 1`

Time Complexity: O(N)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles