Generate an Array such with elements maximized through swapping bits

Given an array arr[], the task is to generate a modified array such that all its elements are maximized by swapping of bits.
Examples: 
 

Input: arr[] = {10, 15} 
Output: 12, 15 
Explanation: 
Binary representation of (10)10 = (1010)2. Swap the second and third bit to get the binary representation as (1100)2 = (12)10
For 15, its binary representation is 1111, which can not be further changed to get greater value. 
Input: arr[] = {8, 15, 9, 10, 14} 
Output: 8, 15, 12, 12, 14 
 

 

Approach: 
Follow the steps below to solve the problem: 
 

  • Count the number of set and unset bits in every array element.
  • Shift all the set bits to the left(MSB) and all the unset bits to the right(LSB) to maximize the array elements.
  • If count of set bits or unset bits is equal to the number of bits of the array element, then that element cannot be altered( e.g. (7)10 = (111)2
  • Print the maximized elements in the array

Below is the implementation of the above approach:
 



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to
// find maximum sequence by
// swapping bits
#include <bits/stdc++.h>
using namespace std;
  
// Function to generate the maximized
// array elements
void maximizedArray(
    int arr[], int N)
{
    int num, i = 0;
  
    // Traverse the array
    while (N--) {
        num = arr[i];
        int one = 0;
        int zero = 0;
  
        // Iterate to count set and
        // unset bits
        while (num) {
  
            // Count of unset bits
            if (num % 2 == 0) {
                zero++;
            }
            else {
  
                // Count of set bits
                one++;
            }
  
            // Bitwise right shift
            num = num >> 1;
        }
  
        for (int j = zero; j < (one + zero);
             j++) {
  
            // Shifting all 1's to MSB
            // and 0's to LSB
            num += (1 << j);
        }
        cout << num;
        i++;
  
        if (N > 0)
            cout << ", ";
    }
}
  
// Driver Code
int main()
{
  
    int arr[] = { 8, 15, 9, 10, 14 };
    int N = sizeof(arr) / sizeof(arr[0]);
  
    maximizedArray(
        arr, N);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation to find
// maximum sequence by swapping bits
class GFG{
  
// Function to generate the maximized
// array elements
public static void maximizedArray(int arr[],
                                  int N)
{
    int num, i = 0;
  
    // Traverse the array
    for(int l = N; l > 0; l--)
    {
       num = arr[i];
       int one = 0;
       int zero = 0;
         
       // Iterate to count set and
       // unset bits
       while (num != 0)
       {
             
           // Count of unset bits
           if (num % 2 == 0)
           {
               zero++;
           }
           else
           {
                 
               // Count of set bits
               one++;
           }
             
           // Bitwise right shift
           num = num >> 1;
       }
         
       for(int j = zero; j < (one + zero); j++)
       {
             
          // Shifting all 1's to MSB
          // and 0's to LSB
          num += (1 << j);
       }
       System.out.print(num);
       i++;
         
       if (N > 0)
           System.out.print(", ");
    }
}
  
// Driver Code
public static void main(String args[])
{
    int arr[] = { 8, 15, 9, 10, 14 };
    int N = arr.length;
  
    maximizedArray(arr, N);
}
}
  
// This code is contributed by SoumikMondal

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation to find 
# maximum sequence by swapping bits
  
# Function to generate the maximized
# array elements
def maximizedArray(arr, N):
      
    i = 0
      
    # Traverse the array
    while (N > 0):
        num = arr[i]
        one = 0
        zero = 0
          
        # Iterate to count set and
        # unset bits
        while (num):
              
            # Count of unset bits
            if (num % 2 == 0):
                zero += 1
      
            else:
  
                # Count of set bits
                one += 1
                  
            # Bitwise right shift
            num = num >> 1
              
        for j in range(zero, (one + zero)):
              
            # Shifting all 1's to MSB
            # and 0's to LSB
            num += (1 << j)
              
        print(num, end = "")
        i += 1
          
        if (N > 0):
            print(", ", end = "")
              
        N -= 1
          
# Driver Code
if __name__ == "__main__":
  
    arr = [ 8, 15, 9, 10, 14 ]
    N = len(arr)
  
    maximizedArray(arr, N)
  
# This code is contributed by chitranayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation to find
// maximum sequence by swapping bits
using System;
class GFG{
  
// Function to generate the maximized
// array elements
public static void maximizedArray(int []arr,
                                  int N)
{
    int num, i = 0;
  
    // Traverse the array
    for(int l = N; l > 0; l--)
    {
        num = arr[i];
        int one = 0;
        int zero = 0;
              
        // Iterate to count set and
        // unset bits
        while (num != 0)
        {
                  
            // Count of unset bits
            if (num % 2 == 0)
            {
                zero++;
            }
            else
            {
                      
                // Count of set bits
                one++;
            }
                  
            // Bitwise right shift
            num = num >> 1;
        }
              
        for(int j = zero; j < (one + zero); j++)
        {
                  
            // Shifting all 1's to MSB
            // and 0's to LSB
            num += (1 << j);
        }
        Console.Write(num);
        i++;
              
        if (N > 0)
            Console.Write(", ");
    }
}
  
// Driver Code
public static void Main(String []args)
{
    int []arr = { 8, 15, 9, 10, 14 };
    int N = arr.Length;
  
    maximizedArray(arr, N);
}
}
  
// This code is contributed by sapnasingh4991

chevron_right


Output: 

8, 15, 12, 12, 14

 

Time Complexity: O(Nlog2N) 
Auxiliary Space: O(1)
 

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

Recommended Posts:


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.