GeeksforGeeks App
Open App
Browser
Continue

# Rearrange given Array such that all set bit positions have higher value than others

Given an array B1[] and a binary array B2[] each of size N, the task is to rearrange array B1[] in a way such that for all setbit position i of B2[] the value of B1[i] will be greater than the values where bit is not set in B2[] i.e for all (i, j) B1[i] > B1[j] when B2[i] = 1, B2[j] = 0 (0 ≤ i, j < N).

Note: If multiple arrangements are possible, print any one of them.

Examples:

Input: N = 7, B1[] = {1, 2, 3, 4, 5, 6, 7}, B2[] = {0, 1, 0, 1, 0, 1, 0}
Output: 1 5 2 6 3 7 4
Explanation: Values having 1 in B2[] array are = {2, 4, 6} and values with 0s are = {1, 3, 5, 7}.
So, in correspondent to B2[] array, B1[] can be rearranged = {1, 5, 2, 6, 3, 7, 4}
B1[] = {1, 5, 2, 6, 3, 7, 4}
B2[] = {0, 1, 0, 1, 0, 1, 0}, now all places in B1[i] > B1[j] where B2[i] = 1, and B2[j] = 0.
It also can be rearranged as {1, 7, 2, 6, 3, 5, 4}

Input: N = 3, B1[] = {4, 3, 5}, B2[] = {1, 1, 1}
Output: 5 4 3

Approach: The problem can be solved based on the following idea:

To arrange B1[] as per set bit positions of B2[], sort the values of B1[] and arrange the higher values in positions with bits set and the lower values in positions in other positions.

Follow the steps mentioned below to implement the above idea:

• Make a list of pairs (say v) with the bit value of B2[] and the corresponding value at B1[],
• Sort the list of pairs in ascending order of bits value of B2[].
• Rearrange B1[] using two pointer approach.
• Declare left pointer with 0 and right pointer with N-1.
• When B2[i] is 0 (0 ≤ i < N), set B1[] as v[left] and increment left.
• Otherwise, set B1[i] as v[right] and decrement right.
• Return B1[] as the final answer.

Below is the implementation of the above approach :

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to do required``// operation``void` `solve(``int` `n, vector<``int``>& b1, ``int` `b2[])``{``    ``//  Initializing vector of pair``    ``// to store b2 and b1 array element``    ``vector > v;` `    ``int` `cnt = 1;``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Pushing 1 and 0 integer along with``        ``// their corresponding element``        ``// in array b1``        ``v.push_back({ b2[i], b1[i] });``    ``}` `    ``// Sorting the vector of pair``    ``// in ascending order``    ``sort(v.begin(), v.end());` `    ``int` `left = 0, right = n - 1;` `    ``// Arranging the array b1``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(b2[i] == 0)``            ``b1[i] = v[left++].second;``        ``else``            ``b1[i] = v[right--].second;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 3;``    ``vector<``int``> B1 = { 3, 4, 5 };``    ``int` `B2[] = { 1, 1, 1 };` `    ``solve(N, B1, B2);``    ``for` `(``int` `x : B1)``        ``cout << x << ``" "``;``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `// User defined Pair class``class` `Pair {``  ``int` `x;``  ``int` `y;` `  ``// Constructor``  ``public` `Pair(``int` `x, ``int` `y)``  ``{``    ``this``.x = x;``    ``this``.y = y;``  ``}``}` `// class to define user defined conparator``class` `Compare {` `  ``static` `void` `compare(Pair arr[], ``int` `n)``  ``{``    ``// Comparator to sort the pair according to second element``    ``Arrays.sort(arr, ``new` `Comparator() {``      ``@Override` `public` `int` `compare(Pair p1, Pair p2)``      ``{``        ``return` `p1.x - p2.x; ``// To compare the first element just``        ``//change the variable from p1.y - p2.y to x.``      ``}``    ``});``  ``}``}` `class` `GFG {` `  ``// Function to do required``  ``// operation``  ``static` `void` `solve(``int` `n, ``int``[] b1, ``int``[] b2)``  ``{``    ` `    ``//  Initializing vector of pair``    ``// to store b2 and b1 array element``    ``// Array of Pair``    ``Pair v[] = ``new` `Pair[n];` `    ``int` `cnt = ``1``;``    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``// Pushing 1 and 0 integer along with``      ``// their corresponding element``      ``// in array b1``      ``v[i] = ``new` `Pair(b2[i], b1[i]);``    ``}` `    ``// Sorting the vector of pair``    ``// in ascending order``    ``Compare obj = ``new` `Compare();``    ``obj.compare(v, n);` `    ``int` `left = ``0``, right = n - ``1``;` `    ``// Arranging the array b1``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``if` `(b2[i] == ``0``)``        ``b1[i] = v[left++].y;``      ``else``        ``b1[i] = v[right--].y;``    ``}``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main (String[] args) {``    ``int` `N = ``3``;``    ``int` `B1[] = { ``3``, ``4``, ``5` `};``    ``int` `B2[] = { ``1``, ``1``, ``1` `};` `    ``solve(N, B1, B2);``    ``for` `(``int` `i = ``0``; i

## Python3

 `# Python3 program for the above approach``# Function to do required operation``def` `solve(n, b1, b2):``  ` `    ``# Initializing list of pair to store b2 and b1 array element``    ``v ``=` `[]``    ``cnt ``=` `1``    ``for` `i ``in` `range``(n):``        ``# Pushing 1 and 0 integer along with``        ``# their corresponding element in array b1``        ``v.append([b2[i], b1[i]])``    ` `    ``v.sort()``    ``left ``=` `0``    ``right ``=` `n ``-` `1``    ` `    ``# Arranging the array b1``    ``for` `i ``in` `range``(n):``        ``if` `b2[i] ``=``=` `0``:``            ``b1[i] ``=` `v[left][``1``]``            ``left ``+``=` `1``        ``else``:``            ``b1[i] ``=` `v[right][``1``]``            ``right ``-``=` `1``            ` `# Driver Code``N ``=` `3``b1 ``=` `[``3``, ``4``, ``5``]``b2 ``=` `[``1``, ``1``, ``1``]``solve(N, b1, b2)``for` `x ``in` `b1:``    ``print``(x, end ``=` `" "``)``''' This code is written by Rajat Kumar (GLA University)'''`

## C#

 `// C# program to implement above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG{` `  ``class` `pair : IComparable``  ``{``    ``public` `int` `first, second;``    ``public` `pair(``int` `first, ``int` `second)``    ``{``      ``this``.first = first;``      ``this``.second = second;``    ``}``    ``public` `int` `CompareTo(pair b)``    ``{``      ``if` `(``this``.first != b.first)``        ``return` `(``this``.first < b.first)?-1:1;``      ``else``        ``return` `this``.second > b.second?-1:1;``    ``}``  ``}`  `  ``static` `void` `solve(``int` `n, ``int``[] b1, ``int``[] b2)``  ``{``    ``List v = ``new` `List ();``    ``for` `(``int` `i = 0; i < n; i++) {` `      ``// Pushing 1 and 0 integer along with``      ``// their corresponding element``      ``// in array b1``      ``v.Add(``new` `pair(b2[i],``                     ``b1[i]));``    ``}` `    ``// Sorting the vector of pair``    ``// in ascending order``    ``v.Sort();` `    ``int` `left = 0, right = n - 1;` `    ``// Arranging the array b1``    ``for` `(``int` `i = 0; i < n; i++) {``      ``if` `(b2[i] == 0)``        ``b1[i] = v[left++].second;``      ``else``        ``b1[i] = v[right--].second;``    ``}``  ``}`  `  ``public` `static` `void` `Main (){` `    ``// Code` `    ``int` `N = 3;``    ``int``[] B1 = { 3, 4, 5 };``    ``int``[] B2 = { 1, 1, 1 };` `    ``solve(N, B1, B2);``    ``for` `(``int` `i = B1.Length-1; i >=0 ; i--) ``    ``{ ``      ``Console.Write(B1[i]);``      ``Console.Write(``" "``);``    ``}  ` `  ``}``}` `// This code is contributed by akashish__`

## Javascript

 ``

Output

`5 4 3 `

Time Complexity: O(N * logN)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up