feat: solve No.341,844

Author: BaffinLee

301-400/341. Flatten Nested List Iterator.md

@@ -0,0 +1,141 @@
+# 341. Flatten Nested List Iterator
+
+- Difficulty: Medium.
+- Related Topics: Stack, Tree, Depth-First Search, Design, Queue, Iterator.
+- Similar Questions: Flatten 2D Vector, Zigzag Iterator, Mini Parser, Array Nesting.
+
+## Problem
+
+You are given a nested list of integers `nestedList`. Each element is either an integer or a list whose elements may also be integers or other lists. Implement an iterator to flatten it.
+
+Implement the `NestedIterator` class:
+
+
+	
+- `NestedIterator(List<NestedInteger> nestedList)` Initializes the iterator with the nested list `nestedList`.
+	
+- `int next()` Returns the next integer in the nested list.
+	
+- `boolean hasNext()` Returns `true` if there are still some integers in the nested list and `false` otherwise.
+
+
+Your code will be tested with the following pseudocode:
+
+```
+initialize iterator with nestedList
+res = []
+while iterator.hasNext()
+    append iterator.next() to the end of res
+return res
+```
+
+If `res` matches the expected flattened list, then your code will be judged as correct.
+
+ 
+Example 1:
+
+```
+Input: nestedList = [[1,1],2,[1,1]]
+Output: [1,1,2,1,1]
+Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].
+```
+
+Example 2:
+
+```
+Input: nestedList = [1,[4,[6]]]
+Output: [1,4,6]
+Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= nestedList.length <= 500`
+	
+- The values of the integers in the nested list is in the range `[-106, 106]`.
+
+
+
+## Solution
+
+```javascript
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * function NestedInteger() {
+ *
+ *     Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     @return {boolean}
+ *     this.isInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     Return null if this NestedInteger holds a nested list
+ *     @return {integer}
+ *     this.getInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     Return null if this NestedInteger holds a single integer
+ *     @return {NestedInteger[]}
+ *     this.getList = function() {
+ *         ...
+ *     };
+ * };
+ */
+/**
+ * @constructor
+ * @param {NestedInteger[]} nestedList
+ */
+var NestedIterator = function(nestedList) {
+    this.index = 0;
+    this.list = [];
+    const flatten = (list) => {
+        for (var item of list) {
+            if (item.isInteger()) {
+                this.list.push(item.getInteger());
+            } else {
+                flatten(item.getList());
+            }
+        }
+    };
+    flatten(nestedList);
+};
+
+
+/**
+ * @this NestedIterator
+ * @returns {boolean}
+ */
+NestedIterator.prototype.hasNext = function() {
+    return this.index < this.list.length;
+};
+
+/**
+ * @this NestedIterator
+ * @returns {integer}
+ */
+NestedIterator.prototype.next = function() {
+    return this.list[this.index++];
+};
+
+/**
+ * Your NestedIterator will be called like this:
+ * var i = new NestedIterator(nestedList), a = [];
+ * while (i.hasNext()) a.push(i.next());
+*/
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

801-900/844. Backspace String Compare.md

@@ -0,0 +1,90 @@
+# 844. Backspace String Compare
+
+- Difficulty: Easy.
+- Related Topics: Two Pointers, String, Stack, Simulation.
+- Similar Questions: Crawler Log Folder, Removing Stars From a String.
+
+## Problem
+
+Given two strings `s` and `t`, return `true` **if they are equal when both are typed into empty text editors**. `'#'` means a backspace character.
+
+Note that after backspacing an empty text, the text will continue empty.
+
+ 
+Example 1:
+
+```
+Input: s = "ab#c", t = "ad#c"
+Output: true
+Explanation: Both s and t become "ac".
+```
+
+Example 2:
+
+```
+Input: s = "ab##", t = "c#d#"
+Output: true
+Explanation: Both s and t become "".
+```
+
+Example 3:
+
+```
+Input: s = "a#c", t = "b"
+Output: false
+Explanation: s becomes "c" while t becomes "b".
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= s.length, t.length <= 200`
+	
+- `s` and `t` only contain lowercase letters and `'#'` characters.
+
+
+ 
+**Follow up:** Can you solve it in `O(n)` time and `O(1)` space?
+
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var backspaceCompare = function(s, t) {
+    var i = s.length - 1;
+    var j = t.length - 1;
+    while (i >= 0 || j >= 0) {
+        i = findCharIndex(s, i);
+        j = findCharIndex(t, j);
+        if (s[i] !== t[j]) return false;
+        i--;
+        j--;
+    }
+    return true;
+};
+
+var findCharIndex = function(s, i) {
+    var num = 0;
+    while (num || s[i] === '#') {
+        s[i] === '#' ? num++ : num--;
+        i--;
+    }
+    return i;
+}
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).