Added tasks 553, 554, 556, 557

Author: ThanhNIT

README.md

@@ -186,6 +186,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0503 |[Next Greater Element II](src/main/kotlin/g0501_0600/s0503_next_greater_element_ii/Solution.kt)| Medium | Array, Stack, Monotonic_Stack | 331 | 92.68
+| 0556 |[Next Greater Element III](src/main/kotlin/g0501_0600/s0556_next_greater_element_iii/Solution.kt)| Medium | String, Math, Two_Pointers | 137 | 80.00
 
 #### Day 11
 
@@ -1098,6 +1099,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0344 |[Reverse String](src.save/main/kotlin/g0301_0400/s0344_reverse_string/Solution.kt)| Easy | Top_Interview_Questions, String, Two_Pointers, Recursion | 445 | 69.75
+| 0557 |[Reverse Words in a String III](src/main/kotlin/g0501_0600/s0557_reverse_words_in_a_string_iii/Solution.kt)| Easy | String, Two_Pointers | 215 | 98.10
 
 #### Day 5 Two Pointers
 
@@ -1654,6 +1656,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | 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
 | 0560 |[Subarray Sum Equals K](src/main/kotlin/g0501_0600/s0560_subarray_sum_equals_k/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Hash_Table, Prefix_Sum, Data_Structure_II_Day_5_Array | 692 | 53.27
+| 0557 |[Reverse Words in a String III](src/main/kotlin/g0501_0600/s0557_reverse_words_in_a_string_iii/Solution.kt)| Easy | String, Two_Pointers, Algorithm_I_Day_4_Two_Pointers | 215 | 98.10
+| 0556 |[Next Greater Element III](src/main/kotlin/g0501_0600/s0556_next_greater_element_iii/Solution.kt)| Medium | String, Math, Two_Pointers, Programming_Skills_II_Day_10 | 137 | 80.00
+| 0554 |[Brick Wall](src/main/kotlin/g0501_0600/s0554_brick_wall/Solution.kt)| Medium | Array, Hash_Table | 307 | 100.00
+| 0553 |[Optimal Division](src/main/kotlin/g0501_0600/s0553_optimal_division/Solution.kt)| Medium | Array, Dynamic_Programming, Math | 154 | 100.00
 | 0552 |[Student Attendance Record II](src/main/kotlin/g0501_0600/s0552_student_attendance_record_ii/Solution.kt)| Hard | Dynamic_Programming | 151 | 100.00
 | 0551 |[Student Attendance Record I](src/main/kotlin/g0501_0600/s0551_student_attendance_record_i/Solution.kt)| Easy | String | 151 | 95.00
 | 0547 |[Number of Provinces](src/main/kotlin/g0501_0600/s0547_number_of_provinces/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Union_Find, Algorithm_II_Day_6_Breadth_First_Search_Depth_First_Search, Graph_Theory_I_Day_8_Standard_Traversal, Level_2_Day_19_Union_Find | 229 | 79.73

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

@@ -4,6 +4,7 @@ package g0501_0600.s0552_student_attendance_record_ii
 
 import java.util.Arrays
 
+@Suppress("NAME_SHADOWING")
 class Solution {
     fun checkRecord(n: Int): Int {
         if (n == 0 || n == 1 || n == 2) {

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

@@ -0,0 +1,29 @@
+package g0501_0600.s0553_optimal_division
+
+// #Medium #Array #Dynamic_Programming #Math #2023_01_17_Time_154_ms_(100.00%)_Space_34_MB_(66.67%)
+
+class Solution {
+    fun optimalDivision(nums: IntArray): String {
+        val sb = StringBuilder()
+        if (nums.size == 1) {
+            sb.append(nums[0])
+            return sb.toString()
+        }
+        if (nums.size == 2) {
+            sb.append(nums[0])
+            sb.append("/")
+            sb.append(nums[1])
+            return sb.toString()
+        }
+        sb.append(nums[0])
+        sb.append("/")
+        sb.append("(")
+        for (i in 1 until nums.size - 1) {
+            sb.append(nums[i])
+            sb.append('/')
+        }
+        sb.append(nums[nums.size - 1])
+        sb.append(")")
+        return sb.toString()
+    }
+}

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

@@ -0,0 +1,48 @@
+553\. Optimal Division
+
+Medium
+
+You are given an integer array `nums`. The adjacent integers in `nums` will perform the float division.
+
+*   For example, for `nums = [2,3,4]`, we will evaluate the expression `"2/3/4"`.
+
+However, you can add any number of parenthesis at any position to change the priority of operations. You want to add these parentheses such the value of the expression after the evaluation is maximum.
+
+Return _the corresponding expression that has the maximum value in string format_.
+
+**Note:** your expression should not contain redundant parenthesis.
+
+**Example 1:**
+
+**Input:** nums = [1000,100,10,2]
+
+**Output:** "1000/(100/10/2)"
+
+**Explanation:**
+
+    1000/(100/10/2) = 1000/((100/10)/2) = 200
+    However, the bold parenthesis in "1000/((100/10)/2)" are redundant, since they don't influence the operation priority.
+    So you should return "1000/(100/10/2)".
+    Other cases:
+    1000/(100/10)/2 = 50
+    1000/(100/(10/2)) = 50
+    1000/100/10/2 = 0.5
+    1000/100/(10/2) = 2 
+
+**Example 2:**
+
+**Input:** nums = [2,3,4]
+
+**Output:** "2/(3/4)"
+
+**Example 3:**
+
+**Input:** nums = [2]
+
+**Output:** "2"
+
+**Constraints:**
+
+*   `1 <= nums.length <= 10`
+*   `2 <= nums[i] <= 1000`
+*   There is only one optimal division for the given iput.

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

@@ -0,0 +1,23 @@
+package g0501_0600.s0554_brick_wall
+
+// #Medium #Array #Hash_Table #2023_01_17_Time_307_ms_(100.00%)_Space_47.5_MB_(90.00%)
+
+class Solution {
+    fun leastBricks(wall: List<List<Int>>): Int {
+        val gapMap = mutableMapOf<Int, Int>()
+
+        wall.forEach { row ->
+            var pos = 0
+            for (brickId in 0 until row.lastIndex) {
+                pos += row[brickId]
+                gapMap[pos] = gapMap.getOrDefault(pos, 0) + 1
+            }
+        }
+        var value = 0
+
+        if (gapMap.size > 0) {
+            value = gapMap.values.max()
+        }
+        return wall.size - value
+    }
+}

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

@@ -0,0 +1,32 @@
+554\. Brick Wall
+
+Medium
+
+There is a rectangular brick wall in front of you with `n` rows of bricks. The <code>i<sup>th</sup></code> row has some number of bricks each of the same height (i.e., one unit) but they can be of different widths. The total width of each row is the same.
+
+Draw a vertical line from the top to the bottom and cross the least bricks. If your line goes through the edge of a brick, then the brick is not considered as crossed. You cannot draw a line just along one of the two vertical edges of the wall, in which case the line will obviously cross no bricks.
+
+Given the 2D array `wall` that contains the information about the wall, return _the minimum number of crossed bricks after drawing such a vertical line_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/24/cutwall-grid.jpg)
+
+**Input:** wall = [[1,2,2,1],[3,1,2],[1,3,2],[2,4],[3,1,2],[1,3,1,1]]
+
+**Output:** 2
+
+**Example 2:**
+
+**Input:** wall = [[1],[1],[1]]
+
+**Output:** 3
+
+**Constraints:**
+
+*   `n == wall.length`
+*   <code>1 <= n <= 10<sup>4</sup></code>
+*   <code>1 <= wall[i].length <= 10<sup>4</sup></code>
+*   <code>1 <= sum(wall[i].length) <= 2 * 10<sup>4</sup></code>
+*   `sum(wall[i])` is the same for each row `i`.
+*   <code>1 <= wall[i][j] <= 2<sup>31</sup> - 1</code>

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

@@ -0,0 +1,72 @@
+package g0501_0600.s0556_next_greater_element_iii
+
+// #Medium #String #Math #Two_Pointers #Programming_Skills_II_Day_10
+// #2023_01_20_Time_137_ms_(80.00%)_Space_32.6_MB_(60.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    /*
+    - What this problem wants is finding the next permutation of n
+    - Steps to find the next permuation:
+       find largest index k such that inp[k] < inp[k+1];
+           if k == -1: return -1
+           else:
+               look for largest index l such that inp[l] > inp[k]
+               swap the two index
+               reverse from k+1 to n.length
+       */
+    fun nextGreaterElement(n: Int): Int {
+        val inp = n.toString().toCharArray()
+        // Find k
+        var k = -1
+        for (i in inp.size - 2 downTo 0) {
+            if (inp[i] < inp[i + 1]) {
+                k = i
+                break
+            }
+        }
+        if (k == -1) {
+            return -1
+        }
+        // Find l
+        var largerIdx = inp.size - 1
+        for (i in inp.indices.reversed()) {
+            if (inp[i] > inp[k]) {
+                largerIdx = i
+                break
+            }
+        }
+        swap(inp, k, largerIdx)
+        reverse(inp, k + 1, inp.size - 1)
+        // Build result
+        var ret = 0
+        for (c in inp) {
+            val digit = c.code - '0'.code
+            // Handle the case if ret > Integer.MAX_VALUE - This idea is borrowed from problem  8.
+            // String to Integer (atoi)
+            if (ret > Int.MAX_VALUE / 10 || ret == Int.MAX_VALUE / 10 && digit > Int.MAX_VALUE % 10) {
+                return -1
+            }
+            ret = ret * 10 + (c.code - '0'.code)
+        }
+        return ret
+    }
+
+    private fun swap(inp: CharArray, i: Int, j: Int) {
+        val temp = inp[i]
+        inp[i] = inp[j]
+        inp[j] = temp
+    }
+
+    private fun reverse(inp: CharArray, start: Int, end: Int) {
+        var start = start
+        var end = end
+        while (start < end) {
+            val temp = inp[start]
+            inp[start] = inp[end]
+            inp[end] = temp
+            start++
+            end--
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+556\. Next Greater Element III
+
+Medium
+
+Given a positive integer `n`, find _the smallest integer which has exactly the same digits existing in the integer_ `n` _and is greater in value than_ `n`. If no such positive integer exists, return `-1`.
+
+**Note** that the returned integer should fit in **32-bit integer**, if there is a valid answer but it does not fit in **32-bit integer**, return `-1`.
+
+**Example 1:**
+
+**Input:** n = 12
+
+**Output:** 21
+
+**Example 2:**
+
+**Input:** n = 21
+
+**Output:** -1
+
+**Constraints:**
+
+*   <code>1 <= n <= 2<sup>31</sup> - 1</code>

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

@@ -0,0 +1,34 @@
+package g0501_0600.s0557_reverse_words_in_a_string_iii
+
+// #Easy #String #Two_Pointers #Algorithm_I_Day_4_Two_Pointers
+// #2023_01_20_Time_215_ms_(98.10%)_Space_36.1_MB_(94.29%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun reverseWords(s: String): String {
+        var l: Int
+        var r = 0
+        val len = s.length
+        val ch = s.toCharArray()
+        for (i in 0..len) {
+            if (i == len || ch[i] == ' ') {
+                l = r
+                r = i
+                reverse(ch, l, r - 1)
+                r++
+            }
+        }
+        return String(ch)
+    }
+
+    private fun reverse(s: CharArray, l: Int, r: Int) {
+        var l = l
+        var r = r
+        var c: Char
+        while (r > l) {
+            c = s[l]
+            s[l++] = s[r]
+            s[r--] = c
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+557\. Reverse Words in a String III
+
+Easy
+
+Given a string `s`, reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.
+
+**Example 1:**
+
+**Input:** s = "Let's take LeetCode contest"
+
+**Output:** "s'teL ekat edoCteeL tsetnoc"
+
+**Example 2:**
+
+**Input:** s = "God Ding"
+
+**Output:** "doG gniD"
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 5 * 10<sup>4</sup></code>
+*   `s` contains printable **ASCII** characters.
+*   `s` does not contain any leading or trailing spaces.
+*   There is **at least one** word in `s`.
+*   All the words in `s` are separated by a single space.