Added tasks 237, 241, 242.

Author: ThanhNIT

README.md

@@ -421,6 +421,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0232 |[Implement Queue using Stacks](src/main/kotlin/g0201_0300/s0232_implement_queue_using_stacks/MyQueue.kt)| Easy | Stack, Design, Queue | 258 | 70.86
+| 0242 |[Valid Anagram](src/main/kotlin/g0201_0300/s0242_valid_anagram/Solution.kt)| Easy | Top_Interview_Questions, String, Hash_Table, Sorting | 251 | 87.65
 | 0217 |[Contains Duplicate](src/main/kotlin/g0201_0300/s0217_contains_duplicate/Solution.kt)| Easy | Top_Interview_Questions, Array, Hash_Table, Sorting | 719 | 73.49
 
 #### Day 12 Class and Object
@@ -931,6 +932,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 0020 |[Valid Parentheses](src/main/kotlin/g0001_0100/s0020_valid_parentheses/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, String, Stack | 226 | 72.53
 | 0005 |[Longest Palindromic Substring](src/main/kotlin/g0001_0100/s0005_longest_palindromic_substring/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Dynamic_Programming | 323 | 75.48
 | 0394 |[Decode String](src/main/kotlin/g0301_0400/s0394_decode_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Stack, Recursion | 224 | 64.86
+| 0242 |[Valid Anagram](src/main/kotlin/g0201_0300/s0242_valid_anagram/Solution.kt)| Easy | Top_Interview_Questions, String, Hash_Table, Sorting | 251 | 87.65
 | 0049 |[Group Anagrams](src/main/kotlin/g0001_0100/s0049_group_anagrams/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, String, Hash_Table, Sorting | 506 | 86.55
 | 0151 |[Reverse Words in a String](src/main/kotlin/g0101_0200/s0151_reverse_words_in_a_string/Solution.kt)| Medium | String, Two_Pointers | 206 | 98.90
 
@@ -1125,6 +1127,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0242 |[Valid Anagram](src/main/kotlin/g0201_0300/s0242_valid_anagram/Solution.kt)| Easy | Top_Interview_Questions, String, Hash_Table, Sorting | 251 | 87.65
 
 #### Day 7 Linked List
 
@@ -1582,9 +1585,12 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 0295 |[Find Median from Data Stream](src/main/kotlin/g0201_0300/s0295_find_median_from_data_stream/MedianFinder.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Sorting, Two_Pointers, Design, Heap_Priority_Queue, Data_Stream | 2289 | 33.60
 | 0287 |[Find the Duplicate Number](src/main/kotlin/g0201_0300/s0287_find_the_duplicate_number/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Binary_Search, Two_Pointers, Bit_Manipulation, Binary_Search_II_Day_5 | 656 | 66.21
 | 0283 |[Move Zeroes](src/main/kotlin/g0201_0300/s0283_move_zeroes/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Two_Pointers, Algorithm_I_Day_3_Two_Pointers, Programming_Skills_I_Day_6_Array, Udemy_Arrays | 516 | 79.07
+| 0242 |[Valid Anagram](src/main/kotlin/g0201_0300/s0242_valid_anagram/Solution.kt)| Easy | Top_Interview_Questions, String, Hash_Table, Sorting, Data_Structure_I_Day_6_String, Programming_Skills_I_Day_11_Containers_and_Libraries, Udemy_Strings | 251 | 87.65
+| 0241 |[Different Ways to Add Parentheses](src/main/kotlin/g0201_0300/s0241_different_ways_to_add_parentheses/Solution.kt)| Medium | String, Dynamic_Programming, Math, Recursion, Memoization | 294 | 73.47
 | 0240 |[Search a 2D Matrix II](src/main/kotlin/g0201_0300/s0240_search_a_2d_matrix_ii/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Binary_Search, Matrix, Divide_and_Conquer, Data_Structure_II_Day_4_Array, Binary_Search_II_Day_8 | 460 | 66.08
 | 0239 |[Sliding Window Maximum](src/main/kotlin/g0201_0300/s0239_sliding_window_maximum/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Heap_Priority_Queue, Sliding_Window, Queue, Monotonic_Queue, Udemy_Arrays | 1059 | 86.14
 | 0238 |[Product of Array Except Self](src/main/kotlin/g0201_0300/s0238_product_of_array_except_self/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Prefix_Sum, Data_Structure_II_Day_5_Array, Udemy_Arrays | 669 | 48.96
+| 0237 |[Delete Node in a Linked List](src/main/kotlin/g0201_0300/s0237_delete_node_in_a_linked_list/Solution.kt)| Easy | Top_Interview_Questions, Linked_List | 183 | 93.00
 | 0236 |[Lowest Common Ancestor of a Binary Tree](src/main/kotlin/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Data_Structure_II_Day_18_Tree, Udemy_Tree_Stack_Queue | 386 | 45.21
 | 0235 |[Lowest Common Ancestor of a Binary Search Tree](src/main/kotlin/g0201_0300/s0235_lowest_common_ancestor_of_a_binary_search_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_I_Day_14_Tree, Level_1_Day_8_Binary_Search_Tree | 404 | 75.59
 | 0234 |[Palindrome Linked List](src/main/kotlin/g0201_0300/s0234_palindrome_linked_list/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Two_Pointers, Stack, Linked_List, Recursion, Level_2_Day_3_Linked_List, Udemy_Linked_List | 641 | 79.53

src/main/kotlin/g0201_0300/s0237_delete_node_in_a_linked_list/Solution.kt

@@ -0,0 +1,22 @@
+package g0201_0300.s0237_delete_node_in_a_linked_list
+
+// #Easy #Top_Interview_Questions #Linked_List #2022_10_27_Time_183_ms_(93.00%)_Space_35_MB_(95.19%)
+
+import com_github_leetcode.ListNode
+
+/*
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+class Solution {
+    fun deleteNode(node: ListNode?) {
+        node ?: return
+        node.`val` = node.next!!.`val`
+        node.next = node.next!!.next
+    }
+}

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

@@ -0,0 +1,49 @@
+237\. Delete Node in a Linked List
+
+Medium
+
+There is a singly-linked list `head` and we want to delete a node `node` in it.
+
+You are given the node to be deleted `node`. You will **not be given access** to the first node of `head`.
+
+All the values of the linked list are **unique**, and it is guaranteed that the given node `node` is not the last node in the linked list.
+
+Delete the given node. Note that by deleting the node, we do not mean removing it from memory. We mean:
+
+*   The value of the given node should not exist in the linked list.
+*   The number of nodes in the linked list should decrease by one.
+*   All the values before `node` should be in the same order.
+*   All the values after `node` should be in the same order.
+
+**Custom testing:**
+
+*   For the input, you should provide the entire linked list `head` and the node to be given `node`. `node` should not be the last node of the list and should be an actual node in the list.
+*   We will build the linked list and pass the node to your function.
+*   The output will be the entire list after calling your function.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/01/node1.jpg)
+
+**Input:** head = [4,5,1,9], node = 5
+
+**Output:** [4,1,9]
+
+**Explanation:** You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/09/01/node2.jpg)
+
+**Input:** head = [4,5,1,9], node = 1
+
+**Output:** [4,5,9]
+
+**Explanation:** You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.
+
+**Constraints:**
+
+*   The number of the nodes in the given list is in the range `[2, 1000]`.
+*   `-1000 <= Node.val <= 1000`
+*   The value of each node in the list is **unique**.
+*   The `node` to be deleted is **in the list** and is **not a tail** node.

src/main/kotlin/g0201_0300/s0241_different_ways_to_add_parentheses/Solution.kt

@@ -0,0 +1,50 @@
+package g0201_0300.s0241_different_ways_to_add_parentheses
+
+// #Medium #String #Dynamic_Programming #Math #Recursion #Memoization
+// #2022_10_27_Time_294_ms_(73.47%)_Space_35.1_MB_(91.84%)
+
+class Solution {
+    fun diffWaysToCompute(expression: String): List<Int> {
+        return diffWayToCompute(expression, hashMapOf())
+    }
+
+    private fun diffWayToCompute(expression: String, hashMap: HashMap<String, List<Int>>): List<Int> {
+        if (hashMap.containsKey(expression)) {
+            return hashMap[expression]!!
+        }
+        val newList = arrayListOf<Int>()
+        if (!hasOperatorInBetween(expression)) {
+            newList.add(Integer.parseInt(expression))
+        } else {
+            for ((index, _) in expression.withIndex()) {
+                val operator = expression[index]
+                if (!Character.isDigit(operator)) {
+                    val leftExpression = diffWayToCompute(expression.substring(0, index), hashMap)
+                    val rightExpression = diffWayToCompute(expression.substring(index + 1), hashMap)
+                    for (l in leftExpression) {
+                        for (r in rightExpression) {
+                            when (operator) {
+                                '+' -> newList.add(l + r)
+                                '-' -> newList.add(l - r)
+                                '*' -> newList.add(l * r)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        hashMap[expression] = newList
+        return newList
+    }
+
+    private fun hasOperatorInBetween(expression: String): Boolean {
+        for ((index, _) in expression.withIndex()) {
+            when (expression[index]) {
+                '+' -> return true
+                '-' -> return true
+                '*' -> return true
+            }
+        }
+        return false
+    }
+}

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

@@ -0,0 +1,33 @@
+241\. Different Ways to Add Parentheses
+
+Medium
+
+Given a string `expression` of numbers and operators, return _all possible results from computing all the different possible ways to group numbers and operators_. You may return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** expression = "2-1-1"
+
+**Output:** [0,2]
+
+**Explanation:** ((2-1)-1) = 0 (2-(1-1)) = 2
+
+**Example 2:**
+
+**Input:** expression = "2\*3-4\*5"
+
+**Output:** [-34,-14,-10,-10,10]
+
+**Explanation:**
+
+    (2*(3-(4*5))) = -34
+    ((2*3)-(4*5)) = -14
+    ((2*(3-4))*5) = -10
+    (2*((3-4)*5)) = -10
+    (((2*3)-4)*5) = 10 
+
+**Constraints:**
+
+*   `1 <= expression.length <= 20`
+*   `expression` consists of digits and the operator `'+'`, `'-'`, and `'*'`.
+*   All the integer values in the input expression are in the range `[0, 99]`.

src/main/kotlin/g0201_0300/s0242_valid_anagram/Solution.kt

@@ -0,0 +1,24 @@
+package g0201_0300.s0242_valid_anagram
+
+// #Easy #Top_Interview_Questions #String #Hash_Table #Sorting #Data_Structure_I_Day_6_String
+// #Programming_Skills_I_Day_11_Containers_and_Libraries #Udemy_Strings
+// #2022_10_27_Time_251_ms_(87.65%)_Space_39.1_MB_(69.49%)
+
+class Solution {
+    fun isAnagram(s: String, t: String): Boolean {
+        if (s.length != t.length) {
+            return false
+        }
+        val counter = IntArray(26)
+        for (i in 0 until s.length) {
+            counter[s[i] - 'a']++
+            counter[t[i] - 'a']--
+        }
+        for (count in counter) {
+            if (count != 0) {
+                return false
+            }
+        }
+        return true
+    }
+}

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

@@ -0,0 +1,26 @@
+242\. Valid Anagram
+
+Easy
+
+Given two strings `s` and `t`, return `true` _if_ `t` _is an anagram of_ `s`_, and_ `false` _otherwise_.
+
+An **Anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.
+
+**Example 1:**
+
+**Input:** s = "anagram", t = "nagaram"
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** s = "rat", t = "car"
+
+**Output:** false
+
+**Constraints:**
+
+*   <code>1 <= s.length, t.length <= 5 * 10<sup>4</sup></code>
+*   `s` and `t` consist of lowercase English letters.
+
+**Follow up:** What if the inputs contain Unicode characters? How would you adapt your solution to such a case?

src/test/kotlin/g0201_0300/s0237_delete_node_in_a_linked_list/SolutionTest.kt

@@ -0,0 +1,38 @@
+package g0201_0300.s0237_delete_node_in_a_linked_list
+
+import com_github_leetcode.ListNode
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun deleteNode() {
+        val headActual = ListNode(1)
+        headActual.next = ListNode(2)
+        headActual.next!!.next = ListNode(3)
+        headActual.next!!.next!!.next = ListNode(4)
+        Solution().deleteNode(headActual.next!!.next)
+        assertThat(headActual.toString(), equalTo("1, 2, 4"))
+    }
+
+    @Test
+    fun deleteNode2() {
+        val headActual = ListNode(1)
+        headActual.next = ListNode(2)
+        headActual.next!!.next = ListNode(3)
+        headActual.next!!.next!!.next = ListNode(4)
+        Solution().deleteNode(headActual)
+        assertThat(headActual.toString(), equalTo("2, 3, 4"))
+    }
+
+    @Test
+    fun deleteNode3() {
+        val headActual = ListNode(1)
+        headActual.next = ListNode(2)
+        headActual.next!!.next = ListNode(3)
+        headActual.next!!.next!!.next = ListNode(4)
+        Solution().deleteNode(headActual.next)
+        assertThat(headActual.toString(), equalTo("1, 3, 4"))
+    }
+}

src/test/kotlin/g0201_0300/s0241_different_ways_to_add_parentheses/SolutionTest.kt

@@ -0,0 +1,21 @@
+package g0201_0300.s0241_different_ways_to_add_parentheses
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+import java.util.Arrays
+
+internal class SolutionTest {
+    @Test
+    fun diffWaysToCompute() {
+        assertThat(Solution().diffWaysToCompute("2-1-1"), equalTo(Arrays.asList(2, 0)))
+    }
+
+    @Test
+    fun diffWaysToCompute2() {
+        assertThat(
+            Solution().diffWaysToCompute("2*3-4*5"),
+            equalTo(Arrays.asList(-34, -10, -14, -10, 10))
+        )
+    }
+}

src/test/kotlin/g0201_0300/s0242_valid_anagram/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0201_0300.s0242_valid_anagram
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isAnagram() {
+        assertThat(Solution().isAnagram("anagram", "nagaram"), equalTo(true))
+    }
+
+    @Test
+    fun isAnagram2() {
+        assertThat(Solution().isAnagram("rat", "car"), equalTo(false))
+    }
+}