feat: add solutions to lcci problem: No.08.04

No.08.04.Power Set

Author: YangFong

lcci/08.04.Power Set/README.md

@@ -74,6 +74,78 @@ function dfs(nums, depth, prev, res) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function subsets(nums: number[]): number[][] {
+    const res = [[]];
+    nums.forEach(num => {
+        res.forEach(item => {
+            res.push(item.concat(num));
+        });
+    });
+    return res;
+}
+```
+
+```rust
+function subsets(nums: number[]): number[][] {
+    const n = nums.length;
+    const res = [];
+    const list = [];
+    const dfs = (i: number) => {
+        if (i === n) {
+            res.push([...list]);
+            return;
+        }
+        list.push(nums[i]);
+        dfs(i + 1);
+        list.pop();
+        dfs(i + 1);
+    };
+    dfs(0);
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let n = nums.len();
+        let mut res: Vec<Vec<i32>> = vec![vec![]];
+        for i in 0..n {
+            for j in 0..res.len() {
+                res.push(vec![..res[j].clone(), vec![nums[i]]].concat());
+            }
+        }
+        res
+    }
+}
+```
+
+```rust
+impl Solution {
+    fn dfs(nums: &Vec<i32>, i: usize, res: &mut Vec<Vec<i32>>, list: &mut Vec<i32>) {
+        if i == nums.len() {
+            res.push(list.clone());
+            return;
+        }
+        list.push(nums[i]);
+        Self::dfs(nums, i + 1, res, list);
+        list.pop();
+        Self::dfs(nums, i + 1, res, list);
+    }
+
+    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut res = vec![];
+        Self::dfs(&nums, 0, &mut res, &mut vec![]);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

lcci/08.04.Power Set/README_EN.md

@@ -81,6 +81,78 @@ function dfs(nums, depth, prev, res) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function subsets(nums: number[]): number[][] {
+    const res = [[]];
+    nums.forEach(num => {
+        res.forEach(item => {
+            res.push(item.concat(num));
+        });
+    });
+    return res;
+}
+```
+
+```rust
+function subsets(nums: number[]): number[][] {
+    const n = nums.length;
+    const res = [];
+    const list = [];
+    const dfs = (i: number) => {
+        if (i === n) {
+            res.push([...list]);
+            return;
+        }
+        list.push(nums[i]);
+        dfs(i + 1);
+        list.pop();
+        dfs(i + 1);
+    };
+    dfs(0);
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let n = nums.len();
+        let mut res: Vec<Vec<i32>> = vec![vec![]];
+        for i in 0..n {
+            for j in 0..res.len() {
+                res.push(vec![..res[j].clone(), vec![nums[i]]].concat());
+            }
+        }
+        res
+    }
+}
+```
+
+```rust
+impl Solution {
+    fn dfs(nums: &Vec<i32>, i: usize, res: &mut Vec<Vec<i32>>, list: &mut Vec<i32>) {
+        if i == nums.len() {
+            res.push(list.clone());
+            return;
+        }
+        list.push(nums[i]);
+        Self::dfs(nums, i + 1, res, list);
+        list.pop();
+        Self::dfs(nums, i + 1, res, list);
+    }
+
+    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut res = vec![];
+        Self::dfs(&nums, 0, &mut res, &mut vec![]);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

lcci/08.04.Power Set/Solution.rs

@@ -0,0 +1,18 @@
+impl Solution {
+    fn dfs(nums: &Vec<i32>, i: usize, res: &mut Vec<Vec<i32>>, list: &mut Vec<i32>) {
+        if i == nums.len() {
+            res.push(list.clone());
+            return;
+        }
+        list.push(nums[i]);
+        Self::dfs(nums, i + 1, res, list);
+        list.pop();
+        Self::dfs(nums, i + 1, res, list);
+    }
+
+    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
+        let mut res = vec![];
+        Self::dfs(&nums, 0, &mut res, &mut vec![]);
+        res
+    }
+}

lcci/08.04.Power Set/Solution.ts

@@ -0,0 +1,17 @@
+function subsets(nums: number[]): number[][] {
+    const n = nums.length;
+    const res = [];
+    const list = [];
+    const dfs = (i: number) => {
+        if (i === n) {
+            res.push([...list]);
+            return;
+        }
+        list.push(nums[i]);
+        dfs(i + 1);
+        list.pop();
+        dfs(i + 1);
+    };
+    dfs(0);
+    return res;
+}