feat: add solutions for lc No.1404 (#5051)

Author: yanglbme

README.md

@@ -52,7 +52,6 @@
 - [乘积小于 K 的子数组](/solution/0700-0799/0713.Subarray%20Product%20Less%20Than%20K/README.md) - `双指针`
 - [位 1 的个数](/solution/0100-0199/0191.Number%20of%201%20Bits/README.md) - `位运算`、`lowbit`
 - [合并区间](/solution/0000-0099/0056.Merge%20Intervals/README.md) - `区间合并`
-    <!-- 排序算法、待补充 -->
 
 ### 2. 数据结构
 

solution/1400-1499/1404.Number of Steps to Reduce a Number in Binary Representation to One/README.md

@@ -44,9 +44,9 @@ tags:
 Step 1) 13 是奇数，加 1 得到 14 
 Step 2) 14 是偶数，除 2 得到 7
 Step 3) 7  是奇数，加 1 得到 8
-Step 4) 8  是偶数，除 2 得到 4  
+Step 4) 8  是偶数，除 2 得到 4 
 Step 5) 4  是偶数，除 2 得到 2 
-Step 6) 2  是偶数，除 2 得到 1  
+Step 6) 2  是偶数，除 2 得到 1 
 </pre>
 
 <p><strong>示例 2：</strong></p>
@@ -55,7 +55,7 @@ Step 6) 2  是偶数，除 2 得到 1&nbsp;
 <strong>输入：</strong>s = "10"
 <strong>输出：</strong>1
 <strong>解释：</strong>"10" 表示十进制数 2 。
-Step 1) 2 是偶数，除 2 得到 1 
+Step 1) 2 是偶数，除 2 得到 1
 </pre>
 
 <p><strong>示例 3：</strong></p>
@@ -81,9 +81,17 @@ Step 1) 2 是偶数，除 2 得到 1
 
 <!-- solution:start -->
 
-### 方法一：模拟操作
+### 方法一：模拟
 
-我们模拟操作 $1$ 和 $2$，同时用 carry 记录进位。
+我们模拟操作 $1$ 和 $2$，同时维护一个进位 $\textit{carry}$ 来表示当前是否有进位，初始时 $\textit{carry} = \text{false}$。
+
+我们从字符串 $s$ 的末尾开始向前遍历：
+
+- 如果 $\textit{carry}$ 为 $\text{true}$，则当前位 $c$ 需要加 $1$，如果 $c$ 是 $0$，则加 $1$ 后变为 $1$，同时 $\textit{carry}$ 变为 $\text{false}$；如果 $c$ 是 $1$，则加 $1$ 后变为 $0$，同时 $\textit{carry}$ 保持为 $\text{true}$。
+- 如果 $c$ 是 $1$，则需要执行操作 $1$，即加 $1$，同时 $\textit{carry}$ 变为 $\text{true}$。
+- 此时 $c$ 是 $0$，则需要执行操作 $2$，即除以 $2$。
+
+当遍历结束后，如果 $\textit{carry}$ 仍然为 $\text{true}$，则需要再执行一次操作 $1$。
 
 时间复杂度 $O(n)$，其中 $n$ 是字符串 $s$ 的长度。空间复杂度 $O(1)$。
 
@@ -201,6 +209,79 @@ func numSteps(s string) int {
 }
 ```
 
+#### TypeScript
+
+```ts
+function numSteps(s: string): number {
+    let ans = 0;
+    let carry = false;
+
+    for (let i = s.length - 1; i > 0; i--) {
+        let c = s[i];
+
+        if (carry) {
+            if (c === '0') {
+                c = '1';
+                carry = false;
+            } else {
+                c = '0';
+            }
+        }
+
+        if (c === '1') {
+            ans++;
+            carry = true;
+        }
+
+        ans++;
+    }
+
+    if (carry) {
+        ans++;
+    }
+
+    return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn num_steps(s: String) -> i32 {
+        let bytes = s.as_bytes();
+        let mut ans: i32 = 0;
+        let mut carry = false;
+
+        for i in (1..bytes.len()).rev() {
+            let mut c = bytes[i];
+
+            if carry {
+                if c == b'0' {
+                    c = b'1';
+                    carry = false;
+                } else {
+                    c = b'0';
+                }
+            }
+
+            if c == b'1' {
+                ans += 1;
+                carry = true;
+            }
+
+            ans += 1;
+        }
+
+        if carry {
+            ans += 1;
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1400-1499/1404.Number of Steps to Reduce a Number in Binary Representation to One/README_EN.md

@@ -43,9 +43,9 @@ tags:
 Step 1) 13 is odd, add 1 and obtain 14. 
 Step 2) 14 is even, divide by 2 and obtain 7.
 Step 3) 7 is odd, add 1 and obtain 8.
-Step 4) 8 is even, divide by 2 and obtain 4.  
+Step 4) 8 is even, divide by 2 and obtain 4. 
 Step 5) 4 is even, divide by 2 and obtain 2. 
-Step 6) 2 is even, divide by 2 and obtain 1.  
+Step 6) 2 is even, divide by 2 and obtain 1. 
 </pre>
 
 <p><strong class="example">Example 2:</strong></p>
@@ -54,7 +54,7 @@ Step 6) 2 is even, divide by 2 and obtain 1.&nbsp;
 <strong>Input:</strong> s = &quot;10&quot;
 <strong>Output:</strong> 1
 <strong>Explanation:</strong> &quot;10&quot; corresponds to number 2 in their decimal representation.
-Step 1) 2 is even, divide by 2 and obtain 1.&nbsp; 
+Step 1) 2 is even, divide by 2 and obtain 1.&nbsp;
 </pre>
 
 <p><strong class="example">Example 3:</strong></p>
@@ -81,7 +81,15 @@ Step 1) 2 is even, divide by 2 and obtain 1.&nbsp;
 
 ### Solution 1: Simulation
 
-We simulate operations $1$ and $2$, while using `carry` to record the carry-over.
+We simulate operations $1$ and $2$, while maintaining a carry $\textit{carry}$ to indicate whether there is a current carry. Initially, $\textit{carry} = \text{false}$.
+
+We traverse the string $s$ from the end toward the beginning:
+
+- If $\textit{carry}$ is $\text{true}$, the current bit $c$ needs to be incremented by $1$. If $c$ is $0$, it becomes $1$ after adding $1$, and $\textit{carry}$ becomes $\text{false}$; if $c$ is $1$, it becomes $0$ after adding $1$, and $\textit{carry}$ remains $\text{true}$.
+- If $c$ is $1$, we need to perform operation $1$, i.e., add $1$, and $\textit{carry}$ becomes $\text{true}$.
+- At this point $c$ is $0$, so we need to perform operation $2$, i.e., divide by $2$.
+
+After the traversal, if $\textit{carry}$ is still $\text{true}$, we need to perform operation $1$ one more time.
 
 The time complexity is $O(n)$, where $n$ is the length of the string $s$. The space complexity is $O(1)$.
 
@@ -199,6 +207,79 @@ func numSteps(s string) int {
 }
 ```
 
+#### TypeScript
+
+```ts
+function numSteps(s: string): number {
+    let ans = 0;
+    let carry = false;
+
+    for (let i = s.length - 1; i > 0; i--) {
+        let c = s[i];
+
+        if (carry) {
+            if (c === '0') {
+                c = '1';
+                carry = false;
+            } else {
+                c = '0';
+            }
+        }
+
+        if (c === '1') {
+            ans++;
+            carry = true;
+        }
+
+        ans++;
+    }
+
+    if (carry) {
+        ans++;
+    }
+
+    return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn num_steps(s: String) -> i32 {
+        let bytes = s.as_bytes();
+        let mut ans: i32 = 0;
+        let mut carry = false;
+
+        for i in (1..bytes.len()).rev() {
+            let mut c = bytes[i];
+
+            if carry {
+                if c == b'0' {
+                    c = b'1';
+                    carry = false;
+                } else {
+                    c = b'0';
+                }
+            }
+
+            if c == b'1' {
+                ans += 1;
+                carry = true;
+            }
+
+            ans += 1;
+        }
+
+        if carry {
+            ans += 1;
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1400-1499/1404.Number of Steps to Reduce a Number in Binary Representation to One/Solution.rs

@@ -0,0 +1,33 @@
+impl Solution {
+    pub fn num_steps(s: String) -> i32 {
+        let bytes = s.as_bytes();
+        let mut ans: i32 = 0;
+        let mut carry = false;
+
+        for i in (1..bytes.len()).rev() {
+            let mut c = bytes[i];
+
+            if carry {
+                if c == b'0' {
+                    c = b'1';
+                    carry = false;
+                } else {
+                    c = b'0';
+                }
+            }
+
+            if c == b'1' {
+                ans += 1;
+                carry = true;
+            }
+
+            ans += 1;
+        }
+
+        if carry {
+            ans += 1;
+        }
+
+        ans
+    }
+}

solution/1400-1499/1404.Number of Steps to Reduce a Number in Binary Representation to One/Solution.ts

@@ -0,0 +1,30 @@
+function numSteps(s: string): number {
+    let ans = 0;
+    let carry = false;
+
+    for (let i = s.length - 1; i > 0; i--) {
+        let c = s[i];
+
+        if (carry) {
+            if (c === '0') {
+                c = '1';
+                carry = false;
+            } else {
+                c = '0';
+            }
+        }
+
+        if (c === '1') {
+            ans++;
+            carry = true;
+        }
+
+        ans++;
+    }
+
+    if (carry) {
+        ans++;
+    }
+
+    return ans;
+}