Added tasks 231, 232, 233, 235.

Author: ThanhNIT

README.md

@@ -420,6 +420,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0232 |[Implement Queue using Stacks](src/main/kotlin/g0201_0300/s0232_implement_queue_using_stacks/MyQueue.kt)| Easy | Stack, Design, Queue | 258 | 70.86
 | 0217 |[Contains Duplicate](src/main/kotlin/g0201_0300/s0217_contains_duplicate/Solution.kt)| Easy | Top_Interview_Questions, Array, Hash_Table, Sorting | 719 | 73.49
 
 #### Day 12 Class and Object
@@ -727,6 +728,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0098 |[Validate Binary Search Tree](src/main/kotlin/g0001_0100/s0098_validate_binary_search_tree/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 330 | 41.38
+| 0235 |[Lowest Common Ancestor of a Binary Search Tree](src/main/kotlin/g0201_0300/s0235_lowest_common_ancestor_of_a_binary_search_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 404 | 75.59
 
 #### Day 9 Graph/BFS/DFS
 
@@ -878,6 +880,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0232 |[Implement Queue using Stacks](src/main/kotlin/g0201_0300/s0232_implement_queue_using_stacks/MyQueue.kt)| Easy | Stack, Design, Queue | 258 | 70.86
 | 0155 |[Min Stack](src/main/kotlin/g0101_0200/s0155_min_stack/MinStack.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Stack, Design | 331 | 84.88
 | 0208 |[Implement Trie (Prefix Tree)](src/main/kotlin/g0201_0300/s0208_implement_trie_prefix_tree/Trie.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Design, Trie | 689 | 61.00
 
@@ -1143,6 +1146,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0020 |[Valid Parentheses](src/main/kotlin/g0001_0100/s0020_valid_parentheses/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, String, Stack | 226 | 72.53
+| 0232 |[Implement Queue using Stacks](src/main/kotlin/g0201_0300/s0232_implement_queue_using_stacks/MyQueue.kt)| Easy | Stack, Design, Queue | 258 | 70.86
 
 #### Day 10 Tree
 
@@ -1177,6 +1181,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0098 |[Validate Binary Search Tree](src/main/kotlin/g0001_0100/s0098_validate_binary_search_tree/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 330 | 41.38
+| 0235 |[Lowest Common Ancestor of a Binary Search Tree](src/main/kotlin/g0201_0300/s0235_lowest_common_ancestor_of_a_binary_search_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 404 | 75.59
 
 ### Data Structure II
 
@@ -1400,6 +1405,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0231 |[Power of Two](src/main/kotlin/g0201_0300/s0231_power_of_two/Solution.kt)| Easy | Math, Bit_Manipulation, Recursion | 161 | 86.81
 | 0191 |[Number of 1 Bits](src/main/kotlin/g0101_0200/s0191_number_of_1_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation | 237 | 68.44
 
 #### Day 14 Bit Manipulation
@@ -1580,7 +1586,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 0239 |[Sliding Window Maximum](src/main/kotlin/g0201_0300/s0239_sliding_window_maximum/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Heap_Priority_Queue, Sliding_Window, Queue, Monotonic_Queue, Udemy_Arrays | 1059 | 86.14
 | 0238 |[Product of Array Except Self](src/main/kotlin/g0201_0300/s0238_product_of_array_except_self/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Prefix_Sum, Data_Structure_II_Day_5_Array, Udemy_Arrays | 669 | 48.96
 | 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
+| 0235 |[Lowest Common Ancestor of a Binary Search Tree](src/main/kotlin/g0201_0300/s0235_lowest_common_ancestor_of_a_binary_search_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_I_Day_14_Tree, Level_1_Day_8_Binary_Search_Tree | 404 | 75.59
 | 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
+| 0233 |[Number of Digit One](src/main/kotlin/g0201_0300/s0233_number_of_digit_one/Solution.kt)| Hard | Dynamic_Programming, Math, Recursion | 129 | 100.00
+| 0232 |[Implement Queue using Stacks](src/main/kotlin/g0201_0300/s0232_implement_queue_using_stacks/MyQueue.kt)| Easy | Stack, Design, Queue, Data_Structure_I_Day_9_Stack_Queue, Programming_Skills_I_Day_11_Containers_and_Libraries, Level_2_Day_16_Design | 258 | 70.86
+| 0231 |[Power of Two](src/main/kotlin/g0201_0300/s0231_power_of_two/Solution.kt)| Easy | Math, Bit_Manipulation, Recursion, Algorithm_I_Day_13_Bit_Manipulation | 161 | 86.81
 | 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

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

@@ -0,0 +1,10 @@
+package g0201_0300.s0231_power_of_two
+
+// #Easy #Math #Bit_Manipulation #Recursion #Algorithm_I_Day_13_Bit_Manipulation
+// #2022_10_26_Time_161_ms_(86.81%)_Space_33.6_MB_(88.19%)
+
+class Solution {
+    fun isPowerOfTwo(n: Int): Boolean {
+        return n > 0 && Integer.bitCount(n) == 1
+    }
+}

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

@@ -0,0 +1,35 @@
+231\. Power of Two
+
+Easy
+
+Given an integer `n`, return _`true` if it is a power of two. Otherwise, return `false`_.
+
+An integer `n` is a power of two, if there exists an integer `x` such that <code>n == 2<sup>x</sup></code>.
+
+**Example 1:**
+
+**Input:** n = 1
+
+**Output:** true
+
+**Explanation:** 2<sup>0</sup> = 1
+
+**Example 2:**
+
+**Input:** n = 16
+
+**Output:** true
+
+**Explanation:** 2<sup>4</sup> = 16
+
+**Example 3:**
+
+**Input:** n = 3
+
+**Output:** false
+
+**Constraints:**
+
+*   <code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code>
+
+**Follow up:** Could you solve it without loops/recursion?

src/main/kotlin/g0201_0300/s0232_implement_queue_using_stacks/MyQueue.kt

@@ -0,0 +1,31 @@
+package g0201_0300.s0232_implement_queue_using_stacks
+
+// #Easy #Stack #Design #Queue #Data_Structure_I_Day_9_Stack_Queue
+// #Programming_Skills_I_Day_11_Containers_and_Libraries #Level_2_Day_16_Design
+// #2022_10_26_Time_258_ms_(70.86%)_Space_36_MB_(58.94%)
+
+import java.util.Deque
+import java.util.LinkedList
+
+class MyQueue() {
+    private val deque: Deque<Int> = LinkedList()
+
+    fun push(x: Int) {
+        deque.add(x)
+    }
+
+    fun pop(): Int = deque.removeFirst()
+
+    fun peek(): Int = deque.first()
+
+    fun empty(): Boolean = deque.isEmpty()
+}
+
+/*
+ * Your MyQueue object will be instantiated and called as such:
+ * var obj = MyQueue()
+ * obj.push(x)
+ * var param_2 = obj.pop()
+ * var param_3 = obj.peek()
+ * var param_4 = obj.empty()
+ */

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

@@ -0,0 +1,45 @@
+232\. Implement Queue using Stacks
+
+Easy
+
+Implement a first in first out (FIFO) queue using only two stacks. The implemented queue should support all the functions of a normal queue (`push`, `peek`, `pop`, and `empty`).
+
+Implement the `MyQueue` class:
+
+*   `void push(int x)` Pushes element x to the back of the queue.
+*   `int pop()` Removes the element from the front of the queue and returns it.
+*   `int peek()` Returns the element at the front of the queue.
+*   `boolean empty()` Returns `true` if the queue is empty, `false` otherwise.
+
+**Notes:**
+
+*   You must use **only** standard operations of a stack, which means only `push to top`, `peek/pop from top`, `size`, and `is empty` operations are valid.
+*   Depending on your language, the stack may not be supported natively. You may simulate a stack using a list or deque (double-ended queue) as long as you use only a stack's standard operations.
+
+**Example 1:**
+
+**Input:**
+
+    ["MyQueue", "push", "push", "peek", "pop", "empty"]
+    [[], [1], [2], [], [], []]
+
+**Output:**
+
+    [null, null, null, 1, 1, false]
+
+**Explanation:**
+
+    MyQueue myQueue = new MyQueue();
+    myQueue.push(1); // queue is: [1]
+    myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
+    myQueue.peek(); // return 1
+    myQueue.pop(); // return 1, queue is [2]
+    myQueue.empty(); // return false 
+
+**Constraints:**
+
+*   `1 <= x <= 9`
+*   At most `100` calls will be made to `push`, `pop`, `peek`, and `empty`.
+*   All the calls to `pop` and `peek` are valid.
+
+**Follow-up:** Can you implement the queue such that each operation is **[amortized](https://en.wikipedia.org/wiki/Amortized_analysis)** `O(1)` time complexity? In other words, performing `n` operations will take overall `O(n)` time even if one of those operations may take longer.

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

@@ -0,0 +1,28 @@
+package g0201_0300.s0233_number_of_digit_one
+
+// #Hard #Dynamic_Programming #Math #Recursion
+// #2022_10_26_Time_129_ms_(100.00%)_Space_32.6_MB_(100.00%)
+
+class Solution {
+    fun countDigitOne(n: Int): Int {
+        var ans = 0
+        var k = n
+        var cum = 0
+        var curr10 = 1
+        while (k > 0) {
+            val rem = k % 10
+            val q = k / 10
+            ans += if (rem == 0) {
+                q * curr10
+            } else if (rem == 1) {
+                q * curr10 + cum + 1
+            } else {
+                (q + 1) * curr10
+            }
+            k = q
+            cum += rem * curr10
+            curr10 *= 10
+        }
+        return ans
+    }
+}

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

@@ -0,0 +1,21 @@
+233\. Number of Digit One
+
+Hard
+
+Given an integer `n`, count _the total number of digit_ `1` _appearing in all non-negative integers less than or equal to_ `n`.
+
+**Example 1:**
+
+**Input:** n = 13
+
+**Output:** 6
+
+**Example 2:**
+
+**Input:** n = 0
+
+**Output:** 0
+
+**Constraints:**
+
+*   <code>0 <= n <= 10<sup>9</sup></code>

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

@@ -0,0 +1,28 @@
+package g0201_0300.s0235_lowest_common_ancestor_of_a_binary_search_tree
+
+// #Easy #Depth_First_Search #Tree #Binary_Tree #Binary_Search_Tree #Data_Structure_I_Day_14_Tree
+// #Level_1_Day_8_Binary_Search_Tree #2022_10_26_Time_404_ms_(75.59%)_Space_46.1_MB_(78.74%)
+
+import com_github_leetcode.TreeNode
+
+/*
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int = 0) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun lowestCommonAncestor(root: TreeNode?, p: TreeNode?, q: TreeNode?): TreeNode? {
+        if (root == null) {
+            return null
+        }
+        if (p!!.`val` < root.`val` && q!!.`val` < root.`val`) {
+            return lowestCommonAncestor(root.left, q, p)
+        }
+        if (p.`val` > root.`val` && q!!.`val` > root.`val`) {
+            return lowestCommonAncestor(root.right, q, p)
+        }
+        return root
+    }
+}

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

@@ -0,0 +1,41 @@
+235\. Lowest Common Ancestor of a Binary Search Tree
+
+Medium
+
+Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.
+
+According to the [definition of LCA on Wikipedia](https://en.wikipedia.org/wiki/Lowest_common_ancestor): “The lowest common ancestor is defined between two nodes `p` and `q` as the lowest node in `T` that has both `p` and `q` as descendants (where we allow **a node to be a descendant of itself**).”
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png)
+
+**Input:** root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
+
+**Output:** 6
+
+**Explanation:** The LCA of nodes 2 and 8 is 6.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png)
+
+**Input:** root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
+
+**Output:** 2
+
+**Explanation:** The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
+
+**Example 3:**
+
+**Input:** root = [2,1], p = 2, q = 1
+
+**Output:** 2
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.
+*   <code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code>
+*   All `Node.val` are **unique**.
+*   `p != q`
+*   `p` and `q` will exist in the BST.

src/test/kotlin/g0201_0300/s0231_power_of_two/SolutionTest.kt

@@ -0,0 +1,32 @@
+package g0201_0300.s0231_power_of_two
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isPowerOfTwo() {
+        assertThat(Solution().isPowerOfTwo(1), equalTo(true))
+    }
+
+    @Test
+    fun isPowerOfTwo2() {
+        assertThat(Solution().isPowerOfTwo(16), equalTo(true))
+    }
+
+    @Test
+    fun isPowerOfTwo3() {
+        assertThat(Solution().isPowerOfTwo(3), equalTo(false))
+    }
+
+    @Test
+    fun isPowerOfTwo4() {
+        assertThat(Solution().isPowerOfTwo(4), equalTo(true))
+    }
+
+    @Test
+    fun isPowerOfTwo5() {
+        assertThat(Solution().isPowerOfTwo(5), equalTo(false))
+    }
+}