Given a number N, the task is to find the maximum distance between two 1’s in the binary representation of given N. Print -1 if binary representation contains less than two 1’s.
Examples:
Input: N = 131 Output: 7 131 in binary = 10000011. The maximum distance between two 1's = 7. Input: N = 8 Output: -1 8 in binary = 01000. It contains less than two 1's.
Approach:
- First find the binary representation of N.
- For each bit calculated, check if its a ‘1’.
- Store the index of first ‘1’ found in first_1, and the last ‘1’ found in last_1
- Then check if the last_1 is less than or equal to first_1. It will be the case when N is a power of 2. Hence print -1 in this case.
- In any other case, find the difference between the last_1 and first_1. This will be the required distance.
Below is the implementation of the above approach:
C++
// C++ program to find the // Maximum distance between two 1's // in Binary representation of N #include <bits/stdc++.h> using namespace std;
int longest_gap( int N)
{ int distance = 0, count = 0,
first_1 = -1, last_1 = -1;
// Compute the binary representation
while (N) {
count++;
int r = N & 1;
if (r == 1) {
first_1 = first_1 == -1
? count
: first_1;
last_1 = count;
}
N = N / 2;
}
// if N is a power of 2
// then return -1
if (last_1 <= first_1) {
return -1;
}
// else find the distance
// between the first position of 1
// and last position of 1
else {
distance = (last_1 - first_1);
return distance;
}
} // Driver code int main()
{ int N = 131;
cout << longest_gap(N) << endl;
N = 8;
cout << longest_gap(N) << endl;
N = 17;
cout << longest_gap(N) << endl;
N = 33;
cout << longest_gap(N) << endl;
return 0;
} |
Java
// Java program to find the // Maximum distance between two 1's // in Binary representation of N class GFG
{ static int longest_gap( int N)
{
int distance = 0 , count = 0 ,
first_1 = - 1 , last_1 = - 1 ;
// Compute the binary representation
while (N != 0 )
{
count++;
int r = N & 1 ;
if (r == 1 )
{
first_1 = first_1 == - 1 ?
count : first_1;
last_1 = count;
}
N = N / 2 ;
}
// if N is a power of 2
// then return -1
if (last_1 <= first_1)
{
return - 1 ;
}
// else find the distance
// between the first position of 1
// and last position of 1
else
{
distance = (last_1 - first_1);
return distance;
}
}
// Driver code
public static void main (String[] args)
{
int N = 131 ;
System.out.println(longest_gap(N));
N = 8 ;
System.out.println(longest_gap(N));
N = 17 ;
System.out.println(longest_gap(N));
N = 33 ;
System.out.println(longest_gap(N));
}
} // This code is contributed by AnkitRai01 |
Python3
# Python3 program to find the # Maximum distance between two 1's # in Binary representation of N def longest_gap(N):
distance = 0
count = 0
first_1 = - 1
last_1 = - 1
# Compute the binary representation
while (N > 0 ):
count + = 1
r = N & 1
if (r = = 1 ):
if first_1 = = - 1 :
first_1 = count
else :
first_1 = first_1
last_1 = count
N = N / / 2
# if N is a power of 2
# then return -1
if (last_1 < = first_1):
return - 1
# else find the distance
# between the first position of 1
# and last position of 1
else :
distance = last_1 - first_1
return distance
# Driver code N = 131
print (longest_gap(N))
N = 8
print (longest_gap(N))
N = 17
print (longest_gap(N))
N = 33
print (longest_gap(N))
# This code is contributed by Mohit Kumar |
C#
// C# program to find the // Maximum distance between two 1's // in Binary representation of N using System;
class GFG
{ static int longest_gap( int N)
{
int distance = 0, count = 0,
first_1 = -1, last_1 = -1;
// Compute the binary representation
while (N != 0)
{
count++;
int r = N & 1;
if (r == 1)
{
first_1 = first_1 == -1 ?
count : first_1;
last_1 = count;
}
N = N / 2;
}
// if N is a power of 2
// then return -1
if (last_1 <= first_1)
{
return -1;
}
// else find the distance
// between the first position of 1
// and last position of 1
else
{
distance = (last_1 - first_1);
return distance;
}
}
// Driver code
public static void Main (String []args)
{
int N = 131;
Console.WriteLine(longest_gap(N));
N = 8;
Console.WriteLine(longest_gap(N));
N = 17;
Console.WriteLine(longest_gap(N));
N = 33;
Console.WriteLine(longest_gap(N));
}
} // This code is contributed by Arnab Kundu |
Javascript
<script> // Javascript program to find the // Maximum distance between two 1's // in Binary representation of N function longest_gap(N)
{ let distance = 0, count = 0,
first_1 = -1, last_1 = -1;
// Compute the binary representation
while (N) {
count++;
let r = N & 1;
if (r == 1) {
first_1 = first_1 == -1
? count
: first_1;
last_1 = count;
}
N = parseInt(N / 2);
}
// if N is a power of 2
// then return -1
if (last_1 <= first_1) {
return -1;
}
// else find the distance
// between the first position of 1
// and last position of 1
else {
distance = (last_1 - first_1);
return distance;
}
} // Driver code let N = 131;
document.write(longest_gap(N) + "<br>" );
N = 8;
document.write(longest_gap(N) + "<br>" );
N = 17;
document.write(longest_gap(N) + "<br>" );
N = 33;
document.write(longest_gap(N) + "<br>" );
</script> |
Output
7 -1 4 5
Time Complexity: O(log N)
Auxiliary Space: O(1)