Added tasks 1053, 1054, 1061, 1068

Author: ThanhNIT

README.md

@@ -1781,6 +1781,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | 1155 |[Number of Dice Rolls With Target Sum](src/main/kotlin/g1101_1200/s1155_number_of_dice_rolls_with_target_sum/Solution.kt)| Medium | Dynamic_Programming | 158 | 80.95
 | 1154 |[Day of the Year](src/main/kotlin/g1101_1200/s1154_day_of_the_year/Solution.kt)| Easy | String, Math | 317 | 70.00
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 307 | 38.36
+| 1068 |[Product Sales Analysis I](src/main/kotlin/g1001_1100/s1068_product_sales_analysis_i/script.sql)| Easy | Database | 1897 | 79.88
+| 1061 |[Lexicographically Smallest Equivalent String](src/main/kotlin/g1001_1100/s1061_lexicographically_smallest_equivalent_string/Solution.kt)| Medium | String, Union_Find | 166 | 100.00
+| 1054 |[Distant Barcodes](src/main/kotlin/g1001_1100/s1054_distant_barcodes/Solution.kt)| Medium | Array, Hash_Table, Sorting, Greedy, Heap_Priority_Queue, Counting | 622 | 75.00
+| 1053 |[Previous Permutation With One Swap](src/main/kotlin/g1001_1100/s1053_previous_permutation_with_one_swap/Solution.kt)| Medium | Array, Greedy | 338 | 25.00
 | 1052 |[Grumpy Bookstore Owner](src/main/kotlin/g1001_1100/s1052_grumpy_bookstore_owner/Solution.kt)| Medium | Array, Sliding_Window | 268 | 80.00
 | 1051 |[Height Checker](src/main/kotlin/g1001_1100/s1051_height_checker/Solution.kt)| Easy | Array, Sorting, Counting_Sort | 140 | 94.37
 | 1050 |[Actors and Directors Who Cooperated At Least Three Times](src/main/kotlin/g1001_1100/s1050_actors_and_directors_who_cooperated_at_least_three_times/script.sql)| Easy | LeetCode_Curated_SQL_70, Database, SQL_I_Day_10_Where | 629 | 81.02

src/main/kotlin/g1001_1100/s1053_previous_permutation_with_one_swap/Solution.kt

@@ -0,0 +1,25 @@
+package g1001_1100.s1053_previous_permutation_with_one_swap
+
+// #Medium #Array #Greedy #2023_05_30_Time_338_ms_(25.00%)_Space_71.2_MB_(25.00%)
+
+class Solution {
+    fun prevPermOpt1(arr: IntArray): IntArray {
+        for (i in arr.indices.reversed()) {
+            var diff = Int.MAX_VALUE
+            var index = i
+            for (j in i + 1 until arr.size) {
+                if (arr[i] - arr[j] in 1 until diff) {
+                    diff = arr[i] - arr[j]
+                    index = j
+                }
+            }
+            if (diff != Int.MAX_VALUE) {
+                val temp = arr[i]
+                arr[i] = arr[index]
+                arr[index] = temp
+                break
+            }
+        }
+        return arr
+    }
+}

src/main/kotlin/g1001_1100/s1053_previous_permutation_with_one_swap/readme.md

@@ -0,0 +1,36 @@
+1053\. Previous Permutation With One Swap
+
+Medium
+
+Given an array of positive integers `arr` (not necessarily distinct), return _the_ _lexicographically_ _largest permutation that is smaller than_ `arr`, that can be **made with exactly one swap**. If it cannot be done, then return the same array.
+
+**Note** that a _swap_ exchanges the positions of two numbers `arr[i]` and `arr[j]`
+
+**Example 1:**
+
+**Input:** arr = [3,2,1]
+
+**Output:** [3,1,2]
+
+**Explanation:** Swapping 2 and 1.
+
+**Example 2:**
+
+**Input:** arr = [1,1,5]
+
+**Output:** [1,1,5]
+
+**Explanation:** This is already the smallest permutation.
+
+**Example 3:**
+
+**Input:** arr = [1,9,4,6,7]
+
+**Output:** [1,7,4,6,9]
+
+**Explanation:** Swapping 9 and 7.
+
+**Constraints:**
+
+*   <code>1 <= arr.length <= 10<sup>4</sup></code>
+*   <code>1 <= arr[i] <= 10<sup>4</sup></code>

src/main/kotlin/g1001_1100/s1054_distant_barcodes/Solution.kt

@@ -0,0 +1,30 @@
+package g1001_1100.s1054_distant_barcodes
+
+// #Medium #Array #Hash_Table #Sorting #Greedy #Heap_Priority_Queue #Counting
+// #2023_05_30_Time_622_ms_(75.00%)_Space_102.5_MB_(75.00%)
+
+import java.util.PriorityQueue
+
+class Solution {
+    fun rearrangeBarcodes(barcodes: IntArray): IntArray {
+        val map = barcodes.groupBy { it }.mapValues { it.value.size }
+        val pq = PriorityQueue<Pair<Int, Int>> { a, b -> b.second - a.second }
+        map.forEach { kv -> pq.offer(kv.toPair()) }
+        val result = IntArray(barcodes.size)
+        var ind = 0
+        while (pq.isNotEmpty()) {
+            val remainingBcs = mutableListOf<Pair<Int, Int>>()
+            for (i in 0 until 2) {
+                if (pq.isNotEmpty()) {
+                    val max = pq.poll()
+                    result[ind++] = max.first
+                    if (max.second - 1 != 0) {
+                        remainingBcs.add(Pair(max.first, max.second - 1))
+                    }
+                }
+            }
+            remainingBcs.forEach { bc -> pq.offer(bc) }
+        }
+        return result
+    }
+}

src/main/kotlin/g1001_1100/s1054_distant_barcodes/readme.md

@@ -0,0 +1,24 @@
+1054\. Distant Barcodes
+
+Medium
+
+In a warehouse, there is a row of barcodes, where the <code>i<sup>th</sup></code> barcode is `barcodes[i]`.
+
+Rearrange the barcodes so that no two adjacent barcodes are equal. You may return any answer, and it is guaranteed an answer exists.
+
+**Example 1:**
+
+**Input:** barcodes = [1,1,1,2,2,2]
+
+**Output:** [2,1,2,1,2,1]
+
+**Example 2:**
+
+**Input:** barcodes = [1,1,1,1,2,2,3,3]
+
+**Output:** [1,3,1,3,1,2,1,2]
+
+**Constraints:**
+
+*   `1 <= barcodes.length <= 10000`
+*   `1 <= barcodes[i] <= 10000`

src/main/kotlin/g1001_1100/s1061_lexicographically_smallest_equivalent_string/Solution.kt

@@ -0,0 +1,43 @@
+package g1001_1100.s1061_lexicographically_smallest_equivalent_string
+
+// #Medium #String #Union_Find #2023_05_30_Time_166_ms_(100.00%)_Space_50.7_MB_(25.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    lateinit var parent: IntArray
+
+    fun smallestEquivalentString(s1: String, s2: String, baseStr: String): String? {
+        parent = IntArray(26)
+        val n = s1.length
+        var result = ""
+        for (i in 0..25) parent[i] = i
+        for (i in 0 until n) {
+            union(s1[i].code - 'a'.code, s2[i].code - 'a'.code)
+        }
+        val base = 'a'.code
+        for (element in baseStr) {
+            result += (base + find(element.code - 'a'.code)).toChar()
+        }
+        return result
+    }
+
+    private fun union(a: Int, b: Int) {
+        val parentA = find(a)
+        val parentB = find(b)
+        if (parentA != parentB) {
+            if (parentA < parentB) {
+                parent[parentB] = parentA
+            } else {
+                parent[parentA] = parentB
+            }
+        }
+    }
+
+    private fun find(x: Int): Int {
+        var x = x
+        while (parent[x] != x) {
+            x = parent[x]
+        }
+        return x
+    }
+}

src/main/kotlin/g1001_1100/s1061_lexicographically_smallest_equivalent_string/readme.md

@@ -0,0 +1,55 @@
+1061\. Lexicographically Smallest Equivalent String
+
+Medium
+
+You are given two strings of the same length `s1` and `s2` and a string `baseStr`.
+
+We say `s1[i]` and `s2[i]` are equivalent characters.
+
+*   For example, if `s1 = "abc"` and `s2 = "cde"`, then we have `'a' == 'c'`, `'b' == 'd'`, and `'c' == 'e'`.
+
+Equivalent characters follow the usual rules of any equivalence relation:
+
+*   **Reflexivity:** `'a' == 'a'`.
+*   **Symmetry:** `'a' == 'b'` implies `'b' == 'a'`.
+*   **Transitivity:** `'a' == 'b'` and `'b' == 'c'` implies `'a' == 'c'`.
+
+For example, given the equivalency information from `s1 = "abc"` and `s2 = "cde"`, `"acd"` and `"aab"` are equivalent strings of `baseStr = "eed"`, and `"aab"` is the lexicographically smallest equivalent string of `baseStr`.
+
+Return _the lexicographically smallest equivalent string of_ `baseStr` _by using the equivalency information from_ `s1` _and_ `s2`.
+
+**Example 1:**
+
+**Input:** s1 = "parker", s2 = "morris", baseStr = "parser"
+
+**Output:** "makkek"
+
+**Explanation:** Based on the equivalency information in s1 and s2, we can group their characters as [m,p], [a,o], [k,r,s], [e,i]. 
+
+The characters in each group are equivalent and sorted in lexicographical order.
+
+So the answer is "makkek".
+
+**Example 2:**
+
+**Input:** s1 = "hello", s2 = "world", baseStr = "hold"
+
+**Output:** "hdld"
+
+**Explanation:** Based on the equivalency information in s1 and s2, we can group their characters as [h,w], [d,e,o], [l,r]. 
+
+So only the second letter 'o' in baseStr is changed to 'd', the answer is "hdld".
+
+**Example 3:**
+
+**Input:** s1 = "leetcode", s2 = "programs", baseStr = "sourcecode"
+
+**Output:** "aauaaaaada"
+
+**Explanation:** We group the equivalent characters in s1 and s2 as [a,o,e,r,s,c], [l,p], [g,t] and [d,m], thus all letters in baseStr except 'u' and 'd' are transformed to 'a', the answer is "aauaaaaada".
+
+**Constraints:**
+
+*   `1 <= s1.length, s2.length, baseStr <= 1000`
+*   `s1.length == s2.length`
+*   `s1`, `s2`, and `baseStr` consist of lowercase English letters.

src/main/kotlin/g1001_1100/s1068_product_sales_analysis_i/readme.md

@@ -0,0 +1,78 @@
+1068\. Product Sales Analysis I
+
+Easy
+
+SQL Schema
+
+Table: `Sales`
+
+    +-------------+-------+ 
+    | Column Name | Type  | 
+    +-------------+-------+ 
+    | sale_id     | int   | 
+    | product_id  | int   | 
+    | year        | int   | 
+    | quantity    | int   | 
+    | price       | int   | 
+    +-------------+-------+ 
+
+(sale_id, year) is the primary key of this table. 
+
+product_id is a foreign key to `Product` table. 
+
+Each row of this table shows a sale on the product product_id in a certain year. 
+
+Note that the price is per unit.
+
+Table: `Product`
+
+    +--------------+---------+ 
+    | Column Name  | Type    | 
+    +--------------+---------+ 
+    | product_id   | int     | 
+    | product_name | varchar | 
+    +--------------+---------+ 
+
+product_id is the primary key of this table. 
+
+Each row of this table indicates the product name of each product.
+
+Write an SQL query that reports the `product_name`, `year`, and `price` for each `sale_id` in the `Sales` table.
+
+Return the resulting table in **any order**.
+
+The query result format is in the following example.
+
+**Example 1:**
+
+**Input:** Sales table: 
+
+    +---------+------------+------+----------+-------+ 
+    | sale_id | product_id | year | quantity | price | 
+    +---------+------------+------+----------+-------+ 
+    | 1       | 100        | 2008 | 10       | 5000  | 
+    | 2       | 100        | 2009 | 12       | 5000  | 
+    | 7       | 200        | 2011 | 15       | 9000  | 
+    +---------+------------+------+----------+-------+ 
+
+Product table: 
+    
+    +------------+--------------+ 
+    | product_id | product_name | 
+    +------------+--------------+ 
+    | 100        | Nokia        | 
+    | 200        | Apple        | 
+    | 300        | Samsung      | 
+    +------------+--------------+
+
+**Output:** 
+
+    +--------------+-------+-------+ 
+    | product_name | year  | price | 
+    +--------------+-------+-------+ 
+    | Nokia        | 2008  | 5000  | 
+    | Nokia        | 2009  | 5000  | 
+    | Apple        | 2011  | 9000  | 
+    +--------------+-------+-------+
+
+**Explanation:** From sale\_id = 1, we can conclude that Nokia was sold for 5000 in the year 2008. From sale\_id = 2, we can conclude that Nokia was sold for 5000 in the year 2009. From sale\_id = 7, we can conclude that Apple was sold for 9000 in the year 2011. 

src/main/kotlin/g1001_1100/s1068_product_sales_analysis_i/script.sql

@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+# #Easy #Database #2023_05_30_Time_1897_ms_(79.88%)_Space_0B_(100.00%)
+Select Product.product_name, Sales.sale_year, Sales.price
+from Sales
+Inner Join Product On Product.product_id = Sales.product_id

src/test/kotlin/g1001_1100/s1053_previous_permutation_with_one_swap/SolutionTest.kt

@@ -0,0 +1,25 @@
+package g1001_1100.s1053_previous_permutation_with_one_swap
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun prevPermOpt1() {
+        assertThat(Solution().prevPermOpt1(intArrayOf(3, 2, 1)), equalTo(intArrayOf(3, 1, 2)))
+    }
+
+    @Test
+    fun prevPermOpt2() {
+        assertThat(Solution().prevPermOpt1(intArrayOf(1, 1, 5)), equalTo(intArrayOf(1, 1, 5)))
+    }
+
+    @Test
+    fun prevPermOpt3() {
+        assertThat(
+            Solution().prevPermOpt1(intArrayOf(1, 9, 4, 6, 7)),
+            equalTo(intArrayOf(1, 7, 4, 6, 9))
+        )
+    }
+}