GFG App
Open App
Browser
Continue

# Permutations of an array having sum of Bitwise AND of adjacent elements at least K

Given an array arr[] consisting of N integers and a positive integer K, the task is to find all permutations of the array arr[] such that the sum of Bitwise AND of adjacent elements in each permutation is greater than or equal to K. If no such permutation exists, print “-1”.

Examples:

Input: arr[] = {1, 2, 3, 4, 5}, K = 8
Output:
2, 3, 1, 5, 4
4, 5, 1, 3, 2
Explanation:
For the permutation {2, 3, 1, 5, 4}: (2 & 3) + (3 & 1) + (1 & 5) + (5 & 4) = 8, which is at least K( = 8).
For the permutation {4, 5, 1, 3, 2}: (4 & 5) + (5 & 1) + (1 & 3) + (3 & 2) = 8, which is at least K( = 8).

Input: arr[] = {1, 2, 3}, K = 4
Output: -1

Approach: The idea is to generate all possible permutations of arr[] and check for each permutation, if the required condition is satisfied or not.
Follow the steps below to solve the problem:

• Initialize a boolean variable, say flag as false, to check if any required permutation exists or not.
• Generate all possible permutations of the array arr[] and perform the following steps:
• Calculate the sum of Bitwise AND of all adjacent pairs of array elements in the current permutation and store t in a variable, say sum.
• Traverse the current permutation over the range [0, N – 2] and add Bitwise AND of arr[i] and arr[i + 1] to the sum.
• If the value of sum is at least K, then set the flag to true and print the current permutation.
• After completing the above steps, If the value of flag is false, the print “-1”.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to print all permutations of` `// arr[] such that the sum of Bitwise AND` `// of all adjacent element is at least K` `void` `printPermutation(``int` `arr[], ``int` `n,` `                      ``int` `k)` `{` `    ``// To check if any permutation` `    ``// exists or not` `    ``bool` `flag = ``false``;`   `    ``// Sort the given array` `    ``sort(arr, arr + n);`   `    ``// Find all possible permutations` `    ``do` `{`   `        ``// Stores the sum of bitwise AND` `        ``// of adjacent elements of the` `        ``// current permutation` `        ``int` `sum = 0;`   `        ``// Traverse the current` `        ``// permutation of arr[]` `        ``for` `(``int` `i = 0; i < n - 1; i++) {`   `            ``// Update the sum` `            ``sum += arr[i] & arr[i + 1];` `        ``}`   `        ``// If the sum is at least K, then` `        ``// print the current permutation` `        ``if` `(sum >= k) {`   `            ``// Set the flag variable` `            ``flag = ``true``;`   `            ``// Print the current permutation` `            ``for` `(``int` `i = 0; i < n; i++) {` `                ``cout << arr[i] << ``" "``;` `            ``}` `            ``cout << ``"\n"``;` `        ``}`   `    ``} ``while` `(next_permutation(arr, arr + n));`   `    ``// If flag is unset, then print -1` `    ``if` `(flag == ``false``) {` `        ``cout << ``"-1"``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 1, 2, 3, 4, 5 };` `    ``int` `K = 8;` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// Function Call` `    ``printPermutation(arr, N, K);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG{`   `  ``// Function to print all permutations of` `  ``// arr[] such that the sum of Bitwise AND` `  ``// of all adjacent element is at least K` `  ``static` `void` `printPermutation(``int` `arr[], ``int` `n,` `                               ``int` `k)` `  ``{`   `    ``// To check if any permutation` `    ``// exists or not` `    ``boolean` `flag = ``false``;`   `    ``// Sort the given array` `    ``Arrays.sort(arr);`   `    ``// Find all possible permutations` `    ``do` `    ``{`   `      ``// Stores the sum of bitwise AND` `      ``// of adjacent elements of the` `      ``// current permutation` `      ``int` `sum = ``0``;`   `      ``// Traverse the current` `      ``// permutation of arr[]` `      ``for` `(``int` `i = ``0``; i < n - ``1``; i++) ` `      ``{`   `        ``// Update the sum` `        ``sum += arr[i] & arr[i + ``1``];` `      ``}`   `      ``// If the sum is at least K, then` `      ``// print the current permutation` `      ``if` `(sum >= k) ` `      ``{`   `        ``// Set the flag variable` `        ``flag = ``true``;`   `        ``// Print the current permutation` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{` `          ``System.out.print(arr[i]+ ``" "``);` `        ``}` `        ``System.out.print(``"\n"``);` `      ``}`   `    ``} ``while` `(next_permutation(arr));`   `    ``// If flag is unset, then print -1` `    ``if` `(flag == ``false``) ` `    ``{` `      ``System.out.print(``"-1"``);` `    ``}` `  ``}` `  ``static` `boolean` `next_permutation(``int``[] p) {` `    ``for` `(``int` `a = p.length - ``2``; a >= ``0``; --a)` `      ``if` `(p[a] < p[a + ``1``])` `        ``for` `(``int` `b = p.length - ``1``;; --b)` `          ``if` `(p[b] > p[a]) {` `            ``int` `t = p[a];` `            ``p[a] = p[b];` `            ``p[b] = t;` `            ``for` `(++a, b = p.length - ``1``; a < b; ++a, --b) {` `              ``t = p[a];` `              ``p[a] = p[b];` `              ``p[b] = t;` `            ``}` `            ``return` `true``;` `          ``}` `    ``return` `false``;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5` `};` `    ``int` `K = ``8``;` `    ``int` `N = arr.length;`   `    ``// Function Call` `    ``printPermutation(arr, N, K);` `  ``}` `}`   `// This code is contributed by 29AjayKumar`

## C#

 `// C# program for the above approach` `using` `System;` `class` `GFG{`   `  ``// Function to print all permutations of` `  ``// []arr such that the sum of Bitwise AND` `  ``// of all adjacent element is at least K` `  ``static` `void` `printPermutation(``int` `[]arr, ``int` `n,` `                               ``int` `k)` `  ``{`   `    ``// To check if any permutation` `    ``// exists or not` `    ``bool` `flag = ``false``;`   `    ``// Sort the given array` `    ``Array.Sort(arr);`   `    ``// Find all possible permutations` `    ``do` `    ``{`   `      ``// Stores the sum of bitwise AND` `      ``// of adjacent elements of the` `      ``// current permutation` `      ``int` `sum = 0;`   `      ``// Traverse the current` `      ``// permutation of []arr` `      ``for` `(``int` `i = 0; i < n - 1; i++) ` `      ``{`   `        ``// Update the sum` `        ``sum += arr[i] & arr[i + 1];` `      ``}`   `      ``// If the sum is at least K, then` `      ``// print the current permutation` `      ``if` `(sum >= k) ` `      ``{`   `        ``// Set the flag variable` `        ``flag = ``true``;`   `        ``// Print the current permutation` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{` `          ``Console.Write(arr[i] + ``" "``);` `        ``}` `        ``Console.Write(``"\n"``);` `      ``}`   `    ``} ``while` `(next_permutation(arr));`   `    ``// If flag is unset, then print -1` `    ``if` `(flag == ``false``) ` `    ``{` `      ``Console.Write(``"-1"``);` `    ``}` `  ``}` `  ``static` `bool` `next_permutation(``int``[] p) {` `    ``for` `(``int` `a = p.Length - 2; a >= 0; --a)` `      ``if` `(p[a] < p[a + 1])` `        ``for` `(``int` `b = p.Length - 1;; --b)` `          ``if` `(p[b] > p[a]) {` `            ``int` `t = p[a];` `            ``p[a] = p[b];` `            ``p[b] = t;` `            ``for` `(++a, b = p.Length - 1; a < b; ++a, --b) {` `              ``t = p[a];` `              ``p[a] = p[b];` `              ``p[b] = t;` `            ``}` `            ``return` `true``;` `          ``}` `    ``return` `false``;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``int` `[]arr = { 1, 2, 3, 4, 5 };` `    ``int` `K = 8;` `    ``int` `N = arr.Length;` `    `  `    ``// Function Call` `    ``printPermutation(arr, N, K);` `  ``}` `}`   `// This code is contributed by shikhasingrajput`

## Python3

 `# Python3 program for the above approach` `def` `next_permutation(a):` `    ``for` `i ``in` `reversed``(``range``(``len``(a) ``-` `1``)):` `        ``if` `a[i] < a[i ``+` `1``]:` `            ``break` `    ``else``:` `        ``return` `False` `    ``j ``=` `next``(j ``for` `j ``in` `             ``reversed``(``range``(i ``+` `1``, ``len``(a)))` `             ``if` `a[i] < a[j])` `    ``a[i], a[j] ``=` `a[j], a[i]` `    ``a[i ``+` `1``:] ``=` `reversed``(a[i ``+` `1``:])` `    ``return` `True`   `# Function to print all permutations of` `# arr[] such that the sum of Bitwise AND` `# of all adjacent element is at least K` `def` `printPermutation(arr, n, k):` `  `  `    ``# To check if any permutation` `    ``# exists or not` `    ``flag ``=` `False`   `    ``# Sort the given array` `    ``arr.sort()`   `    ``# Find all possible permutations` `    ``while` `True``:`   `        ``# Stores the sum of bitwise AND` `        ``# of adjacent elements of the` `        ``# current permutation` `        ``sum` `=` `0`   `        ``# Traverse the current` `        ``# permutation of arr[]` `        ``for` `i ``in` `range``(n ``-` `1``):`   `            ``# Update the sum` `            ``sum` `+``=` `arr[i] & arr[i ``+` `1``]`   `        ``# If the sum is at least K, then` `        ``# print the current permutation` `        ``if` `(``sum` `>``=` `k):`   `            ``# Set the flag variable` `            ``flag ``=` `True`   `            ``# Print the current permutation` `            ``for` `i ``in` `range``(n):` `                ``print``(arr[i], end ``=` `" "``)`   `            ``print``()` `        ``if` `(next_permutation(arr) ``=``=` `False``):` `            ``break`   `        ``# If flag is unset, then print -1` `    ``if` `(flag ``=``=` `False``):` `        ``print``(``"-1"``)`   `# Driver Code` `arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `K ``=` `8` `N ``=` `len``(arr)`   `# Function Call` `printPermutation(arr, N, K)`   `# This code is contributed by Dharanendra L V`

## Javascript

 ``

Output:

```2 3 1 5 4
4 5 1 3 2```

Time Complexity: O(N*(N!))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up