Added tasks 458, 459, 460, 461.

Author: ThanhNIT

README.md

@@ -275,6 +275,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0110 |[Balanced Binary Tree](src/main/kotlin/g0101_0200/s0110_balanced_binary_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree | 310 | 63.63
+| 0459 |[Repeated Substring Pattern](src/main/kotlin/g0401_0500/s0459_repeated_substring_pattern/Solution.kt)| Easy | String, String_Matching | 201 | 100.00
 
 #### Day 3
 
@@ -941,6 +942,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 0191 |[Number of 1 Bits](src/main/kotlin/g0101_0200/s0191_number_of_1_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation | 237 | 68.44
 | 0389 |[Find the Difference](src/main/kotlin/g0301_0400/s0389_find_the_difference/Solution.kt)| Easy | String, Hash_Table, Sorting, Bit_Manipulation | 256 | 64.81
 | 0190 |[Reverse Bits](src/main/kotlin/g0101_0200/s0190_reverse_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation, Divide_and_Conquer | 198 | 81.82
+| 0461 |[Hamming Distance](src/main/kotlin/g0401_0500/s0461_hamming_distance/Solution.kt)| Easy | Bit_Manipulation | 150 | 96.15
 | 0338 |[Counting Bits](src/main/kotlin/g0301_0400/s0338_counting_bits/Solution.kt)| Easy | Top_100_Liked_Questions, Dynamic_Programming, Bit_Manipulation | 186 | 99.26
 | 0371 |[Sum of Two Integers](src/main/kotlin/g0301_0400/s0371_sum_of_two_integers/Solution.kt)| Medium | Top_Interview_Questions, Math, Bit_Manipulation | 129 | 95.45
 | 0029 |[Divide Two Integers](src/main/kotlin/g0001_0100/s0029_divide_two_integers/Solution.kt)| Medium | Top_Interview_Questions, Math, Bit_Manipulation | 281 | 31.67
@@ -1638,6 +1640,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 0560 |[Subarray Sum Equals K](src/main/kotlin/g0501_0600/s0560_subarray_sum_equals_k/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Hash_Table, Prefix_Sum, Data_Structure_II_Day_5_Array | 692 | 53.27
 | 0543 |[Diameter of Binary Tree](src/main/kotlin/g0501_0600/s0543_diameter_of_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree, Udemy_Tree_Stack_Queue | 307 | 43.93
 | 0494 |[Target Sum](src/main/kotlin/g0401_0500/s0494_target_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Backtracking | 308 | 89.61
+| 0461 |[Hamming Distance](src/main/kotlin/g0401_0500/s0461_hamming_distance/Solution.kt)| Easy | Bit_Manipulation, Udemy_Bit_Manipulation | 150 | 96.15
+| 0460 |[LFU Cache](src/main/kotlin/g0401_0500/s0460_lfu_cache/LFUCache.kt)| Hard | Hash_Table, Design, Linked_List, Doubly_Linked_List | 1143 | 100.00
+| 0459 |[Repeated Substring Pattern](src/main/kotlin/g0401_0500/s0459_repeated_substring_pattern/Solution.kt)| Easy | String, String_Matching, Programming_Skills_II_Day_2 | 201 | 100.00
+| 0458 |[Poor Pigs](src/main/kotlin/g0401_0500/s0458_poor_pigs/Solution.kt)| Hard | Dynamic_Programming, Math, Combinatorics | 133 | 80.00
 | 0457 |[Circular Array Loop](src/main/kotlin/g0401_0500/s0457_circular_array_loop/Solution.kt)| Medium | Array, Hash_Table, Two_Pointers | 143 | 100.00
 | 0456 |[132 Pattern](src/main/kotlin/g0401_0500/s0456_132_pattern/Solution.kt)| Medium | Array, Binary_Search, Stack, Ordered_Set, Monotonic_Stack, Udemy_Arrays | 434 | 100.00
 | 0455 |[Assign Cookies](src/main/kotlin/g0401_0500/s0455_assign_cookies/Solution.kt)| Easy | Array, Sorting, Greedy | 260 | 96.67

src/main/kotlin/g0401_0500/s0458_poor_pigs/Solution.kt

@@ -0,0 +1,21 @@
+package g0401_0500.s0458_poor_pigs
+
+// #Hard #Dynamic_Programming #Math #Combinatorics
+// #2022_12_27_Time_133_ms_(80.00%)_Space_32.8_MB_(80.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun poorPigs(buckets: Int, minutesToDie: Int, minutesToTest: Int): Int {
+        var buckets = buckets
+        if (buckets-- == 1) {
+            return 0
+        }
+        val base = minutesToTest / minutesToDie + 1
+        var count = 0
+        while (buckets > 0) {
+            buckets /= base
+            count++
+        }
+        return count
+    }
+}

src/main/kotlin/g0401_0500/s0458_poor_pigs/readme.md

@@ -0,0 +1,38 @@
+458\. Poor Pigs
+
+Hard
+
+There are `buckets` buckets of liquid, where **exactly one** of the buckets is poisonous. To figure out which one is poisonous, you feed some number of (poor) pigs the liquid to see whether they will die or not. Unfortunately, you only have `minutesToTest` minutes to determine which bucket is poisonous.
+
+You can feed the pigs according to these steps:
+
+1.  Choose some live pigs to feed.
+2.  For each pig, choose which buckets to feed it. The pig will consume all the chosen buckets simultaneously and will take no time.
+3.  Wait for `minutesToDie` minutes. You may **not** feed any other pigs during this time.
+4.  After `minutesToDie` minutes have passed, any pigs that have been fed the poisonous bucket will die, and all others will survive.
+5.  Repeat this process until you run out of time.
+
+Given `buckets`, `minutesToDie`, and `minutesToTest`, return _the **minimum** number of pigs needed to figure out which bucket is poisonous within the allotted time_.
+
+**Example 1:**
+
+**Input:** buckets = 1000, minutesToDie = 15, minutesToTest = 60
+
+**Output:** 5
+
+**Example 2:**
+
+**Input:** buckets = 4, minutesToDie = 15, minutesToTest = 15
+
+**Output:** 2
+
+**Example 3:**
+
+**Input:** buckets = 4, minutesToDie = 15, minutesToTest = 30
+
+**Output:** 2
+
+**Constraints:**
+
+*   `1 <= buckets <= 1000`
+*   `1 <= minutesToDie <= minutesToTest <= 100`

src/main/kotlin/g0401_0500/s0459_repeated_substring_pattern/Solution.kt

@@ -0,0 +1,38 @@
+package g0401_0500.s0459_repeated_substring_pattern
+
+// #Easy #String #String_Matching #Programming_Skills_II_Day_2
+// #2022_12_27_Time_201_ms_(100.00%)_Space_36.2_MB_(89.29%)
+
+class Solution {
+    fun repeatedSubstringPattern(s: String): Boolean {
+        val n = s.length
+        if (n < 2) {
+            return false
+        }
+        var i = 0
+        while (i < (n + 1) / 2) {
+            if (n % (i + 1) != 0) {
+                i++
+                continue
+            }
+            var match = true
+            val substring = s.substring(0, i + 1)
+            var skippedI = i
+            var j = i + 1
+            while (j < n) {
+                if (s.substring(j, j + i + 1) != substring) {
+                    match = false
+                    break
+                }
+                skippedI += i + 1
+                j += i + 1
+            }
+            if (match) {
+                return true
+            }
+            i = skippedI
+            i++
+        }
+        return false
+    }
+}

src/main/kotlin/g0401_0500/s0459_repeated_substring_pattern/readme.md

@@ -0,0 +1,32 @@
+459\. Repeated Substring Pattern
+
+Easy
+
+Given a string `s`, check if it can be constructed by taking a substring of it and appending multiple copies of the substring together.
+
+**Example 1:**
+
+**Input:** s = "abab"
+
+**Output:** true
+
+**Explanation:** It is the substring "ab" twice.
+
+**Example 2:**
+
+**Input:** s = "aba"
+
+**Output:** false
+
+**Example 3:**
+
+**Input:** s = "abcabcabcabc"
+
+**Output:** true
+
+**Explanation:** It is the substring "abc" four times or the substring "abcabc" twice.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` consists of lowercase English letters.

src/main/kotlin/g0401_0500/s0460_lfu_cache/LFUCache.kt

@@ -0,0 +1,114 @@
+package g0401_0500.s0460_lfu_cache
+
+// #Hard #Hash_Table #Design #Linked_List #Doubly_Linked_List
+// #2022_12_27_Time_1143_ms_(100.00%)_Space_151.2_MB_(66.67%)
+
+class LFUCache(capacity: Int) {
+    private class Node {
+        var prev: Node? = null
+        var next: Node? = null
+        var key = -1
+        var `val` = 0
+        var freq = 0
+    }
+
+    private val endOfBlock: MutableMap<Int, Node?>
+    private val map: MutableMap<Int, Node>
+    private val capacity: Int
+    private val linkedList: Node
+
+    init {
+        endOfBlock = HashMap()
+        map = HashMap()
+        this.capacity = capacity
+        linkedList = Node()
+    }
+
+    operator fun get(key: Int): Int {
+        if (map.containsKey(key)) {
+            val newEndNode = map[key]
+            val endNode: Node?
+            val currEndNode = endOfBlock[newEndNode!!.freq]
+            if (currEndNode === newEndNode) {
+                findNewEndOfBlock(newEndNode)
+                if (currEndNode.next == null || currEndNode.next!!.freq > newEndNode.freq + 1) {
+                    newEndNode.freq++
+                    endOfBlock[newEndNode.freq] = newEndNode
+                    return newEndNode.`val`
+                }
+            }
+            if (newEndNode.next != null) {
+                newEndNode.next!!.prev = newEndNode.prev
+            }
+            newEndNode.prev!!.next = newEndNode.next
+            newEndNode.freq++
+            endNode = if (currEndNode!!.next == null || currEndNode.next!!.freq > newEndNode.freq) {
+                currEndNode
+            } else {
+                endOfBlock[newEndNode.freq]
+            }
+            endOfBlock[newEndNode.freq] = newEndNode
+            if (endNode!!.next != null) {
+                endNode.next!!.prev = newEndNode
+            }
+            newEndNode.next = endNode.next
+            endNode.next = newEndNode
+            newEndNode.prev = endNode
+            return newEndNode.`val`
+        }
+        return -1
+    }
+
+    fun put(key: Int, value: Int) {
+        val endNode: Node?
+        val newEndNode: Node
+        if (capacity == 0) {
+            return
+        }
+        if (map.containsKey(key)) {
+            map[key]!!.`val` = value
+            get(key)
+        } else {
+            if (map.size == capacity) {
+                val toDelete = linkedList.next
+                map.remove(toDelete!!.key)
+                if (toDelete.next != null) {
+                    toDelete.next!!.prev = linkedList
+                }
+                linkedList.next = toDelete.next
+                if (endOfBlock[toDelete.freq] === toDelete) {
+                    endOfBlock.remove(toDelete.freq)
+                }
+            }
+            newEndNode = Node()
+            newEndNode.key = key
+            newEndNode.`val` = value
+            newEndNode.freq = 1
+            map[key] = newEndNode
+            endNode = endOfBlock.getOrDefault(1, linkedList)
+            endOfBlock[1] = newEndNode
+            if (endNode!!.next != null) {
+                endNode.next!!.prev = newEndNode
+            }
+            newEndNode.next = endNode.next
+            endNode.next = newEndNode
+            newEndNode.prev = endNode
+        }
+    }
+
+    private fun findNewEndOfBlock(node: Node?) {
+        val prev = node!!.prev
+        if (prev!!.freq == node.freq) {
+            endOfBlock[node.freq] = prev
+        } else {
+            endOfBlock.remove(node.freq)
+        }
+    }
+}
+
+/*
+ * Your LFUCache object will be instantiated and called as such:
+ * var obj = LFUCache(capacity)
+ * var param_1 = obj.get(key)
+ * obj.put(key,value)
+ */

src/main/kotlin/g0401_0500/s0460_lfu_cache/readme.md

@@ -0,0 +1,57 @@
+460\. LFU Cache
+
+Hard
+
+Design and implement a data structure for a [Least Frequently Used (LFU)](https://en.wikipedia.org/wiki/Least_frequently_used) cache.
+
+Implement the `LFUCache` class:
+
+*   `LFUCache(int capacity)` Initializes the object with the `capacity` of the data structure.
+*   `int get(int key)` Gets the value of the `key` if the `key` exists in the cache. Otherwise, returns `-1`.
+*   `void put(int key, int value)` Update the value of the `key` if present, or inserts the `key` if not already present. When the cache reaches its `capacity`, it should invalidate and remove the **least frequently used** key before inserting a new item. For this problem, when there is a **tie** (i.e., two or more keys with the same frequency), the **least recently used** `key` would be invalidated.
+
+To determine the least frequently used key, a **use counter** is maintained for each key in the cache. The key with the smallest **use counter** is the least frequently used key.
+
+When a key is first inserted into the cache, its **use counter** is set to `1` (due to the `put` operation). The **use counter** for a key in the cache is incremented either a `get` or `put` operation is called on it.
+
+The functions `get` and `put` must each run in `O(1)` average time complexity.
+
+**Example 1:**
+
+**Input**
+
+    ["LFUCache", "put", "put", "get", "put", "get", "get", "put", "get", "get", "get"] 
+    [[2], [1, 1], [2, 2], [1], [3, 3], [2], [3], [4, 4], [1], [3], [4]]
+
+**Output:** [null, null, null, 1, null, -1, 3, null, -1, 3, 4]
+
+**Explanation:**
+
+    // cnt(x) = the use counter for key x 
+   
+    // cache=[] will show the last used order for tiebreakers (leftmost element is most recent) 
+    
+    LFUCache lfu = new LFUCache(2); 
+    lfu.put(1, 1); // cache=[1,_], cnt(1)=1
+    lfu.put(2, 2);  // cache=[2,1], cnt(2)=1, cnt(1)=1
+    lfu.get(1);     // return 1 
+                    // cache=[1,2], cnt(2)=1, cnt(1)=2
+    lfu.put(3, 3);  // 2 is the LFU key because cnt(2)=1 is the smallest, invalidate 2. 
+                    // cache=[3,1], cnt(3)=1, cnt(1)=2
+    lfu.get(2);     // return -1 (not found)
+    lfu.get(3);     // return 3
+                    // cache=[3,1], cnt(3)=2, cnt(1)=2
+    lfu.put(4, 4);  // Both 1 and 3 have the same cnt, but 1 is LRU, invalidate 1. 
+                    // cache=[4,3], cnt(4)=1, cnt(3)=2
+    lfu.get(1);     // return -1 (not found)
+    lfu.get(3);     // return 3 
+                    // cache=[3,4], cnt(4)=1, cnt(3)=3
+    lfu.get(4);     // return 4 
+                    // cache=[3,4], cnt(4)=2, cnt(3)=3
+
+**Constraints:**
+
+*   <code>0 <= capacity <= 10<sup>4</sup></code>
+*   <code>0 <= key <= 10<sup>5</sup></code>
+*   <code>0 <= value <= 10<sup>9</sup></code>
+*   At most <code>2 * 10<sup>5</sup></code> calls will be made to `get` and `put`.

src/main/kotlin/g0401_0500/s0461_hamming_distance/Solution.kt

@@ -0,0 +1,10 @@
+package g0401_0500.s0461_hamming_distance
+
+// #Easy #Bit_Manipulation #Udemy_Bit_Manipulation
+// #2022_12_27_Time_150_ms_(96.15%)_Space_32.9_MB_(92.31%)
+
+class Solution {
+    fun hammingDistance(x: Int, y: Int): Int {
+        return Integer.bitCount(x xor y)
+    }
+}

src/main/kotlin/g0401_0500/s0461_hamming_distance/readme.md

@@ -0,0 +1,25 @@
+461\. Hamming Distance
+
+Easy
+
+The [Hamming distance](https://en.wikipedia.org/wiki/Hamming_distance) between two integers is the number of positions at which the corresponding bits are different.
+
+Given two integers `x` and `y`, return _the **Hamming distance** between them_.
+
+**Example 1:**
+
+**Input:** x = 1, y = 4
+
+**Output:** 2
+
+**Explanation:** 1 (0 0 0 1) 4 (0 1 0 0) ↑ ↑ The above arrows point to positions where the corresponding bits are different.
+
+**Example 2:**
+
+**Input:** x = 3, y = 1
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>0 <= x, y <= 2<sup>31</sup> - 1</code>

src/test/kotlin/g0401_0500/s0458_poor_pigs/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0401_0500.s0458_poor_pigs
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun poorPigs() {
+        assertThat(Solution().poorPigs(1000, 15, 60), equalTo(5))
+    }
+
+    @Test
+    fun poorPigs2() {
+        assertThat(Solution().poorPigs(4, 15, 15), equalTo(2))
+    }
+
+    @Test
+    fun poorPigs3() {
+        assertThat(Solution().poorPigs(4, 15, 30), equalTo(2))
+    }
+}