Concatenation of Consecutive Binary Numbers

Concatenation of Consecutive Binary Numbers - Problem

You're given an integer n, and your task is to create a binary concatenation sequence. Here's how it works:

Convert each number from 1 to n into its binary representation
Concatenate all these binary strings together in order
Convert the final concatenated binary string back to decimal
Return the result modulo 10⁹ + 7

Example: For n = 3:

1 in binary: "1"
2 in binary: "10"
3 in binary: "11"
Concatenated: "11011"
Decimal value: 27

The challenge lies in handling large values of n efficiently, as the concatenated binary string can become extremely long. You'll need to use bit manipulation techniques to avoid actually building the string!

Input & Output

example_1.py — Basic Case

$ Input: n = 1

› Output: 1

💡 Note: Only number 1, binary is '1', decimal value is 1

example_2.py — Small Sequence

$ Input: n = 3

› Output: 27

💡 Note: 1→'1', 2→'10', 3→'11'. Concatenated: '11011' = 16+8+2+1 = 27

example_3.py — Larger Case

$ Input: n = 12

› Output: 505379714

💡 Note: Binary sequence: '1101110010110111000100110101111110011011' converted to decimal and taken modulo 10^9+7

Visualization

Tap to expand

Understanding the Visualization

Initialize Chain

Start with empty result = 0

Add Number 1

1 has 1 bit, result becomes 1

Add Number 2

2 has 2 bits, shift result left 2 positions, add 2: result = 6

Add Number 3

3 has 2 bits, shift result left 2 positions, add 3: result = 27

Continue Pattern

Keep shifting and adding for all numbers up to n

Key Takeaway

🎯 Key Insight: Use bit shifting `(result << bits) + number` instead of string concatenation to achieve O(n) time and O(1) space complexity while handling modular arithmetic efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through numbers 1 to n, with O(1) operations per iteration

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for variables

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
Result must be returned modulo 10⁹ + 7
The concatenated binary string can be extremely long

Asked in

f Facebook 45 G Google 35 a Amazon 28 ⊞ Microsoft 22

The optimal approach uses bit manipulation instead of string concatenation. For each number i, we calculate its bit length, shift the current result left by that many positions, and add i. This gives us O(n) time and O(1) space complexity while avoiding expensive string operations.

Common Approaches

Approach	Time	Space	Notes
✓ Bit Manipulation (Optimal)	O(n)	O(1)	Use bit shifting to build the result without creating the actual string

Bit Manipulation (Optimal) — Algorithm Steps

Initialize result = 0 and MOD = 10^9 + 7
For each number i from 1 to n:
Calculate number of bits in i using bit_length() or log2
Shift result left by that many bits: result = (result << bits) % MOD
Add current number: result = (result + i) % MOD
Return final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with result = 0

Initialize empty result

Process i = 1

1 has 1 bit, shift result << 1, add 1: result = 1

Process i = 2

2 has 2 bits, shift result << 2, add 2: result = (1 << 2) + 2 = 6

Process i = 3

3 has 2 bits, shift result << 2, add 3: result = (6 << 2) + 3 = 27

Code -

solution.c — C

#include <stdio.h>
#include <math.h>

#define MOD 1000000007

int getBitLength(int n) {
    if (n == 0) return 1;
    return (int)log2(n) + 1;
}

int concatenatedBinary(int n) {
    long long result = 0;
    
    for (int i = 1; i <= n; i++) {
        // Calculate number of bits in i
        int bits = getBitLength(i);
        // Shift result left by 'bits' positions and add i
        result = ((result << bits) + i) % MOD;
    }
    
    return (int)result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through numbers 1 to n, with O(1) operations per iteration

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for variables

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
Result must be returned modulo 10⁹ + 7
The concatenated binary string can be extremely long

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler