Added tasks 153-208

Author: javadev

README.md

@@ -0,0 +1,32 @@
+package g0101_0200.s0153_find_minimum_in_rotated_sorted_array
+
+// #Medium #Top_100_Liked_Questions #Array #Binary_Search #Algorithm_II_Day_2_Binary_Search
+// #Binary_Search_I_Day_12 #Udemy_Binary_Search #Big_O_Time_O(log_N)_Space_O(log_N)
+// #2023_11_05_Time_457_ms_(78.79%)_Space_55.5_MB_(6.06%)
+
+object Solution {
+    def findMin(nums: Array[Int]): Int = {
+        def findMinUtil(l: Int, r: Int): Int = {
+            if (l == r) {
+                nums(l)
+            } else {
+                val mid = (l + r) / 2
+                if (mid == l && nums(mid) < nums(r)) {
+                    nums(l)
+                } else if (mid - 1 >= 0 && nums(mid - 1) > nums(mid)) {
+                    nums(mid)
+                } else if (nums(mid) < nums(l)) {
+                    findMinUtil(l, mid - 1)
+                } else if (nums(mid) > nums(r)) {
+                    findMinUtil(mid + 1, r)
+                } else {
+                    findMinUtil(l, mid - 1)
+                }
+            }
+        }
+
+        val l = 0
+        val r = nums.length - 1
+        findMinUtil(l, r)
+    }
+}

src/main/scala/g0101_0200/s0153_find_minimum_in_rotated_sorted_array/Solution.scala

@@ -0,0 +1,46 @@
+153\. Find Minimum in Rotated Sorted Array
+
+Medium
+
+Suppose an array of length `n` sorted in ascending order is **rotated** between `1` and `n` times. For example, the array `nums = [0,1,2,4,5,6,7]` might become:
+
+*   `[4,5,6,7,0,1,2]` if it was rotated `4` times.
+*   `[0,1,2,4,5,6,7]` if it was rotated `7` times.
+
+Notice that **rotating** an array `[a[0], a[1], a[2], ..., a[n-1]]` 1 time results in the array `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]`.
+
+Given the sorted rotated array `nums` of **unique** elements, return _the minimum element of this array_.
+
+You must write an algorithm that runs in `O(log n) time.`
+
+**Example 1:**
+
+**Input:** nums = [3,4,5,1,2]
+
+**Output:** 1
+
+**Explanation:** The original array was [1,2,3,4,5] rotated 3 times. 
+
+**Example 2:**
+
+**Input:** nums = [4,5,6,7,0,1,2]
+
+**Output:** 0
+
+**Explanation:** The original array was [0,1,2,4,5,6,7] and it was rotated 4 times. 
+
+**Example 3:**
+
+**Input:** nums = [11,13,15,17]
+
+**Output:** 11
+
+**Explanation:** The original array was [11,13,15,17] and it was rotated 4 times. 
+
+**Constraints:**
+
+*   `n == nums.length`
+*   `1 <= n <= 5000`
+*   `-5000 <= nums[i] <= 5000`
+*   All the integers of `nums` are **unique**.
+*   `nums` is sorted and rotated between `1` and `n` times.

src/main/scala/g0101_0200/s0153_find_minimum_in_rotated_sorted_array/readme.md

@@ -0,0 +1,42 @@
+package g0101_0200.s0155_min_stack
+
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Stack #Design
+// #Data_Structure_II_Day_14_Stack_Queue #Programming_Skills_II_Day_18 #Level_2_Day_16_Design
+// #Udemy_Design #Big_O_Time_O(1)_Space_O(N)
+// #2023_11_05_Time_566_ms_(90.91%)_Space_60.6_MB_(84.85%)
+
+class MinStack {
+    private class Node(var min: Int, var data: Int, var previousNode: Node, var nextNode: Node)
+
+    private var currentNode: Node = _
+
+    def push(`val`: Int): Unit = {
+        if (currentNode == null) {
+            currentNode = new Node(`val`, `val`, null, null)
+        } else {
+            currentNode.nextNode = new Node(Math.min(currentNode.min, `val`), `val`, currentNode, null)
+            currentNode = currentNode.nextNode
+        }
+    }
+
+    def pop(): Unit = {
+        currentNode = currentNode.previousNode
+    }
+
+    def top(): Int = {
+        currentNode.data
+    }
+
+    def getMin(): Int = {
+        currentNode.min
+    }
+}
+
+/*
+ * Your MinStack object will be instantiated and called as such:
+ * var obj = new MinStack()
+ * obj.push(`val`)
+ * obj.pop()
+ * var param_3 = obj.top()
+ * var param_4 = obj.getMin()
+ */

src/main/scala/g0101_0200/s0155_min_stack/MinStack.scala

@@ -0,0 +1,39 @@
+155\. Min Stack
+
+Easy
+
+Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
+
+Implement the `MinStack` class:
+
+*   `MinStack()` initializes the stack object.
+*   `void push(int val)` pushes the element `val` onto the stack.
+*   `void pop()` removes the element on the top of the stack.
+*   `int top()` gets the top element of the stack.
+*   `int getMin()` retrieves the minimum element in the stack.
+
+**Example 1:**
+
+**Input**
+
+    ["MinStack","push","push","push","getMin","pop","top","getMin"]
+    [[],[-2],[0],[-3],[],[],[],[]]
+
+**Output:** [null,null,null,null,-3,null,0,-2]
+
+**Explanation:**
+
+    MinStack minStack = new MinStack();
+    minStack.push(-2);
+    minStack.push(0);
+    minStack.push(-3);
+    minStack.getMin(); // return -3
+    minStack.pop();
+    minStack.top(); // return 0
+    minStack.getMin(); // return -2 
+
+**Constraints:**
+
+*   <code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code>
+*   Methods `pop`, `top` and `getMin` operations will always be called on **non-empty** stacks.
+*   At most <code>3 * 10<sup>4</sup></code> calls will be made to `push`, `pop`, `top`, and `getMin`.

src/main/scala/g0101_0200/s0155_min_stack/readme.md

@@ -0,0 +1,28 @@
+package g0101_0200.s0160_intersection_of_two_linked_lists
+
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Hash_Table #Two_Pointers #Linked_List
+// #Data_Structure_II_Day_11_Linked_List #Udemy_Linked_List #Big_O_Time_O(M+N)_Space_O(1)
+// #2023_11_05_Time_564_ms_(96.43%)_Space_59.1_MB_(10.71%)
+
+import com_github_leetcode.ListNode
+
+/*
+ * Definition for singly-linked list.
+ * class ListNode(var _x: Int = 0) {
+ *   var next: ListNode = null
+ *   var x: Int = _x
+ * }
+ */
+object Solution {
+    def getIntersectionNode(headA: ListNode, headB: ListNode): ListNode = {
+        var node1 = headA
+        var node2 = headB
+
+        while (node1 != node2) {
+            node1 = if (node1 == null) headB else node1.next
+            node2 = if (node2 == null) headA else node2.next
+        }
+
+        node1
+    }
+}

src/main/scala/g0101_0200/s0160_intersection_of_two_linked_lists/Solution.scala

@@ -0,0 +1,68 @@
+160\. Intersection of Two Linked Lists
+
+Easy
+
+Given the heads of two singly linked-lists `headA` and `headB`, return _the node at which the two lists intersect_. If the two linked lists have no intersection at all, return `null`.
+
+For example, the following two linked lists begin to intersect at node `c1`:
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_statement.png)
+
+The test cases are generated such that there are no cycles anywhere in the entire linked structure.
+
+**Note** that the linked lists must **retain their original structure** after the function returns.
+
+**Custom Judge:**
+
+The inputs to the **judge** are given as follows (your program is **not** given these inputs):
+
+*   `intersectVal` - The value of the node where the intersection occurs. This is `0` if there is no intersected node.
+*   `listA` - The first linked list.
+*   `listB` - The second linked list.
+*   `skipA` - The number of nodes to skip ahead in `listA` (starting from the head) to get to the intersected node.
+*   `skipB` - The number of nodes to skip ahead in `listB` (starting from the head) to get to the intersected node.
+
+The judge will then create the linked structure based on these inputs and pass the two heads, `headA` and `headB` to your program. If you correctly return the intersected node, then your solution will be **accepted**.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_example_1_1.png)
+
+**Input:** intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
+
+**Output:** Intersected at '8'
+
+**Explanation:** The intersected node's value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,6,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_example_2.png)
+
+**Input:** intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+
+**Output:** Intersected at '2'
+
+**Explanation:** The intersected node's value is 2 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [1,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B. 
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/03/05/160_example_3.png)
+
+**Input:** intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+
+**Output:** No intersection
+
+**Explanation:** From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values. Explanation: The two lists do not intersect, so return null. 
+
+**Constraints:**
+
+*   The number of nodes of `listA` is in the `m`.
+*   The number of nodes of `listB` is in the `n`.
+*   <code>0 <= m, n <= 3 * 10<sup>4</sup></code>
+*   <code>1 <= Node.val <= 10<sup>5</sup></code>
+*   `0 <= skipA <= m`
+*   `0 <= skipB <= n`
+*   `intersectVal` is `0` if `listA` and `listB` do not intersect.
+*   `intersectVal == listA[skipA] == listB[skipB]` if `listA` and `listB` intersect.
+
+**Follow up:** Could you write a solution that runs in `O(n)` time and use only `O(1)` memory?

src/main/scala/g0101_0200/s0160_intersection_of_two_linked_lists/readme.md

@@ -0,0 +1,39 @@
+package g0101_0200.s0169_majority_element
+
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table #Sorting #Counting
+// #Divide_and_Conquer #Data_Structure_II_Day_1_Array #Udemy_Famous_Algorithm
+// #Big_O_Time_O(n)_Space_O(1) #2023_11_05_Time_538_ms_(92.57%)_Space_59.7_MB_(52.70%)
+
+object Solution {
+    def majorityElement(nums: Array[Int]): Int = {
+        var count = 1
+        var majority = nums(0)
+
+        // For Potential Majority Element
+        for (i <- 1 until nums.length) {
+            if (nums(i) == majority) {
+                count += 1
+            } else {
+                if (count > 1) {
+                    count -= 1
+                } else {
+                    majority = nums(i)
+                }
+            }
+        }
+
+        // For Confirmation
+        count = 0
+        for (j <- nums) {
+            if (j == majority) {
+                count += 1
+            }
+        }
+
+        if (count >= (nums.length / 2) + 1) {
+            majority
+        } else {
+            -1
+        }
+    }
+}

src/main/scala/g0101_0200/s0169_majority_element/Solution.scala

@@ -0,0 +1,27 @@
+169\. Majority Element
+
+Easy
+
+Given an array `nums` of size `n`, return _the majority element_.
+
+The majority element is the element that appears more than `⌊n / 2⌋` times. You may assume that the majority element always exists in the array.
+
+**Example 1:**
+
+**Input:** nums = [3,2,3]
+
+**Output:** 3 
+
+**Example 2:**
+
+**Input:** nums = [2,2,1,1,1,2,2]
+
+**Output:** 2 
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 5 * 10<sup>4</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+
+**Follow-up:** Could you solve the problem in linear time and in `O(1)` space?

src/main/scala/g0101_0200/s0169_majority_element/readme.md

@@ -0,0 +1,27 @@
+package g0101_0200.s0189_rotate_array
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Math #Two_Pointers
+// #Algorithm_I_Day_2_Two_Pointers #Udemy_Arrays #Big_O_Time_O(n)_Space_O(1)
+// #2023_11_05_Time_600_ms_(96.59%)_Space_73.7_MB_(17.05%)
+
+object Solution {
+    private def reverse(nums: Array[Int], l: Int, r: Int): Unit = {
+        var left = l
+        var right = r
+        while (left <= right) {
+            val temp = nums(left)
+            nums(left) = nums(right)
+            nums(right) = temp
+            left += 1
+            right -= 1
+        }
+    }
+
+    def rotate(nums: Array[Int], k: Int): Unit = {
+        val n = nums.length
+        val t = n - (k % n)
+        reverse(nums, 0, t - 1)
+        reverse(nums, t, n - 1)
+        reverse(nums, 0, n - 1)
+    }
+}