Binary Number with Alternating Bits - Practice Coding Problems

Binary Number with Alternating Bits - Problem

Bit Manipulation Easy

Given a positive integer, determine if its binary representation contains alternating bits. In other words, check if every two adjacent bits in the binary form have different values (no two consecutive 0s or 1s).

For example:

5 in binary is 101 → alternating ✓
7 in binary is 111 → not alternating ✗
10 in binary is 1010 → alternating ✓

Goal: Return true if the number has alternating bits, false otherwise.

Input & Output

example_1.py — Simple Alternating

$ Input: n = 5

› Output: true

💡 Note: 5 in binary is '101'. Adjacent bits are: 1≠0, 0≠1. All adjacent bits are different, so return true.

example_2.py — Non-Alternating

$ Input: n = 7

› Output: false

💡 Note: 7 in binary is '111'. Adjacent bits are: 1=1, 1=1. Adjacent bits are the same, so return false.

example_3.py — Longer Alternating

$ Input: n = 10

› Output: true

💡 Note: 10 in binary is '1010'. Adjacent bits are: 1≠0, 0≠1, 1≠0. All adjacent bits alternate, so return true.

Constraints

1 ≤ n ≤ 2³¹ - 1
n is a positive integer
Return type is boolean

Visualization

Tap to expand

Understanding the Visualization

Examine the Pattern

Look at the binary representation to see the bit sequence

Apply XOR Magic

XOR the number with its right-shifted version to highlight differences

Check for All 1s

If alternating, the XOR result will be all 1s (111, 1111, etc.)

Verify Power of 2 - 1

Use (xor & (xor + 1)) == 0 to confirm the pattern

Key Takeaway

🎯 Key Insight: XOR operation between a number and its right-shifted version creates all 1s pattern (2^k - 1) if and only if the original bits were alternating. This mathematical property allows O(1) detection!

Asked in

G Google 15 ⊞ Microsoft 12 a Amazon 8 f Meta 6

The optimal solution uses an elegant XOR trick: n ^ (n >> 1) creates a pattern of all 1s when bits alternate. Then check if the result is of the form 2^k - 1 using (xor & (xor + 1)) == 0. This achieves O(1) time complexity with minimal operations.

Common Approaches

Approach	Time	Space	Notes
✓ Bit Manipulation (Check Each Bit)	O(log n)	O(1)	Use bit operations to check each adjacent pair without string conversion
Brute Force (Bit-by-Bit Comparison)	O(log n)	O(log n)	Convert to binary string and compare each adjacent pair of bits
XOR Bit Manipulation (Optimal)	O(1)	O(1)	Use XOR trick to detect alternating pattern in one elegant operation

Bit Manipulation (Check Each Bit) — Algorithm Steps

Start from the least significant bit
Extract current bit using (n & 1)
Right shift n by 1 to get the next bit
Extract next bit using (n & 1)
Compare the two bits - they should be different
Continue until n becomes 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract LSB

Use n & 1 to get the least significant bit

Right Shift

Shift n right by 1 to examine next bit

Compare Bits

Check if current bit differs from previous

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

bool hasAlternatingBits(int n) {
    int prevBit = n & 1;
    n >>= 1;
    
    while (n > 0) {
        int currBit = n & 1;
        if (currBit == prevBit) {
            return false;
        }
        prevBit = currBit;
        n >>= 1;
    }
    
    return true;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%s\n", hasAlternatingBits(n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Need to examine each bit position, total of log n bits

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for bit comparisons

✓ Linear Space

42.3K Views

Medium Frequency

~8 min Avg. Time

1.8K 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 (Check Each Bit) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler