Binary Gap

Binary Gap - Problem

Bit Manipulation Easy

Given a positive integer n, find and return the longest distance between any two adjacent 1's in the binary representation of n.

If there are no two adjacent 1's, return 0.

Two 1's are adjacent if there are only 0's separating them (possibly no 0's). The distance between two 1's is the absolute difference between their bit positions.

For example, the two 1's in "1001" have a distance of 3.

Input & Output

Example 1 — Basic Gap

$ Input: n = 22

› Output: 1

💡 Note: 22 in binary is 10110. The gaps between consecutive 1's are: between positions 0 and 2 (gap = 1), between positions 2 and 3 (gap = 0). Maximum gap is 1.

Example 2 — No Gap

$ Input: n = 6

› Output: 0

💡 Note: 6 in binary is 110. The gap between consecutive 1's at positions 0 and 1 is 0. Maximum gap is 0.

Example 3 — Power of 2

$ Input: n = 8

› Output: 0

💡 Note: 8 in binary is 1000. There's only one 1, so no adjacent 1's exist. Return 0.

Constraints

1 ≤ n ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 A Apple 5

The key insight is to find consecutive 1's in the binary representation and measure gaps between them. Best approach uses bit manipulation to process bits directly without string conversion. Time: O(log n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Bit Manipulation with Single Pass	O(log n)	O(1)	Use bit operations to find gaps without string conversion
Convert to String and Find Gaps	O(log n)	O(log n)	Convert number to binary string and find all gaps between 1's

Bit Manipulation with Single Pass — Algorithm Steps

Initialize variables to track last 1 position and max gap
Process each bit from right to left using bit shifting
When a 1 bit is found, calculate gap from previous 1
Update maximum gap and continue until all bits processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Check LSB

Use n & 1 to check if current bit is 1

Track Positions

Record position when 1 bit is found

Right Shift

Use n >>= 1 to move to next bit

Code -

solution.c — C

#include <stdio.h>

int solution(int n) {
    if (n == 0) {
        return 0;
    }
    
    int maxGap = 0;
    int lastOnePos = -1;
    int currentPos = 0;
    
    while (n > 0) {
        if (n & 1) {  // Found a 1 bit
            if (lastOnePos != -1) {
                int gap = currentPos - lastOnePos - 1;
                if (gap > maxGap) {
                    maxGap = gap;
                }
            }
            lastOnePos = currentPos;
        }
        
        n >>= 1;  // Right shift to process next bit
        currentPos++;
    }
    
    return maxGap;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int result = solution(n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We process each bit of the number once, which is O(log n) bits

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables, no extra data structures needed

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bit Manipulation with Single Pass — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler