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)2 = (6)10.
Reversing this binary string gives (01100000000000000000000000000000)2 = (1610612736)10.
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++ 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 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 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# 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 |
<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> |
1610612736
Time Complexity: O(32)
Auxiliary Space: O(1)