Added tasks 830, 831, 832, 833

Author: ThanhNIT

README.md

@@ -1713,6 +1713,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 | 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
 | 0994 |[Rotting Oranges](src/main/kotlin/g0901_1000/s0994_rotting_oranges/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix, Algorithm_I_Day_9_Breadth_First_Search_Depth_First_Search, Level_2_Day_10_Graph/BFS/DFS | 308 | 57.93
 | 0864 |[Shortest Path to Get All Keys](src/main/kotlin/g0801_0900/s0864_shortest_path_to_get_all_keys/Solution.kt)| Hard | Breadth_First_Search, Bit_Manipulation | 176 | 100.00
+| 0833 |[Find And Replace in String](src/main/kotlin/g0801_0900/s0833_find_and_replace_in_string/Solution.kt)| Medium | Array, String, Sorting | 158 | 100.00
+| 0832 |[Flipping an Image](src/main/kotlin/g0801_0900/s0832_flipping_an_image/Solution.kt)| Easy | Array, Matrix, Two_Pointers, Simulation | 190 | 94.44
+| 0831 |[Masking Personal Information](src/main/kotlin/g0801_0900/s0831_masking_personal_information/Solution.kt)| Medium | String | 149 | 100.00
+| 0830 |[Positions of Large Groups](src/main/kotlin/g0801_0900/s0830_positions_of_large_groups/Solution.kt)| Easy | String | 221 | 100.00
 | 0829 |[Consecutive Numbers Sum](src/main/kotlin/g0801_0900/s0829_consecutive_numbers_sum/Solution.kt)| Hard | Math, Enumeration | 151 | 100.00
 | 0828 |[Count Unique Characters of All Substrings of a Given String](src/main/kotlin/g0801_0900/s0828_count_unique_characters_of_all_substrings_of_a_given_string/Solution.kt)| Hard | String, Hash_Table, Dynamic_Programming | 216 | 100.00
 | 0827 |[Making A Large Island](src/main/kotlin/g0801_0900/s0827_making_a_large_island/Solution.kt)| Hard | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find | 985 | 100.00

src/main/kotlin/g0801_0900/s0830_positions_of_large_groups/Solution.kt

@@ -0,0 +1,21 @@
+package g0801_0900.s0830_positions_of_large_groups
+
+// #Easy #String #2023_03_25_Time_221_ms_(100.00%)_Space_37.2_MB_(85.71%)
+
+class Solution {
+    fun largeGroupPositions(s: String): List<List<Int>> {
+        val map: MutableList<List<Int>> = ArrayList()
+        var i = 0
+        while (i < s.length) {
+            var j = i
+            while (j < s.length && s[j] == s[i]) {
+                j++
+            }
+            if (j - 1 - i + 1 >= 3) {
+                map.add(listOf(i, j - 1))
+            }
+            i = j
+        }
+        return map
+    }
+}

src/main/kotlin/g0801_0900/s0830_positions_of_large_groups/readme.md

@@ -0,0 +1,42 @@
+830\. Positions of Large Groups
+
+Easy
+
+In a string `s` of lowercase letters, these letters form consecutive groups of the same character.
+
+For example, a string like `s = "abbxxxxzyy"` has the groups `"a"`, `"bb"`, `"xxxx"`, `"z"`, and `"yy"`.
+
+A group is identified by an interval `[start, end]`, where `start` and `end` denote the start and end indices (inclusive) of the group. In the above example, `"xxxx"` has the interval `[3,6]`.
+
+A group is considered **large** if it has 3 or more characters.
+
+Return _the intervals of every **large** group sorted in **increasing order by start index**_.
+
+**Example 1:**
+
+**Input:** s = "abbxxxxzzy"
+
+**Output:** [[3,6]]
+
+**Explanation:** `"xxxx" is the only` large group with start index 3 and end index 6.
+
+**Example 2:**
+
+**Input:** s = "abc"
+
+**Output:** []
+
+**Explanation:** We have groups "a", "b", and "c", none of which are large groups.
+
+**Example 3:**
+
+**Input:** s = "abcdddeeeeaabbbcd"
+
+**Output:** [[3,5],[6,9],[12,14]]
+
+**Explanation:** The large groups are "ddd", "eeee", and "bbb".
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s` contains lowercase English letters only.

src/main/kotlin/g0801_0900/s0831_masking_personal_information/Solution.kt

@@ -0,0 +1,34 @@
+package g0801_0900.s0831_masking_personal_information
+
+// #Medium #String #2023_03_25_Time_149_ms_(100.00%)_Space_35.3_MB_(100.00%)
+
+import java.util.Locale
+
+class Solution {
+    fun maskPII(s: String): String {
+        val masked = StringBuilder()
+        return if (Character.isAlphabetic(s[0].code)) {
+            val locationOfAtSymbol = s.indexOf("@") - 1
+            masked.append(s[0]).append("*****").append(s.substring(locationOfAtSymbol))
+            masked.toString().lowercase(Locale.getDefault())
+        } else {
+            val allDigits = StringBuilder()
+            var pointer = -1
+            while (++pointer < s.length) {
+                if (Character.isDigit(s[pointer])) {
+                    allDigits.append(s[pointer])
+                }
+            }
+            val numDigits = allDigits.length
+            if (numDigits == 11) {
+                masked.append("+*-")
+            } else if (numDigits == 12) {
+                masked.append("+**-")
+            } else if (numDigits == 13) {
+                masked.append("+***-")
+            }
+            masked.append("***-***-").append(allDigits.substring(numDigits - 4))
+            masked.toString()
+        }
+    }
+}

src/main/kotlin/g0801_0900/s0831_masking_personal_information/readme.md

@@ -0,0 +1,81 @@
+831\. Masking Personal Information
+
+Medium
+
+You are given a personal information string `s`, representing either an **email address** or a **phone number**. Return _the **masked** personal information using the below rules_.
+
+**Email address:**
+
+An email address is:
+
+*   A **name** consisting of uppercase and lowercase English letters, followed by
+*   The `'@'` symbol, followed by
+*   The **domain** consisting of uppercase and lowercase English letters with a dot `'.'` somewhere in the middle (not the first or last character).
+
+To mask an email:
+
+*   The uppercase letters in the **name** and **domain** must be converted to lowercase letters.
+*   The middle letters of the **name** (i.e., all but the first and last letters) must be replaced by 5 asterisks `"*****"`.
+
+**Phone number:**
+
+A phone number is formatted as follows:
+
+*   The phone number contains 10-13 digits.
+*   The last 10 digits make up the **local number**.
+*   The remaining 0-3 digits, in the beginning, make up the **country code**.
+*   **Separation characters** from the set `{'+', '-', '(', ')', ' '}` separate the above digits in some way.
+
+To mask a phone number:
+
+*   Remove all **separation characters**.
+*   The masked phone number should have the form:
+    *   `"***-***-XXXX"` if the country code has 0 digits.
+    *   `"+*-***-***-XXXX"` if the country code has 1 digit.
+    *   `"+**-***-***-XXXX"` if the country code has 2 digits.
+    *   `"+***-***-***-XXXX"` if the country code has 3 digits.
+*   `"XXXX"` is the last 4 digits of the **local number**.
+
+**Example 1:**
+
+**Input:** s = "[email protected]"
+
+**Output:** "l\*\*\*\*\*[email protected]"
+
+**Explanation:** s is an email address.
+
+The name and domain are converted to lowercase, and the middle of the name is replaced by 5 asterisks.
+
+**Example 2:**
+
+**Input:** s = "[email protected]"
+
+**Output:** "a\*\*\*\*\*[email protected]"
+
+**Explanation:** s is an email address.
+
+The name and domain are converted to lowercase, and the middle of the name is replaced by 5 asterisks.
+
+Note that even though "ab" is 2 characters, it still must have 5 asterisks in the middle.
+
+**Example 3:**
+
+**Input:** s = "1(234)567-890"
+
+**Output:** "\*\*\*-\*\*\*-7890"
+
+**Explanation:** s is a phone number.
+
+There are 10 digits, so the local number is 10 digits and the country code is 0 digits.
+
+Thus, the resulting masked number is "\*\*\*-\*\*\*-7890".
+
+**Constraints:**
+
+*   `s` is either a **valid** email or a phone number.
+*   If `s` is an email:
+    *   `8 <= s.length <= 40`
+    *   `s` consists of uppercase and lowercase English letters and exactly one `'@'` symbol and `'.'` symbol.
+*   If `s` is a phone number:
+    *   `10 <= s.length <= 20`
+    *   `s` consists of digits, spaces, and the symbols `'('`, `')'`, `'-'`, and `'+'`.

src/main/kotlin/g0801_0900/s0832_flipping_an_image/Solution.kt

@@ -0,0 +1,42 @@
+package g0801_0900.s0832_flipping_an_image
+
+// #Easy #Array #Matrix #Two_Pointers #Simulation
+// #2023_03_27_Time_190_ms_(94.44%)_Space_36.3_MB_(66.67%)
+
+class Solution {
+    fun flipAndInvertImage(image: Array<IntArray>): Array<IntArray> {
+        val m = image.size
+        val n = image[0].size
+        val result = Array(m) { IntArray(n) }
+        for (i in 0 until m) {
+            val flipped = reverse(image[i])
+            result[i] = invert(flipped)
+        }
+        return result
+    }
+
+    private fun invert(flipped: IntArray): IntArray {
+        val result = IntArray(flipped.size)
+        for (i in flipped.indices) {
+            if (flipped[i] == 0) {
+                result[i] = 1
+            } else {
+                result[i] = 0
+            }
+        }
+        return result
+    }
+
+    private fun reverse(nums: IntArray): IntArray {
+        var i = 0
+        var j = nums.size - 1
+        while (i < j) {
+            val tmp = nums[i]
+            nums[i] = nums[j]
+            nums[j] = tmp
+            i++
+            j--
+        }
+        return nums
+    }
+}

src/main/kotlin/g0801_0900/s0832_flipping_an_image/readme.md

@@ -0,0 +1,36 @@
+832\. Flipping an Image
+
+Easy
+
+Given an `n x n` binary matrix `image`, flip the image **horizontally**, then invert it, and return _the resulting image_.
+
+To flip an image horizontally means that each row of the image is reversed.
+
+*   For example, flipping `[1,1,0]` horizontally results in `[0,1,1]`.
+
+To invert an image means that each `0` is replaced by `1`, and each `1` is replaced by `0`.
+
+*   For example, inverting `[0,1,1]` results in `[1,0,0]`.
+
+**Example 1:**
+
+**Input:** image = [[1,1,0],[1,0,1],[0,0,0]]
+
+**Output:** [[1,0,0],[0,1,0],[1,1,1]]
+
+**Explanation:** First reverse each row: [[0,1,1],[1,0,1],[0,0,0]]. Then, invert the image: [[1,0,0],[0,1,0],[1,1,1]]
+
+**Example 2:**
+
+**Input:** image = [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
+
+**Output:** [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
+
+**Explanation:** First reverse each row: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]]. Then invert the image: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
+
+**Constraints:**
+
+*   `n == image.length`
+*   `n == image[i].length`
+*   `1 <= n <= 20`
+*   `images[i][j]` is either `0` or `1`.

src/main/kotlin/g0801_0900/s0833_find_and_replace_in_string/Solution.kt

@@ -0,0 +1,34 @@
+package g0801_0900.s0833_find_and_replace_in_string
+
+// #Medium #Array #String #Sorting #2023_03_27_Time_158_ms_(100.00%)_Space_35.4_MB_(100.00%)
+
+class Solution {
+    fun findReplaceString(s: String, indices: IntArray, sources: Array<String>, targets: Array<String?>): String {
+        val sb = StringBuilder()
+        val stringIndexToKIndex: MutableMap<Int, Int> = HashMap()
+        for (i in indices.indices) {
+            stringIndexToKIndex[indices[i]] = i
+        }
+        var indexIntoS = 0
+        while (indexIntoS < s.length) {
+            if (stringIndexToKIndex.containsKey(indexIntoS)) {
+                val substringInSources = sources[stringIndexToKIndex[indexIntoS]!!]
+                if (indexIntoS + substringInSources.length <= s.length) {
+                    val substringInS = s.substring(indexIntoS, indexIntoS + substringInSources.length)
+                    if (substringInS == substringInSources) {
+                        sb.append(targets[stringIndexToKIndex[indexIntoS]!!])
+                        indexIntoS += substringInS.length - 1
+                    } else {
+                        sb.append(s[indexIntoS])
+                    }
+                } else {
+                    sb.append(s[indexIntoS])
+                }
+            } else {
+                sb.append(s[indexIntoS])
+            }
+            indexIntoS++
+        }
+        return sb.toString()
+    }
+}

src/main/kotlin/g0801_0900/s0833_find_and_replace_in_string/readme.md

@@ -0,0 +1,51 @@
+833\. Find And Replace in String
+
+Medium
+
+You are given a **0-indexed** string `s` that you must perform `k` replacement operations on. The replacement operations are given as three **0-indexed** parallel arrays, `indices`, `sources`, and `targets`, all of length `k`.
+
+To complete the <code>i<sup>th</sup></code> replacement operation:
+
+1.  Check if the **substring** `sources[i]` occurs at index `indices[i]` in the **original string** `s`.
+2.  If it does not occur, **do nothing**.
+3.  Otherwise if it does occur, **replace** that substring with `targets[i]`.
+
+For example, if `s = "abcd"`, `indices[i] = 0`, `sources[i] = "ab"`, and `targets[i] = "eee"`, then the result of this replacement will be `"eeecd"`.
+
+All replacement operations must occur **simultaneously**, meaning the replacement operations should not affect the indexing of each other. The testcases will be generated such that the replacements will **not overlap**.
+
+*   For example, a testcase with `s = "abc"`, `indices = [0, 1]`, and `sources = ["ab","bc"]` will not be generated because the `"ab"` and `"bc"` replacements overlap.
+
+Return _the **resulting string** after performing all replacement operations on_ `s`.
+
+A **substring** is a contiguous sequence of characters in a string.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/06/12/833-ex1.png)
+
+**Input:** s = "abcd", indices = [0, 2], sources = ["a", "cd"], targets = ["eee", "ffff"]
+
+**Output:** "eeebffff"
+
+**Explanation:** "a" occurs at index 0 in s, so we replace it with "eee". "cd" occurs at index 2 in s, so we replace it with "ffff".
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/06/12/833-ex2-1.png)
+
+**Input:** s = "abcd", indices = [0, 2], sources = ["ab","ec"], targets = ["eee","ffff"]
+
+**Output:** "eeecd"
+
+**Explanation:** "ab" occurs at index 0 in s, so we replace it with "eee". "ec" does not occur at index 2 in s, so we do nothing.
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `k == indices.length == sources.length == targets.length`
+*   `1 <= k <= 100`
+*   `0 <= indexes[i] < s.length`
+*   `1 <= sources[i].length, targets[i].length <= 50`
+*   `s` consists of only lowercase English letters.
+*   `sources[i]` and `targets[i]` consist of only lowercase English letters.

src/test/kotlin/g0801_0900/s0830_positions_of_large_groups/SolutionTest.kt

@@ -0,0 +1,32 @@
+package g0801_0900.s0830_positions_of_large_groups
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun largeGroupPositions() {
+        assertThat(
+            Solution().largeGroupPositions("abbxxxxzzy"),
+            equalTo(listOf(listOf(3, 6)))
+        )
+    }
+
+    @Test
+    fun largeGroupPositions2() {
+        assertThat(Solution().largeGroupPositions("abc"), equalTo(emptyList()))
+    }
+
+    @Test
+    fun largeGroupPositions3() {
+        assertThat(
+            Solution().largeGroupPositions("abcdddeeeeaabbbcd"),
+            equalTo(
+                listOf(
+                    listOf(3, 5), listOf(6, 9), listOf(12, 14)
+                )
+            )
+        )
+    }
+}