Added tasks 701, 703, 704, 705

Author: ThanhNIT

README.md

@@ -368,6 +368,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0704 |[Binary Search](src/main/kotlin/g0701_0800/s0704_binary_search/Solution.kt)| Easy | Array, Binary_Search | 261 | 77.91
 | 0278 |[First Bad Version](src.save/main/kotlin/g0201_0300/s0278_first_bad_version/Solution.kt)| Easy | Binary_Search, Interactive | 349 | 76.86
 
 #### Day 8 Binary Search Tree
@@ -597,6 +598,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0704 |[Binary Search](src/main/kotlin/g0701_0800/s0704_binary_search/Solution.kt)| Easy | Array, Binary_Search | 261 | 77.91
 | 0033 |[Search in Rotated Sorted Array](src.save/main/kotlin/g0001_0100/s0033_search_in_rotated_sorted_array/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Binary_Search | 184 | 86.08
 | 0153 |[Find Minimum in Rotated Sorted Array](src.save/main/kotlin/g0101_0200/s0153_find_minimum_in_rotated_sorted_array/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Binary_Search | 262 | 60.96
 
@@ -693,6 +695,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 0111 |[Minimum Depth of Binary Tree](src.save/main/kotlin/g0101_0200/s0111_minimum_depth_of_binary_tree/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 525 | 90.51
 | 0104 |[Maximum Depth of Binary Tree](src.save/main/kotlin/g0101_0200/s0104_maximum_depth_of_binary_tree/Solution.kt)| 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.save/main/kotlin/g0101_0200/s0110_balanced_binary_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree | 310 | 63.63
+| 0701 |[Insert into a Binary Search Tree](src/main/kotlin/g0701_0800/s0701_insert_into_a_binary_search_tree/Solution.kt)| Medium | Tree, Binary_Tree, Binary_Search_Tree | 311 | 79.03
 | 0297 |[Serialize and Deserialize Binary Tree](src.save/main/kotlin/g0201_0300/s0297_serialize_and_deserialize_binary_tree/Codec.kt)| 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.save/main/kotlin/g0101_0200/s0124_binary_tree_maximum_path_sum/Solution.kt)| 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.save/main/kotlin/g0001_0100/s0098_validate_binary_search_tree/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 330 | 41.38
@@ -857,6 +860,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0700 |[Search in a Binary Search Tree](src/main/kotlin/g0601_0700/s0700_search_in_a_binary_search_tree/Solution.kt)| Easy | Tree, Binary_Tree, Binary_Search_Tree | 251 | 88.31
+| 0701 |[Insert into a Binary Search Tree](src/main/kotlin/g0701_0800/s0701_insert_into_a_binary_search_tree/Solution.kt)| Medium | Tree, Binary_Tree, Binary_Search_Tree | 311 | 79.03
 
 #### Day 14 Tree
 
@@ -1021,6 +1025,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0704 |[Binary Search](src/main/kotlin/g0701_0800/s0704_binary_search/Solution.kt)| Easy | Array, Binary_Search | 261 | 77.91
 | 0278 |[First Bad Version](src.save/main/kotlin/g0201_0300/s0278_first_bad_version/Solution.kt)| Easy | Binary_Search, Interactive | 349 | 76.86
 | 0035 |[Search Insert Position](src.save/main/kotlin/g0001_0100/s0035_search_insert_position/Solution.kt)| Easy | Top_100_Liked_Questions, Array, Binary_Search | 267 | 50.32
 
@@ -1268,6 +1273,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0704 |[Binary Search](src/main/kotlin/g0701_0800/s0704_binary_search/Solution.kt)| Easy | Array, Binary_Search | 261 | 77.91
 | 0374 |[Guess Number Higher or Lower](src.save/main/kotlin/g0301_0400/s0374_guess_number_higher_or_lower/Solution.kt)| Easy | Binary_Search, Interactive | 134 | 94.19
 
 #### Day 2
@@ -1681,6 +1687,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 0864 |[Shortest Path to Get All Keys](src/main/kotlin/g0801_0900/s0864_shortest_path_to_get_all_keys/Solution.kt)| Hard | Breadth_First_Search, Bit_Manipulation | 176 | 100.00
 | 0763 |[Partition Labels](src/main/kotlin/g0701_0800/s0763_partition_labels/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Greedy, Two_Pointers, Data_Structure_II_Day_7_String | 235 | 84.75
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6 | 936 | 80.54
+| 0705 |[Design HashSet](src/main/kotlin/g0701_0800/s0705_design_hashset/MyHashSet.kt)| Easy | Array, Hash_Table, Design, Linked_List, Hash_Function | 385 | 75.61
+| 0704 |[Binary Search](src/main/kotlin/g0701_0800/s0704_binary_search/Solution.kt)| Easy | Array, Binary_Search, Algorithm_I_Day_1_Binary_Search, Binary_Search_I_Day_1, Level_1_Day_7_Binary_Search, Udemy_Binary_Search | 261 | 77.91
+| 0703 |[Kth Largest Element in a Stream](src/main/kotlin/g0701_0800/s0703_kth_largest_element_in_a_stream/KthLargest.kt)| Easy | Tree, Binary_Tree, Design, Heap_Priority_Queue, Binary_Search_Tree, Data_Stream | 286 | 95.45
+| 0701 |[Insert into a Binary Search Tree](src/main/kotlin/g0701_0800/s0701_insert_into_a_binary_search_tree/Solution.kt)| Medium | Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_I_Day_13_Tree, Udemy_Tree_Stack_Queue | 311 | 79.03
 | 0700 |[Search in a Binary Search Tree](src/main/kotlin/g0601_0700/s0700_search_in_a_binary_search_tree/Solution.kt)| Easy | Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_I_Day_13_Tree | 251 | 88.31
 | 0699 |[Falling Squares](src/main/kotlin/g0601_0700/s0699_falling_squares/Solution.kt)| Hard | Array, Ordered_Set, Segment_Tree | 293 | 100.00
 | 0698 |[Partition to K Equal Sum Subsets](src/main/kotlin/g0601_0700/s0698_partition_to_k_equal_sum_subsets/Solution.kt)| Medium | Array, Dynamic_Programming, Bit_Manipulation, Backtracking, Bitmask, Memoization | 191 | 100.00

src/main/kotlin/g0701_0800/s0701_insert_into_a_binary_search_tree/Solution.kt

@@ -0,0 +1,35 @@
+package g0701_0800.s0701_insert_into_a_binary_search_tree
+
+// #Medium #Tree #Binary_Tree #Binary_Search_Tree #Data_Structure_I_Day_13_Tree
+// #Udemy_Tree_Stack_Queue #2023_02_23_Time_311_ms_(79.03%)_Space_38.5_MB_(11.29%)
+
+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 insertIntoBST(
+        root: TreeNode?,
+        value: Int
+    ): TreeNode? {
+        if (root == null) {
+            return TreeNode(value)
+        }
+
+        when {
+            root.value < value -> root.right = insertIntoBST(root.right, value)
+            root.value > value -> root.left = insertIntoBST(root.left, value)
+        }
+
+        return root
+    }
+    private val TreeNode.value get() = `val`
+}

src/main/kotlin/g0701_0800/s0701_insert_into_a_binary_search_tree/readme.md

@@ -0,0 +1,37 @@
+701\. Insert into a Binary Search Tree
+
+Medium
+
+You are given the `root` node of a binary search tree (BST) and a `value` to insert into the tree. Return _the root node of the BST after the insertion_. It is **guaranteed** that the new value does not exist in the original BST.
+
+**Notice** that there may exist multiple valid ways for the insertion, as long as the tree remains a BST after insertion. You can return **any of them**.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/05/insertbst.jpg)
+
+**Input:** root = [4,2,7,1,3], val = 5
+
+**Output:** [4,2,7,1,3,5]
+
+**Explanation:** Another accepted tree is: ![](https://assets.leetcode.com/uploads/2020/10/05/bst.jpg)
+
+**Example 2:**
+
+**Input:** root = [40,20,60,10,30,50,70], val = 25
+
+**Output:** [40,20,60,10,30,50,70,null,null,25]
+
+**Example 3:**
+
+**Input:** root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
+
+**Output:** [4,2,7,1,3,5]
+
+**Constraints:**
+
+*   The number of nodes in the tree will be in the range <code>[0, 10<sup>4</sup>]</code>.
+*   <code>-10<sup>8</sup> <= Node.val <= 10<sup>8</sup></code>
+*   All the values `Node.val` are **unique**.
+*   <code>-10<sup>8</sup> <= val <= 10<sup>8</sup></code>
+*   It's **guaranteed** that `val` does not exist in the original BST.

src/main/kotlin/g0701_0800/s0703_kth_largest_element_in_a_stream/KthLargest.kt

@@ -0,0 +1,32 @@
+package g0701_0800.s0703_kth_largest_element_in_a_stream
+
+// #Easy #Tree #Binary_Tree #Design #Heap_Priority_Queue #Binary_Search_Tree #Data_Stream
+// #2023_02_23_Time_286_ms_(95.45%)_Space_59.4_MB_(32.95%)
+
+import java.util.PriorityQueue
+
+class KthLargest(private val maxSize: Int, nums: IntArray) {
+    private val heap: PriorityQueue<Int> = PriorityQueue()
+
+    init {
+        for (num in nums) {
+            add(num)
+        }
+    }
+
+    fun add(`val`: Int): Int {
+        if (heap.size < maxSize) {
+            heap.add(`val`)
+        } else if (heap.peek() < `val`) {
+            heap.add(`val`)
+            heap.poll()
+        }
+        return heap.peek()
+    }
+}
+
+/*
+ * Your KthLargest object will be instantiated and called as such:
+ * var obj = KthLargest(k, nums)
+ * var param_1 = obj.add(`val`)
+ */

src/main/kotlin/g0701_0800/s0703_kth_largest_element_in_a_stream/readme.md

@@ -0,0 +1,37 @@
+703\. Kth Largest Element in a Stream
+
+Easy
+
+Design a class to find the <code>k<sup>th</sup></code> largest element in a stream. Note that it is the <code>k<sup>th</sup></code> largest element in the sorted order, not the <code>k<sup>th</sup></code> distinct element.
+
+Implement `KthLargest` class:
+
+*   `KthLargest(int k, int[] nums)` Initializes the object with the integer `k` and the stream of integers `nums`.
+*   `int add(int val)` Appends the integer `val` to the stream and returns the element representing the <code>k<sup>th</sup></code> largest element in the stream.
+
+**Example 1:**
+
+**Input**
+
+    ["KthLargest", "add", "add", "add", "add", "add"] 
+    [[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]
+
+**Output:** [null, 4, 5, 5, 8, 8]
+
+**Explanation:**
+
+    KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]); 
+    kthLargest.add(3); // return 4 
+    kthLargest.add(5); // return 5 
+    kthLargest.add(10); // return 5 
+    kthLargest.add(9); // return 8 
+    kthLargest.add(4); // return 8
+
+**Constraints:**
+
+*   <code>1 <= k <= 10<sup>4</sup></code>
+*   <code>0 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= val <= 10<sup>4</sup></code>
+*   At most <code>10<sup>4</sup></code> calls will be made to `add`.
+*   It is guaranteed that there will be at least `k` elements in the array when you search for the <code>k<sup>th</sup></code> element.

src/main/kotlin/g0701_0800/s0704_binary_search/Solution.kt

@@ -0,0 +1,12 @@
+package g0701_0800.s0704_binary_search
+
+// #Easy #Array #Binary_Search #Algorithm_I_Day_1_Binary_Search #Binary_Search_I_Day_1
+// #Level_1_Day_7_Binary_Search #Udemy_Binary_Search
+// #2023_02_23_Time_261_ms_(77.91%)_Space_38.7_MB_(34.19%)
+
+class Solution {
+    fun search(nums: IntArray, target: Int): Int {
+        val index = nums.binarySearch(target)
+        return if (index >= 0) index else -1
+    }
+}

src/main/kotlin/g0701_0800/s0704_binary_search/readme.md

@@ -0,0 +1,30 @@
+704\. Binary Search
+
+Easy
+
+Given an array of integers `nums` which is sorted in ascending order, and an integer `target`, write a function to search `target` in `nums`. If `target` exists, then return its index. Otherwise, return `-1`.
+
+You must write an algorithm with `O(log n)` runtime complexity.
+
+**Example 1:**
+
+**Input:** nums = [-1,0,3,5,9,12], target = 9
+
+**Output:** 4
+
+**Explanation:** 9 exists in nums and its index is 4
+
+**Example 2:**
+
+**Input:** nums = [-1,0,3,5,9,12], target = 2
+
+**Output:** -1
+
+**Explanation:** 2 does not exist in nums so return -1
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> < nums[i], target < 10<sup>4</sup></code>
+*   All the integers in `nums` are **unique**.
+*   `nums` is sorted in ascending order.

src/main/kotlin/g0701_0800/s0705_design_hashset/MyHashSet.kt

@@ -0,0 +1,28 @@
+package g0701_0800.s0705_design_hashset
+
+// #Easy #Array #Hash_Table #Design #Linked_List #Hash_Function
+// #2023_02_23_Time_385_ms_(75.61%)_Space_111.9_MB_(7.32%)
+
+class MyHashSet {
+    private val arr: BooleanArray = BooleanArray(1000001)
+
+    fun add(key: Int) {
+        arr[key] = true
+    }
+
+    fun remove(key: Int) {
+        arr[key] = false
+    }
+
+    operator fun contains(key: Int): Boolean {
+        return arr[key]
+    }
+}
+
+/*
+ * Your MyHashSet object will be instantiated and called as such:
+ * var obj = MyHashSet()
+ * obj.add(key)
+ * obj.remove(key)
+ * var param_3 = obj.contains(key)
+ */

src/main/kotlin/g0701_0800/s0705_design_hashset/readme.md

@@ -0,0 +1,37 @@
+705\. Design HashSet
+
+Easy
+
+Design a HashSet without using any built-in hash table libraries.
+
+Implement `MyHashSet` class:
+
+*   `void add(key)` Inserts the value `key` into the HashSet.
+*   `bool contains(key)` Returns whether the value `key` exists in the HashSet or not.
+*   `void remove(key)` Removes the value `key` in the HashSet. If `key` does not exist in the HashSet, do nothing.
+
+**Example 1:**
+
+**Input**
+
+    ["MyHashSet", "add", "add", "contains", "contains", "add", "contains", "remove", "contains"]
+    [[], [1], [2], [1], [3], [2], [2], [2], [2]]
+
+**Output:** [null, null, null, true, false, null, true, null, false]
+
+**Explanation:**
+
+    MyHashSet myHashSet = new MyHashSet(); 
+    myHashSet.add(1); // set = [1] 
+    myHashSet.add(2); // set = [1, 2] 
+    myHashSet.contains(1); // return True 
+    myHashSet.contains(3); // return False, (not found) 
+    myHashSet.add(2); // set = [1, 2] 
+    myHashSet.contains(2); // return True 
+    myHashSet.remove(2); // set = [1] 
+    myHashSet.contains(2); // return False, (already removed)
+
+**Constraints:**
+
+*   <code>0 <= key <= 10<sup>6</sup></code>
+*   At most <code>10<sup>4</sup></code> calls will be made to `add`, `remove`, and `contains`.

src/test/kotlin/g0701_0800/s0701_insert_into_a_binary_search_tree/SolutionTest.kt

@@ -0,0 +1,36 @@
+package g0701_0800.s0701_insert_into_a_binary_search_tree
+
+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 insertIntoBST() {
+        val treeNode: TreeNode? = TreeNode.create(listOf(4, 2, 7, 1, 3))
+        val expected: TreeNode? = TreeNode.create(listOf(4, 2, 7, 1, 3, 5))
+        assertThat(
+            Solution().insertIntoBST(treeNode, 5).toString(), equalTo(expected.toString())
+        )
+    }
+
+    @Test
+    fun insertIntoBST2() {
+        val treeNode: TreeNode? = TreeNode.create(listOf(40, 20, 60, 10, 30, 50, 70))
+        val expected: TreeNode? = TreeNode.create(listOf(40, 20, 60, 10, 30, 50, 70, null, null, 25))
+        assertThat(
+            Solution().insertIntoBST(treeNode, 25).toString(),
+            equalTo(expected.toString())
+        )
+    }
+
+    @Test
+    fun insertIntoBST3() {
+        val treeNode: TreeNode? = TreeNode.create(listOf(4, 2, 7, 1, 3, null, null, null, null, null, null))
+        val expected: TreeNode? = TreeNode.create(listOf(4, 2, 7, 1, 3, 5))
+        assertThat(
+            Solution().insertIntoBST(treeNode, 5).toString(), equalTo(expected.toString())
+        )
+    }
+}