feat: add solutions to lc problem: No.0046,0077

- No.0046.Permutations
- No.0077.Combinations

Author: YangFong

solution/0000-0099/0046.Permutations/README.md

@@ -186,6 +186,53 @@ func dfs(u, n int, nums []int, used []bool, path []int, res *[][]int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function permute(nums: number[]): number[][] {
+    const res: number[][] = [];
+    const dfs = (paths: number[]) => {
+        if (paths.length === nums.length) {
+            res.push(paths);
+            return;
+        }
+        for (const num of nums) {
+            if (!paths.includes(num)) {
+                dfs(paths.concat(num));
+            }
+        }
+    };
+    dfs([]);
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(nums: &Vec<i32>, paths: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
+        if paths.len() == nums.len() {
+            res.push(paths.clone());
+            return;
+        }
+        for i in nums.iter() {
+            if !paths.contains(i) {
+                paths.push(*i);
+                Self::dfs(nums, paths, res);
+                paths.pop();
+            }
+        }
+    }
+
+    pub fn permute(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut res = vec![];
+        Self::dfs(&nums, &mut vec![], &mut res);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0000-0099/0046.Permutations/README_EN.md

@@ -185,6 +185,53 @@ func dfs(u, n int, nums []int, used []bool, path []int, res *[][]int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function permute(nums: number[]): number[][] {
+    const res: number[][] = [];
+    const dfs = (paths: number[]) => {
+        if (paths.length === nums.length) {
+            res.push(paths);
+            return;
+        }
+        for (const num of nums) {
+            if (!paths.includes(num)) {
+                dfs(paths.concat(num));
+            }
+        }
+    };
+    dfs([]);
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(nums: &Vec<i32>, paths: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
+        if paths.len() == nums.len() {
+            res.push(paths.clone());
+            return;
+        }
+        for i in nums.iter() {
+            if !paths.contains(i) {
+                paths.push(*i);
+                Self::dfs(nums, paths, res);
+                paths.pop();
+            }
+        }
+    }
+
+    pub fn permute(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut res = vec![];
+        Self::dfs(&nums, &mut vec![], &mut res);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0000-0099/0046.Permutations/Solution.rs

@@ -0,0 +1,21 @@
+impl Solution {
+    fn dfs(nums: &Vec<i32>, paths: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
+        if paths.len() == nums.len() {
+            res.push(paths.clone());
+            return;
+        }
+        for i in nums.iter() {
+            if !paths.contains(i) {
+                paths.push(*i);
+                Self::dfs(nums, paths, res);
+                paths.pop();
+            }
+        }
+    }
+
+    pub fn permute(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut res = vec![];
+        Self::dfs(&nums, &mut vec![], &mut res);
+        res
+    }
+}

solution/0000-0099/0046.Permutations/Solution.ts

@@ -0,0 +1,16 @@
+function permute(nums: number[]): number[][] {
+    const res: number[][] = [];
+    const dfs = (paths: number[]) => {
+        if (paths.length === nums.length) {
+            res.push(paths);
+            return;
+        }
+        for (const num of nums) {
+            if (!paths.includes(num)) {
+                dfs(paths.concat(num));
+            }
+        }
+    };
+    dfs([]);
+    return res;
+}

solution/0000-0099/0077.Combinations/README.md

@@ -130,6 +130,57 @@ func dfs(i, n, k int, t []int, res *[][]int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function combine(n: number, k: number): number[][] {
+    const res: number[][] = [];
+    const dfs = (i: number, t: number[]) => {
+        if (t.length == k) {
+            res.push(t);
+            return;
+        }
+        // 剪枝
+        if (t.length + n - i + 1 < k) {
+            return;
+        }
+        for (let j = i; j <= n; j++) {
+            dfs(j + 1, [...t, j]);
+        }
+    };
+    dfs(1, []);
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(i: i32, n: i32, k: i32, t: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
+        if k == 0 {
+            res.push(t.clone());
+            return;
+        }
+        // 剪枝
+        if n - i + 1 < k {
+            return;
+        }
+        for j in i..=n {
+            t.push(j);
+            Self::dfs(j + 1, n, k - 1, t, res);
+            t.pop();
+        }
+    }
+
+    pub fn combine(n: i32, k: i32) -> Vec<Vec<i32>> {
+        let mut res = vec![];
+        Self::dfs(1, n, k, &mut vec![], &mut res);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0000-0099/0077.Combinations/README_EN.md

@@ -142,6 +142,57 @@ func dfs(i, n, k int, t []int, res *[][]int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function combine(n: number, k: number): number[][] {
+    const res: number[][] = [];
+    const dfs = (i: number, t: number[]) => {
+        if (t.length == k) {
+            res.push(t);
+            return;
+        }
+        // pruning
+        if (t.length + n - i + 1 < k) {
+            return;
+        }
+        for (let j = i; j <= n; j++) {
+            dfs(j + 1, [...t, j]);
+        }
+    };
+    dfs(1, []);
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(i: i32, n: i32, k: i32, t: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
+        if k == 0 {
+            res.push(t.clone());
+            return;
+        }
+        // pruning
+        if n - i + 1 < k {
+            return;
+        }
+        for j in i..=n {
+            t.push(j);
+            Self::dfs(j + 1, n, k - 1, t, res);
+            t.pop();
+        }
+    }
+
+    pub fn combine(n: i32, k: i32) -> Vec<Vec<i32>> {
+        let mut res = vec![];
+        Self::dfs(1, n, k, &mut vec![], &mut res);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0000-0099/0077.Combinations/Solution.rs

@@ -0,0 +1,23 @@
+impl Solution {
+    fn dfs(i: i32, n: i32, k: i32, t: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
+        if k == 0 {
+            res.push(t.clone());
+            return;
+        }
+        // 剪枝
+        if n - i + 1 < k {
+            return;
+        }
+        for j in i..=n {
+            t.push(j);
+            Self::dfs(j + 1, n, k - 1, t, res);
+            t.pop();
+        }
+    }
+
+    pub fn combine(n: i32, k: i32) -> Vec<Vec<i32>> {
+        let mut res = vec![];
+        Self::dfs(1, n, k, &mut vec![], &mut res);
+        res
+    }
+}

solution/0000-0099/0077.Combinations/Solution.ts

@@ -0,0 +1,18 @@
+function combine(n: number, k: number): number[][] {
+    const res: number[][] = [];
+    const dfs = (i: number, t: number[]) => {
+        if (t.length == k) {
+            res.push(t);
+            return;
+        }
+        // 剪枝
+        if (t.length + n - i + 1 < k) {
+            return;
+        }
+        for (let j = i; j <= n; j++) {
+            dfs(j + 1, [...t, j]);
+        }
+    };
+    dfs(1, []);
+    return res;
+}