Added tasks 220, 222, 223, 224.

Author: ThanhNIT

README.md

@@ -173,6 +173,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0222 |[Count Complete Tree Nodes](src/main/kotlin/g0201_0300/s0222_count_complete_tree_nodes/Solution.kt)| |||
 
 #### Day 11
 
@@ -1581,7 +1582,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 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
 | 0230 |[Kth Smallest Element in a BST](src/main/kotlin/g0201_0300/s0230_kth_smallest_element_in_a_bst/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_II_Day_17_Tree, Level_2_Day_9_Binary_Search_Tree | 393 | 33.33
 | 0226 |[Invert Binary Tree](src/main/kotlin/g0201_0300/s0226_invert_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Data_Structure_I_Day_12_Tree, Level_2_Day_6_Tree, Udemy_Tree_Stack_Queue | 233 | 54.90
+| 0224 |[Basic Calculator](src/main/kotlin/g0201_0300/s0224_basic_calculator/Solution.kt)| Hard | String, Math, Stack, Recursion | 294 | 93.33
+| 0223 |[Rectangle Area](src/main/kotlin/g0201_0300/s0223_rectangle_area/Solution.kt)| Medium | Math, Geometry | 291 | 66.67
+| 0222 |[Count Complete Tree Nodes](src/main/kotlin/g0201_0300/s0222_count_complete_tree_nodes/Solution.kt)| |||
 | 0221 |[Maximal Square](src/main/kotlin/g0201_0300/s0221_maximal_square/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Matrix, Dynamic_Programming_I_Day_16 | 614 | 44.00
+| 0220 |[Contains Duplicate III](src/main/kotlin/g0201_0300/s0220_contains_duplicate_iii/Solution.kt)| Medium | Array, Sorting, Sliding_Window, Ordered_Set, Bucket_Sort | 921 | 72.22
 | 0219 |[Contains Duplicate II](src/main/kotlin/g0201_0300/s0219_contains_duplicate_ii/Solution.kt)| Easy | Array, Hash_Table, Sliding_Window | 813 | 80.46
 | 0218 |[The Skyline Problem](src/main/kotlin/g0201_0300/s0218_the_skyline_problem/Solution.kt)| Hard | Top_Interview_Questions, Array, Heap_Priority_Queue, Ordered_Set, Divide_and_Conquer, Segment_Tree, Binary_Indexed_Tree, Line_Sweep | 365 | 93.14
 | 0217 |[Contains Duplicate](src/main/kotlin/g0201_0300/s0217_contains_duplicate/Solution.kt)| Easy | Top_Interview_Questions, Array, Hash_Table, Sorting, Data_Structure_I_Day_1_Array, Programming_Skills_I_Day_11_Containers_and_Libraries, Udemy_Arrays | 719 | 73.49

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

@@ -0,0 +1,35 @@
+package g0201_0300.s0220_contains_duplicate_iii
+
+// #Medium #Array #Sorting #Sliding_Window #Ordered_Set #Bucket_Sort
+// #2022_10_25_Time_921_ms_(72.22%)_Space_77.4_MB_(41.67%)
+
+class Solution {
+    private fun getId(i: Long, w: Long): Long {
+        return if (i < 0) (i + 1) / w - 1 else i / w
+    }
+
+    fun containsNearbyAlmostDuplicate(nums: IntArray, k: Int, t: Int): Boolean {
+        if (t < 0) {
+            return false
+        }
+        val d: MutableMap<Long, Long> = HashMap()
+        val w = t.toLong() + 1
+        for (i in nums.indices) {
+            val m = getId(nums[i].toLong(), w)
+            if (d.containsKey(m)) {
+                return true
+            }
+            if (d.containsKey(m - 1) && Math.abs(nums[i] - d[m - 1]!!) < w) {
+                return true
+            }
+            if (d.containsKey(m + 1) && Math.abs(nums[i] - d[m + 1]!!) < w) {
+                return true
+            }
+            d[m] = nums[i].toLong()
+            if (i >= k) {
+                d.remove(getId(nums[i - k].toLong(), w))
+            }
+        }
+        return false
+    }
+}

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

@@ -0,0 +1,46 @@
+220\. Contains Duplicate III
+
+Hard
+
+You are given an integer array `nums` and two integers `indexDiff` and `valueDiff`.
+
+Find a pair of indices `(i, j)` such that:
+
+*   `i != j`,
+*   `abs(i - j) <= indexDiff`.
+*   `abs(nums[i] - nums[j]) <= valueDiff`, and
+
+Return `true` _if such pair exists or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,1], indexDiff = 3, valueDiff = 0
+
+**Output:** true
+
+**Explanation:** We can choose (i, j) = (0, 3). 
+
+We satisfy the three conditions: 
+
+i != j --> 0 != 3 
+
+abs(i - j) <= indexDiff --> 
+
+abs(0 - 3) <= 3 
+
+abs(nums[i] - nums[j]) <= valueDiff --> abs(1 - 1) <= 0
+
+**Example 2:**
+
+**Input:** nums = [1,5,9,1,5,9], indexDiff = 2, valueDiff = 3
+
+**Output:** false
+
+**Explanation:** After trying all the possible pairs (i, j), we cannot satisfy the three conditions, so we return false.
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   `1 <= indexDiff <= nums.length`
+*   <code>0 <= valueDiff <= 10<sup>9</sup></code>

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

@@ -0,0 +1,41 @@
+package g0201_0300.s0222_count_complete_tree_nodes
+
+import com_github_leetcode.TreeNode
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun countNodes(root: TreeNode?): Int {
+        if (root == null) {
+            return 0
+        }
+        val leftHeight = leftHeight(root)
+        val rightHeight = rightHeight(root)
+        // case 1: When Height(Left sub-tree) = Height(right sub-tree) 2^h - 1
+        return if (leftHeight == rightHeight) {
+            (1 shl leftHeight) - 1
+        } else {
+            1 + countNodes(root.left) + countNodes(root.right)
+        }
+    }
+
+    private fun leftHeight(root: TreeNode?): Int {
+        return if (root == null) {
+            0
+        } else 1 + leftHeight(root.left)
+    }
+
+    private fun rightHeight(root: TreeNode?): Int {
+        return if (root == null) {
+            0
+        } else 1 + rightHeight(root.right)
+    }
+}

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

@@ -0,0 +1,35 @@
+222\. Count Complete Tree Nodes
+
+Medium
+
+Given the `root` of a **complete** binary tree, return the number of the nodes in the tree.
+
+According to **[Wikipedia](http://en.wikipedia.org/wiki/Binary_tree#Types_of_binary_trees)**, every level, except possibly the last, is completely filled in a complete binary tree, and all nodes in the last level are as far left as possible. It can have between `1` and <code>2<sup>h</sup></code> nodes inclusive at the last level `h`.
+
+Design an algorithm that runs in less than `O(n)` time complexity.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/14/complete.jpg)
+
+**Input:** root = [1,2,3,4,5,6]
+
+**Output:** 6
+
+**Example 2:**
+
+**Input:** root = []
+
+**Output:** 0
+
+**Example 3:**
+
+**Input:** root = [1]
+
+**Output:** 1
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.
+*   <code>0 <= Node.val <= 5 * 10<sup>4</sup></code>
+*   The tree is guaranteed to be **complete**.

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

@@ -0,0 +1,20 @@
+package g0201_0300.s0223_rectangle_area
+
+// #Medium #Math #Geometry #2022_10_25_Time_291_ms_(66.67%)_Space_37.8_MB_(55.56%)
+
+@Suppress("kotlin:S107")
+class Solution {
+    fun computeArea(ax1: Int, ay1: Int, ax2: Int, ay2: Int, bx1: Int, by1: Int, bx2: Int, by2: Int): Int {
+        val left = Math.max(ax1, bx1).toLong()
+        val right = Math.min(ax2, bx2).toLong()
+        val top = Math.min(ay2, by2).toLong()
+        val bottom = Math.max(ay1, by1).toLong()
+        var area = (right - left) * (top - bottom)
+        // if not overlaping, either of these two will be non-posittive
+        // if right - left = 0, are will automtically be 0 as well
+        if (right - left < 0 || top - bottom < 0) {
+            area = 0
+        }
+        return ((ax2 - ax1) * (ay2 - ay1) + (bx2 - bx1) * (by2 - by1) - area).toInt()
+    }
+}

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

@@ -0,0 +1,30 @@
+223\. Rectangle Area
+
+Medium
+
+Given the coordinates of two **rectilinear** rectangles in a 2D plane, return _the total area covered by the two rectangles_.
+
+The first rectangle is defined by its **bottom-left** corner `(ax1, ay1)` and its **top-right** corner `(ax2, ay2)`.
+
+The second rectangle is defined by its **bottom-left** corner `(bx1, by1)` and its **top-right** corner `(bx2, by2)`.
+
+**Example 1:**
+
+![Rectangle Area](https://assets.leetcode.com/uploads/2021/05/08/rectangle-plane.png)
+
+**Input:** ax1 = -3, ay1 = 0, ax2 = 3, ay2 = 4, bx1 = 0, by1 = -1, bx2 = 9, by2 = 2
+
+**Output:** 45
+
+**Example 2:**
+
+**Input:** ax1 = -2, ay1 = -2, ax2 = 2, ay2 = 2, bx1 = -2, by1 = -2, bx2 = 2, by2 = 2
+
+**Output:** 16
+
+**Constraints:**
+
+*   <code>-10<sup>4</sup> <= ax1 <= ax2 <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= ay1 <= ay2 <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= bx1 <= bx2 <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= by1 <= by2 <= 10<sup>4</sup></code>

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

@@ -0,0 +1,46 @@
+package g0201_0300.s0224_basic_calculator
+
+// #Hard #String #Math #Stack #Recursion #2022_10_25_Time_294_ms_(93.33%)_Space_40.3_MB_(90.00%)
+
+class Solution {
+    private var i = 0
+    fun calculate(s: String): Int {
+        val ca = s.toCharArray()
+        return helper(ca)
+    }
+
+    private fun helper(ca: CharArray): Int {
+        var num = 0
+        var prenum = 0
+        var isPlus = true
+        while (i < ca.size) {
+            val c = ca[i]
+            if (c != ' ') {
+                if (c >= '0' && c <= '9') {
+                    num = if (num == 0) {
+                        c.code - '0'.code
+                    } else {
+                        num * 10 + c.code - '0'.code
+                    }
+                } else if (c == '+') {
+                    prenum += num * if (isPlus) 1 else -1
+                    isPlus = true
+                    num = 0
+                } else if (c == '-') {
+                    prenum += num * if (isPlus) 1 else -1
+                    num = 0
+                    isPlus = false
+                } else if (c == '(') {
+                    i++
+                    prenum += helper(ca) * if (isPlus) 1 else -1
+                    isPlus = true
+                    num = 0
+                } else if (c == ')') {
+                    return prenum + num * if (isPlus) 1 else -1
+                }
+            }
+            i++
+        }
+        return prenum + num * if (isPlus) 1 else -1
+    }
+}

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

@@ -0,0 +1,35 @@
+224\. Basic Calculator
+
+Hard
+
+Given a string `s` representing a valid expression, implement a basic calculator to evaluate it, and return _the result of the evaluation_.
+
+**Note:** You are **not** allowed to use any built-in function which evaluates strings as mathematical expressions, such as `eval()`.
+
+**Example 1:**
+
+**Input:** s = "1 + 1"
+
+**Output:** 2
+
+**Example 2:**
+
+**Input:** s = " 2-1 + 2 "
+
+**Output:** 3
+
+**Example 3:**
+
+**Input:** s = "(1+(4+5+2)-3)+(6+8)"
+
+**Output:** 23
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 3 * 10<sup>5</sup></code>
+*   `s` consists of digits, `'+'`, `'-'`, `'('`, `')'`, and `' '`.
+*   `s` represents a valid expression.
+*   `'+'` is **not** used as a unary operation (i.e., `"+1"` and `"+(2 + 3)"` is invalid).
+*   `'-'` could be used as a unary operation (i.e., `"-1"` and `"-(2 + 3)"` is valid).
+*   There will be no two consecutive operators in the input.
+*   Every number and running calculation will fit in a signed 32-bit integer.

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

@@ -0,0 +1,31 @@
+package g0201_0300.s0220_contains_duplicate_iii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun containsNearbyAlmostDuplicate() {
+        assertThat(
+            Solution().containsNearbyAlmostDuplicate(intArrayOf(1, 2, 3, 1), 3, 0),
+            equalTo(true)
+        )
+    }
+
+    @Test
+    fun containsNearbyAlmostDuplicate2() {
+        assertThat(
+            Solution().containsNearbyAlmostDuplicate(intArrayOf(1, 0, 1, 1), 1, 2),
+            equalTo(true)
+        )
+    }
+
+    @Test
+    fun containsNearbyAlmostDuplicate3() {
+        assertThat(
+            Solution().containsNearbyAlmostDuplicate(intArrayOf(1, 5, 9, 1, 5, 9), 2, 3),
+            equalTo(false)
+        )
+    }
+}

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

@@ -0,0 +1,29 @@
+package g0201_0300.s0222_count_complete_tree_nodes
+
+import com_github_leetcode.TreeNode
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun countNodes() {
+        val leftNodeLeftNode = TreeNode(4)
+        val leftNodeRightNode = TreeNode(5)
+        val leftNode = TreeNode(2, leftNodeLeftNode, leftNodeRightNode)
+        val rightNodeLeftNode = TreeNode(6)
+        val rightNode = TreeNode(3, rightNodeLeftNode, null)
+        val root = TreeNode(1, leftNode, rightNode)
+        assertThat(Solution().countNodes(root), equalTo(6))
+    }
+
+    @Test
+    fun countNodes2() {
+        assertThat(Solution().countNodes(null), equalTo(0))
+    }
+
+    @Test
+    fun countNodes3() {
+        assertThat(Solution().countNodes(TreeNode(1)), equalTo(1))
+    }
+}

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

@@ -0,0 +1,17 @@
+package g0201_0300.s0223_rectangle_area
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun rectangleArea() {
+        assertThat(Solution().computeArea(-3, 0, 3, 4, 0, -1, 9, 2), equalTo(45))
+    }
+
+    @Test
+    fun rectangleArea2() {
+        assertThat(Solution().computeArea(-2, -2, 2, 2, -2, -2, 2, 2), equalTo(16))
+    }
+}