Added tasks 473, 474, 475, 476.

Author: ThanhNIT

README.md

@@ -1640,6 +1640,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | 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
+| 0476 |[Number Complement](src/main/kotlin/g0401_0500/s0476_number_complement/Solution.kt)| Easy | Bit_Manipulation | 133 | 100.00
+| 0475 |[Heaters](src/main/kotlin/g0401_0500/s0475_heaters/Solution.kt)| Medium | Array, Sorting, Binary_Search, Two_Pointers | 356 | 87.50
+| 0474 |[Ones and Zeroes](src/main/kotlin/g0401_0500/s0474_ones_and_zeroes/Solution.kt)| Medium | Array, String, Dynamic_Programming | 204 | 100.00
+| 0473 |[Matchsticks to Square](src/main/kotlin/g0401_0500/s0473_matchsticks_to_square/Solution.kt)| Medium | Array, Dynamic_Programming, Bit_Manipulation, Backtracking, Bitmask | 255 | 100.00
 | 0472 |[Concatenated Words](src/main/kotlin/g0401_0500/s0472_concatenated_words/Solution.kt)| Hard | Array, String, Dynamic_Programming, Depth_First_Search, Trie | 484 | 100.00
 | 0470 |[Implement Rand10() Using Rand7()](src/main/kotlin/g0401_0500/s0470_implement_rand10_using_rand7/Solution.kt)| Medium | Math, Randomized, Probability_and_Statistics, Rejection_Sampling | 220 | 100.00
 | 0468 |[Validate IP Address](src/main/kotlin/g0401_0500/s0468_validate_ip_address/Solution.kt)| Medium | String | 192 | 62.50

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

@@ -0,0 +1,40 @@
+package g0401_0500.s0473_matchsticks_to_square
+
+// #Medium #Array #Dynamic_Programming #Bit_Manipulation #Backtracking #Bitmask
+// #2022_12_31_Time_255_ms_(100.00%)_Space_33.9_MB_(100.00%)
+
+class Solution {
+    fun makesquare(matchsticks: IntArray): Boolean {
+        if (matchsticks.size < 4) {
+            return false
+        }
+        var per = 0
+        for (ele in matchsticks) {
+            per = ele + per
+        }
+        if (per % 4 != 0) {
+            return false
+        }
+        matchsticks.sort()
+        val side = per / 4
+        val sides = intArrayOf(side, side, side, side)
+        return help(matchsticks, matchsticks.size - 1, sides)
+    }
+
+    private fun help(nums: IntArray, i: Int, side: IntArray): Boolean {
+        if (i == -1) {
+            return side[0] == 0 && side[1] == 0 && side[2] == 0 && side[3] == 0
+        }
+        for (j in 0..3) {
+            if (nums[i] > side[j]) {
+                continue
+            }
+            side[j] -= nums[i]
+            if (help(nums, i - 1, side)) {
+                return true
+            }
+            side[j] += nums[i]
+        }
+        return false
+    }
+}

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

@@ -0,0 +1,30 @@
+473\. Matchsticks to Square
+
+Medium
+
+You are given an integer array `matchsticks` where `matchsticks[i]` is the length of the <code>i<sup>th</sup></code> matchstick. You want to use **all the matchsticks** to make one square. You **should not break** any stick, but you can link them up, and each matchstick must be used **exactly one time**.
+
+Return `true` if you can make this square and `false` otherwise.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/09/matchsticks1-grid.jpg)
+
+**Input:** matchsticks = [1,1,2,2,2]
+
+**Output:** true
+
+**Explanation:** You can form a square with length 2, one side of the square came two sticks with length 1.
+
+**Example 2:**
+
+**Input:** matchsticks = [3,3,3,3,4]
+
+**Output:** false
+
+**Explanation:** You cannot find a way to form a square with all the matchsticks.
+
+**Constraints:**
+
+*   `1 <= matchsticks.length <= 15`
+*   <code>1 <= matchsticks[i] <= 10<sup>8</sup></code>

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

@@ -0,0 +1,38 @@
+package g0401_0500.s0474_ones_and_zeroes
+
+// #Medium #Array #String #Dynamic_Programming
+// #2022_12_31_Time_204_ms_(100.00%)_Space_35.7_MB_(92.31%)
+
+class Solution {
+    /*
+     * The problem can be interpreted as:
+     * What's the max number of str can we pick from strs with limitation of m "0"s and n "1"s.
+     *
+     * Thus we can define dp[i][j] as it stands for max number of str can we pick from strs with limitation
+     * of i "0"s and j "1"s.
+     *
+     * For each str, assume it has a "0"s and b "1"s, we update the dp array iteratively
+     * and set dp[i][j] = Math.max(dp[i][j], dp[i - a][j - b] + 1).
+     * So at the end, dp[m][n] is the answer.
+     */
+    fun findMaxForm(strs: Array<String>, m: Int, n: Int): Int {
+        val dp = Array(m + 1) { IntArray(n + 1) }
+        for (str in strs) {
+            val count = count(str)
+            for (i in m downTo count[0]) {
+                for (j in n downTo count[1]) {
+                    dp[i][j] = Math.max(dp[i][j], dp[i - count[0]][j - count[1]] + 1)
+                }
+            }
+        }
+        return dp[m][n]
+    }
+
+    private fun count(str: String): IntArray {
+        val res = IntArray(2)
+        for (i in 0 until str.length) {
+            res[str[i].code - '0'.code]++
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,36 @@
+474\. Ones and Zeroes
+
+Medium
+
+You are given an array of binary strings `strs` and two integers `m` and `n`.
+
+Return _the size of the largest subset of `strs` such that there are **at most**_ `m` `0`_'s and_ `n` `1`_'s in the subset_.
+
+A set `x` is a **subset** of a set `y` if all elements of `x` are also elements of `y`.
+
+**Example 1:**
+
+**Input:** strs = ["10","0001","111001","1","0"], m = 5, n = 3
+
+**Output:** 4
+
+**Explanation:** The largest subset with at most 5 0's and 3 1's is {"10", "0001", "1", "0"}, so the answer is 4. 
+
+Other valid but smaller subsets include {"0001", "1"} and {"10", "1", "0"}. 
+
+{"111001"} is an invalid subset because it contains 4 1's, greater than the maximum of 3.
+
+**Example 2:**
+
+**Input:** strs = ["10","0","1"], m = 1, n = 1
+
+**Output:** 2
+
+**Explanation:** The largest subset is {"0", "1"}, so the answer is 2.
+
+**Constraints:**
+
+*   `1 <= strs.length <= 600`
+*   `1 <= strs[i].length <= 100`
+*   `strs[i]` consists only of digits `'0'` and `'1'`.
+*   `1 <= m, n <= 100`

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

@@ -0,0 +1,37 @@
+package g0401_0500.s0475_heaters
+
+// #Medium #Array #Sorting #Binary_Search #Two_Pointers
+// #2022_12_31_Time_356_ms_(87.50%)_Space_44.6_MB_(87.50%)
+
+class Solution {
+    fun findRadius(houses: IntArray, heaters: IntArray): Int {
+        var res = 0
+        val m = houses.size
+        val n = heaters.size
+        var hs = 0
+        var ht = 0
+        houses.sort()
+        heaters.sort()
+        if (n == 1) {
+            return Math.max(Math.abs(houses[0] - heaters[0]), Math.abs(houses[m - 1] - heaters[0]))
+        }
+        while (hs < m && ht < n - 1) {
+            if (houses[hs] <= heaters[ht]) {
+                res = Math.max(heaters[ht] - houses[hs], res)
+                hs++
+            } else if (houses[hs] <= heaters[ht + 1]) {
+                res = Math.max(
+                    res,
+                    Math.min(houses[hs] - heaters[ht], heaters[ht + 1] - houses[hs])
+                )
+                hs++
+            } else {
+                ht++
+            }
+        }
+        if (ht == n - 1) {
+            res = Math.max(res, houses[m - 1] - heaters[n - 1])
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,38 @@
+475\. Heaters
+
+Medium
+
+Winter is coming! During the contest, your first job is to design a standard heater with a fixed warm radius to warm all the houses.
+
+Every house can be warmed, as long as the house is within the heater's warm radius range.
+
+Given the positions of `houses` and `heaters` on a horizontal line, return _the minimum radius standard of heaters so that those heaters could cover all houses._
+
+**Notice** that all the `heaters` follow your radius standard, and the warm radius will the same.
+
+**Example 1:**
+
+**Input:** houses = [1,2,3], heaters = [2]
+
+**Output:** 1
+
+**Explanation:** The only heater was placed in the position 2, and if we use the radius 1 standard, then all the houses can be warmed.
+
+**Example 2:**
+
+**Input:** houses = [1,2,3,4], heaters = [1,4]
+
+**Output:** 1
+
+**Explanation:** The two heater was placed in the position 1 and 4. We need to use radius 1 standard, then all the houses can be warmed.
+
+**Example 3:**
+
+**Input:** houses = [1,5], heaters = [2]
+
+**Output:** 3
+
+**Constraints:**
+
+*   <code>1 <= houses.length, heaters.length <= 3 * 10<sup>4</sup></code>
+*   <code>1 <= houses[i], heaters[i] <= 10<sup>9</sup></code>

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

@@ -0,0 +1,9 @@
+package g0401_0500.s0476_number_complement
+
+// #Easy #Bit_Manipulation #2022_12_31_Time_133_ms_(100.00%)_Space_33.1_MB_(76.47%)
+
+class Solution {
+    fun findComplement(num: Int): Int {
+        return num.inv() and (Integer.highestOneBit(num) shl 1) - 1
+    }
+}

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

@@ -0,0 +1,31 @@
+476\. Number Complement
+
+Easy
+
+The **complement** of an integer is the integer you get when you flip all the `0`'s to `1`'s and all the `1`'s to `0`'s in its binary representation.
+
+*   For example, The integer `5` is `"101"` in binary and its **complement** is `"010"` which is the integer `2`.
+
+Given an integer `num`, return _its complement_.
+
+**Example 1:**
+
+**Input:** num = 5
+
+**Output:** 2
+
+**Explanation:** The binary representation of 5 is 101 (no leading zero bits), and its complement is 010. So you need to output 2.
+
+**Example 2:**
+
+**Input:** num = 1
+
+**Output:** 0
+
+**Explanation:** The binary representation of 1 is 1 (no leading zero bits), and its complement is 0. So you need to output 0.
+
+**Constraints:**
+
+*   <code>1 <= num < 2<sup>31</sup></code>
+
+**Note:** This question is the same as 1009: [https://leetcode.com/problems/complement-of-base-10-integer/](https://leetcode.com/problems/complement-of-base-10-integer/)

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

@@ -0,0 +1,17 @@
+package g0401_0500.s0473_matchsticks_to_square
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun makeSquare() {
+        assertThat(Solution().makesquare(intArrayOf(1, 1, 2, 2, 2)), equalTo(true))
+    }
+
+    @Test
+    fun makeSquare2() {
+        assertThat(Solution().makesquare(intArrayOf(3, 3, 3, 3, 4)), equalTo(false))
+    }
+}