Added tasks 292-299.

Author: javadev

README.md

@@ -663,6 +663,7 @@
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0001 |[Two Sum](src/main/kotlin/g0001_0100/s0001_two_sum)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table | 234 | 92.75
+| 0299 |[Bulls and Cows](src/main/kotlin/g0201_0300/s0299_bulls_and_cows)| Medium | String, Hash_Table, Counting | 254 | 84.82
 
 #### Day 14 Stack
 
@@ -930,6 +931,7 @@
 | 0111 |[Minimum Depth of Binary Tree](src/main/kotlin/g0101_0200/s0111_minimum_depth_of_binary_tree)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 525 | 90.51
 | 0104 |[Maximum Depth of Binary Tree](src/main/kotlin/g0101_0200/s0104_maximum_depth_of_binary_tree)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 236 | 83.39
 | 0110 |[Balanced Binary Tree](src/main/kotlin/g0101_0200/s0110_balanced_binary_tree)| Easy | Depth_First_Search, Tree, Binary_Tree | 310 | 63.63
+| 0297 |[Serialize and Deserialize Binary Tree](src/main/kotlin/g0201_0300/s0297_serialize_and_deserialize_binary_tree)| Hard | Top_Interview_Questions, String, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Design | 475 | 78.85
 | 0124 |[Binary Tree Maximum Path Sum](src/main/kotlin/g0101_0200/s0124_binary_tree_maximum_path_sum)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Depth_First_Search, Tree, Binary_Tree | 331 | 74.42
 | 0098 |[Validate Binary Search Tree](src/main/kotlin/g0001_0100/s0098_validate_binary_search_tree)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 330 | 41.38
 | 0236 |[Lowest Common Ancestor of a Binary Tree](src/main/kotlin/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree | 386 | 45.21
@@ -1214,6 +1216,7 @@
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0236 |[Lowest Common Ancestor of a Binary Tree](src/main/kotlin/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree | 386 | 45.21
+| 0297 |[Serialize and Deserialize Binary Tree](src/main/kotlin/g0201_0300/s0297_serialize_and_deserialize_binary_tree)| Hard | Top_Interview_Questions, String, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Design | 475 | 78.85
 
 #### Day 19 Graph
 
@@ -1558,7 +1561,10 @@
 | 0338 |[Counting Bits](src/main/kotlin/g0301_0400/s0338_counting_bits)| Easy | Top_100_Liked_Questions, Dynamic_Programming, Bit_Manipulation, Udemy_Bit_Manipulation | 186 | 99.26
 | 0322 |[Coin Change](src/main/kotlin/g0301_0400/s0322_coin_change)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Breadth_First_Search, Algorithm_II_Day_18_Dynamic_Programming, Dynamic_Programming_I_Day_20, Level_2_Day_12_Dynamic_Programming | 332 | 50.68
 | 0300 |[Longest Increasing Subsequence](src/main/kotlin/g0201_0300/s0300_longest_increasing_subsequence)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Binary_Search, Algorithm_II_Day_16_Dynamic_Programming, Binary_Search_II_Day_3, Dynamic_Programming_I_Day_18, Udemy_Dynamic_Programming | 318 | 82.28
+| 0299 |[Bulls and Cows](src/main/kotlin/g0201_0300/s0299_bulls_and_cows)| Medium | String, Hash_Table, Counting, Level_1_Day_13_Hashmap | 254 | 84.82
+| 0297 |[Serialize and Deserialize Binary Tree](src/main/kotlin/g0201_0300/s0297_serialize_and_deserialize_binary_tree)| Hard | Top_Interview_Questions, String, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Design, Data_Structure_II_Day_18_Tree, Udemy_Tree_Stack_Queue | 475 | 78.85
 | 0295 |[Find Median from Data Stream](src/main/kotlin/g0201_0300/s0295_find_median_from_data_stream)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Sorting, Two_Pointers, Design, Heap_Priority_Queue, Data_Stream | 2289 | 33.60
+| 0292 |[Nim Game](src/main/kotlin/g0201_0300/s0292_nim_game)| Easy | Math, Game_Theory, Brainteaser | 129 | 94.29
 | 0290 |[Word Pattern](src/main/kotlin/g0201_0300/s0290_word_pattern)| Easy | String, Hash_Table, Data_Structure_II_Day_7_String | 177 | 89.55
 | 0289 |[Game of Life](src/main/kotlin/g0201_0300/s0289_game_of_life)| Medium | Top_Interview_Questions, Array, Matrix, Simulation | 174 | 96.97
 | 0287 |[Find the Duplicate Number](src/main/kotlin/g0201_0300/s0287_find_the_duplicate_number)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Binary_Search, Two_Pointers, Bit_Manipulation, Binary_Search_II_Day_5 | 656 | 66.21

src/main/kotlin/g0101_0200/s0177_nth_highest_salary/readme.md

@@ -72,7 +72,6 @@ DECLARE M INT;
 SET M=N-1;
   RETURN (
       # Write your MySQL query statement below.
-      # #Medium #Database #2022_10_18_Time_338_ms_(86.68%)_Space_0B_(100.00%)
       SELECT DISTINCT Salary FROM Employee ORDER BY Salary DESC LIMIT M, 1
   );
 END

src/main/kotlin/g0201_0300/s0292_nim_game/readme.md

@@ -0,0 +1,52 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 292\. Nim Game
+
+Easy
+
+You are playing the following Nim Game with your friend:
+
+*   Initially, there is a heap of stones on the table.
+*   You and your friend will alternate taking turns, and **you go first**.
+*   On each turn, the person whose turn it is will remove 1 to 3 stones from the heap.
+*   The one who removes the last stone is the winner.
+
+Given `n`, the number of stones in the heap, return `true` _if you can win the game assuming both you and your friend play optimally, otherwise return_ `false`.
+
+**Example 1:**
+
+**Input:** n = 4
+
+**Output:** false
+
+**Explanation:** These are the possible outcomes: 1. You remove 1 stone. Your friend removes 3 stones, including the last stone. Your friend wins. 2. You remove 2 stones. Your friend removes 2 stones, including the last stone. Your friend wins. 3. You remove 3 stones. Your friend removes the last stone. Your friend wins. In all outcomes, your friend wins.
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** true
+
+**Example 3:**
+
+**Input:** n = 2
+
+**Output:** true
+
+**Constraints:**
+
+*   <code>1 <= n <= 2<sup>31</sup> - 1</code>
+
+## Solution
+
+```kotlin
+class Solution {
+    fun canWinNim(n: Int): Boolean {
+        if (n % 4 == 0) {
+            return false
+        }
+        return true
+    }
+}
+```

src/main/kotlin/g0201_0300/s0297_serialize_and_deserialize_binary_tree/readme.md

@@ -0,0 +1,103 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 297\. Serialize and Deserialize Binary Tree
+
+Hard
+
+Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.
+
+Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.
+
+**Clarification:** The input/output format is the same as [how LeetCode serializes a binary tree](https://support.leetcode.com/hc/en-us/articles/360011883654-What-does-1-null-2-3-mean-in-binary-tree-representation-). You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/15/serdeser.jpg)
+
+**Input:** root = [1,2,3,null,null,4,5]
+
+**Output:** [1,2,3,null,null,4,5]
+
+**Example 2:**
+
+**Input:** root = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   `-1000 <= Node.val <= 1000`
+
+## Solution
+
+```kotlin
+import com_github_leetcode.TreeNode
+
+/*
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+
+class Codec {
+    private var offset = 0
+
+    // Encodes a tree to a single string.
+    fun serialize(root: TreeNode?): String {
+        val sb = StringBuilder()
+        offset = 0
+        serialize(root, sb)
+        return sb.toString()
+    }
+
+    fun serialize(root: TreeNode?, sb: StringBuilder) {
+        // all nodes fit into 4 bits.
+        // IFF we offset at 0. So encode(val) = val + min(default - 1000)
+        if (root == null) {
+            sb.append(DELIM)
+            return
+        }
+        val s = Integer.toHexString(root.`val` + BASE_OFFSET)
+        val sb2 = StringBuilder()
+        for (i in 0 until 3 - s.length) {
+            sb2.append('0')
+        }
+        sb2.append(s)
+        sb.append(sb2)
+        serialize(root.left, sb)
+        serialize(root.right, sb)
+    }
+
+    // Decodes your encoded data to tree.
+    fun deserialize(data: String): TreeNode? {
+        if (data[offset] == '*') {
+            offset++
+            return null
+        }
+        val root = TreeNode(
+            data.substring(offset, offset + 3).toInt(16) - BASE_OFFSET
+        )
+        offset += 3
+        root.left = deserialize(data)
+        root.right = deserialize(data)
+        return root
+    }
+
+    companion object {
+        private const val BASE_OFFSET = 1000
+        private const val DELIM = "*"
+    }
+}
+
+/*
+ * Your Codec object will be instantiated and called as such:
+ * var ser = Codec()
+ * var deser = Codec()
+ * var data = ser.serialize(longUrl)
+ * var ans = deser.deserialize(data)
+ */
+```

src/main/kotlin/g0201_0300/s0299_bulls_and_cows/readme.md

@@ -0,0 +1,93 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 299\. Bulls and Cows
+
+Medium
+
+You are playing the **[Bulls and Cows](https://en.wikipedia.org/wiki/Bulls_and_Cows)** game with your friend.
+
+You write down a secret number and ask your friend to guess what the number is. When your friend makes a guess, you provide a hint with the following info:
+
+*   The number of "bulls", which are digits in the guess that are in the correct position.
+*   The number of "cows", which are digits in the guess that are in your secret number but are located in the wrong position. Specifically, the non-bull digits in the guess that could be rearranged such that they become bulls.
+
+Given the secret number `secret` and your friend's guess `guess`, return _the hint for your friend's guess_.
+
+The hint should be formatted as `"xAyB"`, where `x` is the number of bulls and `y` is the number of cows. Note that both `secret` and `guess` may contain duplicate digits.
+
+**Example 1:**
+
+**Input:** secret = "1807", guess = "7810"
+
+**Output:** "1A3B"
+
+**Explanation:**
+
+    Bulls are connected with a '|' and cows are underlined:
+    "1807"
+      |
+    "7810"
+
+**Example 2:**
+
+**Input:** secret = "1123", guess = "0111"
+
+**Output:** "1A1B"
+
+**Explanation:**
+
+    Bulls are connected with a '|' and cows are underlined:
+    "1123"       "1123"
+      |      or    |
+    "0111"       "0111"
+    Note that only one of the two unmatched 1s is counted as a cow since the non-bull digits can only be rearranged to allow one 1 to be a bull. 
+
+**Example 3:**
+
+**Input:** secret = "1", guess = "0"
+
+**Output:** "0A0B"
+
+**Example 4:**
+
+**Input:** secret = "1", guess = "1"
+
+**Output:** "1A0B"
+
+**Constraints:**
+
+*   `1 <= secret.length, guess.length <= 1000`
+*   `secret.length == guess.length`
+*   `secret` and `guess` consist of digits only.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun getHint(secret: String, guess: String): String {
+        val ans = IntArray(10)
+        var bulls = 0
+        var cows = 0
+        for (i in 0 until secret.length) {
+            val s = Character.getNumericValue(secret[i])
+            val g = Character.getNumericValue(guess[i])
+            if (s == g) {
+                bulls++
+            } else {
+                // digit s was already seen in guess, is being seen again in secret
+                if (ans[s] < 0) {
+                    cows++
+                }
+                // digit was already seen in secret, now being seen again in guess
+                if (ans[g] > 0) {
+                    cows++
+                }
+                ans[s]++
+                ans[g]--
+            }
+        }
+        return bulls.toString() + "A" + cows + "B"
+    }
+}
+```