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

// 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<Pair>() {
      @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 <B1.length; i++)
      System.out.print(B1[i] + " ");
  }
}

// This code is contributed by hrithikgarg03188.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

    // Function to rearrange elements in b1 according to the
    // bit values in b2
    static void rearrangeArray(List<Integer> b1,
                               List<Integer> b2)
    {
        // Check if the sizes of b1 and b2 are the same
        if (b1.size() != b2.size()) {
            System.err.println(
                "Error: Arrays b1 and b2 must be of the same size.");
            return;
        }

        // Lists to store indices of set and unset bits in
        // b2
        List<Integer> indicesWithSetBits
            = new ArrayList<>();
        List<Integer> indicesWithUnsetBits
            = new ArrayList<>();

        // Loop through b2 to categorize indices based on
        // bit value
        for (int i = 0; i < b2.size(); i++) {
            if (b2.get(i) == 1) {
                indicesWithSetBits.add(i);
            }
            else if (b2.get(i) == 0) {
                indicesWithUnsetBits.add(i);
            }
        }

        // Lists to hold the values from b1 corresponding to
        // the categorized indices
        List<Integer> valuesWithSetBits = new ArrayList<>();
        List<Integer> valuesWithUnsetBits
            = new ArrayList<>();

        // Extract values from b1 based on the indices of
        // set and unset bits
        for (int index : indicesWithSetBits) {
            valuesWithSetBits.add(b1.get(index));
        }
        for (int index : indicesWithUnsetBits) {
            valuesWithUnsetBits.add(b1.get(index));
        }

        // Sorting values with set bits in descending order
        Collections.sort(valuesWithSetBits,
                         Collections.reverseOrder());
        // Sorting values with unset bits in ascending order
        Collections.sort(valuesWithUnsetBits);

        // Reinserting the sorted values back into b1 based
        // on the original bit positions
        for (int i = 0; i < indicesWithSetBits.size();
             i++) {
            b1.set(indicesWithSetBits.get(i),
                   valuesWithSetBits.get(i));
        }
        for (int i = 0; i < indicesWithUnsetBits.size();
             i++) {
            b1.set(indicesWithUnsetBits.get(i),
                   valuesWithUnsetBits.get(i));
        }
    }

    public static void main(String[] args)
    {
        // Example arrays
        List<Integer> B1 = new ArrayList<>();
        Collections.addAll(B1, 3, 4, 5);
        List<Integer> B2 = new ArrayList<>();
        Collections.addAll(B2, 1, 1, 1);

        // Calling the function to rearrange B1 according to
        // B2
        rearrangeArray(B1, B2);

        // Output the rearranged array
        for (int i : B1) {
            System.out.print(i + " ");
        }
    }
}