Added tasks 532, 535, 537, 538.

Author: ThanhNIT

README.md

@@ -2,7 +2,7 @@
 
 [![Maven Central](https://img.shields.io/maven-central/v/com.github.javadev/leetcode-in-kotlin.svg)](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.github.javadev%22%20AND%20a%3A%22leetcode-in-kotlin%22)
 [![MIT License](http://img.shields.io/badge/license-MIT-green.svg) ](https://github.com/javadev/leetcode-in-kotlin/blob/main/LICENSE)
-[![Java CI with Maven](https://github.com/javadev/LeetCode-in-Kotlin/actions/workflows/gradle.yml/badge.svg)](https://github.com/javadev/LeetCode-in-Kotlin/actions/workflows/gradle.yml)
+[![Java CI with Maven](https://github.com/javadev/LeetCode-in-Kotlin/actions/workflows/maven.yml/badge.svg)](https://github.com/javadev/LeetCode-in-Kotlin/actions/workflows/maven.yml)
 [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=javadev_LeetCode-in-Kotlin&metric=sqale_rating)](https://sonarcloud.io/summary/overall?id=javadev_LeetCode-in-Kotlin)
 [![javadoc](https://javadoc.io/badge2/com.github.javadev/leetcode-in-kotlin/javadoc.svg)](https://javadoc.io/doc/com.github.javadev/leetcode-in-kotlin)
 [![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
@@ -677,6 +677,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | 0448 |[Find All Numbers Disappeared in an Array](src.save/main/kotlin/g0401_0500/s0448_find_all_numbers_disappeared_in_an_array/Solution.kt)| Easy | Array, Hash_Table | 394 | 100.00
 | 0442 |[Find All Duplicates in an Array](src.save/main/kotlin/g0401_0500/s0442_find_all_duplicates_in_an_array/Solution.kt)| Medium | Array, Hash_Table | 480 | 73.81
 | 0041 |[First Missing Positive](src.save/main/kotlin/g0001_0100/s0041_first_missing_positive/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table | 345 | 100.00
+| 0532 |[K-diff Pairs in an Array](src/main/kotlin/g0501_0600/s0532_k_diff_pairs_in_an_array/Solution.kt)| Medium | Array, Hash_Table, Sorting, Binary_Search, Two_Pointers | 230 | 84.62
 | 0456 |[132 Pattern](src.save/main/kotlin/g0401_0500/s0456_132_pattern/Solution.kt)| Medium | Array, Binary_Search, Stack, Ordered_Set, Monotonic_Stack | 434 | 100.00
 | 0239 |[Sliding Window Maximum](src.save/main/kotlin/g0201_0300/s0239_sliding_window_maximum/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Heap_Priority_Queue, Sliding_Window, Queue, Monotonic_Queue | 1059 | 86.14
 
@@ -1648,6 +1649,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
+| 0538 |[Convert BST to Greater Tree](src/main/kotlin/g0501_0600/s0538_convert_bst_to_greater_tree/Solution.kt)| Medium | Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 252 | 77.78
+| 0537 |[Complex Number Multiplication](src/main/kotlin/g0501_0600/s0537_complex_number_multiplication/Solution.kt)| Medium | String, Math, Simulation | 171 | 75.00
+| 0535 |[Encode and Decode TinyURL](src/main/kotlin/g0501_0600/s0535_encode_and_decode_tinyurl/Codec.kt)| Medium | String, Hash_Table, Design, Hash_Function | 183 | 81.25
+| 0532 |[K-diff Pairs in an Array](src/main/kotlin/g0501_0600/s0532_k_diff_pairs_in_an_array/Solution.kt)| Medium | Array, Hash_Table, Sorting, Binary_Search, Two_Pointers, Udemy_Arrays | 230 | 84.62
 | 0530 |[Minimum Absolute Difference in BST](src/main/kotlin/g0501_0600/s0530_minimum_absolute_difference_in_bst/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 209 | 86.96
 | 0529 |[Minesweeper](src/main/kotlin/g0501_0600/s0529_minesweeper/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix | 243 | 87.50
 | 0528 |[Random Pick with Weight](src/main/kotlin/g0501_0600/s0528_random_pick_with_weight/Solution.kt)| Medium | Math, Binary_Search, Prefix_Sum, Randomized, Binary_Search_II_Day_13 | 393 | 91.38

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

@@ -0,0 +1,31 @@
+package g0501_0600.s0532_k_diff_pairs_in_an_array
+
+// #Medium #Array #Hash_Table #Sorting #Binary_Search #Two_Pointers #Udemy_Arrays
+// #2023_01_15_Time_230_ms_(84.62%)_Space_37.3_MB_(92.31%)
+
+class Solution {
+    fun findPairs(nums: IntArray, k: Int): Int {
+        var res = 0
+        val set: HashSet<Int> = HashSet()
+        val twice: HashSet<Int> = HashSet()
+        for (n in nums) {
+            if (set.contains(n)) {
+                if (k == 0 && !twice.contains(n)) {
+                    res++
+                    twice.add(n)
+                } else {
+                    continue
+                }
+            } else {
+                if (set.contains(n - k)) {
+                    res++
+                }
+                if (set.contains(n + k)) {
+                    res++
+                }
+            }
+            set.add(n)
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,43 @@
+532\. K-diff Pairs in an Array
+
+Medium
+
+Given an array of integers `nums` and an integer `k`, return _the number of **unique** k-diff pairs in the array_.
+
+A **k-diff** pair is an integer pair `(nums[i], nums[j])`, where the following are true:
+
+*   `0 <= i, j < nums.length`
+*   `i != j`
+*   `nums[i] - nums[j] == k`
+
+**Notice** that `|val|` denotes the absolute value of `val`.
+
+**Example 1:**
+
+**Input:** nums = [3,1,4,1,5], k = 2
+
+**Output:** 2
+
+**Explanation:** There are two 2-diff pairs in the array, (1, 3) and (3, 5). Although we have two 1s in the input, we should only return the number of **unique** pairs.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4,5], k = 1
+
+**Output:** 4
+
+**Explanation:** There are four 1-diff pairs in the array, (1, 2), (2, 3), (3, 4) and (4, 5).
+
+**Example 3:**
+
+**Input:** nums = [1,3,1,5,4], k = 0
+
+**Output:** 1
+
+**Explanation:** There is one 0-diff pair in the array, (1, 1).
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>7</sup> <= nums[i] <= 10<sup>7</sup></code>
+*   <code>0 <= k <= 10<sup>7</sup></code>

src/main/kotlin/g0501_0600/s0535_encode_and_decode_tinyurl/Codec.kt

@@ -0,0 +1,30 @@
+package g0501_0600.s0535_encode_and_decode_tinyurl
+
+// #Medium #String #Hash_Table #Design #Hash_Function
+// #2023_01_15_Time_183_ms_(81.25%)_Space_35.8_MB_(68.75%)
+
+class Codec {
+    private val map: MutableMap<String, String> = HashMap()
+    private var n = 0
+
+    // Encodes a URL to a shortened URL.
+    fun encode(longUrl: String): String {
+        n++
+        var ans = "http://tinyurl.com/"
+        ans += n.toString()
+        map[ans] = longUrl
+        return ans
+    }
+
+    // Decodes a shortened URL to its original URL.
+    fun decode(shortUrl: String): String? {
+        return map[shortUrl]
+    }
+}
+
+/*
+ * Your Codec object will be instantiated and called as such:
+ * var obj = Codec()
+ * var url = obj.encode(longUrl)
+ * var ans = obj.decode(url)
+ */

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

@@ -0,0 +1,32 @@
+535\. Encode and Decode TinyURL
+
+Medium
+
+> Note: This is a companion problem to the [System Design](https://leetcode.com/discuss/interview-question/system-design/) problem: [Design TinyURL](https://leetcode.com/discuss/interview-question/124658/Design-a-URL-Shortener-(-TinyURL-)-System/).
+
+TinyURL is a URL shortening service where you enter a URL such as `https://leetcode.com/problems/design-tinyurl` and it returns a short URL such as `http://tinyurl.com/4e9iAk`. Design a class to encode a URL and decode a tiny URL.
+
+There is no restriction on how your encode/decode algorithm should work. You just need to ensure that a URL can be encoded to a tiny URL and the tiny URL can be decoded to the original URL.
+
+Implement the `Solution` class:
+
+*   `Solution()` Initializes the object of the system.
+*   `String encode(String longUrl)` Returns a tiny URL for the given `longUrl`.
+*   `String decode(String shortUrl)` Returns the original long URL for the given `shortUrl`. It is guaranteed that the given `shortUrl` was encoded by the same object.
+
+**Example 1:**
+
+**Input:** url = "https://leetcode.com/problems/design-tinyurl"
+
+**Output:** "https://leetcode.com/problems/design-tinyurl"
+
+**Explanation:**
+
+    Solution obj = new Solution();
+    string tiny = obj.encode(url); // returns the encoded tiny url.
+    string ans = obj.decode(tiny); // returns the original url after deconding it. 
+
+**Constraints:**
+
+*   <code>1 <= url.length <= 10<sup>4</sup></code>
+*   `url` is guranteed to be a valid URL.

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

@@ -0,0 +1,19 @@
+package g0501_0600.s0537_complex_number_multiplication
+
+// #Medium #String #Math #Simulation #2023_01_16_Time_171_ms_(75.00%)_Space_35.2_MB_(100.00%)
+
+class Solution {
+    fun complexNumberMultiply(num1: String, num2: String): String {
+        val countReal: Int
+        val countImagine: Int
+        val arr1 = IntArray(2)
+        val arr2 = IntArray(2)
+        arr1[0] = num1.substring(0, num1.indexOf("+")).toInt()
+        arr1[1] = num1.substring(num1.indexOf("+") + 1, num1.length - 1).toInt()
+        arr2[0] = num2.substring(0, num2.indexOf("+")).toInt()
+        arr2[1] = num2.substring(num2.indexOf("+") + 1, num2.length - 1).toInt()
+        countReal = arr1[0] * arr2[0] - arr1[1] * arr2[1]
+        countImagine = arr1[0] * arr2[1] + arr1[1] * arr2[0]
+        return countReal.toString() + "+" + countImagine + "i"
+    }
+}

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

@@ -0,0 +1,31 @@
+537\. Complex Number Multiplication
+
+Medium
+
+A [complex number](https://en.wikipedia.org/wiki/Complex_number) can be represented as a string on the form <code>"**real**+**imaginary**i"</code> where:
+
+*   `real` is the real part and is an integer in the range `[-100, 100]`.
+*   `imaginary` is the imaginary part and is an integer in the range `[-100, 100]`.
+*   <code>i<sup>2</sup> == -1</code>.
+
+Given two complex numbers `num1` and `num2` as strings, return _a string of the complex number that represents their multiplications_.
+
+**Example 1:**
+
+**Input:** num1 = "1+1i", num2 = "1+1i"
+
+**Output:** "0+2i"
+
+**Explanation:** (1 + i) \* (1 + i) = 1 + i2 + 2 \* i = 2i, and you need convert it to the form of 0+2i.
+
+**Example 2:**
+
+**Input:** num1 = "1+-1i", num2 = "1+-1i"
+
+**Output:** "0+-2i"
+
+**Explanation:** (1 - i) \* (1 - i) = 1 + i2 - 2 \* i = -2i, and you need convert it to the form of 0+-2i.
+
+**Constraints:**
+
+*   `num1` and `num2` are valid complex numbers.

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

@@ -0,0 +1,38 @@
+package g0501_0600.s0538_convert_bst_to_greater_tree
+
+// #Medium #Depth_First_Search #Tree #Binary_Tree #Binary_Search_Tree
+// #2023_01_16_Time_252_ms_(77.78%)_Space_36_MB_(100.00%)
+
+import com_github_leetcode.TreeNode
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun convertBST(root: TreeNode?): TreeNode? {
+        if (root != null) {
+            postOrder(root, 0)
+        }
+        return root
+    }
+
+    private fun postOrder(node: TreeNode, `val`: Int): Int {
+        var newVal = 0
+        if (node.right != null) {
+            newVal += postOrder(node.right!!, `val`)
+        }
+        newVal += if (newVal == 0) `val` + node.`val` else node.`val`
+        node.`val` = newVal
+        if (node.left != null) {
+            newVal = postOrder(node.left!!, newVal)
+        }
+        return newVal
+    }
+}

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

@@ -0,0 +1,34 @@
+538\. Convert BST to Greater Tree
+
+Medium
+
+Given the `root` of a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus the sum of all keys greater than the original key in BST.
+
+As a reminder, a _binary search tree_ is a tree that satisfies these constraints:
+
+*   The left subtree of a node contains only nodes with keys **less than** the node's key.
+*   The right subtree of a node contains only nodes with keys **greater than** the node's key.
+*   Both the left and right subtrees must also be binary search trees.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/05/02/tree.png)
+
+**Input:** root = [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
+
+**Output:** [30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
+
+**Example 2:**
+
+**Input:** root = [0,null,1]
+
+**Output:** [1,null,1]
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   <code>-10<sup>4</sup> <= Node.val <= 10<sup>4</sup></code>
+*   All the values in the tree are **unique**.
+*   `root` is guaranteed to be a valid binary search tree.
+
+**Note:** This question is the same as 1038: [https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/](https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/)

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

@@ -0,0 +1,22 @@
+package g0501_0600.s0532_k_diff_pairs_in_an_array
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun findPairs() {
+        assertThat(Solution().findPairs(intArrayOf(3, 1, 4, 1, 5), 2), equalTo(2))
+    }
+
+    @Test
+    fun findPairs2() {
+        assertThat(Solution().findPairs(intArrayOf(1, 2, 3, 4, 5), 1), equalTo(4))
+    }
+
+    @Test
+    fun findPairs3() {
+        assertThat(Solution().findPairs(intArrayOf(1, 3, 1, 5, 4), 0), equalTo(1))
+    }
+}