# Maximum distance between two 1’s in Binary representation of N

• Difficulty Level : Medium
• Last Updated : 21 Jan, 2022

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 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 codeint 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 Nclass 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 Ndef 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 codeN = 131print(longest_gap(N)) N = 8print(longest_gap(N)) N = 17print(longest_gap(N)) N = 33print(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 Nusing 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



Output

7
-1
4
5

Time Complexity: O(log N)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up