Related Articles

# 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 ``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);` `    ``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

 ``
Output:
`8, 15, 12, 12, 14`

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

My Personal Notes arrow_drop_up