feat: solve No.706,2038,1512

BaffinLee · BaffinLee · commit d88b70a17983 · 2023-10-04T22:37:29.000+08:00
diff --git a/1501-1600/1512. Number of Good Pairs.md b/1501-1600/1512. Number of Good Pairs.md
@@ -0,0 +1,79 @@
+# 1512. Number of Good Pairs
+
+- Difficulty: Easy.
+- Related Topics: Array, Hash Table, Math, Counting.
+- Similar Questions: Number of Pairs of Interchangeable Rectangles, Substrings That Begin and End With the Same Letter.
+
+## Problem
+
+Given an array of integers `nums`, return **the number of **good pairs****.
+
+A pair `(i, j)` is called **good** if `nums[i] == nums[j]` and `i` < `j`.
+
+ 
+Example 1:
+
+```
+Input: nums = [1,2,3,1,1,3]
+Output: 4
+Explanation: There are 4 good pairs (0,3), (0,4), (3,4), (2,5) 0-indexed.
+```
+
+Example 2:
+
+```
+Input: nums = [1,1,1,1]
+Output: 6
+Explanation: Each pair in the array are good.
+```
+
+Example 3:
+
+```
+Input: nums = [1,2,3]
+Output: 0
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= nums.length <= 100`
+	
+- `1 <= nums[i] <= 100`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var numIdenticalPairs = function(nums) {
+    var map = Array(100).fill(0);
+    for (var i = 0; i < nums.length; i++) {
+        map[nums[i] - 1]++;
+    }
+    var res = 0;
+    for (var j = 0; j < map.length; j++) {
+        res += helper(map[j] - 1);
+    }
+    return res;
+};
+
+var helper = function(num) {
+    return num * (1 + num) / 2;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).
diff --git a/2001-2100/2038. Remove Colored Pieces if Both Neighbors are the Same Color.md b/2001-2100/2038. Remove Colored Pieces if Both Neighbors are the Same Color.md
@@ -0,0 +1,116 @@
+# 2038. Remove Colored Pieces if Both Neighbors are the Same Color
+
+- Difficulty: Medium.
+- Related Topics: Math, String, Greedy, Game Theory.
+- Similar Questions: Longest Subarray With Maximum Bitwise AND.
+
+## Problem
+
+There are `n` pieces arranged in a line, and each piece is colored either by `'A'` or by `'B'`. You are given a string `colors` of length `n` where `colors[i]` is the color of the `ith` piece.
+
+Alice and Bob are playing a game where they take **alternating turns** removing pieces from the line. In this game, Alice moves** first**.
+
+
+	
+- Alice is only allowed to remove a piece colored `'A'` if **both its neighbors** are also colored `'A'`. She is **not allowed** to remove pieces that are colored `'B'`.
+	
+- Bob is only allowed to remove a piece colored `'B'` if **both its neighbors** are also colored `'B'`. He is **not allowed** to remove pieces that are colored `'A'`.
+	
+- Alice and Bob **cannot** remove pieces from the edge of the line.
+	
+- If a player cannot make a move on their turn, that player **loses** and the other player **wins**.
+
+
+Assuming Alice and Bob play optimally, return `true`** if Alice wins, or return **`false`** if Bob wins**.
+
+ 
+Example 1:
+
+```
+Input: colors = "AAABABB"
+Output: true
+Explanation:
+AAABABB -> AABABB
+Alice moves first.
+She removes the second 'A' from the left since that is the only 'A' whose neighbors are both 'A'.
+
+Now it's Bob's turn.
+Bob cannot make a move on his turn since there are no 'B's whose neighbors are both 'B'.
+Thus, Alice wins, so return true.
+```
+
+Example 2:
+
+```
+Input: colors = "AA"
+Output: false
+Explanation:
+Alice has her turn first.
+There are only two 'A's and both are on the edge of the line, so she cannot move on her turn.
+Thus, Bob wins, so return false.
+```
+
+Example 3:
+
+```
+Input: colors = "ABBBBBBBAAA"
+Output: false
+Explanation:
+ABBBBBBBAAA -> ABBBBBBBAA
+Alice moves first.
+Her only option is to remove the second to last 'A' from the right.
+
+ABBBBBBBAA -> ABBBBBBAA
+Next is Bob's turn.
+He has many options for which 'B' piece to remove. He can pick any.
+
+On Alice's second turn, she has no more pieces that she can remove.
+Thus, Bob wins, so return false.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= colors.length <= 105`
+	
+- `colors` consists of only the letters `'A'` and `'B'`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {string} colors
+ * @return {boolean}
+ */
+var winnerOfGame = function(colors) {
+    var i = 0;
+    var a = 0;
+    var b = 0;
+    while (i < colors.length) {
+        var j = i;
+        while (colors[j] === colors[i]) j++;
+        if (j - i >= 3) {
+            if (colors[i] === 'A') {
+                a += j - i - 2;
+            } else {
+                b += j - i - 2;
+            }
+        }
+        i = j;
+    }
+    return a > b;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).
diff --git a/701-800/706. Design HashMap.md b/701-800/706. Design HashMap.md
@@ -0,0 +1,106 @@
+# 706. Design HashMap
+
+- Difficulty: Easy.
+- Related Topics: Array, Hash Table, Linked List, Design, Hash Function.
+- Similar Questions: Design HashSet, Design Skiplist.
+
+## Problem
+
+Design a HashMap without using any built-in hash table libraries.
+
+Implement the `MyHashMap` class:
+
+
+	
+- `MyHashMap()` initializes the object with an empty map.
+	
+- `void put(int key, int value)` inserts a `(key, value)` pair into the HashMap. If the `key` already exists in the map, update the corresponding `value`.
+	
+- `int get(int key)` returns the `value` to which the specified `key` is mapped, or `-1` if this map contains no mapping for the `key`.
+	
+- `void remove(key)` removes the `key` and its corresponding `value` if the map contains the mapping for the `key`.
+
+
+ 
+Example 1:
+
+```
+Input
+["MyHashMap", "put", "put", "get", "get", "put", "get", "remove", "get"]
+[[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]]
+Output
+[null, null, null, 1, -1, null, 1, null, -1]
+
+Explanation
+MyHashMap myHashMap = new MyHashMap();
+myHashMap.put(1, 1); // The map is now [[1,1]]
+myHashMap.put(2, 2); // The map is now [[1,1], [2,2]]
+myHashMap.get(1);    // return 1, The map is now [[1,1], [2,2]]
+myHashMap.get(3);    // return -1 (i.e., not found), The map is now [[1,1], [2,2]]
+myHashMap.put(2, 1); // The map is now [[1,1], [2,1]] (i.e., update the existing value)
+myHashMap.get(2);    // return 1, The map is now [[1,1], [2,1]]
+myHashMap.remove(2); // remove the mapping for 2, The map is now [[1,1]]
+myHashMap.get(2);    // return -1 (i.e., not found), The map is now [[1,1]]
+```
+
+ 
+**Constraints:**
+
+
+	
+- `0 <= key, value <= 106`
+	
+- At most `104` calls will be made to `put`, `get`, and `remove`.
+
+
+
+## Solution
+
+```javascript
+
+var MyHashMap = function() {
+    this.map = [];
+};
+
+/** 
+ * @param {number} key 
+ * @param {number} value
+ * @return {void}
+ */
+MyHashMap.prototype.put = function(key, value) {
+    this.map[key] = value;
+};
+
+/** 
+ * @param {number} key
+ * @return {number}
+ */
+MyHashMap.prototype.get = function(key) {
+    return this.map[key] ?? -1;
+};
+
+/** 
+ * @param {number} key
+ * @return {void}
+ */
+MyHashMap.prototype.remove = function(key) {
+    this.map[key] = undefined;
+};
+
+/** 
+ * Your MyHashMap object will be instantiated and called as such:
+ * var obj = new MyHashMap()
+ * obj.put(key,value)
+ * var param_2 = obj.get(key)
+ * obj.remove(key)
+ */
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(1).
+* Space complexity : O(1).
