Find the maximum between N and the number formed by reversing 32-bit binary representation of N

Given a positive 32-bit integer N, the task is to find the maximum between the value of N and the number obtained by decimal representation of reversal of binary representation of N in a 32-bit integer.

Examples:

Input: N = 6
Output: 1610612736
Explanation:  
Binary representation of 6 in a 32-bit integer is 00000000000000000000000000000110 i.e., (00000000000000000000000000000110)₂ = (6)₁₀.
Reversing this binary string gives (01100000000000000000000000000000)₂ = (1610612736)₁₀.
The maximum between N and the obtained number is 1610612736. Therefore, print 1610612736.

Input: N = 1610612736
Output: 1610612736

Approach: Follow the steps below to solve the problem:

• Calculate the binary string of the number N and store it in a string S.
• Reverse the string S.
• Calculate the decimal value of the newly reversed string S in a variable, say M.
• After completing the above steps, print the maximum value of N and M as the result.

Below is the implementation of the above approach:  

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function that obtains the number
// using said operations from N
int reverseBin(int N)
{
    // Stores the binary representation
    // of the number N
    string S = "";
    int i;

    // Find the binary representation
    // of the number N
    for (i = 0; i < 32; i++) {

        // Check for the set bits
        if (N & (1LL << i))
            S += '1';
        else
            S += '0';
    }

    // Reverse the string S
    reverse(S.begin(), S.end());

    // Stores the obtained number
    int M = 0;

    // Calculating the decimal value
    for (i = 0; i < 32; i++) {

        // Check for set bits
        if (S[i] == '1')
            M += (1LL << i);
    }
    return M;
}

// Function to find the maximum value
// between N and the obtained number
int maximumOfTwo(int N)
{
    int M = reverseBin(N);

    return max(N, M);
}

// Driver Code
int main()
{
    int N = 6;
    cout << maximumOfTwo(N);

    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;

public class GFG {

    // Function that obtains the number
    // using said operations from N
    static int reverseBin(int N)
    {
        // Stores the binary representation
        // of the number N
        String S = "";
        int i;

        // Find the binary representation
        // of the number N
        for (i = 0; i < 32; i++) {

            // Check for the set bits
            if ((N & (1L << i)) != 0)
                S += '1';
            else
                S += '0';
        }

        // Reverse the string S
        S = (new StringBuilder(S)).reverse().toString();

        // Stores the obtained number
        int M = 0;

        // Calculating the decimal value
        for (i = 0; i < 32; i++) {

            // Check for set bits
            if (S.charAt(i) == '1')
                M += (1L << i);
        }
        return M;
    }

    // Function to find the maximum value
    // between N and the obtained number
    static int maximumOfTwo(int N)
    {
        int M = reverseBin(N);

        return Math.max(N, M);
    }

    // Driver Code
    public static void main(String[] args)
    {

        int N = 6;
        System.out.print(maximumOfTwo(N));
    }
}

// This code is contributed by Kingash.

Python3

# Python3 program for the above approach

# Function that obtains the number
# using said operations from N
def reverseBin(N):

    # Stores the binary representation
    # of the number N
    S = ""
    i = 0

    # Find the binary representation
    # of the number N
    for i in range(32):

        # Check for the set bits
        if (N & (1 << i)):
            S += '1'
        else:
            S += '0'

    # Reverse the string S
    S = list(S)
    S = S[::-1]
    S = ''.join(S)

    # Stores the obtained number
    M = 0

    # Calculating the decimal value
    for i in range(32):

        # Check for set bits
        if (S[i] == '1'):
            M += (1 << i)

    return M

# Function to find the maximum value
# between N and the obtained number
def maximumOfTwo(N):

    M = reverseBin(N)

    return max(N, M)

# Driver Code
if __name__ == '__main__':

    N = 6
    print(maximumOfTwo(N))

# This code is contributed by SURENDRA_GANGWAR

C#

// C# program for the above approach
using System;

class GFG{
static string ReverseString(string s)
    {
        char[] array = s.ToCharArray();
        Array.Reverse(array);
        return new string(array);
    }

// Function that obtains the number
// using said operations from N
public static int reverseBin(int N)
{

    // Stores the binary representation
    // of the number N
    string S = "";
    int i;

    // Find the binary representation
    // of the number N
    for (i = 0; i < 32; i++) {

        // Check for the set bits
        if ((N & (1L << i)) != 0)
            S += '1';
        else
            S += '0';
    }

    // Reverse the string S
    S = ReverseString(S);


    // Stores the obtained number
    int M = 0;

    // Calculating the decimal value
    for (i = 0; i < 32; i++) {

        // Check for set bits
        if (S[i] == '1')
            M +=  (1 << i);
    }
    return M;
}

// Function to find the maximum value
// between N and the obtained number
static int maximumOfTwo(int N)
{
    int M = reverseBin(N);

    return Math.Max(N, M);
}

// Driver Code
static void Main()
{
    int N = 6;
    Console.Write(maximumOfTwo(N));

}
}

// This code is contributed by SoumikMondal

Javascript

<script>

// JavaScript program for the above approach

// Function that obtains the number
// using said operations from N
function reverseBin(N)
{
    // Stores the binary representation
    // of the number N
    let S = "";
    let i;

    // Find the binary representation
    // of the number N
    for (i = 0; i < 32; i++) {

        // Check for the set bits
        if (N & (1 << i))
            S += '1';
        else
            S += '0';
    }

    // Reverse the string S
    S = S.split("").reverse().join("");

    // Stores the obtained number
    let M = 0;

    // Calculating the decimal value
    for (i = 0; i < 32; i++) {

        // Check for set bits
        if (S[i] == '1')
            M += (1 << i);
    }
    return M;
}

// Function to find the maximum value
// between N and the obtained number
function maximumOfTwo(N)
{
    let M = reverseBin(N);

    return Math.max(N, M);
}

// Driver Code
    let N = 6;
    document.write(maximumOfTwo(N));

</script>

Output:

1610612736

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