Added tasks 225, 227, 228, 229.

Author: ThanhNIT

README.md

@@ -892,6 +892,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0227 |[Basic Calculator II](src/main/kotlin/g0201_0300/s0227_basic_calculator_ii/Solution.kt)| Medium | Top_Interview_Questions, String, Math, Stack | 383 | 62.50
 
 #### Day 19 Union Find
 
@@ -1581,7 +1582,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 0236 |[Lowest Common Ancestor of a Binary Tree](src/main/kotlin/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Data_Structure_II_Day_18_Tree, Udemy_Tree_Stack_Queue | 386 | 45.21
 | 0234 |[Palindrome Linked List](src/main/kotlin/g0201_0300/s0234_palindrome_linked_list/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Two_Pointers, Stack, Linked_List, Recursion, Level_2_Day_3_Linked_List, Udemy_Linked_List | 641 | 79.53
 | 0230 |[Kth Smallest Element in a BST](src/main/kotlin/g0201_0300/s0230_kth_smallest_element_in_a_bst/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_II_Day_17_Tree, Level_2_Day_9_Binary_Search_Tree | 393 | 33.33
+| 0229 |[Majority Element II](src/main/kotlin/g0201_0300/s0229_majority_element_ii/Solution.kt)| Medium | Array, Hash_Table, Sorting, Counting | 408 | 71.21
+| 0228 |[Summary Ranges](src/main/kotlin/g0201_0300/s0228_summary_ranges/Solution.kt)| Easy | Array | 169 | 91.89
+| 0227 |[Basic Calculator II](src/main/kotlin/g0201_0300/s0227_basic_calculator_ii/Solution.kt)| Medium | Top_Interview_Questions, String, Math, Stack, Level_2_Day_18_Stack | 383 | 62.50
 | 0226 |[Invert Binary Tree](src/main/kotlin/g0201_0300/s0226_invert_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Data_Structure_I_Day_12_Tree, Level_2_Day_6_Tree, Udemy_Tree_Stack_Queue | 233 | 54.90
+| 0225 |[Implement Stack using Queues](src/main/kotlin/g0201_0300/s0225_implement_stack_using_queues/MyStack.kt)| Easy | Stack, Design, Queue | 248 | 73.44
 | 0224 |[Basic Calculator](src/main/kotlin/g0201_0300/s0224_basic_calculator/Solution.kt)| Hard | String, Math, Stack, Recursion | 294 | 93.33
 | 0223 |[Rectangle Area](src/main/kotlin/g0201_0300/s0223_rectangle_area/Solution.kt)| Medium | Math, Geometry | 291 | 66.67
 | 0222 |[Count Complete Tree Nodes](src/main/kotlin/g0201_0300/s0222_count_complete_tree_nodes/Solution.kt)| |||

src/main/kotlin/g0201_0300/s0225_implement_stack_using_queues/MyStack.kt

@@ -0,0 +1,74 @@
+package g0201_0300.s0225_implement_stack_using_queues
+
+// #Easy #Stack #Design #Queue #2022_10_26_Time_248_ms_(73.44%)_Space_36.1_MB_(43.75%)
+
+import java.util.LinkedList
+
+class MyStack {
+    private var queuePair = Pair(LinkedList<Int>(), LinkedList<Int>())
+    private var top: Int? = null
+
+    fun push(x: Int) {
+        queuePair.first.addLast(x)
+        top = x
+    }
+
+    fun pop(): Int {
+        if (isQueuesEmpty()) {
+            throw Exception()
+        }
+        val queuePair = selectSourceAndDestinationQueues(queuePair)
+        var value = 0
+        repeat(queuePair.first.size) {
+            when (queuePair.first.size) {
+                2 -> {
+                    top = queuePair.first.removeFirst()
+                    queuePair.second.addLast(top)
+                }
+                1 -> {
+                    value = queuePair.first.removeFirst()
+                }
+                else -> {
+                    queuePair.second.addLast(queuePair.first.removeFirst())
+                }
+            }
+        }
+        return value
+    }
+
+    fun top(): Int {
+        if (isQueuesEmpty()) {
+            throw Exception()
+        }
+        return top!!
+    }
+
+    fun empty(): Boolean {
+        return isQueuesEmpty()
+    }
+
+    private fun isQueuesEmpty(): Boolean {
+        if (queuePair.first.isEmpty() && queuePair.second.isEmpty()) {
+            return true
+        }
+        return false
+    }
+
+    private fun selectSourceAndDestinationQueues(queuePair: Pair<LinkedList<Int>, LinkedList<Int>>):
+        Pair<LinkedList<Int>, LinkedList<Int>> {
+        return if (queuePair.first.isNotEmpty()) {
+            Pair(queuePair.first, queuePair.second)
+        } else {
+            Pair(queuePair.second, queuePair.first)
+        }
+    }
+}
+
+/*
+ * Your MyStack object will be instantiated and called as such:
+ * var obj = MyStack()
+ * obj.push(x)
+ * var param_2 = obj.pop()
+ * var param_3 = obj.top()
+ * var param_4 = obj.empty()
+ */

src/main/kotlin/g0201_0300/s0225_implement_stack_using_queues/readme.md

@@ -0,0 +1,40 @@
+225\. Implement Stack using Queues
+
+Easy
+
+Implement a last-in-first-out (LIFO) stack using only two queues. The implemented stack should support all the functions of a normal stack (`push`, `top`, `pop`, and `empty`).
+
+Implement the `MyStack` class:
+
+*   `void push(int x)` Pushes element x to the top of the stack.
+*   `int pop()` Removes the element on the top of the stack and returns it.
+*   `int top()` Returns the element on the top of the stack.
+*   `boolean empty()` Returns `true` if the stack is empty, `false` otherwise.
+
+**Notes:**
+
+*   You must use **only** standard operations of a queue, which means that only `push to back`, `peek/pop from front`, `size` and `is empty` operations are valid.
+*   Depending on your language, the queue may not be supported natively. You may simulate a queue using a list or deque (double-ended queue) as long as you use only a queue's standard operations.
+
+**Example 1:**
+
+**Input** ["MyStack", "push", "push", "top", "pop", "empty"] [[], [1], [2], [], [], []]
+
+**Output:** [null, null, null, 2, 2, false]
+
+**Explanation:**
+
+    MyStack myStack = new MyStack();
+    myStack.push(1);
+    myStack.push(2);
+    myStack.top(); // return 2
+    myStack.pop(); // return 2
+    myStack.empty(); // return False 
+
+**Constraints:**
+
+*   `1 <= x <= 9`
+*   At most `100` calls will be made to `push`, `pop`, `top`, and `empty`.
+*   All the calls to `pop` and `top` are valid.
+
+**Follow-up:** Can you implement the stack using only one queue?

src/main/kotlin/g0201_0300/s0227_basic_calculator_ii/Solution.kt

@@ -0,0 +1,39 @@
+package g0201_0300.s0227_basic_calculator_ii
+
+// #Medium #Top_Interview_Questions #String #Math #Stack #Level_2_Day_18_Stack
+// #2022_10_26_Time_383_ms_(62.50%)_Space_39.5_MB_(83.33%)
+
+class Solution {
+    fun calculate(s: String): Int {
+        var sum = 0
+        var tempSum = 0
+        var num = 0
+        var lastSign = '+'
+        for (i in 0 until s.length) {
+            val c = s[i]
+            if (Character.isDigit(c)) {
+                num = num * 10 + c.code - '0'.code
+            }
+            if (i == s.length - 1 || !Character.isDigit(c) && c != ' ') {
+                when (lastSign) {
+                    '+' -> {
+                        sum += tempSum
+                        tempSum = num
+                    }
+                    '-' -> {
+                        sum += tempSum
+                        tempSum = -num
+                    }
+                    '*' -> tempSum *= num
+                    '/' -> if (num != 0) {
+                        tempSum /= num
+                    }
+                }
+                lastSign = c
+                num = 0
+            }
+        }
+        sum += tempSum
+        return sum
+    }
+}

src/main/kotlin/g0201_0300/s0227_basic_calculator_ii/readme.md

@@ -0,0 +1,37 @@
+227\. Basic Calculator II
+
+Medium
+
+Given a string `s` which represents an expression, _evaluate this expression and return its value_.
+
+The integer division should truncate toward zero.
+
+You may assume that the given expression is always valid. All intermediate results will be in the range of <code>[-2<sup>31</sup>, 2<sup>31</sup> - 1]</code>.
+
+**Note:** You are not allowed to use any built-in function which evaluates strings as mathematical expressions, such as `eval()`.
+
+**Example 1:**
+
+**Input:** s = "3+2\*2"
+
+**Output:** 7
+
+**Example 2:**
+
+**Input:** s = " 3/2 "
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** s = " 3+5 / 2 "
+
+**Output:** 5
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 3 * 10<sup>5</sup></code>
+*   `s` consists of integers and operators `('+', '-', '*', '/')` separated by some number of spaces.
+*   `s` represents **a valid expression**.
+*   All the integers in the expression are non-negative integers in the range <code>[0, 2<sup>31</sup> - 1]</code>.
+*   The answer is **guaranteed** to fit in a **32-bit integer**.

src/main/kotlin/g0201_0300/s0228_summary_ranges/Solution.kt

@@ -0,0 +1,53 @@
+package g0201_0300.s0228_summary_ranges
+
+// #Easy #Array #2022_10_26_Time_169_ms_(91.89%)_Space_34_MB_(95.95%)
+
+class Solution {
+    fun summaryRanges(nums: IntArray): List<String> {
+        val ranges: MutableList<String> = ArrayList()
+        if (nums.size == 0) {
+            return ranges
+        }
+        // size of array
+        val n = nums.size
+        // start of range
+        var a = nums[0]
+        // end of range
+        var b = a
+        val strB = StringBuilder()
+        for (i in 1 until n) {
+            // we need to make a decision if the next element
+            // will expand the range
+            // i starts at 1, not 0, because 1 is the next
+            // candidate for expanding the range
+            if (nums[i] != b + 1) {
+                // only when our next element does not expand the range
+                // do we add the range a->b to our list of ranges
+                strB.append(a)
+                if (a != b) {
+                    strB.append("->").append(b)
+                }
+                ranges.add(strB.toString())
+                // since nums[i] is not accounted for by our range a->b
+                // because nums[i] is not b+1, we need to set a and b
+                // to this new range start point of bigger than b+1
+                // maybe it is b+2? b+3? b+4? all we know is it is not b+1
+                a = nums[i]
+                b = a
+                // Reset string builder
+                strB.setLength(0)
+            } else {
+                // if the next element expands our range we do so
+                b++
+            }
+        }
+        // the only range that is not accounted for at this point is the last range
+        // if our a and b are not equal then we add the range accordingly
+        strB.append(a)
+        if (a != b) {
+            strB.append("->").append(b)
+        }
+        ranges.add(strB.toString())
+        return ranges
+    }
+}

src/main/kotlin/g0201_0300/s0228_summary_ranges/readme.md

@@ -0,0 +1,53 @@
+228\. Summary Ranges
+
+Easy
+
+You are given a **sorted unique** integer array `nums`.
+
+Return _the **smallest sorted** list of ranges that **cover all the numbers in the array exactly**_. That is, each element of `nums` is covered by exactly one of the ranges, and there is no integer `x` such that `x` is in one of the ranges but not in `nums`.
+
+Each range `[a,b]` in the list should be output as:
+
+*   `"a->b"` if `a != b`
+*   `"a"` if `a == b`
+
+**Example 1:**
+
+**Input:** nums = [0,1,2,4,5,7]
+
+**Output:** ["0->2","4->5","7"]
+
+**Explanation:** The ranges are: [0,2] --> "0->2" [4,5] --> "4->5" [7,7] --> "7"
+
+**Example 2:**
+
+**Input:** nums = [0,2,3,4,6,8,9]
+
+**Output:** ["0","2->4","6","8->9"]
+
+**Explanation:** The ranges are: [0,0] --> "0" [2,4] --> "2->4" [6,6] --> "6" [8,9] --> "8->9"
+
+**Example 3:**
+
+**Input:** nums = []
+
+**Output:** []
+
+**Example 4:**
+
+**Input:** nums = [-1]
+
+**Output:** ["-1"]
+
+**Example 5:**
+
+**Input:** nums = [0]
+
+**Output:** ["0"]
+
+**Constraints:**
+
+*   `0 <= nums.length <= 20`
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   All the values of `nums` are **unique**.
+*   `nums` is sorted in ascending order.

src/main/kotlin/g0201_0300/s0229_majority_element_ii/Solution.kt

@@ -0,0 +1,48 @@
+package g0201_0300.s0229_majority_element_ii
+
+// #Medium #Array #Hash_Table #Sorting #Counting
+// #2022_10_26_Time_408_ms_(71.21%)_Space_47.7_MB_(60.61%)
+
+class Solution {
+    fun majorityElement(nums: IntArray): List<Int> {
+        val results: MutableList<Int> = ArrayList()
+        val len = nums.size
+        var first = 0
+        var second = 1
+        var count1 = 0
+        var count2 = 0
+        for (temp in nums) {
+            if (temp == first) {
+                count1++
+            } else if (temp == second) {
+                count2++
+            } else if (count1 == 0) {
+                first = temp
+                count1++
+            } else if (count2 == 0) {
+                second = temp
+                count2++
+            } else {
+                count1--
+                count2--
+            }
+        }
+        count1 = 0
+        count2 = 0
+        for (temp in nums) {
+            if (temp == first) {
+                count1++
+            }
+            if (temp == second) {
+                count2++
+            }
+        }
+        if (count1 > len / 3) {
+            results.add(first)
+        }
+        if (count2 > len / 3) {
+            results.add(second)
+        }
+        return results
+    }
+}