跳转至

1680. 连接连续二进制数字

题目描述

给你一个整数 n ，请你将 1 到 n 的二进制表示连接起来，并返回连接结果对应的 十进制 数字对 109 + 7 取余的结果。

 

示例 1：

输入：n = 1
输出：1
解释：二进制的 "1" 对应着十进制的 1 。

示例 2：

输入：n = 3
输出：27
解释：二进制下，1，2 和 3 分别对应 "1" ，"10" 和 "11" 。
将它们依次连接，我们得到 "11011" ，对应着十进制的 27 。

示例 3：

输入：n = 12
输出：505379714
解释：连接结果为 "1101110010111011110001001101010111100" 。
对应的十进制数字为 118505380540 。
对 109 + 7 取余后，结果为 505379714 。

 

提示：

  • 1 <= n <= 105

解法

方法一：位运算

观察数字的连接规律，我们可以发现，当连接到第 \(i\) 个数时，实际上是将前 \(i-1\) 个数连接而成的结果 \(ans\) 往左移动一定的位数，然后再加上 \(i\) 这个数，移动的位数是 \(i\) 中二进制的位数。

时间复杂度 \(O(n)\)，其中 \(n\) 为给定的整数。空间复杂度 \(O(1)\)。

1
2
3
4
5
6
7
class Solution:
    def concatenatedBinary(self, n: int) -> int:
        mod = 10**9 + 7
        ans = 0
        for i in range(1, n + 1):
            ans = (ans << i.bit_length() | i) % mod
        return ans

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Solution {
    public int concatenatedBinary(int n) {
        final int mod = (int) 1e9 + 7;
        long ans = 0;
        for (int i = 1; i <= n; ++i) {
            ans = (ans << (32 - Integer.numberOfLeadingZeros(i)) | i) % mod;
        }
        return (int) ans;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Solution {
public:
    int concatenatedBinary(int n) {
        const int mod = 1e9 + 7;
        long long ans = 0;
        for (int i = 1; i <= n; ++i) {
            ans = (ans << (32 - __builtin_clz(i)) | i) % mod;
        }
        return ans;
    }
};

1
2
3
4
5
6
7
func concatenatedBinary(n int) (ans int) {
    const mod = 1e9 + 7
    for i := 1; i <= n; i++ {
        ans = (ans<<bits.Len(uint(i)) | i) % mod
    }
    return
}

1
2
3
4
5
6
7
8
function concatenatedBinary(n: number): number {
    const mod = 1_000_000_007;
    let ans = 0;
    for (let i = 1; i <= n; i++) {
        ans = (((ans * (1 << (32 - Math.clz32(i)))) % mod) + i) % mod;
    }
    return ans;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
impl Solution {
    pub fn concatenated_binary(n: i32) -> i32 {
        let mod_: i64 = 1_000_000_007;
        let mut ans: i64 = 0;
        for i in 1..=n as i64 {
            let bit_length: u32 = 64 - i.leading_zeros() as u32;
            ans = ((ans << bit_length) | i) % mod_;
        }
        ans as i32
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
/**
 * @param {number} n
 * @return {number}
 */
var concatenatedBinary = function (n) {
    const mod = 1_000_000_007;
    let ans = 0;
    for (let i = 1; i <= n; i++) {
        ans = (((ans * (1 << (32 - Math.clz32(i)))) % mod) + i) % mod;
    }
    return ans;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
public class Solution {
    public int ConcatenatedBinary(int n) {
        const int mod = 1000000007;
        long ans = 0;
        for (int i = 1; i <= n; ++i) {
            int bitLength = 32 - System.Numerics.BitOperations.LeadingZeroCount((uint)i);
            ans = ((ans << bitLength) | i) % mod;
        }
        return (int)ans;
    }
}

方法二：位运算（优化）

在方法一中，我们每次都需要计算 \(i\) 的二进制位数，这样会增加一些额外的计算。我们可以通过一个变量 \(\textit{shift}\) 来记录当前需要移动的位数，当 \(i\) 是 \(2\) 的幂时，\(\textit{shift}\) 需要增加 \(1\)。

时间复杂度 \(O(n)\)，其中 \(n\) 为给定的整数。空间复杂度 \(O(1)\)。

1
2
3
4
5
6
7
8
9
class Solution:
    def concatenatedBinary(self, n: int) -> int:
        mod = 10**9 + 7
        ans = shift = 0
        for i in range(1, n + 1):
            if (i & (i - 1)) == 0:
                shift += 1
            ans = (ans << shift | i) % mod
        return ans

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Solution {
    public int concatenatedBinary(int n) {
        final int mod = (int) 1e9 + 7;
        long ans = 0;
        int shift = 0;
        for (int i = 1; i <= n; ++i) {
            if ((i & (i - 1)) == 0) {
                ++shift;
            }
            ans = (ans << shift | i) % mod;
        }
        return (int) ans;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
class Solution {
public:
    int concatenatedBinary(int n) {
        const int mod = 1e9 + 7;
        long ans = 0;
        int shift = 0;
        for (int i = 1; i <= n; ++i) {
            if ((i & (i - 1)) == 0) {
                ++shift;
            }
            ans = (ans << shift | i) % mod;
        }
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
func concatenatedBinary(n int) (ans int) {
    const mod = 1e9 + 7
    shift := 0
    for i := 1; i <= n; i++ {
        if i&(i-1) == 0 {
            shift++
        }
        ans = (ans<<shift | i) % mod
    }
    return
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
function concatenatedBinary(n: number): number {
    const mod = 1_000_000_007;
    let ans = 0;
    let shift = 0;
    for (let i = 1; i <= n; i++) {
        if ((i & (i - 1)) === 0) {
            shift++;
        }
        ans = (((ans * (1 << shift)) % mod) + i) % mod;
    }
    return ans;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
impl Solution {
    pub fn concatenated_binary(n: i32) -> i32 {
        let mod_: i64 = 1_000_000_007;
        let mut ans: i64 = 0;
        let mut shift: u32 = 0;
        for i in 1..=n as i64 {
            if (i & (i - 1)) == 0 {
                shift += 1;
            }
            ans = ((ans << shift) | i) % mod_;
        }
        ans as i32
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
/**
 * @param {number} n
 * @return {number}
 */
var concatenatedBinary = function (n) {
    const mod = 1_000_000_007;
    let ans = 0;
    let shift = 0;
    for (let i = 1; i <= n; i++) {
        if ((i & (i - 1)) === 0) {
            shift++;
        }
        ans = (((ans * (1 << shift)) % mod) + i) % mod;
    }
    return ans;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public class Solution {
    public int ConcatenatedBinary(int n) {
        const int mod = 1000000007;
        long ans = 0;
        int shift = 0;
        for (int i = 1; i <= n; ++i) {
            if ((i & (i - 1)) == 0) {
                ++shift;
            }
            ans = ((ans << shift) | i) % mod;
        }
        return (int)ans;
    }
}

评论