Added tasks 388, 389, 390, 391.

Author: ThanhNIT

README.md

@@ -343,6 +343,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0389 |[Find the Difference](src/main/kotlin/g0301_0400/s0389_find_the_difference/Solution.kt)| Easy | String, Hash_Table, Sorting, Bit_Manipulation | 256 | 64.81
 
 #### Day 9 String
 
@@ -1031,6 +1032,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0191 |[Number of 1 Bits](src.save/main/kotlin/g0101_0200/s0191_number_of_1_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation | 237 | 68.44
+| 0389 |[Find the Difference](src/main/kotlin/g0301_0400/s0389_find_the_difference/Solution.kt)| Easy | String, Hash_Table, Sorting, Bit_Manipulation | 256 | 64.81
 | 0190 |[Reverse Bits](src.save/main/kotlin/g0101_0200/s0190_reverse_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation, Divide_and_Conquer | 198 | 81.82
 | 0338 |[Counting Bits](src/main/kotlin/g0301_0400/s0338_counting_bits/Solution.kt)| Easy | Top_100_Liked_Questions, Dynamic_Programming, Bit_Manipulation | 186 | 99.26
 | 0371 |[Sum of Two Integers](src/main/kotlin/g0301_0400/s0371_sum_of_two_integers/Solution.kt)| Medium | Top_Interview_Questions, Math, Bit_Manipulation | 129 | 95.45
@@ -1614,6 +1616,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 | 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
 | 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
 | 0394 |[Decode String](src/main/kotlin/g0301_0400/s0394_decode_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Stack, Recursion, Level_1_Day_14_Stack, Udemy_Strings | 224 | 64.86
+| 0391 |[Perfect Rectangle](src/main/kotlin/g0301_0400/s0391_perfect_rectangle/Solution.kt)| Hard | Array, Line_Sweep | 897 | 100.00
+| 0390 |[Elimination Game](src/main/kotlin/g0301_0400/s0390_elimination_game/Solution.kt)| Medium | Math, Recursion | 319 | 55.56
+| 0389 |[Find the Difference](src/main/kotlin/g0301_0400/s0389_find_the_difference/Solution.kt)| Easy | String, Hash_Table, Sorting, Bit_Manipulation, Programming_Skills_I_Day_8_String, Udemy_Bit_Manipulation | 256 | 64.81
+| 0388 |[Longest Absolute File Path](src/main/kotlin/g0301_0400/s0388_longest_absolute_file_path/Solution.kt)| Medium | String, Depth_First_Search, Stack | 150 | 100.00
 | 0387 |[First Unique Character in a String](src/main/kotlin/g0301_0400/s0387_first_unique_character_in_a_string/Solution.kt)| Easy | Top_Interview_Questions, String, Hash_Table, Counting, Queue, Data_Structure_I_Day_6_String | 369 | 82.68
 | 0386 |[Lexicographical Numbers](src/main/kotlin/g0301_0400/s0386_lexicographical_numbers/Solution.kt)| Medium | Depth_First_Search, Trie | 463 | 83.33
 | 0385 |[Mini Parser](src/main/kotlin/g0301_0400/s0385_mini_parser/Solution.kt)| Medium | String, Depth_First_Search, Stack | 210 | 100.00

src/main/kotlin/g0301_0400/s0388_longest_absolute_file_path/Solution.kt

@@ -0,0 +1,69 @@
+package g0301_0400.s0388_longest_absolute_file_path
+
+// #Medium #String #Depth_First_Search #Stack
+// #2022_11_24_Time_150_ms_(100.00%)_Space_33.6_MB_(100.00%)
+
+import java.util.ArrayDeque
+import java.util.Deque
+
+class Solution {
+    fun lengthLongestPath(input: String): Int {
+        val stack: Deque<Int> = ArrayDeque()
+        var longestLen = 0
+        var currDirLen = 0
+        var i = 0
+        var currLevel: Int
+        var nextLevel = 0
+        var isFile = false
+        val period = '.'
+        val space = ' '
+        while (i < input.length) {
+            currLevel = nextLevel
+            var currStrLen = 0
+            while (i < input.length &&
+                (Character.isLetterOrDigit(input[i]) || period == input[i] || space == input[i])
+            ) {
+                if (period == input[i]) {
+                    isFile = true
+                }
+                i++
+                currStrLen++
+            }
+            if (isFile) {
+                longestLen = Math.max(longestLen, currDirLen + currStrLen)
+            } else {
+                currDirLen += currStrLen + 1
+                stack.push(currStrLen + 1)
+            }
+            nextLevel = 0
+            // increment one to let it pass "\n" and start from "\t"
+            i = i + 1
+            while (i < input.length - 1 && input[i] == '\t') {
+                nextLevel++
+                i = i + 1
+            }
+            if (nextLevel < currLevel) {
+                var j = 0
+                if (isFile) {
+                    while (!stack.isEmpty() && j < currLevel - nextLevel) {
+                        currDirLen -= stack.pop()
+                        j++
+                    }
+                } else {
+                    while (!stack.isEmpty() && j <= currLevel - nextLevel) {
+                        currDirLen -= stack.pop()
+                        j++
+                    }
+                }
+            } else if (nextLevel == currLevel && !isFile && !stack.isEmpty()) {
+                currDirLen -= stack.pop()
+            }
+            if (nextLevel == 0) {
+                currDirLen = 0
+                stack.clear()
+            }
+            isFile = false
+        }
+        return longestLen
+    }
+}

src/main/kotlin/g0301_0400/s0388_longest_absolute_file_path/readme.md

@@ -0,0 +1,76 @@
+388\. Longest Absolute File Path
+
+Medium
+
+Suppose we have a file system that stores both files and directories. An example of one system is represented in the following picture:
+
+![](https://assets.leetcode.com/uploads/2020/08/28/mdir.jpg)
+
+Here, we have `dir` as the only directory in the root. `dir` contains two subdirectories, `subdir1` and `subdir2`. `subdir1` contains a file `file1.ext` and subdirectory `subsubdir1`. `subdir2` contains a subdirectory `subsubdir2`, which contains a file `file2.ext`.
+
+In text form, it looks like this (with ⟶ representing the tab character):
+
+    dir 
+    ⟶ subdir1
+    ⟶ ⟶ file1.ext
+    ⟶ ⟶ subsubdir1
+    ⟶ subdir2
+    ⟶ ⟶ subsubdir2
+    ⟶ ⟶ ⟶ file2.ext
+
+If we were to write this representation in code, it will look like this: `"dir  
+\tsubdir1  
+\t\tfile1.ext  
+\t\tsubsubdir1  
+\tsubdir2  
+\t\tsubsubdir2  
+\t\t\tfile2.ext"`. Note that the `'  
+'` and `'\t'` are the new-line and tab characters.
+
+Every file and directory has a unique **absolute path** in the file system, which is the order of directories that must be opened to reach the file/directory itself, all concatenated by `'/'s`. Using the above example, the **absolute path** to `file2.ext` is `"dir/subdir2/subsubdir2/file2.ext"`. Each directory name consists of letters, digits, and/or spaces. Each file name is of the form `name.extension`, where `name` and `extension` consist of letters, digits, and/or spaces.
+
+Given a string `input` representing the file system in the explained format, return _the length of the **longest absolute path** to a **file** in the abstracted file system_. If there is no file in the system, return `0`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/08/28/dir1.jpg)
+
+**Input:** input = "dir\n\tsubdir1\n\tsubdir2\n\t\tfile.ext"
+
+**Output:** 20
+
+**Explanation:** We have only one file, and the absolute path is "dir/subdir2/file.ext" of length 20.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/08/28/dir2.jpg)
+
+**Input:** input = input = "dir\n\tsubdir1\n\t\tfile1.ext\n\t\tsubsubdir1\n\tsubdir2\n\t\tsubsubdir2\n\t\t\tfile2.ext"
+
+**Output:** 32
+
+**Explanation:** We have two files: "dir/subdir1/file1.ext" of length 21 "dir/subdir2/subsubdir2/file2.ext" of length 32. We return 32 since it is the longest absolute path to a file.
+
+**Example 3:**
+
+**Input:** input = "a"
+
+**Output:** 0
+
+**Explanation:** We do not have any files, just a single directory named "a".
+
+**Example 4:**
+
+**Input:** input = "file1.txt  
+file2.txt  
+longfile.txt"
+
+**Output:** 12
+
+**Explanation:** There are 3 files at the root directory. Since the absolute path for anything at the root directory is just the name itself, the answer is "longfile.txt" with length 12.
+
+**Constraints:**
+
+*   <code>1 <= input.length <= 10<sup>4</sup></code>
+*   `input` may contain lowercase or uppercase English letters, a new line character `'  
+    '`, a tab character `'\t'`, a dot `'.'`, a space `' '`, and digits.

src/main/kotlin/g0301_0400/s0389_find_the_difference/Solution.kt

@@ -0,0 +1,17 @@
+package g0301_0400.s0389_find_the_difference
+
+// #Easy #String #Hash_Table #Sorting #Bit_Manipulation #Programming_Skills_I_Day_8_String
+// #Udemy_Bit_Manipulation #2022_11_24_Time_256_ms_(64.81%)_Space_34.8_MB_(100.00%)
+
+class Solution {
+    fun findTheDifference(s: String, t: String): Char {
+        var c = 0.toChar()
+        for (cs in s.toCharArray()) {
+            c = (c.code xor cs.code).toChar()
+        }
+        for (ct in t.toCharArray()) {
+            c = (c.code xor ct.code).toChar()
+        }
+        return c
+    }
+}

src/main/kotlin/g0301_0400/s0389_find_the_difference/readme.md

@@ -0,0 +1,29 @@
+389\. Find the Difference
+
+Easy
+
+You are given two strings `s` and `t`.
+
+String `t` is generated by random shuffling string `s` and then add one more letter at a random position.
+
+Return the letter that was added to `t`.
+
+**Example 1:**
+
+**Input:** s = "abcd", t = "abcde"
+
+**Output:** "e"
+
+**Explanation:** 'e' is the letter that was added.
+
+**Example 2:**
+
+**Input:** s = "", t = "y"
+
+**Output:** "y"
+
+**Constraints:**
+
+*   `0 <= s.length <= 1000`
+*   `t.length == s.length + 1`
+*   `s` and `t` consist of lowercase English letters.

src/main/kotlin/g0301_0400/s0390_elimination_game/Solution.kt

@@ -0,0 +1,9 @@
+package g0301_0400.s0390_elimination_game
+
+// #Medium #Math #Recursion #2022_11_24_Time_319_ms_(55.56%)_Space_35.5_MB_(33.33%)
+
+class Solution {
+    fun lastRemaining(n: Int): Int {
+        return if (n == 1) 1 else 2 * (n / 2 - lastRemaining(n / 2) + 1)
+    }
+}

src/main/kotlin/g0301_0400/s0390_elimination_game/readme.md

@@ -0,0 +1,34 @@
+390\. Elimination Game
+
+Medium
+
+You have a list `arr` of all integers in the range `[1, n]` sorted in a strictly increasing order. Apply the following algorithm on `arr`:
+
+*   Starting from left to right, remove the first number and every other number afterward until you reach the end of the list.
+*   Repeat the previous step again, but this time from right to left, remove the rightmost number and every other number from the remaining numbers.
+*   Keep repeating the steps again, alternating left to right and right to left, until a single number remains.
+
+Given the integer `n`, return _the last number that remains in_ `arr`.
+
+**Example 1:**
+
+**Input:** n = 9
+
+**Output:** 6
+
+**Explanation:**
+
+    arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+    arr = [2, 4, 6, 8]
+    arr = [2, 6]
+    arr = [6]
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>9</sup></code>

src/main/kotlin/g0301_0400/s0391_perfect_rectangle/Solution.kt

@@ -0,0 +1,76 @@
+package g0301_0400.s0391_perfect_rectangle
+
+// #Hard #Array #Line_Sweep #2022_11_24_Time_897_ms_(100.00%)_Space_89.8_MB_(100.00%)
+
+import java.util.Objects
+
+class Solution {
+    fun isRectangleCover(rectangles: Array<IntArray>): Boolean {
+        val container: MutableSet<Point> = HashSet()
+        // add each rectangle area to totalArea
+        var totalArea = 0
+        // A rectangle has four points, if a point appears twice, it will be deleted it from the set
+        for (rectangle in rectangles) {
+            totalArea += (rectangle[2] - rectangle[0]) * (rectangle[3] - rectangle[1])
+            val p1 = Point(rectangle[0], rectangle[1])
+            val p2 = Point(rectangle[2], rectangle[1])
+            val p3 = Point(rectangle[2], rectangle[3])
+            val p4 = Point(rectangle[0], rectangle[3])
+            if (container.contains(p1)) {
+                container.remove(p1)
+            } else {
+                container.add(p1)
+            }
+            if (container.contains(p2)) {
+                container.remove(p2)
+            } else {
+                container.add(p2)
+            }
+            if (container.contains(p3)) {
+                container.remove(p3)
+            } else {
+                container.add(p3)
+            }
+            if (container.contains(p4)) {
+                container.remove(p4)
+            } else {
+                container.add(p4)
+            }
+        }
+        // A perfect rectangle must has four points
+        if (container.size != 4) {
+            return false
+        }
+
+        // these four points represent the last perfect rectangle, check this rectangle area to the
+        // totalArea
+        var minX = Int.MAX_VALUE
+        var maxX = Int.MIN_VALUE
+        var minY = Int.MAX_VALUE
+        var maxY = Int.MIN_VALUE
+        for (p in container) {
+            minX = Math.min(minX, p.x)
+            maxX = Math.max(maxX, p.x)
+            minY = Math.min(minY, p.y)
+            maxY = Math.max(maxY, p.y)
+        }
+        return totalArea == (maxX - minX) * (maxY - minY)
+    }
+
+    private class Point(val x: Int, val y: Int) {
+        override fun equals(o: Any?): Boolean {
+            if (this === o) {
+                return true
+            }
+            if (o == null || javaClass != o.javaClass) {
+                return false
+            }
+            val point = o as Point
+            return x == point.x && y == point.y
+        }
+
+        override fun hashCode(): Int {
+            return Objects.hash(x, y)
+        }
+    }
+}

src/main/kotlin/g0301_0400/s0391_perfect_rectangle/readme.md

@@ -0,0 +1,43 @@
+391\. Perfect Rectangle
+
+Hard
+
+Given an array `rectangles` where <code>rectangles[i] = [x<sub>i</sub>, y<sub>i</sub>, a<sub>i</sub>, b<sub>i</sub>]</code> represents an axis-aligned rectangle. The bottom-left point of the rectangle is <code>(x<sub>i</sub>, y<sub>i</sub>)</code> and the top-right point of it is <code>(a<sub>i</sub>, b<sub>i</sub>)</code>.
+
+Return `true` _if all the rectangles together form an exact cover of a rectangular region_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/27/perectrec1-plane.jpg)
+
+**Input:** rectangles = [[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]
+
+**Output:** true
+
+**Explanation:** All 5 rectangles together form an exact cover of a rectangular region.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/27/perfectrec2-plane.jpg)
+
+**Input:** rectangles = [[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]
+
+**Output:** false
+
+**Explanation:** Because there is a gap between the two rectangular regions.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/03/27/perfecrrec4-plane.jpg)
+
+**Input:** rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[2,2,4,4]]
+
+**Output:** false
+
+**Explanation:** Because two of the rectangles overlap with each other.
+
+**Constraints:**
+
+*   <code>1 <= rectangles.length <= 2 * 10<sup>4</sup></code>
+*   `rectangles[i].length == 4`
+*   <code>-10<sup>5</sup> <= x<sub>i</sub>, y<sub>i</sub>, a<sub>i</sub>, b<sub>i</sub> <= 10<sup>5</sup></code>