Added tasks 1074, 1075, 1078, 1079

Author: ThanhNIT

README.md

@@ -0,0 +1,32 @@
+package g1001_1100.s1074_number_of_submatrices_that_sum_to_target
+
+// #Hard #Array #Hash_Table #Matrix #Prefix_Sum
+// #2023_06_01_Time_770_ms_(100.00%)_Space_115.7_MB_(100.00%)
+
+class Solution {
+    fun numSubmatrixSumTarget(matrix: Array<IntArray>, target: Int): Int {
+        val rows = matrix.size
+        val columns = matrix[0].size
+        for (i in 0 until rows) {
+            for (j in 1 until columns) {
+                matrix[i][j] += matrix[i][j - 1]
+            }
+        }
+        val sumMap: HashMap<Int, Int> = HashMap()
+        var cur: Int
+        var res = 0
+        for (i in 0 until columns) {
+            for (j in i until columns) {
+                sumMap.clear()
+                sumMap[0] = 1
+                cur = 0
+                for (ints in matrix) {
+                    cur += ints[j] - if (i > 0) ints[i - 1] else 0
+                    res += sumMap.getOrDefault(cur - target, 0)
+                    sumMap[cur] = sumMap.getOrDefault(cur, 0) + 1
+                }
+            }
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,40 @@
+1074\. Number of Submatrices That Sum to Target
+
+Hard
+
+Given a `matrix` and a `target`, return the number of non-empty submatrices that sum to target.
+
+A submatrix `x1, y1, x2, y2` is the set of all cells `matrix[x][y]` with `x1 <= x <= x2` and `y1 <= y <= y2`.
+
+Two submatrices `(x1, y1, x2, y2)` and `(x1', y1', x2', y2')` are different if they have some coordinate that is different: for example, if `x1 != x1'`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/02/mate1.jpg)
+
+**Input:** matrix = [[0,1,0],[1,1,1],[0,1,0]], target = 0
+
+**Output:** 4
+
+**Explanation:** The four 1x1 submatrices that only contain 0.
+
+**Example 2:**
+
+**Input:** matrix = [[1,-1],[-1,1]], target = 0
+
+**Output:** 5
+
+**Explanation:** The two 1x2 submatrices, plus the two 2x1 submatrices, plus the 2x2 submatrix.
+
+**Example 3:**
+
+**Input:** matrix = [[904]], target = 0
+
+**Output:** 0
+
+**Constraints:**
+
+*   `1 <= matrix.length <= 100`
+*   `1 <= matrix[0].length <= 100`
+*   `-1000 <= matrix[i] <= 1000`
+*   `-10^8 <= target <= 10^8`

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

@@ -0,0 +1,76 @@
+1075\. Project Employees I
+
+Easy
+
+SQL Schema
+
+Table: `Project`
+
+    +-------------+---------+ 
+    | Column Name | Type    |
+    +-------------+---------+ 
+    | project_id  | int     | 
+    | employee_id | int     | 
+    +-------------+---------+ 
+
+(project_id, employee_id) is the primary key of this table. 
+
+employee_id is a foreign key to `Employee` table.
+
+Each row of this table indicates that the employee with employee_id is working on the project with project_id.
+
+Table: `Employee`
+
+    +------------------+---------+ 
+    | Column Name      | Type    | 
+    +------------------+---------+ 
+    | employee_id      | int     | 
+    | name             | varchar | 
+    | experience_years | int     | 
+    +------------------+---------+ 
+
+employee_id is the primary key of this table. It's guaranteed that experience_years is not NULL. 
+
+Each row of this table contains information about one employee.
+
+Write an SQL query that reports the **average** experience years of all the employees for each project, **rounded to 2 digits**.
+
+Return the result table in **any order**.
+
+The query result format is in the following example.
+
+**Example 1:**
+
+**Input:** Project table:
+
+    +-------------+-------------+ 
+    | project_id  | employee_id | 
+    +-------------+-------------+ 
+    | 1           | 1           | 
+    | 1           | 2           | 
+    | 1           | 3           | 
+    | 2           | 1           | 
+    | 2           | 4           | 
+    +-------------+-------------+ 
+
+Employee table: 
+
+    +-------------+--------+------------------+ 
+    | employee_id | name   | experience_years | 
+    +-------------+--------+------------------+ 
+    | 1           | Khaled | 3                | 
+    | 2           | Ali    | 2                | 
+    | 3           | John   | 1                | 
+    | 4           | Doe    | 2                | 
+    +-------------+--------+------------------+
+
+**Output:** 
+
+    +-------------+---------------+ 
+    | project_id  | average_years | 
+    +-------------+---------------+ 
+    | 1           | 2.00          | 
+    | 2           | 2.50          | 
+    +-------------+---------------+
+
+**Explanation:** The average experience years for the first project is (3 + 2 + 1) / 3 = 2.00 and for the second project is (3 + 2) / 2 = 2.50 

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

@@ -0,0 +1,7 @@
+# Write your MySQL query statement below
+# #Easy #Database #2023_06_01_Time_1268_ms_(94.71%)_Space_0B_(100.00%)
+select project_id,round(avg(
+  experience_years
+),2) as average_years from Project p
+left join
+Employee e on p.employee_id=e.employee_id group by p.project_id;

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

@@ -0,0 +1,21 @@
+package g1001_1100.s1078_occurrences_after_bigram
+
+// #Easy #String #2023_06_01_Time_151_ms_(88.24%)_Space_36.5_MB_(70.59%)
+
+class Solution {
+    fun findOcurrences(text: String, first: String, second: String): Array<String?> {
+        val list: MutableList<String> = ArrayList()
+        val str = text.split(" ".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        for (i in str.indices) {
+            if (str[i] == first && str.size - 1 >= i + 2 && str[i + 1] == second) {
+                list.add(str[i + 2])
+            }
+        }
+        val s = arrayOfNulls<String>(list.size)
+        var j = 0
+        for (ele in list) {
+            s[j++] = ele
+        }
+        return s
+    }
+}

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

@@ -0,0 +1,27 @@
+1078\. Occurrences After Bigram
+
+Easy
+
+Given two strings `first` and `second`, consider occurrences in some text of the form `"first second third"`, where `second` comes immediately after `first`, and `third` comes immediately after `second`.
+
+Return _an array of all the words_ `third` _for each occurrence of_ `"first second third"`.
+
+**Example 1:**
+
+**Input:** text = "alice is a good girl she is a good student", first = "a", second = "good"
+
+**Output:** ["girl","student"]
+
+**Example 2:**
+
+**Input:** text = "we will we will rock you", first = "we", second = "will"
+
+**Output:** ["we","rock"]
+
+**Constraints:**
+
+*   `1 <= text.length <= 1000`
+*   `text` consists of lowercase English letters and spaces.
+*   All the words in `text` a separated by **a single space**.
+*   `1 <= first.length, second.length <= 10`
+*   `first` and `second` consist of lowercase English letters.

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

@@ -0,0 +1,31 @@
+package g1001_1100.s1079_letter_tile_possibilities
+
+// #Medium #String #Backtracking #2023_06_01_Time_144_ms_(100.00%)_Space_34.2_MB_(100.00%)
+
+class Solution {
+    private var count = 0
+
+    fun numTilePossibilities(tiles: String): Int {
+        count = 0
+        val chars = tiles.toCharArray()
+        chars.sort()
+        val visited = BooleanArray(chars.size)
+        dfs(chars, 0, visited)
+        return count
+    }
+
+    private fun dfs(chars: CharArray, length: Int, visited: BooleanArray) {
+        if (length == chars.size) {
+            return
+        }
+        for (i in chars.indices) {
+            if (visited[i] || i - 1 >= 0 && chars[i] == chars[i - 1] && !visited[i - 1]) {
+                continue
+            }
+            count++
+            visited[i] = true
+            dfs(chars, length + 1, visited)
+            visited[i] = false
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+1079\. Letter Tile Possibilities
+
+Medium
+
+You have `n` `tiles`, where each tile has one letter `tiles[i]` printed on it.
+
+Return _the number of possible non-empty sequences of letters_ you can make using the letters printed on those `tiles`.
+
+**Example 1:**
+
+**Input:** tiles = "AAB"
+
+**Output:** 8
+
+**Explanation:** The possible sequences are "A", "B", "AA", "AB", "BA", "AAB", "ABA", "BAA".
+
+**Example 2:**
+
+**Input:** tiles = "AAABBC"
+
+**Output:** 188
+
+**Example 3:**
+
+**Input:** tiles = "V"
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= tiles.length <= 7`
+*   `tiles` consists of uppercase English letters.

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

@@ -0,0 +1,24 @@
+package g1001_1100.s1074_number_of_submatrices_that_sum_to_target
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun numSubmatrixSumTarget() {
+        assertThat(
+            Solution()
+                .numSubmatrixSumTarget(arrayOf(intArrayOf(0, 1, 0), intArrayOf(1, 1, 1), intArrayOf(0, 1, 0)), 0),
+            equalTo(4)
+        )
+    }
+
+    @Test
+    fun numSubmatrixSumTarget2() {
+        assertThat(
+            Solution().numSubmatrixSumTarget(arrayOf(intArrayOf(1, -1), intArrayOf(-1, 1)), 0),
+            equalTo(5)
+        )
+    }
+}

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

@@ -0,0 +1,69 @@
+package g1001_1100.s1075_project_employees_i
+
+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 Project(project_id INTEGER, employee_id INTEGER); " +
+            "INSERT INTO Project(project_id, employee_id)" +
+            " VALUES (1, 1); " +
+            "INSERT INTO Project(project_id, employee_id)" +
+            " VALUES (1, 2); " +
+            "INSERT INTO Project(project_id, employee_id)" +
+            " VALUES (1, 3); " +
+            "INSERT INTO Project(project_id, employee_id)" +
+            " VALUES (2, 1); " +
+            "INSERT INTO Project(project_id, employee_id)" +
+            " VALUES (2, 4); " +
+            "CREATE TABLE Employee(employee_id INTEGER, name VARCHAR, experience_years INTEGER); " +
+            "INSERT INTO Employee(employee_id, name, experience_years)" +
+            " VALUES (1, 'Khaled', 3); " +
+            "INSERT INTO Employee(employee_id, name, experience_years)" +
+            " VALUES (2, 'Ali', 2); " +
+            "INSERT INTO Employee(employee_id, name, experience_years)" +
+            " VALUES (3, 'John', 1); " +
+            "INSERT INTO Employee(employee_id, name, experience_years)" +
+            " VALUES (4, 'Doe', 2); "
+    ]
+)
+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/s1075_project_employees_i" +
+                                "/script.sql"
+                        )
+                    )
+                        .lines()
+                        .collect(Collectors.joining("\n"))
+                        .replace("#.*?\\r?\\n".toRegex(), "")
+                ).use { resultSet ->
+                    assertThat(resultSet.next(), equalTo(true))
+                    assertThat(resultSet.getInt(1), equalTo(1))
+                    assertThat(resultSet.getDouble(2), equalTo(2.00))
+                    assertThat(resultSet.next(), equalTo(true))
+                    assertThat(resultSet.getInt(1), equalTo(2))
+                    assertThat(resultSet.getInt(2), equalTo(3))
+                    assertThat(resultSet.next(), equalTo(false))
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+package g1001_1100.s1078_occurrences_after_bigram
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun findOcurrences() {
+        assertThat(
+            Solution()
+                .findOcurrences("alice is a good girl she is a good student", "a", "good"),
+            equalTo(arrayOf("girl", "student"))
+        )
+    }
+
+    @Test
+    fun findOcurrences2() {
+        assertThat(
+            Solution().findOcurrences("we will we will rock you", "we", "will"),
+            equalTo(arrayOf("we", "rock"))
+        )
+    }
+}