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

Understanding the Visualization

Pattern Recognition

Valid strings of length n = Valid strings ending in 0 + Valid strings ending in 1

Recurrence Relation

If string ends in 0, previous bit can be 0 or 1. If ends in 1, previous must be 0

Fibonacci Connection

This gives us F(n) = F(n-1) + F(n-2), the Fibonacci recurrence

Key Takeaway

🎯 Key Insight: The problem combines Fibonacci sequence properties with digit DP technique to efficiently count valid numbers without checking each one individually.

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

Approach	Time	Space	Notes
✓ Brute Force (Check Every Number)	O(n log n)	O(log n)	Convert each number to binary and check for consecutive ones
Dynamic Programming (Optimal)	O(log n)	O(log n)	Use digit DP with Fibonacci pattern to count valid numbers efficiently

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