feat: add solutions to lc problems: No.0589, 0799

- No.0589.N-ary Tree Preorder Traversal
- No.0799.Champagne Tower

Author: YangFong

solution/0500-0599/0589.N-ary Tree Preorder Traversal/README.md

@@ -241,16 +241,52 @@ function preorder(root: Node | null): number[] {
  */
 
 function preorder(root: Node | null): number[] {
-    if (root == null) {
-        return [];
+    const ans = [];
+    const dfs = (root: Node | null) => {
+        if (root == null) {
+            return;
+        }
+        ans.push(root.val);
+        for (const node of root.children) {
+            dfs(node);
+        }
+    };
+    dfs(root);
+    return ans;
+}
+```
+
+### **C**
+
+```c
+/**
+ * Definition for a Node.
+ * struct Node {
+ *     int val;
+ *     int numChildren;
+ *     struct Node** children;
+ * };
+ */
+
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+
+void dfs(struct Node *root, int *ans, int *i) {
+    if (!root) {
+        return;
+    }
+    ans[(*i)++] = root->val;
+    for (int j = 0; j < root->numChildren; j++) {
+        dfs(root->children[j], ans, i);
     }
-    const { val, children } = root;
-    return [
-        val,
-        ...children
-            .map(node => preorder(node))
-            .reduce((p, v) => p.concat(v), []),
-    ];
+}
+
+int *preorder(struct Node *root, int *returnSize) {
+    int *ans = malloc(sizeof(int) * 10000);
+    *returnSize = 0;
+    dfs(root, ans, returnSize);
+    return ans;
 }
 ```
 

solution/0500-0599/0589.N-ary Tree Preorder Traversal/README_EN.md

@@ -231,16 +231,52 @@ function preorder(root: Node | null): number[] {
  */
 
 function preorder(root: Node | null): number[] {
-    if (root == null) {
-        return [];
+    const ans = [];
+    const dfs = (root: Node | null) => {
+        if (root == null) {
+            return;
+        }
+        ans.push(root.val);
+        for (const node of root.children) {
+            dfs(node);
+        }
+    };
+    dfs(root);
+    return ans;
+}
+```
+
+### **C**
+
+```c
+/**
+ * Definition for a Node.
+ * struct Node {
+ *     int val;
+ *     int numChildren;
+ *     struct Node** children;
+ * };
+ */
+
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+
+void dfs(struct Node *root, int *ans, int *i) {
+    if (!root) {
+        return;
+    }
+    ans[(*i)++] = root->val;
+    for (int j = 0; j < root->numChildren; j++) {
+        dfs(root->children[j], ans, i);
     }
-    const { val, children } = root;
-    return [
-        val,
-        ...children
-            .map(node => preorder(node))
-            .reduce((p, v) => p.concat(v), []),
-    ];
+}
+
+int *preorder(struct Node *root, int *returnSize) {
+    int *ans = malloc(sizeof(int) * 10000);
+    *returnSize = 0;
+    dfs(root, ans, returnSize);
+    return ans;
 }
 ```
 

solution/0500-0599/0589.N-ary Tree Preorder Traversal/Solution.c

@@ -0,0 +1,29 @@
+/**
+ * Definition for a Node.
+ * struct Node {
+ *     int val;
+ *     int numChildren;
+ *     struct Node** children;
+ * };
+ */
+
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+
+void dfs(struct Node *root, int *ans, int *i) {
+    if (!root) {
+        return;
+    }
+    ans[(*i)++] = root->val;
+    for (int j = 0; j < root->numChildren; j++) {
+        dfs(root->children[j], ans, i);
+    }
+}
+
+int *preorder(struct Node *root, int *returnSize) {
+    int *ans = malloc(sizeof(int) * 10000);
+    *returnSize = 0;
+    dfs(root, ans, returnSize);
+    return ans;
+}

solution/0500-0599/0589.N-ary Tree Preorder Traversal/Solution.ts

@@ -11,18 +11,16 @@
  */
 
 function preorder(root: Node | null): number[] {
-    const res = [];
-    if (root == null) {
-        return res;
-    }
-    const stack = [root];
-    while (stack.length !== 0) {
-        const { val, children } = stack.pop();
-        res.push(val);
-        const n = children.length;
-        for (let i = n - 1; i >= 0; i--) {
-            stack.push(children[i]);
+    const ans = [];
+    const dfs = (root: Node | null) => {
+        if (root == null) {
+            return;
         }
-    }
-    return res;
+        ans.push(root.val);
+        for (const node of root.children) {
+            dfs(node);
+        }
+    };
+    dfs(root);
+    return ans;
 }

solution/0700-0799/0799.Champagne Tower/README.md

@@ -229,6 +229,52 @@ func champagneTower(poured int, query_row int, query_glass int) float64 {
 }
 ```
 
+### **TypeScipt**
+
+```ts
+function champagneTower(
+    poured: number,
+    query_row: number,
+    query_glass: number,
+): number {
+    let row = [poured];
+    for (let i = 1; i <= query_row; i++) {
+        const nextRow = new Array(i + 1).fill(0);
+        for (let j = 0; j < i; j++) {
+            if (row[j] > 1) {
+                nextRow[j] += (row[j] - 1) / 2;
+                nextRow[j + 1] += (row[j] - 1) / 2;
+            }
+        }
+        row = nextRow;
+    }
+    return Math.min(1, row[query_glass]);
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn champagne_tower(poured: i32, query_row: i32, query_glass: i32) -> f64 {
+        let query_row = query_row as usize;
+        let query_glass = query_glass as usize;
+        let mut row = vec![poured as f64];
+        for i in 1..=query_row {
+            let mut next_row = vec![0f64; i + 1];
+            for j in 0..i {
+                if row[j] > 1f64 {
+                    next_row[j] += (row[j] - 1f64) / 2f64;
+                    next_row[j + 1] += (row[j] - 1f64) / 2f64;
+                }
+            }
+            row = next_row;
+        }
+        1f64.min(row[query_glass])
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0700-0799/0799.Champagne Tower/README_EN.md

@@ -220,6 +220,52 @@ func champagneTower(poured int, query_row int, query_glass int) float64 {
 }
 ```
 
+### **TypeScipt**
+
+```ts
+function champagneTower(
+    poured: number,
+    query_row: number,
+    query_glass: number,
+): number {
+    let row = [poured];
+    for (let i = 1; i <= query_row; i++) {
+        const nextRow = new Array(i + 1).fill(0);
+        for (let j = 0; j < i; j++) {
+            if (row[j] > 1) {
+                nextRow[j] += (row[j] - 1) / 2;
+                nextRow[j + 1] += (row[j] - 1) / 2;
+            }
+        }
+        row = nextRow;
+    }
+    return Math.min(1, row[query_glass]);
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn champagne_tower(poured: i32, query_row: i32, query_glass: i32) -> f64 {
+        let query_row = query_row as usize;
+        let query_glass = query_glass as usize;
+        let mut row = vec![poured as f64];
+        for i in 1..=query_row {
+            let mut next_row = vec![0f64; i + 1];
+            for j in 0..i {
+                if row[j] > 1f64 {
+                    next_row[j] += (row[j] - 1f64) / 2f64;
+                    next_row[j + 1] += (row[j] - 1f64) / 2f64;
+                }
+            }
+            row = next_row;
+        }
+        1f64.min(row[query_glass])
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0700-0799/0799.Champagne Tower/Solution.rs

@@ -0,0 +1,18 @@
+impl Solution {
+    pub fn champagne_tower(poured: i32, query_row: i32, query_glass: i32) -> f64 {
+        let query_row = query_row as usize;
+        let query_glass = query_glass as usize;
+        let mut row = vec![poured as f64];
+        for i in 1..=query_row {
+            let mut next_row = vec![0f64; i + 1];
+            for j in 0..i {
+                if row[j] > 1f64 {
+                    next_row[j] += (row[j] - 1f64) / 2f64;
+                    next_row[j + 1] += (row[j] - 1f64) / 2f64;
+                }
+            }
+            row = next_row;
+        }
+        1f64.min(row[query_glass])
+    }
+}

solution/0700-0799/0799.Champagne Tower/Solution.ts

@@ -0,0 +1,18 @@
+function champagneTower(
+    poured: number,
+    query_row: number,
+    query_glass: number,
+): number {
+    let row = [poured];
+    for (let i = 1; i <= query_row; i++) {
+        const nextRow = new Array(i + 1).fill(0);
+        for (let j = 0; j < i; j++) {
+            if (row[j] > 1) {
+                nextRow[j] += (row[j] - 1) / 2;
+                nextRow[j + 1] += (row[j] - 1) / 2;
+            }
+        }
+        row = nextRow;
+    }
+    return Math.min(1, row[query_glass]);
+}