Added tasks 583, 584, 586, 587

Author: ThanhNIT

README.md

@@ -336,6 +336,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0584 |[Find Customer Referee](src/main/kotlin/g0501_0600/s0584_find_customer_referee/script.sql)| Easy | Database | 779 | 43.48
 | 0183 |[Customers Who Never Order](src/main/kotlin/g0101_0200/s0183_customers_who_never_order/script.sql)| Easy | Database | 712 | 33.67
 
 #### Day 2 Select and Order
@@ -376,6 +377,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0586 |[Customer Placing the Largest Number of Orders](src/main/kotlin/g0501_0600/s0586_customer_placing_the_largest_number_of_orders/script.sql)| Easy | LeetCode_Curated_SQL_70, Database | 768 | 44.85
 | 0511 |[Game Play Analysis I](src/main/kotlin/g0501_0600/s0511_game_play_analysis_i/script.sql)| Easy | LeetCode_Curated_SQL_70, Database | 790 | 45.04
 
 #### Day 9 Control of Flow
@@ -1289,6 +1291,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming | 307 | 38.36
+| 0583 |[Delete Operation for Two Strings](src/main/kotlin/g0501_0600/s0583_delete_operation_for_two_strings/Solution.kt)| Medium | String, Dynamic_Programming | 197 | 100.00
 
 #### Day 18 Dynamic Programming
 
@@ -1659,6 +1662,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | 0763 |[Partition Labels](src/main/kotlin/g0701_0800/s0763_partition_labels/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Greedy, Two_Pointers, Data_Structure_II_Day_7_String | 235 | 84.75
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6 | 936 | 80.54
 | 0647 |[Palindromic Substrings](src/main/kotlin/g0601_0700/s0647_palindromic_substrings/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming | 266 | 67.83
+| 0587 |[Erect the Fence](src/main/kotlin/g0501_0600/s0587_erect_the_fence/Solution.kt)| Hard | Array, Math, Geometry | 470 | 100.00
+| 0586 |[Customer Placing the Largest Number of Orders](src/main/kotlin/g0501_0600/s0586_customer_placing_the_largest_number_of_orders/script.sql)| Easy | LeetCode_Curated_SQL_70, Database, SQL_I_Day_8_Function | 768 | 44.85
+| 0584 |[Find Customer Referee](src/main/kotlin/g0501_0600/s0584_find_customer_referee/script.sql)| Easy | Database, SQL_I_Day_1_Select | 779 | 43.48
+| 0583 |[Delete Operation for Two Strings](src/main/kotlin/g0501_0600/s0583_delete_operation_for_two_strings/Solution.kt)| Medium | String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming | 197 | 100.00
 | 0581 |[Shortest Unsorted Continuous Subarray](src/main/kotlin/g0501_0600/s0581_shortest_unsorted_continuous_subarray/Solution.kt)| Medium | Array, Sorting, Greedy, Two_Pointers, Stack, Monotonic_Stack | 246 | 100.00
 | 0576 |[Out of Boundary Paths](src/main/kotlin/g0501_0600/s0576_out_of_boundary_paths/Solution.kt)| Medium | Dynamic_Programming | 153 | 100.00
 | 0575 |[Distribute Candies](src/main/kotlin/g0501_0600/s0575_distribute_candies/Solution.kt)| Easy | Array, Hash_Table | 538 | 76.92

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

@@ -0,0 +1,21 @@
+package g0501_0600.s0583_delete_operation_for_two_strings
+
+// #Medium #String #Dynamic_Programming #Algorithm_II_Day_17_Dynamic_Programming
+// #2023_01_30_Time_197_ms_(100.00%)_Space_35.8_MB_(100.00%)
+
+class Solution {
+    fun minDistance(word1: String, word2: String): Int {
+        val m = word1.length
+        val n = word2.length
+        val dp = Array(m + 1) { IntArray(n + 1) }
+        for (i in 1..m) {
+            for (j in 1..n) {
+                dp[i][j] = if (word1[i - 1] == word2[j - 1]) dp[i - 1][j - 1] + 1 else Math.max(
+                    dp[i - 1][j],
+                    dp[i][j - 1]
+                )
+            }
+        }
+        return m + n - 2 * dp[m][n]
+    }
+}

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

@@ -0,0 +1,26 @@
+583\. Delete Operation for Two Strings
+
+Medium
+
+Given two strings `word1` and `word2`, return _the minimum number of **steps** required to make_ `word1` _and_ `word2` _the same_.
+
+In one **step**, you can delete exactly one character in either string.
+
+**Example 1:**
+
+**Input:** word1 = "sea", word2 = "eat"
+
+**Output:** 2
+
+**Explanation:** You need one step to make "sea" to "ea" and another step to make "eat" to "ea".
+
+**Example 2:**
+
+**Input:** word1 = "leetcode", word2 = "etco"
+
+**Output:** 4
+
+**Constraints:**
+
+*   `1 <= word1.length, word2.length <= 500`
+*   `word1` and `word2` consist of only lowercase English letters.

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

@@ -0,0 +1,50 @@
+584\. Find Customer Referee
+
+Easy
+
+SQL Schema
+
+Table: `Customer`
+
+    +-------------+---------+
+    | Column Name | Type    |
+    +-------------+---------+
+    | id          | int     |
+    | name        | varchar |
+    | referee_id  | int     |
+    +-------------+---------+
+    id is the primary key column for this table.
+    Each row of this table indicates the id of a customer, their name, and the id of the customer who referred them. 
+
+Write an SQL query to report the IDs of the customer that are **not referred by** the customer with `id = 2`.
+
+Return the result table in **any order**.
+
+The query result format is in the following example.
+
+**Example 1:**
+
+**Input:**
+
+    Customer table:
+    +----+------+------------+
+    | id | name | referee_id |
+    +----+------+------------+
+    | 1  | Will | null       |
+    | 2  | Jane | null       |
+    | 3  | Alex | 2          |
+    | 4  | Bill | null       |
+    | 5  | Zack | 1          |
+    | 6  | Mark | 2          |
+    +----+------+------------+
+
+**Output:**
+
+    +------+
+    | name |
+    +------+
+    | Will |
+    | Jane |
+    | Bill |
+    | Zack |
+    +------+ 

src/main/kotlin/g0501_0600/s0584_find_customer_referee/script.sql

@@ -0,0 +1,3 @@
+# Write your MySQL query statement below
+# #Easy #Database #SQL_I_Day_1_Select #2023_01_30_Time_779_ms_(43.48%)_Space_0B_(100.00%)
+SELECT name FROM customer where referee_id != 2 or referee_id is null;

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

@@ -0,0 +1,52 @@
+586\. Customer Placing the Largest Number of Orders
+
+Easy
+
+SQL Schema
+
+Table: `Orders`
+
+    +-----------------+----------+
+    | Column Name     | Type     |
+    +-----------------+----------+
+    | order_number    | int      |
+    | customer_number | int      |
+    +-----------------+----------+
+    order_number is the primary key for this table.
+    This table contains information about the order ID and the customer ID. 
+
+Write an SQL query to find the `customer_number` for the customer who has placed **the largest number of orders**.
+
+The test cases are generated so that **exactly one customer** will have placed more orders than any other customer.
+
+The query result format is in the following example.
+
+**Example 1:**
+
+**Input:**
+
+    Orders table:
+    +--------------+-----------------+
+    | order_number | customer_number |
+    +--------------+-----------------+
+    | 1            | 1               |
+    | 2            | 2               |
+    | 3            | 3               |
+    | 4            | 3               |
+    +--------------+-----------------+
+
+**Output:**
+
+    +-----------------+
+    | customer_number |
+    +-----------------+
+    | 3               |
+    +-----------------+
+
+**Explanation:**
+
+The customer with number 3 has two orders, which is greater than either customer 1 or 2 because each of them only has one order.
+
+So the result is customer\_number 3.
+
+**Follow up:** What if more than one customer has the largest number of orders, can you find all the `customer_number` in this case?

src/main/kotlin/g0501_0600/s0586_customer_placing_the_largest_number_of_orders/script.sql

@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+# #Easy #LeetCode_Curated_SQL_70 #Database #SQL_I_Day_8_Function
+# #2023_01_30_Time_768_ms_(44.85%)_Space_0B_(100.00%)
+select customer_number from orders group by customer_number order by count(customer_number) desc limit 1

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

@@ -0,0 +1,67 @@
+package g0501_0600.s0587_erect_the_fence
+
+import kotlin.math.abs
+import kotlin.math.atan2
+import kotlin.math.pow
+import kotlin.math.sqrt
+
+// #Hard #Array #Math #Geometry #2023_01_30_Time_470_ms_(100.00%)_Space_54.7_MB_(100.00%)
+
+class Solution {
+    private fun dist(p1: Pair<Int, Int>, p2: Pair<Int, Int>): Double {
+        return sqrt((p2.second - p1.second).toDouble().pow(2.0) + Math.pow((p2.first - p1.first).toDouble(), 2.0))
+    }
+
+    private fun angle(p1: Pair<Int, Int>, p2: Pair<Int, Int>): Double {
+        return atan2((p2.second - p1.second).toDouble(), (p2.first - p1.first).toDouble()).let {
+            if (it < 0) return (2.0 * Math.PI + it) else it
+        }
+    }
+
+    fun outerTrees(trees: Array<IntArray>): Array<IntArray> {
+        if (trees.size < 3) {
+            return trees
+        }
+        val left = trees.asSequence().map { it[0] to it[1] }.toMutableList()
+        left.sortWith(compareBy<Pair<Int, Int>> { it.second }.thenBy { it.first })
+        val firstPoint = left[0]
+        var nowPoint = firstPoint
+        val pointList = mutableListOf(nowPoint)
+        var prevAngle = 0.0
+        while (true) {
+            val nowList = mutableListOf<Pair<Pair<Int, Int>, Double>>()
+            var nowMinAngleDiff = 7.0
+            var nowMinAngle = 7.0
+            left.forEach {
+                if (it != nowPoint) {
+                    val angle = angle(nowPoint, it)
+                    if (abs(angle - nowMinAngle) < 0.0000001) {
+                        nowList.add(it to dist(it, nowPoint))
+                    } else {
+                        val diff = if (angle >= prevAngle) (angle - prevAngle) else 2.0 * Math.PI - (angle - prevAngle)
+                        if ((diff) < nowMinAngleDiff) {
+                            nowMinAngle = angle
+                            nowMinAngleDiff = (diff)
+                            nowList.clear()
+                            nowList.add(it to dist(it, nowPoint))
+                        }
+                    }
+                }
+            }
+            prevAngle = nowMinAngle
+            nowList.sortBy { it.second }
+            val nowListOnlyPoints = nowList.map { it.first }.toMutableList()
+            if (nowListOnlyPoints.last() == firstPoint) {
+                nowListOnlyPoints.removeAt(nowListOnlyPoints.size - 1)
+                left.removeAll(nowListOnlyPoints)
+                pointList.addAll(nowListOnlyPoints)
+                break
+            } else {
+                nowPoint = nowListOnlyPoints.last()
+                left.removeAll(nowListOnlyPoints)
+                pointList.addAll(nowListOnlyPoints)
+            }
+        }
+        return pointList.asSequence().map { intArrayOf(it.first, it.second) }.toList().toTypedArray()
+    }
+}

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

@@ -0,0 +1,36 @@
+587\. Erect the Fence
+
+Hard
+
+You are given an array `trees` where <code>trees[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents the location of a tree in the garden.
+
+Fence the entire garden using the minimum length of rope, as it is expensive. The garden is well-fenced only if **all the trees are enclosed**.
+
+Return _the coordinates of trees that are exactly located on the fence perimeter_. You may return the answer in **any order**.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/24/erect2-plane.jpg)
+
+**Input:** trees = [[1,1],[2,2],[2,0],[2,4],[3,3],[4,2]]
+
+**Output:** [[1,1],[2,0],[4,2],[3,3],[2,4]]
+
+**Explanation:** All the trees will be on the perimeter of the fence except the tree at [2, 2], which will be inside the fence.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/04/24/erect1-plane.jpg)
+
+**Input:** trees = [[1,2],[2,2],[4,2]]
+
+**Output:** [[4,2],[2,2],[1,2]]
+
+**Explanation:** The fence forms a line that passes through all the trees.
+
+**Constraints:**
+
+*   `1 <= trees.length <= 3000`
+*   `trees[i].length == 2`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 100</code>
+*   All the given positions are **unique**.

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

@@ -0,0 +1,17 @@
+package g0501_0600.s0583_delete_operation_for_two_strings
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minDistance() {
+        assertThat(Solution().minDistance("sea", "eat"), equalTo(2))
+    }
+
+    @Test
+    fun minDistance2() {
+        assertThat(Solution().minDistance("leetcode", "etco"), equalTo(4))
+    }
+}

src/test/kotlin/g0501_0600/s0584_find_customer_referee/MysqlTest.kt

@@ -0,0 +1,58 @@
+package g0501_0600.s0584_find_customer_referee
+
+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 Customer(id INTEGER PRIMARY KEY, name VARCHAR, referee_id INTEGER); " +
+            "INSERT INTO Customer(id, name, referee_id) VALUES (1, 'Will', NULL); " +
+            "INSERT INTO Customer(id, name, referee_id) VALUES (2, 'Jane', NULL); " +
+            "INSERT INTO Customer(id, name, referee_id) VALUES (3, 'Alex', 2); " +
+            "INSERT INTO Customer(id, name, referee_id) VALUES (4, 'Bill', NULL); " +
+            "INSERT INTO Customer(id, name, referee_id) VALUES (5, 'Zack', 1); " +
+            "INSERT INTO Customer(id, name, referee_id) VALUES (6, 'Mark', 2); "
+    ]
+)
+internal class MysqlTest {
+    @Test
+    @Throws(SQLException::class, FileNotFoundException::class)
+    fun testScript(@EmbeddedDatabase dataSource: DataSource) {
+        dataSource.getConnection().use { connection ->
+            connection.createStatement().use { statement ->
+                statement.executeQuery(
+                    BufferedReader(
+                        FileReader(
+                            "src/main/kotlin/g0501_0600/" +
+                                "s0584_find_customer_referee/script.sql"
+                        )
+                    )
+                        .lines()
+                        .collect(Collectors.joining("\n"))
+                        .replace("#.*?\\r?\\n".toRegex(), "")
+                ).use { resultSet ->
+                    assertThat(resultSet.next(), equalTo(true))
+                    assertThat(resultSet.getString(1), equalTo("Will"))
+                    assertThat(resultSet.next(), equalTo(true))
+                    assertThat(resultSet.getString(1), equalTo("Jane"))
+                    assertThat(resultSet.next(), equalTo(true))
+                    assertThat(resultSet.getString(1), equalTo("Bill"))
+                    assertThat(resultSet.next(), equalTo(true))
+                    assertThat(resultSet.getString(1), equalTo("Zack"))
+                    assertThat(resultSet.next(), equalTo(false))
+                }
+            }
+        }
+    }
+}