feat: add solutions for lc No.1680 (#5049)

Author: yanglbme

solution/1600-1699/1680.Concatenation of Consecutive Binary Numbers/README.md

@@ -64,7 +64,7 @@ tags:
 
 ### 方法一：位运算
 
-观察数字的连接规律，我们可以发现，当连接到第 $i$ 个数时，实际上是将前 $i-1$ 个数连接而成的结果 $ans$ 往左移动一定的位数，然后再加上 $i$ 这个数，移动的位数 $shift$ 是 $i$ 中二进制的位数。由于 $i$ 在不断加 $1$，移动的位数要么与上一次移动的位数保持不变，要么加一。当 $i$ 为 $2$ 的幂次方的时候，也即是说 $i$ 的二进制数中只有一位是 $1$ 时，移动的位数相比于上次加 $1$。
+观察数字的连接规律，我们可以发现，当连接到第 $i$ 个数时，实际上是将前 $i-1$ 个数连接而成的结果 $ans$ 往左移动一定的位数，然后再加上 $i$ 这个数，移动的位数是 $i$ 中二进制的位数。
 
 时间复杂度 $O(n)$，其中 $n$ 为给定的整数。空间复杂度 $O(1)$。
 
@@ -104,7 +104,7 @@ class Solution {
 public:
     int concatenatedBinary(int n) {
         const int mod = 1e9 + 7;
-        long ans = 0;
+        long long ans = 0;
         for (int i = 1; i <= n; ++i) {
             ans = (ans << (32 - __builtin_clz(i)) | i) % mod;
         }
@@ -129,16 +129,28 @@ func concatenatedBinary(n int) (ans int) {
 
 ```ts
 function concatenatedBinary(n: number): number {
-    const mod = BigInt(10 ** 9 + 7);
-    let ans = 0n;
-    let shift = 0n;
-    for (let i = 1n; i <= n; ++i) {
-        if ((i & (i - 1n)) == 0n) {
-            ++shift;
+    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;
+}
+```
+
+#### Rust
+
+```rust
+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 = ((ans << shift) | i) % mod;
+        ans as i32
     }
-    return Number(ans);
 }
 ```
 
@@ -148,7 +160,11 @@ function concatenatedBinary(n: number): number {
 
 <!-- solution:start -->
 
-### 方法二
+### 方法二：位运算（优化）
+
+在方法一中，我们每次都需要计算 $i$ 的二进制位数，这样会增加一些额外的计算。我们可以通过一个变量 $\textit{shift}$ 来记录当前需要移动的位数，当 $i$ 是 $2$ 的幂时，$\textit{shift}$ 需要增加 $1$。
+
+时间复杂度 $O(n)$，其中 $n$ 为给定的整数。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -221,6 +237,42 @@ func concatenatedBinary(n int) (ans int) {
 }
 ```
 
+#### TypeScript
+
+```ts
+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;
+}
+```
+
+#### Rust
+
+```rust
+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
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1600-1699/1680.Concatenation of Consecutive Binary Numbers/README_EN.md

@@ -28,7 +28,7 @@ tags:
 <pre>
 <strong>Input:</strong> n = 1
 <strong>Output:</strong> 1
-<strong>Explanation: </strong>&quot;1&quot; in binary corresponds to the decimal value 1. 
+<strong>Explanation: </strong>&quot;1&quot; in binary corresponds to the decimal value 1.
 </pre>
 
 <p><strong class="example">Example 2:</strong></p>
@@ -65,7 +65,7 @@ After modulo 10<sup>9</sup> + 7, the result is 505379714.
 
 ### Solution 1: Bit Manipulation
 
-By observing the pattern of number concatenation, we can find that when concatenating to the $i$-th number, the result $ans$ formed by concatenating the previous $i-1$ numbers is actually shifted to the left by a certain number of bits, and then $i$ is added. The number of bits shifted, $shift$, is the number of binary digits in $i$. Since $i$ is continuously incremented by $1$, the number of bits shifted either remains the same as the last shift or increases by one. When $i$ is a power of $2$, that is, when there is only one bit in the binary number of $i$ that is $1$, the number of bits shifted increases by $1$ compared to the last time.
+By observing the pattern of number concatenation, we can find that when concatenating to the $i$-th number, the result $ans$ formed by concatenating the previous $i-1$ numbers is actually shifted to the left by a certain number of bits, and then $i$ is added. The number of bits shifted is the number of binary digits in $i$.
 
 The time complexity is $O(n)$, where $n$ is the given integer. The space complexity is $O(1)$.
 
@@ -105,7 +105,7 @@ class Solution {
 public:
     int concatenatedBinary(int n) {
         const int mod = 1e9 + 7;
-        long ans = 0;
+        long long ans = 0;
         for (int i = 1; i <= n; ++i) {
             ans = (ans << (32 - __builtin_clz(i)) | i) % mod;
         }
@@ -130,16 +130,28 @@ func concatenatedBinary(n int) (ans int) {
 
 ```ts
 function concatenatedBinary(n: number): number {
-    const mod = BigInt(10 ** 9 + 7);
-    let ans = 0n;
-    let shift = 0n;
-    for (let i = 1n; i <= n; ++i) {
-        if ((i & (i - 1n)) == 0n) {
-            ++shift;
+    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;
+}
+```
+
+#### Rust
+
+```rust
+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 = ((ans << shift) | i) % mod;
+        ans as i32
     }
-    return Number(ans);
 }
 ```
 
@@ -149,7 +161,11 @@ function concatenatedBinary(n: number): number {
 
 <!-- solution:start -->
 
-### Solution 2
+### Solution 2: Bit Manipulation (Optimization)
+
+In Solution 1, we need to calculate the number of binary digits of $i$ each time, which adds some extra computation. We can use a variable $\textit{shift}$ to record the current number of bits to shift. When $i$ is a power of $2$, $\textit{shift}$ needs to be incremented by $1$.
+
+The time complexity is $O(n)$, where $n$ is the given integer. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -222,6 +238,42 @@ func concatenatedBinary(n int) (ans int) {
 }
 ```
 
+#### TypeScript
+
+```ts
+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;
+}
+```
+
+#### Rust
+
+```rust
+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
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1600-1699/1680.Concatenation of Consecutive Binary Numbers/Solution.cpp

@@ -2,10 +2,10 @@ class Solution {
 public:
     int concatenatedBinary(int n) {
         const int mod = 1e9 + 7;
-        long ans = 0;
+        long long ans = 0;
         for (int i = 1; i <= n; ++i) {
             ans = (ans << (32 - __builtin_clz(i)) | i) % mod;
         }
         return ans;
     }
-};
+};

solution/1600-1699/1680.Concatenation of Consecutive Binary Numbers/Solution.rs

@@ -0,0 +1,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
+    }
+}

solution/1600-1699/1680.Concatenation of Consecutive Binary Numbers/Solution.ts

@@ -1,12 +1,8 @@
 function concatenatedBinary(n: number): number {
-    const mod = BigInt(10 ** 9 + 7);
-    let ans = 0n;
-    let shift = 0n;
-    for (let i = 1n; i <= n; ++i) {
-        if ((i & (i - 1n)) == 0n) {
-            ++shift;
-        }
-        ans = ((ans << shift) | i) % mod;
+    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 Number(ans);
+    return ans;
 }

solution/1600-1699/1680.Concatenation of Consecutive Binary Numbers/Solution2.rs

@@ -0,0 +1,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
+    }
+}

solution/1600-1699/1680.Concatenation of Consecutive Binary Numbers/Solution2.ts

@@ -0,0 +1,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;
+}