 Open in App
Not now

# 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

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