Added tasks 1070, 1071, 1072, 1073

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
+| 1073 |[Adding Two Negabinary Numbers](src/main/kotlin/g1001_1100/s1073_adding_two_negabinary_numbers/Solution.kt)| Medium | Array, Math | 187 | 100.00
+| 1072 |[Flip Columns For Maximum Number of Equal Rows](src/main/kotlin/g1001_1100/s1072_flip_columns_for_maximum_number_of_equal_rows/Solution.kt)| Medium | Array, Hash_Table, Matrix | 536 | 100.00
+| 1071 |[Greatest Common Divisor of Strings](src/main/kotlin/g1001_1100/s1071_greatest_common_divisor_of_strings/Solution.kt)| Easy | String, Math | 150 | 80.68
+| 1070 |[Product Sales Analysis III](src/main/kotlin/g1001_1100/s1070_product_sales_analysis_iii/script.sql)| Medium | Database | 1561 | 95.47
 | 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

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

@@ -0,0 +1,73 @@
+1070\. Product Sales Analysis III
+
+Medium
+
+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 selects the **product id**, **year**, **quantity**, and **price** for the **first year** of every product sold.
+
+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_id | first_year | quantity | price | 
+    +------------+------------+----------+-------+ 
+    | 100        | 2008       | 10       | 5000  | 
+    | 200        | 2011       | 15       | 9000  | 
+    +------------+------------+----------+-------+ 

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

@@ -0,0 +1,18 @@
+# Write your MySQL query statement below
+# #Medium #Database #2023_05_31_Time_1561_ms_(95.47%)_Space_0B_(100.00%)
+SELECT
+    a.product_id, sale_year AS first_year, quantity, price
+FROM
+(
+    SELECT
+        *,
+        RANK() OVER(PARTITION BY product_id ORDER BY sale_year) as rk
+    FROM
+        Sales
+) AS a
+LEFT JOIN
+    Product AS p
+ON
+    a.product_id = p.product_id
+WHERE
+    rk = 1

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

@@ -0,0 +1,22 @@
+package g1001_1100.s1071_greatest_common_divisor_of_strings
+
+// #Easy #String #Math #2023_05_31_Time_150_ms_(80.68%)_Space_36.2_MB_(84.09%)
+
+class Solution {
+    fun gcdOfStrings(str1: String?, str2: String?): String {
+        if (str1 == null || str2 == null) {
+            return ""
+        }
+        if (str1 == str2) {
+            return str1
+        }
+        val m = str1.length
+        val n = str2.length
+        if (m > n && str1.substring(0, n) == str2) {
+            return gcdOfStrings(str1.substring(n), str2)
+        }
+        return if (n > m && str2.substring(0, m) == str1) {
+            gcdOfStrings(str2.substring(m), str1)
+        } else ""
+    }
+}

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

@@ -0,0 +1,30 @@
+1071\. Greatest Common Divisor of Strings
+
+Easy
+
+For two strings `s` and `t`, we say "`t` divides `s`" if and only if `s = t + ... + t` (i.e., `t` is concatenated with itself one or more times).
+
+Given two strings `str1` and `str2`, return _the largest string_ `x` _such that_ `x` _divides both_ `str1` _and_ `str2`.
+
+**Example 1:**
+
+**Input:** str1 = "ABCABC", str2 = "ABC"
+
+**Output:** "ABC"
+
+**Example 2:**
+
+**Input:** str1 = "ABABAB", str2 = "ABAB"
+
+**Output:** "AB"
+
+**Example 3:**
+
+**Input:** str1 = "LEET", str2 = "CODE"
+
+**Output:** ""
+
+**Constraints:**
+
+*   `1 <= str1.length, str2.length <= 1000`
+*   `str1` and `str2` consist of English uppercase letters.

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

@@ -0,0 +1,40 @@
+package g1001_1100.s1072_flip_columns_for_maximum_number_of_equal_rows
+
+// #Medium #Array #Hash_Table #Matrix #2023_05_31_Time_536_ms_(100.00%)_Space_108.4_MB_(50.00%)
+
+class Solution {
+    fun maxEqualRowsAfterFlips(matrix: Array<IntArray>): Int {
+        /*
+        Idea:
+        For a given row[i], 0<=i<m, row[j], 0<=j<m and j!=i, if either of them can have
+        all values equal after some number of flips, then
+         row[i]==row[j]  <1> or
+         row[i]^row[j] == 111...111 <2> (xor result is a row full of '1')
+
+        Go further, in case<2> row[j] can turn to row[i] by flipping each column of row[j]
+        IF assume row[i][0] is 0, then question is convert into:
+         1> flipping each column of each row if row[i][0] is not '0',
+         2> count the frequency of each row.
+         The biggest number of frequencies is the answer.
+         */
+
+        // O(M*N), int M = matrix.length, N = matrix[0].length;
+        var answer = 0
+        val frequency: MutableMap<String, Int> = HashMap()
+        for (row in matrix) {
+            val rowStr = StringBuilder()
+            for (c in row) {
+                if (row[0] == 1) {
+                    rowStr.append(if (c == 1) 0 else 1)
+                } else {
+                    rowStr.append(c)
+                }
+            }
+            val key = rowStr.toString()
+            val value = frequency.getOrDefault(key, 0) + 1
+            frequency[key] = value
+            answer = answer.coerceAtLeast(value)
+        }
+        return answer
+    }
+}

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

@@ -0,0 +1,40 @@
+1072\. Flip Columns For Maximum Number of Equal Rows
+
+Medium
+
+You are given an `m x n` binary matrix `matrix`.
+
+You can choose any number of columns in the matrix and flip every cell in that column (i.e., Change the value of the cell from `0` to `1` or vice versa).
+
+Return _the maximum number of rows that have all values equal after some number of flips_.
+
+**Example 1:**
+
+**Input:** matrix = [[0,1],[1,1]]
+
+**Output:** 1
+
+**Explanation:** After flipping no values, 1 row has all values equal.
+
+**Example 2:**
+
+**Input:** matrix = [[0,1],[1,0]]
+
+**Output:** 2
+
+**Explanation:** After flipping values in the first column, both rows have equal values.
+
+**Example 3:**
+
+**Input:** matrix = [[0,0,0],[0,0,1],[1,1,0]]
+
+**Output:** 2
+
+**Explanation:** After flipping values in the first two columns, the last two rows have equal values.
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `1 <= m, n <= 300`
+*   `matrix[i][j]` is either `0` or `1`.

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

@@ -0,0 +1,48 @@
+package g1001_1100.s1073_adding_two_negabinary_numbers
+
+// #Medium #Array #Math #2023_05_31_Time_187_ms_(100.00%)_Space_40.9_MB_(100.00%)
+
+class Solution {
+    fun addNegabinary(arr1: IntArray, arr2: IntArray): IntArray {
+        val len1 = arr1.size
+        val len2 = arr2.size
+        val reverseArr1 = IntArray(len1)
+        for (i in len1 - 1 downTo 0) {
+            reverseArr1[len1 - i - 1] = arr1[i]
+        }
+        val reverseArr2 = IntArray(len2)
+        for (i in len2 - 1 downTo 0) {
+            reverseArr2[len2 - i - 1] = arr2[i]
+        }
+        val sumArray = IntArray(len1.coerceAtLeast(len2) + 2)
+        System.arraycopy(reverseArr1, 0, sumArray, 0, len1)
+        for (i in sumArray.indices) {
+            if (i < len2) {
+                sumArray[i] += reverseArr2[i]
+            }
+            if (sumArray[i] > 1) {
+                sumArray[i] -= 2
+                sumArray[i + 1]--
+            } else if (sumArray[i] == -1) {
+                sumArray[i] = 1
+                sumArray[i + 1]++
+            }
+        }
+        var resultLen = sumArray.size
+        for (i in sumArray.indices.reversed()) {
+            if (sumArray[i] == 0) {
+                resultLen--
+            } else {
+                break
+            }
+        }
+        if (resultLen == 0) {
+            return intArrayOf(0)
+        }
+        val result = IntArray(resultLen)
+        for (i in resultLen - 1 downTo 0) {
+            result[resultLen - i - 1] = sumArray[i]
+        }
+        return result
+    }
+}

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

@@ -0,0 +1,35 @@
+1073\. Adding Two Negabinary Numbers
+
+Medium
+
+Given two numbers `arr1` and `arr2` in base **\-2**, return the result of adding them together.
+
+Each number is given in _array format_: as an array of 0s and 1s, from most significant bit to least significant bit. For example, `arr = [1,1,0,1]` represents the number `(-2)^3 + (-2)^2 + (-2)^0 = -3`. A number `arr` in _array, format_ is also guaranteed to have no leading zeros: either `arr == [0]` or `arr[0] == 1`.
+
+Return the result of adding `arr1` and `arr2` in the same format: as an array of 0s and 1s with no leading zeros.
+
+**Example 1:**
+
+**Input:** arr1 = [1,1,1,1,1], arr2 = [1,0,1]
+
+**Output:** [1,0,0,0,0]
+
+**Explanation:** arr1 represents 11, arr2 represents 5, the output represents 16.
+
+**Example 2:**
+
+**Input:** arr1 = [0], arr2 = [0]
+
+**Output:** [0]
+
+**Example 3:**
+
+**Input:** arr1 = [0], arr2 = [1]
+
+**Output:** [1]
+
+**Constraints:**
+
+*   `1 <= arr1.length, arr2.length <= 1000`
+*   `arr1[i]` and `arr2[i]` are `0` or `1`
+*   `arr1` and `arr2` have no leading zeros

src/test/kotlin/g1001_1100/s1070_product_sales_analysis_iii/MysqlTest.kt

@@ -0,0 +1,68 @@
+package g1001_1100.s1070_product_sales_analysis_iii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+import org.zapodot.junit.db.annotations.EmbeddedDatabase
+import org.zapodot.junit.db.annotations.EmbeddedDatabaseTest
+import org.zapodot.junit.db.common.CompatibilityMode
+import java.io.BufferedReader
+import java.io.FileNotFoundException
+import java.io.FileReader
+import java.sql.SQLException
+import java.util.stream.Collectors
+import javax.sql.DataSource
+
+@EmbeddedDatabaseTest(
+    compatibilityMode = CompatibilityMode.MySQL,
+    initialSqls = [
+        "CREATE TABLE Sales(sale_id INTEGER, product_id INTEGER," +
+            " sale_year INTEGER, quantity INTEGER, price INTEGER); " +
+            "INSERT INTO Sales(sale_id, product_id, sale_year, quantity, price)" +
+            " VALUES (1, 100, 2008, 10, 5000); " +
+            "INSERT INTO Sales(sale_id, product_id, sale_year, quantity, price)" +
+            " VALUES (2, 100, 2009, 12, 5000); " +
+            "INSERT INTO Sales(sale_id, product_id, sale_year, quantity, price)" +
+            " VALUES (7, 200, 2011, 15, 9000); " +
+            "CREATE TABLE Product(product_id INTEGER, product_name VARCHAR); " +
+            "INSERT INTO Product(product_id, product_name)" +
+            " VALUES (100, 'Nokia'); " +
+            "INSERT INTO Product(product_id, product_name)" +
+            " VALUES (200, 'Apple'); " +
+            "INSERT INTO Product(product_id, product_name)" +
+            " VALUES (300, 'Samsung'); "
+    ]
+)
+internal class MysqlTest {
+    @Test
+    @Throws(SQLException::class, FileNotFoundException::class)
+    fun testScript(@EmbeddedDatabase dataSource: DataSource) {
+        dataSource.connection.use { connection ->
+            connection.createStatement().use { statement ->
+                statement.executeQuery(
+                    BufferedReader(
+                        FileReader(
+                            "src/main/kotlin/g1001_1100/s1070_product_sales_analysis_iii" +
+                                "/script.sql"
+                        )
+                    )
+                        .lines()
+                        .collect(Collectors.joining("\n"))
+                        .replace("#.*?\\r?\\n".toRegex(), "")
+                ).use { resultSet ->
+                    assertThat(resultSet.next(), equalTo(true))
+                    assertThat(resultSet.getInt(1), equalTo(100))
+                    assertThat(resultSet.getInt(2), equalTo(2008))
+                    assertThat(resultSet.getInt(3), equalTo(10))
+                    assertThat(resultSet.getInt(4), equalTo(5000))
+                    assertThat(resultSet.next(), equalTo(true))
+                    assertThat(resultSet.getInt(1), equalTo(200))
+                    assertThat(resultSet.getInt(2), equalTo(2011))
+                    assertThat(resultSet.getInt(3), equalTo(15))
+                    assertThat(resultSet.getInt(4), equalTo(9000))
+                    assertThat(resultSet.next(), equalTo(false))
+                }
+            }
+        }
+    }
+}