#   # 1680. Concatenation of Consecutive Binary Numbers

## Bit manipulation, mathematics and recursion

### Problem statement

Given an integer `n`, return the decimal value of the binary string formed by concatenating the binary representations of `1` to `n` in order, modulo `10^9 + 7`.

#### Example 1

``````Input: n = 1
Output: 1
Explanation: "1" in binary corresponds to the decimal value 1.
``````

#### Example 2

``````Input: n = 3
Output: 27
Explanation: In binary, 1, 2, and 3 corresponds to "1", "10", and "11".
After concatenating them, we have "11011", which corresponds to the decimal value 27.
``````

#### Example 3

``````Input: n = 12
Output: 505379714
Explanation: The concatenation results in "1101110010111011110001001101010111100".
The decimal value of that is 118505380540.
After modulo 10^9 + 7, the result is 505379714.
``````

#### Constraints

• `1 <= n <= 10^5`.

### Solution: Recursive

There must be some relationship between the result of `n` and the result of `n - 1`.

First, let us list some first values of `n`.

• For `n = 1`: the final binary string is `"1"`, its decimal value is `1`.

• For `n = 2`: the final binary string is `"110"`, its decimal value is `6`.

• For `n = 3`: the final binary string is `"11011"`, its decimal value is `27`.

Look at `n = 3`, you can see the relationship between the decimal value of `"11011"` and the one of `"110"` (of `n = 2`) is:

``````27 = 6 * 2^2 + 3
Dec("11011") = Dec("110") * 2^num_bits("11") + Dec("11")
Result(3) = Result(2) * 2^num_bits(3) + 3.
``````

The same equation for `n = 2`:

``````6 = 1 * 2^2 + 2
Dec("110") = Dec("1") * 2^num_bits("10") + Dec("10")
Result(2) = Result(1) * 2^num_bits(2) + 2.
``````

In general, the recursive relationship between `n` and `n - 1` is:

``````Result(n) = Result(n - 1) * 2^num_bits(n) + n.
``````

#### Code

``````#include <cmath>
#include <iostream>
int concatenatedBinary(int n) {
unsigned long long result = 1;
for (int i = 2; i <= n; i++) {
const int num_bits = std::log2(i) + 1;
result = ((result << num_bits) + i) % 1000000007;
}
return result;
}
int main() {
std::cout << concatenatedBinary(1) << std::endl;
std::cout << concatenatedBinary(3) << std::endl;
std::cout << concatenatedBinary(12) << std::endl;
}
``````
``````Output:
1
27
505379714
``````

#### Complexity

• Runtime: `O(n)`.

• Extra space: `O(1)`.

### References

Thanks for reading. Feel free to share your thought about my content and check out my FREE book “10 Classic Coding Challenges”.