Maximum distance between two 1's in Binary representation of N

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 <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# 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

Time Complexity: O(log N)

Auxiliary Space: O(1)

Maximum distance between two 1's in Binary representation of N

shivanshukumarsingh1

Improve

Article Tags :

Practice Tags :

Maximum distance between two 1's in Binary representation of N

Similar Reads

Thank You!

What kind of Experience do you want to share?