Added tasks 415, 417, 419, 420.

Author: ThanhNIT

README.md

@@ -407,6 +407,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0417 |[Pacific Atlantic Water Flow](src/main/kotlin/g0401_0500/s0417_pacific_atlantic_water_flow/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix | 319 | 100.00
 
 #### Day 5 Matrix Related Problems
 
@@ -682,6 +683,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0994 |[Rotting Oranges](src/main/kotlin/g0901_1000/s0994_rotting_oranges/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix | 308 | 57.93
+| 0417 |[Pacific Atlantic Water Flow](src/main/kotlin/g0401_0500/s0417_pacific_atlantic_water_flow/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix | 319 | 100.00
 
 #### Day 11 Graph/BFS/DFS
 
@@ -892,6 +894,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 |-|-|-|-|-|-
 | 0200 |[Number of Islands](src.save/main/kotlin/g0101_0200/s0200_number_of_islands/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find | 252 | 95.41
 | 0133 |[Clone Graph](src.save/main/kotlin/g0101_0200/s0133_clone_graph/Solution.kt)| Medium | Hash_Table, Depth_First_Search, Breadth_First_Search, Graph | 351 | 60.91
+| 0417 |[Pacific Atlantic Water Flow](src/main/kotlin/g0401_0500/s0417_pacific_atlantic_water_flow/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix | 319 | 100.00
 
 #### Udemy Dynamic Programming
 
@@ -1084,6 +1087,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0415 |[Add Strings](src/main/kotlin/g0401_0500/s0415_add_strings/Solution.kt)| Easy | String, Math, Simulation | 296 | 76.00
 | 0409 |[Longest Palindrome](src/main/kotlin/g0401_0500/s0409_longest_palindrome/Solution.kt)| Easy | String, Hash_Table, Greedy | 259 | 60.71
 
 #### Day 7 String
@@ -1623,7 +1627,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 0494 |[Target Sum](src/main/kotlin/g0401_0500/s0494_target_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Backtracking | 308 | 89.61
 | 0438 |[Find All Anagrams in a String](src/main/kotlin/g0401_0500/s0438_find_all_anagrams_in_a_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Programming_Skills_II_Day_12, Level_1_Day_12_Sliding_Window/Two_Pointer | 561 | 54.68
 | 0437 |[Path Sum III](src/main/kotlin/g0401_0500/s0437_path_sum_iii/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree | 403 | 54.12
+| 0420 |[Strong Password Checker](src/main/kotlin/g0401_0500/s0420_strong_password_checker/Solution.kt)| Hard | String, Greedy, Heap_Priority_Queue | 157 | 80.00
+| 0419 |[Battleships in a Board](src/main/kotlin/g0401_0500/s0419_battleships_in_a_board/Solution.kt)| Medium | Array, Depth_First_Search, Matrix | 273 | 76.92
+| 0417 |[Pacific Atlantic Water Flow](src/main/kotlin/g0401_0500/s0417_pacific_atlantic_water_flow/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Graph_Theory_I_Day_4_Matrix_Related_Problems, Level_2_Day_10_Graph/BFS/DFS, Udemy_Graph | 319 | 100.00
 | 0416 |[Partition Equal Subset Sum](src/main/kotlin/g0401_0500/s0416_partition_equal_subset_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Level_2_Day_13_Dynamic_Programming | 509 | 57.56
+| 0415 |[Add Strings](src/main/kotlin/g0401_0500/s0415_add_strings/Solution.kt)| Easy | String, Math, Simulation, Data_Structure_II_Day_6_String | 296 | 76.00
 | 0414 |[Third Maximum Number](src/main/kotlin/g0401_0500/s0414_third_maximum_number/Solution.kt)| Easy | Array, Sorting | 317 | 73.00
 | 0413 |[Arithmetic Slices](src/main/kotlin/g0401_0500/s0413_arithmetic_slices/Solution.kt)| Medium | Array, Dynamic_Programming, Algorithm_II_Day_14_Dynamic_Programming, Dynamic_Programming_I_Day_10 | 156 | 100.00
 | 0412 |[Fizz Buzz](src/main/kotlin/g0401_0500/s0412_fizz_buzz/Solution.kt)| Easy | Top_Interview_Questions, String, Math, Simulation, Udemy_Integers | 307 | 71.81

src/main/kotlin/g0401_0500/s0415_add_strings/Solution.kt

@@ -0,0 +1,27 @@
+package g0401_0500.s0415_add_strings
+
+// #Easy #String #Math #Simulation #Data_Structure_II_Day_6_String
+// #2022_12_06_Time_296_ms_(76.00%)_Space_36_MB_(84.00%)
+
+class Solution {
+    fun addStrings(num1: String, num2: String): String {
+        var endNum1 = num1.length - 1
+        var endNum2 = num2.length - 1
+        val res = StringBuilder()
+        var carry = 0
+        var sum: Int
+        while (endNum1 >= 0 || endNum2 >= 0) {
+            val a = if (endNum1 >= 0) num1[endNum1] - '0' else 0
+            val b = if (endNum2 >= 0) num2[endNum2] - '0' else 0
+            sum = (a + b + carry) % 10
+            carry = (a + b + carry) / 10
+            res.append(sum)
+            endNum1--
+            endNum2--
+        }
+        if (carry != 0) {
+            res.append(carry)
+        }
+        return res.reverse().toString()
+    }
+}

src/main/kotlin/g0401_0500/s0415_add_strings/readme.md

@@ -0,0 +1,31 @@
+415\. Add Strings
+
+Easy
+
+Given two non-negative integers, `num1` and `num2` represented as string, return _the sum of_ `num1` _and_ `num2` _as a string_.
+
+You must solve the problem without using any built-in library for handling large integers (such as `BigInteger`). You must also not convert the inputs to integers directly.
+
+**Example 1:**
+
+**Input:** num1 = "11", num2 = "123"
+
+**Output:** "134"
+
+**Example 2:**
+
+**Input:** num1 = "456", num2 = "77"
+
+**Output:** "533"
+
+**Example 3:**
+
+**Input:** num1 = "0", num2 = "0"
+
+**Output:** "0"
+
+**Constraints:**
+
+*   <code>1 <= num1.length, num2.length <= 10<sup>4</sup></code>
+*   `num1` and `num2` consist of only digits.
+*   `num1` and `num2` don't have any leading zeros except for the zero itself.

src/main/kotlin/g0401_0500/s0417_pacific_atlantic_water_flow/Solution.kt

@@ -0,0 +1,66 @@
+package g0401_0500.s0417_pacific_atlantic_water_flow
+
+// #Medium #Array #Depth_First_Search #Breadth_First_Search #Matrix
+// #Graph_Theory_I_Day_4_Matrix_Related_Problems #Level_2_Day_10_Graph/BFS/DFS #Udemy_Graph
+// #2022_12_06_Time_319_ms_(100.00%)_Space_37.5_MB_(100.00%)
+
+class Solution {
+    private var col = 0
+    private var row = 0
+    fun pacificAtlantic(matrix: Array<IntArray>): List<List<Int>> {
+        val res: MutableList<List<Int>> = ArrayList()
+        if (matrix.size == 0) {
+            return res
+        }
+        col = matrix.size
+        row = matrix[0].size
+        val pacific = Array(col) {
+            BooleanArray(
+                row
+            )
+        }
+        val atlantic = Array(col) {
+            BooleanArray(
+                row
+            )
+        }
+        for (i in 0 until col) {
+            dfs(i, 0, matrix, pacific)
+            dfs(i, row - 1, matrix, atlantic)
+        }
+        for (i in 0 until row) {
+            dfs(0, i, matrix, pacific)
+            dfs(col - 1, i, matrix, atlantic)
+        }
+        for (i in 0 until col) {
+            for (j in 0 until row) {
+                if (pacific[i][j] && atlantic[i][j]) {
+                    val temp: MutableList<Int> = ArrayList()
+                    temp.add(i)
+                    temp.add(j)
+                    res.add(temp)
+                }
+            }
+        }
+        return res
+    }
+
+    private fun dfs(i: Int, j: Int, matrix: Array<IntArray>, visited: Array<BooleanArray>) {
+        if (i < 0 || j < 0 || i >= matrix.size || j >= matrix[0].size || visited[i][j]) {
+            return
+        }
+        visited[i][j] = true
+        if (i < col - 1 && matrix[i][j] <= matrix[i + 1][j]) {
+            dfs(i + 1, j, matrix, visited)
+        }
+        if (i > 0 && matrix[i][j] <= matrix[i - 1][j]) {
+            dfs(i - 1, j, matrix, visited)
+        }
+        if (j < row - 1 && matrix[i][j] <= matrix[i][j + 1]) {
+            dfs(i, j + 1, matrix, visited)
+        }
+        if (j > 0 && matrix[i][j] <= matrix[i][j - 1]) {
+            dfs(i, j - 1, matrix, visited)
+        }
+    }
+}

src/main/kotlin/g0401_0500/s0417_pacific_atlantic_water_flow/readme.md

@@ -0,0 +1,36 @@
+417\. Pacific Atlantic Water Flow
+
+Medium
+
+There is an `m x n` rectangular island that borders both the **Pacific Ocean** and **Atlantic Ocean**. The **Pacific Ocean** touches the island's left and top edges, and the **Atlantic Ocean** touches the island's right and bottom edges.
+
+The island is partitioned into a grid of square cells. You are given an `m x n` integer matrix `heights` where `heights[r][c]` represents the **height above sea level** of the cell at coordinate `(r, c)`.
+
+The island receives a lot of rain, and the rain water can flow to neighboring cells directly north, south, east, and west if the neighboring cell's height is **less than or equal to** the current cell's height. Water can flow from any cell adjacent to an ocean into the ocean.
+
+Return _a **2D list** of grid coordinates_ `result` _where_ <code>result[i] = [r<sub>i</sub>, c<sub>i</sub>]</code> _denotes that rain water can flow from cell_ <code>(r<sub>i</sub>, c<sub>i</sub>)</code> _to **both** the Pacific and Atlantic oceans_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/06/08/waterflow-grid.jpg)
+
+**Input:** heights = [[1,2,2,3,5],[3,2,3,4,4],[2,4,5,3,1],[6,7,1,4,5],[5,1,1,2,4]]
+
+**Output:** [[0,4],[1,3],[1,4],[2,2],[3,0],[3,1],[4,0]]
+
+**Explanation:** The following cells can flow to the Pacific and Atlantic oceans, as shown below: [0,4]: [0,4] -> Pacific Ocean [0,4] -> Atlantic Ocean [1,3]: [1,3] -> [0,3] -> Pacific Ocean [1,3] -> [1,4] -> Atlantic Ocean [1,4]: [1,4] -> [1,3] -> [0,3] -> Pacific Ocean [1,4] -> Atlantic Ocean [2,2]: [2,2] -> [1,2] -> [0,2] -> Pacific Ocean [2,2] -> [2,3] -> [2,4] -> Atlantic Ocean [3,0]: [3,0] -> Pacific Ocean [3,0] -> [4,0] -> Atlantic Ocean [3,1]: [3,1] -> [3,0] -> Pacific Ocean [3,1] -> [4,1] -> Atlantic Ocean [4,0]: [4,0] -> Pacific Ocean [4,0] -> Atlantic Ocean Note that there are other possible paths for these cells to flow to the Pacific and Atlantic oceans.
+
+**Example 2:**
+
+**Input:** heights = [[1]]
+
+**Output:** [[0,0]]
+
+**Explanation:** The water can flow from the only cell to the Pacific and Atlantic oceans.
+
+**Constraints:**
+
+*   `m == heights.length`
+*   `n == heights[r].length`
+*   `1 <= m, n <= 200`
+*   <code>0 <= heights[r][c] <= 10<sup>5</sup></code>

src/main/kotlin/g0401_0500/s0419_battleships_in_a_board/Solution.kt

@@ -0,0 +1,25 @@
+package g0401_0500.s0419_battleships_in_a_board
+
+// #Medium #Array #Depth_First_Search #Matrix
+// #2022_12_06_Time_273_ms_(76.92%)_Space_41.5_MB_(50.00%)
+
+class Solution {
+    fun countBattleships(board: Array<CharArray>?): Int {
+        if (board == null || board.size == 0) {
+            return 0
+        }
+        var count = 0
+        val m = board.size
+        val n = board[0].size
+        for (i in 0 until m) {
+            for (j in 0 until n) {
+                if (board[i][j] != '.' && (j <= 0 || board[i][j - 1] != 'X') &&
+                    (i <= 0 || board[i - 1][j] != 'X')
+                ) {
+                    count++
+                }
+            }
+        }
+        return count
+    }
+}

src/main/kotlin/g0401_0500/s0419_battleships_in_a_board/readme.md

@@ -0,0 +1,30 @@
+419\. Battleships in a Board
+
+Medium
+
+Given an `m x n` matrix `board` where each cell is a battleship `'X'` or empty `'.'`, return _the number of the **battleships** on_ `board`.
+
+**Battleships** can only be placed horizontally or vertically on `board`. In other words, they can only be made of the shape `1 x k` (`1` row, `k` columns) or `k x 1` (`k` rows, `1` column), where `k` can be of any size. At least one horizontal or vertical cell separates between two battleships (i.e., there are no adjacent battleships).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/10/battelship-grid.jpg)
+
+**Input:** board = [["X",".",".","X"],[".",".",".","X"],[".",".",".","X"]]
+
+**Output:** 2
+
+**Example 2:**
+
+**Input:** board = [["."]]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `m == board.length`
+*   `n == board[i].length`
+*   `1 <= m, n <= 200`
+*   `board[i][j]` is either `'.'` or `'X'`.
+
+**Follow up:** Could you do it in one-pass, using only `O(1)` extra memory and without modifying the values `board`?

src/main/kotlin/g0401_0500/s0420_strong_password_checker/Solution.kt

@@ -0,0 +1,64 @@
+package g0401_0500.s0420_strong_password_checker
+
+// #Hard #String #Greedy #Heap_Priority_Queue
+// #2022_12_06_Time_157_ms_(80.00%)_Space_34.4_MB_(20.00%)
+
+class Solution {
+    fun strongPasswordChecker(s: String): Int {
+        var res = 0
+        var a1 = 1
+        var a2 = 1
+        var d = 1
+        val carr = s.toCharArray()
+        val arr = IntArray(carr.size)
+        var i1 = 0
+        while (i1 < arr.size) {
+            if (Character.isLowerCase(carr[i1])) {
+                a1 = 0
+            }
+            if (Character.isUpperCase(carr[i1])) {
+                a2 = 0
+            }
+            if (Character.isDigit(carr[i1])) {
+                d = 0
+            }
+            val j = i1
+            while (i1 < carr.size && carr[i1] == carr[j]) {
+                i1++
+            }
+            arr[j] = i1 - j
+        }
+        val totalMissing = a1 + a2 + d
+        if (arr.size < 6) {
+            res += totalMissing + Math.max(0, 6 - (arr.size + totalMissing))
+        } else {
+            var overLen = Math.max(arr.size - 20, 0)
+            var leftOver = 0
+            res += overLen
+            for (k in 1..2) {
+                var i = 0
+                while (i < arr.size && overLen > 0) {
+                    if (arr[i] < 3 || arr[i] % 3 != k - 1) {
+                        i++
+                        continue
+                    }
+                    arr[i] -= Math.min(overLen, k)
+                    overLen -= k
+                    i++
+                }
+            }
+            for (i in arr.indices) {
+                if (arr[i] >= 3 && overLen > 0) {
+                    val need = arr[i] - 2
+                    arr[i] -= overLen
+                    overLen -= need
+                }
+                if (arr[i] >= 3) {
+                    leftOver += arr[i] / 3
+                }
+            }
+            res += Math.max(totalMissing, leftOver)
+        }
+        return res
+    }
+}

src/main/kotlin/g0401_0500/s0420_strong_password_checker/readme.md

@@ -0,0 +1,40 @@
+420\. Strong Password Checker
+
+Hard
+
+A password is considered strong if the below conditions are all met:
+
+*   It has at least `6` characters and at most `20` characters.
+*   It contains at least **one lowercase** letter, at least **one uppercase** letter, and at least **one digit**.
+*   It does not contain three repeating characters in a row (i.e., <code>"B<ins>**aaa**</ins>bb0"</code> is weak, but <code>"B**<ins>aa</ins>**b<ins>**a**</ins>0"</code> is strong).
+
+Given a string `password`, return _the minimum number of steps required to make `password` strong. if `password` is already strong, return `0`._
+
+In one step, you can:
+
+*   Insert one character to `password`,
+*   Delete one character from `password`, or
+*   Replace one character of `password` with another character.
+
+**Example 1:**
+
+**Input:** password = "a"
+
+**Output:** 5
+
+**Example 2:**
+
+**Input:** password = "aA1"
+
+**Output:** 3
+
+**Example 3:**
+
+**Input:** password = "1337C0d3"
+
+**Output:** 0
+
+**Constraints:**
+
+*   `1 <= password.length <= 50`
+*   `password` consists of letters, digits, dot `'.'` or exclamation mark `'!'`.

src/test/kotlin/g0401_0500/s0415_add_strings/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0401_0500.s0415_add_strings
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun addStrings() {
+        assertThat(Solution().addStrings("11", "123"), equalTo("134"))
+    }
+
+    @Test
+    fun addStrings2() {
+        assertThat(Solution().addStrings("456", "77"), equalTo("533"))
+    }
+}