# 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++ 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[0]); ` ` `  `    ``maximizedArray( ` `        ``arr, N); ` ` `  `    ``return` `0; ` `} `

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