Merge branch 'master' of github.com:BaffinLee/leetcode-javascript

Author: BaffinLee

Diff for: 1501-1600/1544. Make The String Great.md

@@ -0,0 +1,95 @@
+# 1544. Make The String Great
+
+- Difficulty: Easy.
+- Related Topics: String, Stack.
+- Similar Questions: .
+
+## Problem
+
+Given a string `s` of lower and upper case English letters.
+
+A good string is a string which doesn't have **two adjacent characters** `s[i]` and `s[i + 1]` where:
+
+
+	
+- `0 <= i <= s.length - 2`
+	
+- `s[i]` is a lower-case letter and `s[i + 1]` is the same letter but in upper-case or **vice-versa**.
+
+
+To make the string good, you can choose **two adjacent** characters that make the string bad and remove them. You can keep doing this until the string becomes good.
+
+Return **the string** after making it good. The answer is guaranteed to be unique under the given constraints.
+
+**Notice** that an empty string is also good.
+
+ 
+Example 1:
+
+```
+Input: s = "leEeetcode"
+Output: "leetcode"
+Explanation: In the first step, either you choose i = 1 or i = 2, both will result "leEeetcode" to be reduced to "leetcode".
+```
+
+Example 2:
+
+```
+Input: s = "abBAcC"
+Output: ""
+Explanation: We have many possible scenarios, and all lead to the same answer. For example:
+"abBAcC" --> "aAcC" --> "cC" --> ""
+"abBAcC" --> "abBA" --> "aA" --> ""
+```
+
+Example 3:
+
+```
+Input: s = "s"
+Output: "s"
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= s.length <= 100`
+	
+- `s` contains only lower and upper case English letters.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var makeGood = function(s) {
+    var i = 0;
+    var res = [];
+    while (i < s.length) {
+        if (res.length
+            && s[i] !== res[res.length - 1]
+            && s[i].toLowerCase() === res[res.length - 1].toLowerCase()
+        ) {
+            res.pop();
+        } else {
+            res.push(s[i]);
+        }
+        i += 1;
+    }
+    return res.join('');
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

Diff for: 201-300/205. Isomorphic Strings.md

@@ -50,14 +50,14 @@ Output: true
 var isIsomorphic = function(s, t) {
     if (s.length !== t.length) return false;
     var map = {};
-    var usedMap = {};
+    var used = {};
     for (var i = 0; i < s.length; i++) {
-        if (!map[s[i]]) {
-            if (usedMap[t[i]]) return false;
-            usedMap[t[i]] = true;
+        if (map[s[i]]) {
+            if (map[s[i]] !== t[i]) return false;
+        } else {
+            if (used[t[i]]) return false;
+            used[t[i]] = true;
             map[s[i]] = t[i];
-        } else if (map[s[i]] !== t[i]) {
-            return false;
         }
     }
     return true;
@@ -71,4 +71,4 @@ nope.
 **Complexity:**
 
 * Time complexity : O(n).
-* Space complexity : O(1).
+* Space complexity : O(n).

Diff for: 201-300/289. Game of Life.md

@@ -0,0 +1,133 @@
+# 289. Game of Life
+
+- Difficulty: Medium.
+- Related Topics: Array, Matrix, Simulation.
+- Similar Questions: Set Matrix Zeroes.
+
+## Problem
+
+According to Wikipedia's article: "The **Game of Life**, also known simply as **Life**, is a cellular automaton devised by the British mathematician John Horton Conway in 1970."
+
+The board is made up of an `m x n` grid of cells, where each cell has an initial state: **live** (represented by a `1`) or **dead** (represented by a `0`). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):
+
+
+	
+- Any live cell with fewer than two live neighbors dies as if caused by under-population.
+	
+- Any live cell with two or three live neighbors lives on to the next generation.
+	
+- Any live cell with more than three live neighbors dies, as if by over-population.
+	
+- Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.
+
+
+The next state is created by applying the above rules simultaneously to every cell in the current state, where births and deaths occur simultaneously. Given the current state of the `m x n` grid `board`, return **the next state**.
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2020/12/26/grid1.jpg)
+
+```
+Input: board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
+Output: [[0,0,0],[1,0,1],[0,1,1],[0,1,0]]
+```
+
+Example 2:
+
+![](https://assets.leetcode.com/uploads/2020/12/26/grid2.jpg)
+
+```
+Input: board = [[1,1],[1,0]]
+Output: [[1,1],[1,1]]
+```
+
+ 
+**Constraints:**
+
+
+	
+- `m == board.length`
+	
+- `n == board[i].length`
+	
+- `1 <= m, n <= 25`
+	
+- `board[i][j]` is `0` or `1`.
+
+
+ 
+**Follow up:**
+
+
+	
+- Could you solve it in-place? Remember that the board needs to be updated simultaneously: You cannot update some cells first and then use their updated values to update other cells.
+	
+- In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches upon the border of the array (i.e., live cells reach the border). How would you address these problems?
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} board
+ * @return {void} Do not return anything, modify board in-place instead.
+ */
+var gameOfLife = function(board) {
+    for (var i = 0; i < board.length; i++) {
+        for (var j = 0; j < board[i].length; j++) {
+            var count = countLiveneighbors(board, i, j);
+            if (board[i][j] === 1) {
+                if (count < 2 || count > 3) {
+                    board[i][j] = 2;
+                }
+            } else {
+                if (count === 3) {
+                    board[i][j] = 3;
+                }
+            }
+        }
+    }
+    for (var i = 0; i < board.length; i++) {
+        for (var j = 0; j < board[i].length; j++) {
+            if (board[i][j] === 2) {
+                board[i][j] = 0;
+            } else if (board[i][j] === 3) {
+                board[i][j] = 1;
+            }
+        }
+    }
+};
+
+var countLiveneighbors = function(board, i, j) {
+    var directions = [
+        [0, 1],
+        [0, -1],
+        [1, 0],
+        [-1, 0],
+        [1, 1],
+        [1, -1],
+        [-1, 1],
+        [-1, -1],
+    ];
+    var count = 0;
+    for (var m = 0; m < directions.length; m++) {
+        var [y, x] = directions[m];
+        if (!board[i + y]) continue;
+        if (board[i + y][j + x] === 1 || board[i + y][j + x] === 2) {
+            count += 1;
+        }
+    }
+    return count;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).