Added tasks 4-22

Author: javadev

src/main/scala/g0001_0100/s0004_median_of_two_sorted_arrays/Solution.scala

@@ -0,0 +1,41 @@
+package g0001_0100.s0004_median_of_two_sorted_arrays
+
+// #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search #Divide_and_Conquer
+// #Big_O_Time_O(log(min(N,M)))_Space_O(1)
+
+object Solution {
+    @SuppressWarnings(Array("scala:S3776"))
+    def findMedianSortedArrays(nums1: Array[Int], nums2: Array[Int]): Double = {
+        if (nums2.length < nums1.length) {
+            findMedianSortedArrays(nums2, nums1)
+        } else {
+            val n1 = nums1.length
+            val n2 = nums2.length
+            var cut1: Int = 0
+            var cut2: Int = 0
+            var low: Int = 0
+            var high: Int = n1
+
+            while (low <= high) {
+                cut1 = (low + high) / 2
+                cut2 = (n1 + n2 + 1) / 2 - cut1
+                val l1 = if (cut1 == 0) Int.MinValue else nums1(cut1 - 1)
+                val l2 = if (cut2 == 0) Int.MinValue else nums2(cut2 - 1)
+                val r1 = if (cut1 == n1) Int.MaxValue else nums1(cut1)
+                val r2 = if (cut2 == n2) Int.MaxValue else nums2(cut2)
+
+                if (l1 <= r2 && l2 <= r1) {
+                    if ((n1 + n2) % 2 == 0) {
+                        return (math.max(l1, l2) + math.min(r1, r2)) / 2.0
+                    }
+                    return math.max(l1, l2)
+                } else if (l1 > r2) {
+                    high = cut1 - 1
+                } else {
+                    low = cut1 + 1
+                }
+            }
+            0.0
+        }
+    }
+}

src/main/scala/g0001_0100/s0004_median_of_two_sorted_arrays/readme.md

@@ -0,0 +1,50 @@
+4\. Median of Two Sorted Arrays
+
+Hard
+
+Given two sorted arrays `nums1` and `nums2` of size `m` and `n` respectively, return **the median** of the two sorted arrays.
+
+The overall run time complexity should be `O(log (m+n))`.
+
+**Example 1:**
+
+**Input:** nums1 = [1,3], nums2 = [2]
+
+**Output:** 2.00000
+
+**Explanation:** merged array = [1,2,3] and median is 2. 
+
+**Example 2:**
+
+**Input:** nums1 = [1,2], nums2 = [3,4]
+
+**Output:** 2.50000
+
+**Explanation:** merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. 
+
+**Example 3:**
+
+**Input:** nums1 = [0,0], nums2 = [0,0]
+
+**Output:** 0.00000 
+
+**Example 4:**
+
+**Input:** nums1 = [], nums2 = [1]
+
+**Output:** 1.00000 
+
+**Example 5:**
+
+**Input:** nums1 = [2], nums2 = []
+
+**Output:** 2.00000 
+
+**Constraints:**
+
+*   `nums1.length == m`
+*   `nums2.length == n`
+*   `0 <= m <= 1000`
+*   `0 <= n <= 1000`
+*   `1 <= m + n <= 2000`
+*   <code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code>

src/main/scala/g0001_0100/s0005_longest_palindromic_substring/Solution.scala

@@ -0,0 +1,48 @@
+package g0001_0100.s0005_longest_palindromic_substring
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming
+// #Data_Structure_II_Day_9_String #Algorithm_II_Day_14_Dynamic_Programming
+// #Dynamic_Programming_I_Day_17 #Udemy_Strings #Big_O_Time_O(n)_Space_O(n)
+
+object Solution {
+    def longestPalindrome(s: String): String = {
+        val newStr = new Array[Char](s.length * 2 + 1)
+        newStr(0) = '#'
+        for (i <- 0 until s.length) {
+            newStr(2 * i + 1) = s.charAt(i)
+            newStr(2 * i + 2) = '#'
+        }
+
+        val dp = new Array[Int](newStr.length)
+        var friendCenter = 0
+        var friendRadius = 0
+        var lpsCenter = 0
+        var lpsRadius = 0
+
+        for (i <- 0 until newStr.length) {
+            dp(i) =
+                if (friendCenter + friendRadius > i)
+                    Math.min(dp(friendCenter * 2 - i), (friendCenter + friendRadius) - i)
+                else
+                    1
+
+            while (i + dp(i) < newStr.length
+                && i - dp(i) >= 0
+                && newStr(i + dp(i)) == newStr(i - dp(i))) {
+                dp(i) += 1
+            }
+
+            if (friendCenter + friendRadius < i + dp(i)) {
+                friendCenter = i
+                friendRadius = dp(i)
+            }
+
+            if (lpsRadius < dp(i)) {
+                lpsCenter = i
+                lpsRadius = dp(i)
+            }
+        }
+
+        s.substring((lpsCenter - lpsRadius + 1) / 2, (lpsCenter + lpsRadius - 1) / 2)
+    }
+}

src/main/scala/g0001_0100/s0005_longest_palindromic_substring/readme.md

@@ -0,0 +1,34 @@
+5\. Longest Palindromic Substring
+
+Medium
+
+Given a string `s`, return _the longest palindromic substring_ in `s`.
+
+**Example 1:**
+
+**Input:** s = "babad"
+
+**Output:** "bab" **Note:** "aba" is also a valid answer. 
+
+**Example 2:**
+
+**Input:** s = "cbbd"
+
+**Output:** "bb" 
+
+**Example 3:**
+
+**Input:** s = "a"
+
+**Output:** "a" 
+
+**Example 4:**
+
+**Input:** s = "ac"
+
+**Output:** "a" 
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s` consist of only digits and English letters.

src/main/scala/g0001_0100/s0010_regular_expression_matching/Solution.scala

@@ -0,0 +1,31 @@
+package g0001_0100.s0010_regular_expression_matching
+
+// #Hard #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming #Recursion
+// #Udemy_Dynamic_Programming #Big_O_Time_O(m*n)_Space_O(m*n)
+
+object Solution {
+    private var cache: Array[Array[Option[Boolean]]] = Array.ofDim[Option[Boolean]](0, 0)
+
+    def isMatch(s: String, p: String): Boolean = {
+        cache = Array.ofDim[Option[Boolean]](s.length + 1, p.length + 1)
+        isMatch(s, p, 0, 0)
+    }
+
+    private def isMatch(s: String, p: String, i: Int, j: Int): Boolean = {
+        if (j == p.length) {
+            return i == s.length
+        }
+        var result: Boolean = false
+        if (cache(i).isDefinedAt(j) && cache(i)(j) != null) {
+            return cache(i)(j).get
+        }
+        val firstMatch = i < s.length && (s.charAt(i) == p.charAt(j) || p.charAt(j) == '.')
+        if (j + 1 < p.length && p.charAt(j + 1) == '*') {
+            result = (firstMatch && isMatch(s, p, i + 1, j)) || isMatch(s, p, i, j + 2)
+        } else {
+            result = firstMatch && isMatch(s, p, i + 1, j + 1)
+        }
+        cache(i)(j) = Some(result)
+        result
+    }
+}

src/main/scala/g0001_0100/s0010_regular_expression_matching/readme.md

@@ -0,0 +1,56 @@
+10\. Regular Expression Matching
+
+Hard
+
+Given an input string `s` and a pattern `p`, implement regular expression matching with support for `'.'` and `'*'` where:
+
+*   `'.'` Matches any single character.
+*   `'*'` Matches zero or more of the preceding element.
+
+The matching should cover the **entire** input string (not partial).
+
+**Example 1:**
+
+**Input:** s = "aa", p = "a"
+
+**Output:** false
+
+**Explanation:** "a" does not match the entire string "aa". 
+
+**Example 2:**
+
+**Input:** s = "aa", p = "a\*"
+
+**Output:** true
+
+**Explanation:** '\*' means zero or more of the preceding element, 'a'. Therefore, by repeating 'a' once, it becomes "aa". 
+
+**Example 3:**
+
+**Input:** s = "ab", p = ".\*"
+
+**Output:** true
+
+**Explanation:** ".\*" means "zero or more (\*) of any character (.)". 
+
+**Example 4:**
+
+**Input:** s = "aab", p = "c\*a\*b"
+
+**Output:** true
+
+**Explanation:** c can be repeated 0 times, a can be repeated 1 time. Therefore, it matches "aab". 
+
+**Example 5:**
+
+**Input:** s = "mississippi", p = "mis\*is\*p\*."
+
+**Output:** false 
+
+**Constraints:**
+
+*   `1 <= s.length <= 20`
+*   `1 <= p.length <= 30`
+*   `s` contains only lowercase English letters.
+*   `p` contains only lowercase English letters, `'.'`, and `'*'`.
+*   It is guaranteed for each appearance of the character `'*'`, there will be a previous valid character to match.

src/main/scala/g0001_0100/s0011_container_with_most_water/Solution.scala

@@ -0,0 +1,24 @@
+package g0001_0100.s0011_container_with_most_water
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Greedy #Two_Pointers
+// #Algorithm_II_Day_4_Two_Pointers #Big_O_Time_O(n)_Space_O(1)
+
+object Solution {
+    def maxArea(height: Array[Int]): Int = {
+        var maxArea = -1
+        var left = 0
+        var right = height.length - 1
+
+        while (left < right) {
+            if (height(left) < height(right)) {
+                maxArea = maxArea.max(height(left) * (right - left))
+                left += 1
+            } else {
+                maxArea = maxArea.max(height(right) * (right - left))
+                right -= 1
+            }
+        }
+
+        maxArea
+    }
+}

src/main/scala/g0001_0100/s0011_container_with_most_water/readme.md

@@ -0,0 +1,41 @@
+11\. Container With Most Water
+
+Medium
+
+Given `n` non-negative integers <code>a<sub>1</sub>, a<sub>2</sub>, ..., a<sub>n</sub></code> , where each represents a point at coordinate <code>(i, a<sub>i</sub>)</code>. `n` vertical lines are drawn such that the two endpoints of the line `i` is at <code>(i, a<sub>i</sub>)</code> and `(i, 0)`. Find two lines, which, together with the x-axis forms a container, such that the container contains the most water.
+
+**Notice** that you may not slant the container.
+
+**Example 1:**
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/07/17/question_11.jpg)
+
+**Input:** height = [1,8,6,2,5,4,8,3,7]
+
+**Output:** 49
+
+**Explanation:** The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49. 
+
+**Example 2:**
+
+**Input:** height = [1,1]
+
+**Output:** 1 
+
+**Example 3:**
+
+**Input:** height = [4,3,2,1,4]
+
+**Output:** 16 
+
+**Example 4:**
+
+**Input:** height = [1,2,1]
+
+**Output:** 2 
+
+**Constraints:**
+
+*   `n == height.length`
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= height[i] <= 10<sup>4</sup></code>

src/main/scala/g0001_0100/s0015_3sum/Solution.scala

@@ -0,0 +1,36 @@
+package g0001_0100.s0015_3sum
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Sorting #Two_Pointers
+// #Data_Structure_II_Day_1_Array #Algorithm_II_Day_3_Two_Pointers #Udemy_Two_Pointers
+// #Big_O_Time_O(n*log(n))_Space_O(n^2) #2023_10_29_Time_701_ms_(98.81%)_Space_66.7_MB_(88.10%)
+
+object Solution {
+    @SuppressWarnings(Array("scala:S3776"))
+    def threeSum(nums: Array[Int]): List[List[Int]] = {
+        val sortedNums = nums.sorted
+        var result: List[List[Int]] = List()
+        for (i <- 0 until sortedNums.length - 2) {
+            if (i == 0 || (i > 0 && sortedNums(i) != sortedNums(i - 1))) {
+                var left = i + 1
+                var right = sortedNums.length - 1
+                val target = -sortedNums(i)
+                while (left < right) {
+                    if (sortedNums(left) + sortedNums(right) == target) {
+                        result = List(sortedNums(i), sortedNums(left), sortedNums(right)) :: result
+                        while (left < right && sortedNums(left) == sortedNums(left + 1))
+                            left += 1
+                        while (left < right && sortedNums(right) == sortedNums(right - 1))
+                            right -= 1
+
+                        left += 1
+                        right -= 1
+                    } else if (sortedNums(left) + sortedNums(right) < target)
+                        left += 1
+                    else
+                        right -= 1
+                }
+            }
+        }
+        result
+    }
+}