Related Articles
Generate an Array such with elements maximized through swapping bits
• Last Updated : 22 Jul, 2020

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

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