Non-negative Integers without Consecutive Ones

Non-negative Integers without Consecutive Ones - Problem

Dynamic Programming Hard

Given a positive integer n, you need to count how many integers in the range [0, n] have binary representations without consecutive ones.

In binary representation, consecutive ones mean two or more 1s appearing next to each other. For example:

5 (101₂) ✅ Valid - no consecutive ones
6 (110₂) ❌ Invalid - has consecutive ones
3 (11₂) ❌ Invalid - has consecutive ones

Your task is to efficiently count all valid numbers from 0 to n inclusive that satisfy this constraint.

Challenge: Can you solve this without checking every single number individually?

Input & Output

example_1.py — Basic Case

$ Input: n = 5

› Output: 5

💡 Note: The valid numbers are: 0 (0₂), 1 (1₂), 2 (10₂), 4 (100₂), 5 (101₂). Number 3 (11₂) and 6 (110₂) have consecutive ones, but 6 > 5 anyway.

example_2.py — Larger Number

$ Input: n = 8

› Output: 6

💡 Note: Valid numbers: 0 (0₂), 1 (1₂), 2 (10₂), 4 (100₂), 5 (101₂), 8 (1000₂). Numbers 3, 6, 7 have consecutive 1s in binary.

example_3.py — Edge Case

$ Input: n = 1

› Output: 2

💡 Note: Valid numbers are 0 (0₂) and 1 (1₂). Both have no consecutive ones since they're single bits.

Constraints

1 ≤ n ≤ 10⁹
n is a positive integer
Binary representation constraint: No consecutive 1s allowed

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses Dynamic Programming with Digit DP technique. Key insights: valid binary strings without consecutive 1s follow Fibonacci patterns, and we can use digit DP to handle the upper bound constraint efficiently in O(log n) time.

Common Approaches

✓ Brute Force (Check Every Number)

⏱️ Time: O(n log n) Space: O(log n)

For each number from 0 to n, convert it to binary representation and scan through the bits to detect any consecutive ones. Count all numbers that don't have consecutive ones.

Dynamic Programming (Optimal)

⏱️ Time: O(log n) Space: O(log n)

This problem combines digit DP (dynamic programming) with the observation that valid binary strings without consecutive 1s follow Fibonacci patterns. We build the count by considering each bit position and whether we can place a 1 or 0 based on the previous bit and the constraint that we cannot exceed n.

Brute Force (Check Every Number) — Algorithm Steps

Iterate through each number from 0 to n
Convert current number to binary representation
Scan binary string for consecutive 1s
If no consecutive 1s found, increment counter
Return final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Binary

Convert each number from 0 to n into binary representation

Scan for Consecutive 1s

Check each binary string for adjacent 1s

Count Valid Numbers

Increment counter for numbers without consecutive 1s

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

int findIntegers(int n) {
    int count = 0;
    for (int i = 0; i <= n; i++) {
        char binary[32] = {0};
        int temp = i, pos = 0;
        if (temp == 0) {
            strcpy(binary, "0");
        } else {
            while (temp > 0) {
                binary[pos++] = (temp % 2) + '0';
                temp /= 2;
            }
            // Reverse the string
            for (int j = 0; j < pos / 2; j++) {
                char swap = binary[j];
                binary[j] = binary[pos - 1 - j];
                binary[pos - 1 - j] = swap;
            }
        }
        
        int hasConsecutive = 0;
        int len = strlen(binary);
        for (int j = 0; j < len - 1; j++) {
            if (binary[j] == '1' && binary[j + 1] == '1') {
                hasConsecutive = 1;
                break;
            }
        }
        if (!hasConsecutive) {
            count++;
        }
    }
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

We check n numbers, each taking O(log n) time for binary conversion and scanning

⚡ Linearithmic

Space Complexity

O(log n)

Space needed to store binary representation of each number

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~35 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

Brute Force (Check Every Number) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler