Added tasks 1061, 1068

Author: javadev

settings.gradle

@@ -1 +1 @@
-rootProject.name = 'leetcode-in-java'
+rootProject.name = 'LeetCode-in-Java'

src/main/java/g1001_1100/s1061_lexicographically_smallest_equivalent_string/Solution.java

@@ -0,0 +1,43 @@
+package g1001_1100.s1061_lexicographically_smallest_equivalent_string;
+
+// #Medium #String #Union_Find #2023_06_09_Time_2_ms_(93.75%)_Space_41.7_MB_(41.30%)
+
+public class Solution {
+    private int[] parent;
+
+    public String smallestEquivalentString(String s1, String s2, String baseStr) {
+        parent = new int[26];
+        int n = s1.length();
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < 26; i++) {
+            parent[i] = i;
+        }
+        for (int i = 0; i < n; i++) {
+            union(s1.charAt(i) - 'a', s2.charAt(i) - 'a');
+        }
+        char base = 'a';
+        for (char element : baseStr.toCharArray()) {
+            result.append(Character.toString(base + find(element - 'a')));
+        }
+        return result.toString();
+    }
+
+    private void union(int a, int b) {
+        int parentA = find(a);
+        int parentB = find(b);
+        if (parentA != parentB) {
+            if (parentA < parentB) {
+                parent[parentB] = parentA;
+            } else {
+                parent[parentA] = parentB;
+            }
+        }
+    }
+
+    private int find(int x) {
+        while (parent[x] != x) {
+            x = parent[x];
+        }
+        return x;
+    }
+}

src/main/java/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/java/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/java/g1001_1100/s1068_product_sales_analysis_i/script.sql

@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+# #Easy #Database #2023_06_09_Time_1788_ms_(91.74%)_Space_0B_(100.00%)
+select product.product_name, sales.sale_year, sales.price from sales
+left join product on product.product_id = sales.product_id

src/test/java/g1001_1100/s1061_lexicographically_smallest_equivalent_string/SolutionTest.java

@@ -0,0 +1,28 @@
+package g1001_1100.s1061_lexicographically_smallest_equivalent_string;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void smallestEquivalentString() {
+        assertThat(
+                new Solution().smallestEquivalentString("hello", "world", "hold"), equalTo("hdld"));
+    }
+
+    @Test
+    void smallestEquivalentString2() {
+        assertThat(
+                new Solution().smallestEquivalentString("parker", "morris", "parser"),
+                equalTo("makkek"));
+    }
+
+    @Test
+    void smallestEquivalentString3() {
+        assertThat(
+                new Solution().smallestEquivalentString("leetcode", "programs", "sourcecode"),
+                equalTo("aauaaaaada"));
+    }
+}

src/test/java/g1001_1100/s1068_product_sales_analysis_i/MysqlTest.java

@@ -0,0 +1,69 @@
+package g1001_1100.s1068_product_sales_analysis_i;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.stream.Collectors;
+import javax.sql.DataSource;
+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;
+
+@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'); ")
+class MysqlTest {
+    @Test
+    void testScript(@EmbeddedDatabase DataSource dataSource)
+            throws SQLException, FileNotFoundException {
+        try (final Connection connection = dataSource.getConnection()) {
+            try (final Statement statement = connection.createStatement();
+                    final ResultSet resultSet =
+                            statement.executeQuery(
+                                    new BufferedReader(
+                                                    new FileReader(
+                                                            "src/main/java/g1001_1100/"
+                                                                    + "s1068_product_sales_analysis_i/script.sql"))
+                                            .lines()
+                                            .collect(Collectors.joining("\n"))
+                                            .replaceAll("#.*?\\r?\\n", ""))) {
+                assertThat(resultSet.next(), equalTo(true));
+                assertThat(resultSet.getNString(1), equalTo("Nokia"));
+                assertThat(resultSet.getInt(2), equalTo(2008));
+                assertThat(resultSet.getInt(3), equalTo(5000));
+                assertThat(resultSet.next(), equalTo(true));
+                assertThat(resultSet.getNString(1), equalTo("Nokia"));
+                assertThat(resultSet.getInt(2), equalTo(2009));
+                assertThat(resultSet.getInt(3), equalTo(5000));
+                assertThat(resultSet.next(), equalTo(true));
+                assertThat(resultSet.getNString(1), equalTo("Apple"));
+                assertThat(resultSet.getInt(2), equalTo(2011));
+                assertThat(resultSet.getInt(3), equalTo(9000));
+                assertThat(resultSet.next(), equalTo(false));
+            }
+        }
+    }
+}