Skip to content
Related Articles

Related Articles

Improve Article

Generate an Array such with elements maximized through swapping bits

  • Last Updated : 12 May, 2021

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 
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

 



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++




// 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;
}

Java




// 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

Python3




# 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

C#




// 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

Javascript




<script>
// Javascript implementation to find
// maximum sequence by swapping bits
 
// Function to generate the maximized
// array elements
function maximizedArray(arr, N)
{
    let num, i = 0;
 
    // Traverse the array
    for(let l = N; l > 0; l--)
    {
       num = arr[i];
       let one = 0;
       let 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(let j = zero; j < (one + zero); j++)
       {
            
          // Shifting all 1's to MSB
          // and 0's to LSB
          num += (1 << j);
       }
       document.write(num);
       i++;
        
       if (N > 0)
           document.write(", ");
    }
}
 
 
    // Driver Code
     
    let arr = [ 8, 15, 9, 10, 14 ];
    let N = arr.length;
 
    maximizedArray(arr, N);
 
</script>
Output: 
8, 15, 12, 12, 14

 

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :