 GFG App
Open App Browser
Continue

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

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