Added tasks 522, 523, 524, 525.

Author: ThanhNIT

README.md

@@ -1647,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
+| 0525 |[Contiguous Array](src/main/kotlin/g0501_0600/s0525_contiguous_array/Solution.kt)| Medium | Array, Hash_Table, Prefix_Sum | 471 | 100.00
+| 0524 |[Longest Word in Dictionary through Deleting](src/main/kotlin/g0501_0600/s0524_longest_word_in_dictionary_through_deleting/Solution.kt)| Medium | Array, String, Sorting, Two_Pointers | 307 | 100.00
+| 0523 |[Continuous Subarray Sum](src/main/kotlin/g0501_0600/s0523_continuous_subarray_sum/Solution.kt)| Medium | Array, Hash_Table, Math, Prefix_Sum | 682 | 95.45
+| 0522 |[Longest Uncommon Subsequence II](src/main/kotlin/g0501_0600/s0522_longest_uncommon_subsequence_ii/Solution.kt)| Medium | Array, String, Hash_Table, Sorting, Two_Pointers | 163 | 100.00
 | 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

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

@@ -0,0 +1,36 @@
+package g0501_0600.s0522_longest_uncommon_subsequence_ii
+
+// #Medium #Array #String #Hash_Table #Sorting #Two_Pointers
+// #2023_01_14_Time_163_ms_(100.00%)_Space_33.6_MB_(50.00%)
+
+class Solution {
+    fun findLUSlength(strs: Array<String>): Int {
+        var maxUncommonLen = -1
+        for (indx1 in strs.indices) {
+            var isCommon = false
+            for (indx2 in strs.indices) {
+                if (indx2 != indx1 && isSubSequence(strs[indx1], strs[indx2])) {
+                    isCommon = true
+                    break
+                }
+            }
+            if (!isCommon) {
+                maxUncommonLen = Math.max(maxUncommonLen, strs[indx1].length)
+            }
+        }
+        return maxUncommonLen
+    }
+
+    private fun isSubSequence(str1: String, str2: String): Boolean {
+        var indx1 = 0
+        for (indx2 in 0 until str2.length) {
+            if (str1[indx1] == str2[indx2]) {
+                indx1++
+            }
+            if (indx1 == str1.length) {
+                return true
+            }
+        }
+        return indx1 == str1.length
+    }
+}

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

@@ -0,0 +1,29 @@
+522\. Longest Uncommon Subsequence II
+
+Medium
+
+Given an array of strings `strs`, return _the length of the **longest uncommon subsequence** between them_. If the longest uncommon subsequence does not exist, return `-1`.
+
+An **uncommon subsequence** between an array of strings is a string that is a **subsequence of one string but not the others**.
+
+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:** strs = ["aba","cdc","eae"]
+
+**Output:** 3
+
+**Example 2:**
+
+**Input:** strs = ["aaa","aaa","aa"]
+
+**Output:** -1
+
+**Constraints:**
+
+*   `2 <= strs.length <= 50`
+*   `1 <= strs[i].length <= 10`
+*   `strs[i]` consists of lowercase English letters.

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

@@ -0,0 +1,24 @@
+package g0501_0600.s0523_continuous_subarray_sum
+
+// #Medium #Array #Hash_Table #Math #Prefix_Sum
+// #2023_01_14_Time_682_ms_(95.45%)_Space_55_MB_(86.36%)
+
+class Solution {
+    fun checkSubarraySum(nums: IntArray, k: Int): Boolean {
+        val map: MutableMap<Int, Int> = HashMap()
+        var sum = 0
+        map[0] = -1
+        for (i in nums.indices) {
+            sum += nums[i]
+            val remainder = sum % k
+            if (map.containsKey(remainder)) {
+                if (map[remainder]!! + 1 < i) {
+                    return true
+                }
+            } else {
+                map[remainder] = i
+            }
+        }
+        return false
+    }
+}

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

@@ -0,0 +1,44 @@
+523\. Continuous Subarray Sum
+
+Medium
+
+Given an integer array nums and an integer k, return `true` _if_ `nums` _has a **good subarray** or_ `false` _otherwise_.
+
+A **good subarray** is a subarray where:
+
+*   its length is **at least two**, and
+*   the sum of the elements of the subarray is a multiple of `k`.
+
+**Note** that:
+
+*   A **subarray** is a contiguous part of the array.
+*   An integer `x` is a multiple of `k` if there exists an integer `n` such that `x = n * k`. `0` is **always** a multiple of `k`.
+
+**Example 1:**
+
+**Input:** nums = [23,<ins>2,4</ins>,6,7], k = 6
+
+**Output:** true
+
+**Explanation:** [2, 4] is a continuous subarray of size 2 whose elements sum up to 6.
+
+**Example 2:**
+
+**Input:** nums = [<ins>23,2,6,4,7</ins>], k = 6
+
+**Output:** true
+
+**Explanation:** [23, 2, 6, 4, 7] is an continuous subarray of size 5 whose elements sum up to 42. 42 is a multiple of 6 because 42 = 7 \* 6 and 7 is an integer.
+
+**Example 3:**
+
+**Input:** nums = [23,2,6,4,7], k = 13
+
+**Output:** false
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>
+*   <code>0 <= sum(nums[i]) <= 2<sup>31</sup> - 1</code>
+*   <code>1 <= k <= 2<sup>31</sup> - 1</code>

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

@@ -0,0 +1,46 @@
+package g0501_0600.s0524_longest_word_in_dictionary_through_deleting
+
+// #Medium #Array #String #Sorting #Two_Pointers
+// #2023_01_14_Time_307_ms_(100.00%)_Space_38.4_MB_(100.00%)
+
+import java.util.ArrayDeque
+import java.util.Deque
+
+class Solution {
+    private class Pair(var word: String, var index: Int)
+
+    fun findLongestWord(s: String, dictionary: List<String>): String {
+        val map: MutableMap<Char, Deque<Pair?>> = HashMap()
+        var c = 'a'
+        while (c <= 'z') {
+            map[c] = ArrayDeque()
+            c++
+        }
+        for (word in dictionary) {
+            map[word[0]]!!.offerFirst(Pair(word, 0))
+        }
+        var maxLen = 0
+        var res = ""
+        for (i in 0 until s.length) {
+            if (!map[s[i]]!!.isEmpty()) {
+                val deque = map[s[i]]!!
+                val size = deque.size
+                for (j in 0 until size) {
+                    val pair = deque.pollLast()!!
+                    if (pair.index == pair.word.length - 1) {
+                        if (maxLen < pair.word.length) {
+                            maxLen = pair.word.length
+                            res = pair.word
+                        } else if (maxLen == pair.word.length && res.compareTo(pair.word) > 0) {
+                            res = pair.word
+                        }
+                    } else {
+                        pair.index++
+                        map[pair.word[pair.index]]!!.offerFirst(pair)
+                    }
+                }
+            }
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,24 @@
+524\. Longest Word in Dictionary through Deleting
+
+Medium
+
+Given a string `s` and a string array `dictionary`, return _the longest string in the dictionary that can be formed by deleting some of the given string characters_. If there is more than one possible result, return the longest word with the smallest lexicographical order. If there is no possible result, return the empty string.
+
+**Example 1:**
+
+**Input:** s = "abpcplea", dictionary = ["ale","apple","monkey","plea"]
+
+**Output:** "apple"
+
+**Example 2:**
+
+**Input:** s = "abpcplea", dictionary = ["a","b","c"]
+
+**Output:** "a"
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `1 <= dictionary.length <= 1000`
+*   `1 <= dictionary[i].length <= 1000`
+*   `s` and `dictionary[i]` consist of lowercase English letters.

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

@@ -0,0 +1,26 @@
+package g0501_0600.s0525_contiguous_array
+
+// #Medium #Array #Hash_Table #Prefix_Sum #2023_01_14_Time_471_ms_(100.00%)_Space_45.9_MB_(83.33%)
+
+class Solution {
+    fun findMaxLength(nums: IntArray): Int {
+        for (i in nums.indices) {
+            if (nums[i] == 0) {
+                nums[i] = -1
+            }
+        }
+        val map: HashMap<Int, Int> = HashMap()
+        map[0] = -1
+        var ps = 0
+        var len = 0
+        for (i in nums.indices) {
+            ps += nums[i]
+            if (!map.containsKey(ps)) {
+                map[ps] = i
+            } else {
+                len = Math.max(len, i - map[ps]!!)
+            }
+        }
+        return len
+    }
+}

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

@@ -0,0 +1,26 @@
+525\. Contiguous Array
+
+Medium
+
+Given a binary array `nums`, return _the maximum length of a contiguous subarray with an equal number of_ `0` _and_ `1`.
+
+**Example 1:**
+
+**Input:** nums = [0,1]
+
+**Output:** 2
+
+**Explanation:** [0, 1] is the longest contiguous subarray with an equal number of 0 and 1.
+
+**Example 2:**
+
+**Input:** nums = [0,1,0]
+
+**Output:** 2
+
+**Explanation:** [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   `nums[i]` is either `0` or `1`.

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

@@ -0,0 +1,17 @@
+package g0501_0600.s0522_longest_uncommon_subsequence_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun findLUSlength() {
+        assertThat(Solution().findLUSlength(arrayOf("aba", "cdc", "eae")), equalTo(3))
+    }
+
+    @Test
+    fun findLUSlength2() {
+        assertThat(Solution().findLUSlength(arrayOf("aaa", "aaa", "aa")), equalTo(-1))
+    }
+}