Added tasks 518, 519, 520, 521.

Author: ThanhNIT

README.md

@@ -1625,6 +1625,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0322 |[Coin Change](src.save/main/kotlin/g0301_0400/s0322_coin_change/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Breadth_First_Search | 332 | 50.68
+| 0518 |[Coin Change II](src/main/kotlin/g0501_0600/s0518_coin_change_2/Solution.kt)| Medium | Array, Dynamic_Programming | 139 | 100.00
 
 #### Day 21
 
@@ -1646,6 +1647,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | 0647 |[Palindromic Substrings](src/main/kotlin/g0601_0700/s0647_palindromic_substrings/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming | 266 | 67.83
 | 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
+| 0521 |[Longest Uncommon Subsequence I](src/main/kotlin/g0501_0600/s0521_longest_uncommon_subsequence_i/Solution.kt)| Easy | String | 146 | 88.89
+| 0520 |[Detect Capital](src/main/kotlin/g0501_0600/s0520_detect_capital/Solution.kt)| Easy | String | 161 | 84.54
+| 0519 |[Random Flip Matrix](src/main/kotlin/g0501_0600/s0519_random_flip_matrix/Solution.kt)| Medium | Hash_Table, Math, Randomized, Reservoir_Sampling | 270 | 100.00
+| 0518 |[Coin Change II](src/main/kotlin/g0501_0600/s0518_coin_change_2/Solution.kt)| Medium | Array, Dynamic_Programming, Dynamic_Programming_I_Day_20 | 139 | 100.00
 | 0517 |[Super Washing Machines](src/main/kotlin/g0501_0600/s0517_super_washing_machines/Solution.kt)| Hard | Array, Greedy | 210 | 100.00
 | 0516 |[Longest Palindromic Subsequence](src/main/kotlin/g0501_0600/s0516_longest_palindromic_subsequence/Solution.kt)| Medium | String, Dynamic_Programming, Dynamic_Programming_I_Day_17 | 243 | 87.50
 | 0515 |[Find Largest Value in Each Tree Row](src/main/kotlin/g0501_0600/s0515_find_largest_value_in_each_tree_row/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 238 | 73.33

src/main/kotlin/g0501_0600/s0518_coin_change_2/Solution.kt

@@ -0,0 +1,17 @@
+package g0501_0600.s0518_coin_change_2
+
+// #Medium #Array #Dynamic_Programming #Dynamic_Programming_I_Day_20
+// #2023_01_13_Time_139_ms_(100.00%)_Space_33.6_MB_(94.00%)
+
+class Solution {
+    fun change(amount: Int, coins: IntArray): Int {
+        val dp = IntArray(amount + 1)
+        dp[0] = 1
+        for (coin in coins) {
+            for (i in coin..amount) {
+                dp[i] += dp[i - coin]
+            }
+        }
+        return dp[amount]
+    }
+}

src/main/kotlin/g0501_0600/s0518_coin_change_2/readme.md

@@ -0,0 +1,48 @@
+518\. Coin Change II
+
+Medium
+
+You are given an integer array `coins` representing coins of different denominations and an integer `amount` representing a total amount of money.
+
+Return _the number of combinations that make up that amount_. If that amount of money cannot be made up by any combination of the coins, return `0`.
+
+You may assume that you have an infinite number of each kind of coin.
+
+The answer is **guaranteed** to fit into a signed **32-bit** integer.
+
+**Example 1:**
+
+**Input:** amount = 5, coins = [1,2,5]
+
+**Output:** 4
+
+**Explanation:** there are four ways to make up the amount: 
+
+5=5 
+
+5=2+2+1 
+
+5=2+1+1+1 
+
+5=1+1+1+1+1
+
+**Example 2:**
+
+**Input:** amount = 3, coins = [2]
+
+**Output:** 0
+
+**Explanation:** the amount of 3 cannot be made up just with coins of 2.
+
+**Example 3:**
+
+**Input:** amount = 10, coins = [10]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= coins.length <= 300`
+*   `1 <= coins[i] <= 5000`
+*   All the values of `coins` are **unique**.
+*   `0 <= amount <= 5000`

src/main/kotlin/g0501_0600/s0519_random_flip_matrix/Solution.kt

@@ -0,0 +1,38 @@
+package g0501_0600.s0519_random_flip_matrix
+
+// #Medium #Hash_Table #Math #Randomized #Reservoir_Sampling
+// #2023_01_13_Time_270_ms_(100.00%)_Space_37.6_MB_(100.00%)
+
+import java.util.Random
+
+@Suppress("kotlin:S2245")
+class Solution(nRows: Int, private val cols: Int) {
+    private val total: Int
+    private val rand: Random = Random()
+    private val available: MutableSet<Int>
+
+    init {
+        available = HashSet()
+        total = nRows * cols
+    }
+
+    fun flip(): IntArray {
+        var x: Int = rand.nextInt(total)
+        while (available.contains(x)) {
+            x = rand.nextInt(total)
+        }
+        available.add(x)
+        return intArrayOf(x / cols, x % cols)
+    }
+
+    fun reset() {
+        available.clear()
+    }
+}
+
+/*
+ * Your Solution object will be instantiated and called as such:
+ * var obj = Solution(m, n)
+ * var param_1 = obj.flip()
+ * obj.reset()
+ */

src/main/kotlin/g0501_0600/s0519_random_flip_matrix/readme.md

@@ -0,0 +1,34 @@
+519\. Random Flip Matrix
+
+Medium
+
+There is an `m x n` binary grid `matrix` with all the values set `0` initially. Design an algorithm to randomly pick an index `(i, j)` where `matrix[i][j] == 0` and flips it to `1`. All the indices `(i, j)` where `matrix[i][j] == 0` should be equally likely to be returned.
+
+Optimize your algorithm to minimize the number of calls made to the **built-in** random function of your language and optimize the time and space complexity.
+
+Implement the `Solution` class:
+
+*   `Solution(int m, int n)` Initializes the object with the size of the binary matrix `m` and `n`.
+*   `int[] flip()` Returns a random index `[i, j]` of the matrix where `matrix[i][j] == 0` and flips it to `1`.
+*   `void reset()` Resets all the values of the matrix to be `0`.
+
+**Example 1:**
+
+**Input** ["Solution", "flip", "flip", "flip", "reset", "flip"] [[3, 1], [], [], [], [], []]
+
+**Output:** [null, [1, 0], [2, 0], [0, 0], null, [2, 0]]
+
+**Explanation:** 
+
+    Solution solution = new Solution(3, 1); 
+    solution.flip(); // return [1, 0], [0,0], [1,0], and [2,0] should be equally likely to be returned. 
+    solution.flip(); // return [2, 0], Since [1,0] was returned, [2,0] and [0,0] 
+    solution.flip(); // return [0, 0], Based on the previously returned indices, only [0,0] can be returned. 
+    solution.reset(); // All the values are reset to 0 and can be returned. 
+    solution.flip(); // return [2, 0], [0,0], [1,0], and [2,0] should be equally likely to be returned.
+
+**Constraints:**
+
+*   <code>1 <= m, n <= 10<sup>4</sup></code>
+*   There will be at least one free cell for each call to `flip`.
+*   At most `1000` calls will be made to `flip` and `reset`.

src/main/kotlin/g0501_0600/s0520_detect_capital/Solution.kt

@@ -0,0 +1,26 @@
+package g0501_0600.s0520_detect_capital
+
+// #Easy #String #2023_01_13_Time_161_ms_(84.54%)_Space_33.9_MB_(92.99%)
+
+class Solution {
+    fun detectCapitalUse(word: String?): Boolean {
+        if (word == null || word.length == 0) {
+            return false
+        }
+        var upper = 0
+        var lower = 0
+        val n = word.length
+        var firstUpper = Character.isUpperCase(word[0])
+        for (i in 0 until n) {
+            if (Character.isUpperCase(word[i])) {
+                upper++
+            } else if (Character.isLowerCase(word[i])) {
+                lower++
+            }
+        }
+        if (firstUpper && upper > 1) {
+            firstUpper = false
+        }
+        return upper == n || lower == n || firstUpper
+    }
+}

src/main/kotlin/g0501_0600/s0520_detect_capital/readme.md

@@ -0,0 +1,28 @@
+520\. Detect Capital
+
+Easy
+
+We define the usage of capitals in a word to be right when one of the following cases holds:
+
+*   All letters in this word are capitals, like `"USA"`.
+*   All letters in this word are not capitals, like `"leetcode"`.
+*   Only the first letter in this word is capital, like `"Google"`.
+
+Given a string `word`, return `true` if the usage of capitals in it is right.
+
+**Example 1:**
+
+**Input:** word = "USA"
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** word = "FlaG"
+
+**Output:** false
+
+**Constraints:**
+
+*   `1 <= word.length <= 100`
+*   `word` consists of lowercase and uppercase English letters.

src/main/kotlin/g0501_0600/s0521_longest_uncommon_subsequence_i/Solution.kt

@@ -0,0 +1,11 @@
+package g0501_0600.s0521_longest_uncommon_subsequence_i
+
+// #Easy #String #2023_01_14_Time_146_ms_(88.89%)_Space_33.5_MB_(66.67%)
+
+class Solution {
+    fun findLUSlength(a: String, b: String): Int {
+        return if (a == b) {
+            -1
+        } else a.length.coerceAtLeast(b.length)
+    }
+}

src/main/kotlin/g0501_0600/s0521_longest_uncommon_subsequence_i/readme.md

@@ -0,0 +1,40 @@
+521\. Longest Uncommon Subsequence I
+
+Easy
+
+Given two strings `a` and `b`, return _the length of the **longest uncommon subsequence** between_ `a` _and_ `b`. If the longest uncommon subsequence does not exist, return `-1`.
+
+An **uncommon subsequence** between two strings is a string that is a **subsequence of one but not the other**.
+
+A **subsequence** of a string `s` is a string that can be obtained after deleting any number of characters from `s`.
+
+*   For example, `"abc"` is a subsequence of `"aebdc"` because you can delete the underlined characters in <code>"a<ins>e</ins>b<ins>d</ins>c"</code> to get `"abc"`. Other subsequences of `"aebdc"` include `"aebdc"`, `"aeb"`, and `""` (empty string).
+
+**Example 1:**
+
+**Input:** a = "aba", b = "cdc"
+
+**Output:** 3
+
+**Explanation:** One longest uncommon subsequence is "aba" because "aba" is a subsequence of "aba" but not "cdc". Note that "cdc" is also a longest uncommon subsequence.
+
+**Example 2:**
+
+**Input:** a = "aaa", b = "bbb"
+
+**Output:** 3
+
+**Explanation:** The longest uncommon subsequences are "aaa" and "bbb".
+
+**Example 3:**
+
+**Input:** a = "aaa", b = "aaa"
+
+**Output:** -1
+
+**Explanation:** Every subsequence of string a is also a subsequence of string b. Similarly, every subsequence of string b is also a subsequence of string a.
+
+**Constraints:**
+
+*   `1 <= a.length, b.length <= 100`
+*   `a` and `b` consist of lower-case English letters.

src/test/kotlin/g0501_0600/s0518_coin_change_2/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0501_0600.s0518_coin_change_2
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun change() {
+        assertThat(Solution().change(5, intArrayOf(1, 2, 5)), equalTo(4))
+    }
+
+    @Test
+    fun change2() {
+        assertThat(Solution().change(3, intArrayOf(2)), equalTo(0))
+    }
+
+    @Test
+    fun change3() {
+        assertThat(Solution().change(10, intArrayOf(10)), equalTo(1))
+    }
+}