Added tasks 706, 707, 709, 710

Author: ThanhNIT

README.md

@@ -170,6 +170,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0707 |[Design Linked List](src/main/kotlin/g0701_0800/s0707_design_linked_list/MyLinkedList.kt)| Medium | Design, Linked_List | 243 | 100.00
 
 #### Day 20
 
@@ -678,6 +679,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 0138 |[Copy List with Random Pointer](src.save/main/kotlin/g0101_0200/s0138_copy_list_with_random_pointer/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Hash_Table, Linked_List | 274 | 80.58
 | 0025 |[Reverse Nodes in k-Group](src.save/main/kotlin/g0001_0100/s0025_reverse_nodes_in_k_group/Solution.kt)| Hard | Top_100_Liked_Questions, Linked_List, Recursion | 194 | 87.72
 | 0146 |[LRU Cache](src.save/main/kotlin/g0101_0200/s0146_lru_cache/LRUCache.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Hash_Table, Design, Linked_List, Doubly_Linked_List | 1116 | 97.93
+| 0707 |[Design Linked List](src/main/kotlin/g0701_0800/s0707_design_linked_list/MyLinkedList.kt)| Medium | Design, Linked_List | 243 | 100.00
 
 #### Udemy Tree Stack Queue
 
@@ -886,6 +888,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 |-|-|-|-|-|-
 | 0075 |[Sort Colors](src.save/main/kotlin/g0001_0100/s0075_sort_colors/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers | 198 | 85.66
 | 0056 |[Merge Intervals](src.save/main/kotlin/g0001_0100/s0056_merge_intervals/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting | 323 | 99.68
+| 0706 |[Design HashMap](src/main/kotlin/g0701_0800/s0706_design_hashmap/MyHashMap.kt)| Easy | Array, Hash_Table, Design, Linked_List, Hash_Function | 405 | 92.11
 
 #### Day 3 Array
 
@@ -957,6 +960,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0024 |[Swap Nodes in Pairs](src.save/main/kotlin/g0001_0100/s0024_swap_nodes_in_pairs/Solution.kt)| Medium | Top_100_Liked_Questions, Linked_List, Recursion | 149 | 99.39
+| 0707 |[Design Linked List](src/main/kotlin/g0701_0800/s0707_design_linked_list/MyLinkedList.kt)| Medium | Design, Linked_List | 243 | 100.00
 
 #### Day 13 Linked List
 
@@ -1656,6 +1660,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0709 |[To Lower Case](src/main/kotlin/g0701_0800/s0709_to_lower_case/Solution.kt)| Easy | String | 142 | 98.68
 
 #### Day 10 Linked List and Tree
 
@@ -1687,6 +1692,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
+| 0710 |[Random Pick with Blacklist](src/main/kotlin/g0701_0800/s0710_random_pick_with_blacklist/Solution.kt)| Hard | Hash_Table, Math, Sorting, Binary_Search, Randomized | 632 | 100.00
+| 0709 |[To Lower Case](src/main/kotlin/g0701_0800/s0709_to_lower_case/Solution.kt)| Easy | String, Programming_Skills_I_Day_9_String | 142 | 98.68
+| 0707 |[Design Linked List](src/main/kotlin/g0701_0800/s0707_design_linked_list/MyLinkedList.kt)| Medium | Design, Linked_List, Data_Structure_II_Day_12_Linked_List, Programming_Skills_II_Day_19, Udemy_Linked_List | 243 | 100.00
+| 0706 |[Design HashMap](src/main/kotlin/g0701_0800/s0706_design_hashmap/MyHashMap.kt)| Easy | Array, Hash_Table, Design, Linked_List, Hash_Function, Data_Structure_II_Day_2_Array | 405 | 92.11
 | 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

src/main/kotlin/g0701_0800/s0706_design_hashmap/MyHashMap.kt

@@ -0,0 +1,87 @@
+package g0701_0800.s0706_design_hashmap
+
+// #Easy #Array #Hash_Table #Design #Linked_List #Hash_Function #Data_Structure_II_Day_2_Array
+// #2023_02_24_Time_405_ms_(92.11%)_Space_58.1_MB_(93.42%)
+
+@Suppress("NAME_SHADOWING")
+class MyHashMap {
+    private var arr: Array<MutableList<Entry>?>? = null
+
+    init {
+        arr = arrayOfNulls<MutableList<Entry>?>(1000)
+    }
+
+    fun put(key: Int, value: Int) {
+        val bucket = key % 1000
+        if (arr!![bucket] == null) {
+            val list = ArrayList<Entry>()
+            val e = Entry()
+            e.key = key
+            e.value = value
+            list.add(e)
+            arr!![bucket] = list
+        } else {
+            val list: MutableList<Entry>? = arr!![bucket]
+            val e = Entry()
+            e.key = key
+            e.value = value
+            list!!.remove(e)
+            list.add(e)
+        }
+    }
+
+    fun get(key: Int): Int {
+        val bucket = key % 1000
+        var ans = -1
+        val list: ArrayList<Entry>? = arr!![bucket] as ArrayList<Entry>?
+        if (list != null) {
+            for (e in list) {
+                if (e.key == key) {
+                    ans = e.value
+                }
+            }
+        }
+        return ans
+    }
+
+    fun remove(key: Int) {
+        val bucket = key % 1000
+        val list: ArrayList<Entry>? = arr!![bucket] as ArrayList<Entry>?
+        val e = Entry()
+        e.key = key
+        list?.remove(e)
+    }
+
+    internal class Entry {
+        var key = 0
+        var value = 0
+        override fun hashCode(): Int {
+            val prime = 31
+            var result = 1
+            result = prime * result + key
+            return result
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+            if (other == null) {
+                return false
+            }
+            if (javaClass != other.javaClass) {
+                return false
+            }
+            val other = other as Entry
+            return key == other.key
+        }
+    }
+}
+
+/*
+ * Your MyHashMap object will be instantiated and called as such:
+ * var obj = MyHashMap()
+ * obj.put(key,value)
+ * var param_2 = obj.get(key)
+ * obj.remove(key)
+ */

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

@@ -0,0 +1,39 @@
+706\. Design HashMap
+
+Easy
+
+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:**
+
+*   <code>0 <= key, value <= 10<sup>6</sup></code>
+*   At most <code>10<sup>4</sup></code> calls will be made to `put`, `get`, and `remove`.

src/main/kotlin/g0701_0800/s0707_design_linked_list/MyLinkedList.kt

@@ -0,0 +1,112 @@
+package g0701_0800.s0707_design_linked_list
+
+// #Medium #Design #Linked_List #Data_Structure_II_Day_12_Linked_List #Programming_Skills_II_Day_19
+// #Udemy_Linked_List #2023_02_24_Time_243_ms_(100.00%)_Space_43.8_MB_(46.34%)
+
+class MyLinkedList {
+    private class Node(var `val`: Int) {
+        var next: Node? = null
+    }
+
+    private var head: Node?
+    private var tail: Node? = null
+    private var size: Int
+
+    init {
+        head = tail
+        size = 0
+    }
+
+    operator fun get(index: Int): Int {
+        if (index >= size) {
+            return -1
+        }
+        if (index == 0) {
+            return head!!.`val`
+        }
+        var i = 0
+        var ptr = head
+        while (i++ < index - 1) {
+            ptr = ptr!!.next
+        }
+        return ptr!!.next!!.`val`
+    }
+
+    fun addAtHead(`val`: Int) {
+        val node = Node(`val`)
+        if (head == null) {
+            tail = node
+            head = tail
+            size++
+            return
+        }
+        node.next = head
+        head = node
+        size++
+    }
+
+    fun addAtTail(`val`: Int) {
+        if (head == null) {
+            addAtHead(`val`)
+            return
+        }
+        val node = Node(`val`)
+        tail!!.next = node
+        tail = node
+        size++
+    }
+
+    fun addAtIndex(index: Int, `val`: Int) {
+        if (index > size) {
+            return
+        }
+        if (index == 0) {
+            addAtHead(`val`)
+            return
+        }
+        if (index == size) {
+            addAtTail(`val`)
+            return
+        }
+        var i = 0
+        val node = Node(`val`)
+        var ptr = head
+        while (i++ < index - 1) {
+            ptr = ptr!!.next
+        }
+        node.next = ptr!!.next
+        ptr.next = node
+        size++
+    }
+
+    fun deleteAtIndex(index: Int) {
+        if (index >= size) {
+            return
+        }
+        if (index == 0) {
+            head = head!!.next
+            size--
+            return
+        }
+        var i = 0
+        var ptr = head
+        while (i++ < index - 1) {
+            ptr = ptr!!.next
+        }
+        ptr!!.next = ptr.next!!.next
+        if (index == size - 1) {
+            tail = ptr
+        }
+        size--
+    }
+}
+
+/*
+ * Your MyLinkedList object will be instantiated and called as such:
+ * var obj = MyLinkedList()
+ * var param_1 = obj.get(index)
+ * obj.addAtHead(`val`)
+ * obj.addAtTail(`val`)
+ * obj.addAtIndex(index,`val`)
+ * obj.deleteAtIndex(index)
+ */

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

@@ -0,0 +1,42 @@
+707\. Design Linked List
+
+Medium
+
+Design your implementation of the linked list. You can choose to use a singly or doubly linked list.  
+A node in a singly linked list should have two attributes: `val` and `next`. `val` is the value of the current node, and `next` is a pointer/reference to the next node.  
+If you want to use the doubly linked list, you will need one more attribute `prev` to indicate the previous node in the linked list. Assume all nodes in the linked list are **0-indexed**.
+
+Implement the `MyLinkedList` class:
+
+*   `MyLinkedList()` Initializes the `MyLinkedList` object.
+*   `int get(int index)` Get the value of the <code>index<sup>th</sup></code> node in the linked list. If the index is invalid, return `-1`.
+*   `void addAtHead(int val)` Add a node of value `val` before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
+*   `void addAtTail(int val)` Append a node of value `val` as the last element of the linked list.
+*   `void addAtIndex(int index, int val)` Add a node of value `val` before the <code>index<sup>th</sup></code> node in the linked list. If `index` equals the length of the linked list, the node will be appended to the end of the linked list. If `index` is greater than the length, the node **will not be inserted**.
+*   `void deleteAtIndex(int index)` Delete the <code>index<sup>th</sup></code> node in the linked list, if the index is valid.
+
+**Example 1:**
+
+**Input**
+
+["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
+
+[[], [1], [3], [1, 2], [1], [1], [1]]
+
+**Output:** [null, null, null, null, 2, null, 3]
+
+**Explanation:**
+
+    MyLinkedList myLinkedList = new MyLinkedList(); 
+    myLinkedList.addAtHead(1); 
+    myLinkedList.addAtTail(3); 
+    myLinkedList.addAtIndex(1, 2); // linked list becomes 1->2->3 
+    myLinkedList.get(1); // return 2 
+    myLinkedList.deleteAtIndex(1); // now the linked list is 1->3 
+    myLinkedList.get(1); // return 3
+
+**Constraints:**
+
+*   `0 <= index, val <= 1000`
+*   Please do not use the built-in LinkedList library.
+*   At most `2000` calls will be made to `get`, `addAtHead`, `addAtTail`, `addAtIndex` and `deleteAtIndex`.

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

@@ -0,0 +1,16 @@
+package g0701_0800.s0709_to_lower_case
+
+// #Easy #String #Programming_Skills_I_Day_9_String
+// #2023_02_24_Time_142_ms_(98.68%)_Space_35.1_MB_(7.89%)
+
+class Solution {
+    fun toLowerCase(s: String): String {
+        val c = s.toCharArray()
+        for (i in s.indices) {
+            if (c[i] in 'A'..'Z') {
+                c[i] = (c[i].code - 'A'.code + 'a'.code).toChar()
+            }
+        }
+        return String(c)
+    }
+}

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

@@ -0,0 +1,28 @@
+709\. To Lower Case
+
+Easy
+
+Given a string `s`, return _the string after replacing every uppercase letter with the same lowercase letter_.
+
+**Example 1:**
+
+**Input:** s = "Hello"
+
+**Output:** "hello"
+
+**Example 2:**
+
+**Input:** s = "here"
+
+**Output:** "here"
+
+**Example 3:**
+
+**Input:** s = "LOVELY"
+
+**Output:** "lovely"
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   `s` consists of printable ASCII characters.