Merge branch 'main' into patch-6

Author: K11E3R

solution/0000-0099/0022.Generate Parentheses/README.md

@@ -256,6 +256,46 @@ class Solution {
 
 <!-- tabs:end -->
 
+<!-- solution:start -->
+
+### 方法二：递归
+
+<!-- tabs:start -->
+
+#### TypeScript
+
+```ts
+function generateParenthesis(n: number): string[] {
+    if (n === 1) return ['()'];
+
+    return [
+        ...new Set(
+            generateParenthesis(n - 1).flatMap(s =>
+                Array.from(s, (_, i) => s.slice(0, i) + '()' + s.slice(i)),
+            ),
+        ),
+    ];
+}
+```
+
+#### JavaScript
+
+```js
+function generateParenthesis(n) {
+    if (n === 1) return ['()'];
+
+    return [
+        ...new Set(
+            generateParenthesis(n - 1).flatMap(s =>
+                Array.from(s, (_, i) => s.slice(0, i) + '()' + s.slice(i)),
+            ),
+        ),
+    ];
+}
+```
+
+<!-- tabs:end -->
+
 <!-- solution:end -->
 
 <!-- problem:end -->

solution/0000-0099/0022.Generate Parentheses/README_EN.md

@@ -148,25 +148,21 @@ func generateParenthesis(n int) (ans []string) {
 #### TypeScript
 
 ```ts
-impl Solution {
-    pub fn generate_parenthesis(n: i32) -> Vec<String> {
-        let mut ans = Vec::new();
-
-        fn dfs(ans: &mut Vec<String>, l: i32, r: i32, t: String, n: i32) {
-            if l > n || r > n || l < r {
-                return;
-            }
-            if l == n && r == n {
-                ans.push(t);
-                return;
-            }
-            dfs(ans, l + 1, r, format!("{}(", t), n);
-            dfs(ans, l, r + 1, format!("{})", t), n);
+function generateParenthesis(n: number): string[] {
+    function dfs(l, r, t) {
+        if (l > n || r > n || l < r) {
+            return;
         }
-
-        dfs(&mut ans, 0, 0, String::new(), n);
-        ans
+        if (l == n && r == n) {
+            ans.push(t);
+            return;
+        }
+        dfs(l + 1, r, t + '(');
+        dfs(l, r + 1, t + ')');
     }
+    let ans = [];
+    dfs(0, 0, '');
+    return ans;
 }
 ```
 
@@ -257,4 +253,46 @@ class Solution {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### Solution 2: Recursion
+
+<!-- tabs:start -->
+
+#### TypeScript
+
+```ts
+function generateParenthesis(n: number): string[] {
+    if (n === 1) return ['()'];
+
+    return [
+        ...new Set(
+            generateParenthesis(n - 1).flatMap(s =>
+                Array.from(s, (_, i) => s.slice(0, i) + '()' + s.slice(i)),
+            ),
+        ),
+    ];
+}
+```
+
+#### JavaScript
+
+```js
+function generateParenthesis(n) {
+    if (n === 1) return ['()'];
+
+    return [
+        ...new Set(
+            generateParenthesis(n - 1).flatMap(s =>
+                Array.from(s, (_, i) => s.slice(0, i) + '()' + s.slice(i)),
+            ),
+        ),
+    ];
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->

solution/0000-0099/0022.Generate Parentheses/Solution2.js

@@ -0,0 +1,11 @@
+function generateParenthesis(n) {
+    if (n === 1) return ['()'];
+
+    return [
+        ...new Set(
+            generateParenthesis(n - 1).flatMap(s =>
+                Array.from(s, (_, i) => s.slice(0, i) + '()' + s.slice(i)),
+            ),
+        ),
+    ];
+}

solution/0000-0099/0022.Generate Parentheses/Solution2.ts

@@ -0,0 +1,11 @@
+function generateParenthesis(n: number): string[] {
+    if (n === 1) return ['()'];
+
+    return [
+        ...new Set(
+            generateParenthesis(n - 1).flatMap(s =>
+                Array.from(s, (_, i) => s.slice(0, i) + '()' + s.slice(i)),
+            ),
+        ),
+    ];
+}

solution/0200-0299/0216.Combination Sum III/README.md

@@ -222,6 +222,32 @@ function combinationSum3(k: number, n: number): number[][] {
 }
 ```
 
+#### JavaScript
+
+```js
+function combinationSum3(k, n) {
+    const ans = [];
+    const t = [];
+    const dfs = (i, s) => {
+        if (s === 0) {
+            if (t.length === k) {
+                ans.push(t.slice());
+            }
+            return;
+        }
+        if (i > 9 || i > s || t.length >= k) {
+            return;
+        }
+        t.push(i);
+        dfs(i + 1, s - i);
+        t.pop();
+        dfs(i + 1, s);
+    };
+    dfs(1, n);
+    return ans;
+}
+```
+
 #### Rust
 
 ```rust
@@ -457,6 +483,33 @@ function combinationSum3(k: number, n: number): number[][] {
 }
 ```
 
+#### JavaScript
+
+```js
+function combinationSum3(k, n) {
+    const ans = [];
+    const t = [];
+    const dfs = (i, s) => {
+        if (s === 0) {
+            if (t.length === k) {
+                ans.push(t.slice());
+            }
+            return;
+        }
+        if (i > 9 || i > s || t.length >= k) {
+            return;
+        }
+        for (let j = i; j <= 9; ++j) {
+            t.push(j);
+            dfs(j + 1, s - j);
+            t.pop();
+        }
+    };
+    dfs(1, n);
+    return ans;
+}
+```
+
 #### C#
 
 ```cs
@@ -635,6 +688,39 @@ function bitCount(i: number): number {
 }
 ```
 
+#### JavaScript
+
+```js
+function combinationSum3(k, n) {
+    const ans = [];
+    for (let mask = 0; mask < 1 << 9; ++mask) {
+        if (bitCount(mask) === k) {
+            const t = [];
+            let s = 0;
+            for (let i = 0; i < 9; ++i) {
+                if (mask & (1 << i)) {
+                    t.push(i + 1);
+                    s += i + 1;
+                }
+            }
+            if (s === n) {
+                ans.push(t);
+            }
+        }
+    }
+    return ans;
+}
+
+function bitCount(i) {
+    i = i - ((i >>> 1) & 0x55555555);
+    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
+    i = (i + (i >>> 4)) & 0x0f0f0f0f;
+    i = i + (i >>> 8);
+    i = i + (i >>> 16);
+    return i & 0x3f;
+}
+```
+
 #### C#
 
 ```cs

solution/0200-0299/0216.Combination Sum III/README_EN.md

@@ -221,6 +221,32 @@ function combinationSum3(k: number, n: number): number[][] {
 }
 ```
 
+#### JavaScript
+
+```js
+function combinationSum3(k, n) {
+    const ans = [];
+    const t = [];
+    const dfs = (i, s) => {
+        if (s === 0) {
+            if (t.length === k) {
+                ans.push(t.slice());
+            }
+            return;
+        }
+        if (i > 9 || i > s || t.length >= k) {
+            return;
+        }
+        t.push(i);
+        dfs(i + 1, s - i);
+        t.pop();
+        dfs(i + 1, s);
+    };
+    dfs(1, n);
+    return ans;
+}
+```
+
 #### Rust
 
 ```rust
@@ -456,6 +482,33 @@ function combinationSum3(k: number, n: number): number[][] {
 }
 ```
 
+#### JavaScript
+
+```js
+function combinationSum3(k, n) {
+    const ans = [];
+    const t = [];
+    const dfs = (i, s) => {
+        if (s === 0) {
+            if (t.length === k) {
+                ans.push(t.slice());
+            }
+            return;
+        }
+        if (i > 9 || i > s || t.length >= k) {
+            return;
+        }
+        for (let j = i; j <= 9; ++j) {
+            t.push(j);
+            dfs(j + 1, s - j);
+            t.pop();
+        }
+    };
+    dfs(1, n);
+    return ans;
+}
+```
+
 #### C#
 
 ```cs
@@ -634,6 +687,39 @@ function bitCount(i: number): number {
 }
 ```
 
+#### JavaScript
+
+```js
+function combinationSum3(k, n) {
+    const ans = [];
+    for (let mask = 0; mask < 1 << 9; ++mask) {
+        if (bitCount(mask) === k) {
+            const t = [];
+            let s = 0;
+            for (let i = 0; i < 9; ++i) {
+                if (mask & (1 << i)) {
+                    t.push(i + 1);
+                    s += i + 1;
+                }
+            }
+            if (s === n) {
+                ans.push(t);
+            }
+        }
+    }
+    return ans;
+}
+
+function bitCount(i) {
+    i = i - ((i >>> 1) & 0x55555555);
+    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
+    i = (i + (i >>> 4)) & 0x0f0f0f0f;
+    i = i + (i >>> 8);
+    i = i + (i >>> 16);
+    return i & 0x3f;
+}
+```
+
 #### C#
 
 ```cs

solution/0200-0299/0216.Combination Sum III/Solution.js

@@ -0,0 +1,21 @@
+function combinationSum3(k, n) {
+    const ans = [];
+    const t = [];
+    const dfs = (i, s) => {
+        if (s === 0) {
+            if (t.length === k) {
+                ans.push(t.slice());
+            }
+            return;
+        }
+        if (i > 9 || i > s || t.length >= k) {
+            return;
+        }
+        t.push(i);
+        dfs(i + 1, s - i);
+        t.pop();
+        dfs(i + 1, s);
+    };
+    dfs(1, n);
+    return ans;
+}