Added tasks 215-283

Author: javadev

README.md

@@ -0,0 +1,15 @@
+package g0201_0300.s0215_kth_largest_element_in_an_array
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Sorting #Heap_Priority_Queue
+// #Divide_and_Conquer #Quickselect #Data_Structure_II_Day_20_Heap_Priority_Queue
+// #Big_O_Time_O(n*log(n))_Space_O(log(n)) #2023_11_07_Time_799_ms_(95.45%)_Space_77.8_MB_(62.12%)
+
+import scala.util.Sorting
+
+object Solution {
+    def findKthLargest(nums: Array[Int], k: Int): Int = {
+        val n = nums.length
+        Sorting.quickSort(nums)
+        nums(n - k)
+    }
+}

src/main/scala/g0201_0300/s0215_kth_largest_element_in_an_array/Solution.scala

@@ -0,0 +1,24 @@
+215\. Kth Largest Element in an Array
+
+Medium
+
+Given an integer array `nums` and an integer `k`, return _the_ <code>k<sup>th</sup></code> _largest element in the array_.
+
+Note that it is the <code>k<sup>th</sup></code> largest element in the sorted order, not the <code>k<sup>th</sup></code> distinct element.
+
+**Example 1:**
+
+**Input:** nums = [3,2,1,5,6,4], k = 2
+
+**Output:** 5 
+
+**Example 2:**
+
+**Input:** nums = [3,2,3,1,2,4,5,5,6], k = 4
+
+**Output:** 4 
+
+**Constraints:**
+
+*   <code>1 <= k <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>

src/main/scala/g0201_0300/s0215_kth_largest_element_in_an_array/readme.md

@@ -0,0 +1,35 @@
+package g0201_0300.s0221_maximal_square
+
+// #Medium #Top_100_Liked_Questions #Array #Dynamic_Programming #Matrix
+// #Dynamic_Programming_I_Day_16 #Big_O_Time_O(m*n)_Space_O(m*n)
+// #2023_11_07_Time_626_ms_(100.00%)_Space_65.3_MB_(100.00%)
+
+object Solution {
+    def maximalSquare(matrix: Array[Array[Char]]): Int = {
+        val m = matrix.length
+        if (m == 0) {
+            return 0
+        }
+        val n = matrix(0).length
+        if (n == 0) {
+            return 0
+        }
+
+        val dp = Array.ofDim[Int](m + 1, n + 1)
+        var max = 0
+
+        for (i <- 0 until m) {
+            for (j <- 0 until n) {
+                if (matrix(i)(j) == '1') {
+                    val next = 1 + Math.min(dp(i)(j), Math.min(dp(i + 1)(j), dp(i)(j + 1)))
+                    if (next > max) {
+                        max = next
+                    }
+                    dp(i + 1)(j + 1) = next
+                }
+            }
+        }
+
+        max * max
+    }
+}

src/main/scala/g0201_0300/s0221_maximal_square/Solution.scala

@@ -0,0 +1,34 @@
+221\. Maximal Square
+
+Medium
+
+Given an `m x n` binary `matrix` filled with `0`'s and `1`'s, _find the largest square containing only_ `1`'s _and return its area_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/max1grid.jpg)
+
+**Input:** matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
+
+**Output:** 4 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/max2grid.jpg)
+
+**Input:** matrix = [["0","1"],["1","0"]]
+
+**Output:** 1 
+
+**Example 3:**
+
+**Input:** matrix = [["0"]]
+
+**Output:** 0 
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `1 <= m, n <= 300`
+*   `matrix[i][j]` is `'0'` or `'1'`.

src/main/scala/g0201_0300/s0221_maximal_square/readme.md

@@ -0,0 +1,27 @@
+package g0201_0300.s0226_invert_binary_tree
+
+// #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
+// #Big_O_Time_O(n)_Space_O(n) #2023_11_07_Time_421_ms_(97.33%)_Space_58.9_MB_(6.67%)
+
+import com_github_leetcode.TreeNode
+
+/*
+ * Definition for a binary tree node.
+ * class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null) {
+ *   var value: Int = _value
+ *   var left: TreeNode = _left
+ *   var right: TreeNode = _right
+ * }
+ */
+object Solution {
+    def invertTree(root: TreeNode): TreeNode = {
+        if (root == null) {
+            return null
+        }
+        val temp = root.left
+        root.left = invertTree(root.right)
+        root.right = invertTree(temp)
+        root
+    }
+}

src/main/scala/g0201_0300/s0226_invert_binary_tree/Solution.scala

@@ -0,0 +1,32 @@
+226\. Invert Binary Tree
+
+Easy
+
+Given the `root` of a binary tree, invert the tree, and return _its root_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg)
+
+**Input:** root = [4,2,7,1,3,6,9]
+
+**Output:** [4,7,2,9,6,3,1] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/14/invert2-tree.jpg)
+
+**Input:** root = [2,1,3]
+
+**Output:** [2,3,1] 
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 100]`.
+*   `-100 <= Node.val <= 100`

src/main/scala/g0201_0300/s0226_invert_binary_tree/readme.md

@@ -0,0 +1,30 @@
+package g0201_0300.s0230_kth_smallest_element_in_a_bst
+
+// #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
+// #Big_O_Time_O(n)_Space_O(n) #2023_11_07_Time_503_ms_(91.30%)_Space_57.9_MB_(60.87%)
+
+import com_github_leetcode.TreeNode
+
+object Solution {
+    var index = 0
+    var value = -1
+
+    def kthSmallest(root: TreeNode, k: Int): Int = {
+        index = 0
+        value = -1
+        if (root == null) -1
+        else inorder(root, k)
+        value
+    }
+
+    // Using In order
+    def inorder(root: TreeNode, k: Int): Unit = {
+        if (root != null && index < k) {
+            inorder(root.left, k)
+            index += 1
+            if (index == k) value = root.value
+            inorder(root.right, k)
+        }
+    }
+}

src/main/scala/g0201_0300/s0230_kth_smallest_element_in_a_bst/Solution.scala

@@ -0,0 +1,29 @@
+230\. Kth Smallest Element in a BST
+
+Medium
+
+Given the `root` of a binary search tree, and an integer `k`, return _the_ <code>k<sup>th</sup></code> _smallest value (**1-indexed**) of all the values of the nodes in the tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/28/kthtree1.jpg)
+
+**Input:** root = [3,1,4,null,2], k = 1
+
+**Output:** 1 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/28/kthtree2.jpg)
+
+**Input:** root = [5,3,6,2,4,null,null,1], k = 3
+
+**Output:** 3 
+
+**Constraints:**
+
+*   The number of nodes in the tree is `n`.
+*   <code>1 <= k <= n <= 10<sup>4</sup></code>
+*   <code>0 <= Node.val <= 10<sup>4</sup></code>
+
+**Follow up:** If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the kth smallest frequently, how would you optimize?

src/main/scala/g0201_0300/s0230_kth_smallest_element_in_a_bst/readme.md

@@ -0,0 +1,54 @@
+package g0201_0300.s0234_palindrome_linked_list
+
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Two_Pointers #Stack #Linked_List
+// #Recursion #Level_2_Day_3_Linked_List #Udemy_Linked_List #Big_O_Time_O(n)_Space_O(1)
+// #2023_11_07_Time_811_ms_(85.71%)_Space_67.7_MB_(78.57%)
+
+import com_github_leetcode.ListNode
+
+/*
+ * Definition for singly-linked list.
+ * class ListNode(_x: Int = 0, _next: ListNode = null) {
+ *   var next: ListNode = _next
+ *   var x: Int = _x
+ * }
+ */
+object Solution {
+    def isPalindrome(head: ListNode): Boolean = {
+        var len = 0
+        var right = head
+
+        // Calculate the length
+        while (right != null) {
+            right = right.next
+            len += 1
+        }
+
+        // Reverse the right half of the list
+        len = len / 2
+        right = head
+        for (_ <- 0 until len) {
+            right = right.next
+        }
+
+        var prev: ListNode = null
+        while (right != null) {
+            val next = right.next
+            right.next = prev
+            prev = right
+            right = next
+        }
+        var head2 = head
+        // Compare left half and right half
+        for (_ <- 0 until len) {
+            if (prev != null && head2.x == prev.x) {
+                head2 = head2.next
+                prev = prev.next
+            } else {
+                return false
+            }
+        }
+
+        true
+    }
+}