May-12

Author: geemaple

README.md

@@ -0,0 +1,47 @@
+//  Tag: Array
+//  Time: O(N)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+//  Video: https://youtu.be/23ecGZB559Y
+
+//  Given an integer array arr, return true if there are three consecutive odd numbers in the array. Otherwise, return false.
+//   
+//  Example 1:
+//  
+//  Input: arr = [2,6,4,1]
+//  Output: false
+//  Explanation: There are no three consecutive odds.
+//  
+//  Example 2:
+//  
+//  Input: arr = [1,2,34,3,4,5,7,23,12]
+//  Output: true
+//  Explanation: [5,7,23] are three consecutive odds.
+//  
+//   
+//  Constraints:
+//  
+//  1 <= arr.length <= 1000
+//  1 <= arr[i] <= 1000
+//  
+//  
+
+class Solution {
+public:
+    bool threeConsecutiveOdds(vector<int>& arr) {
+        int count = 0;
+        for (auto &x: arr) {
+            if (x % 2 == 1) {
+                count += 1;
+            } else {
+                count = 0;
+            }
+
+            if (count == 3) {
+                return true;
+            }
+        }
+        return false;
+    }
+};

leetcode/1550.three-consecutive-odds.cpp

@@ -0,0 +1,42 @@
+#  Tag: Array
+#  Time: O(N)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+#  Video: https://youtu.be/23ecGZB559Y
+
+#  Given an integer array arr, return true if there are three consecutive odd numbers in the array. Otherwise, return false.
+#   
+#  Example 1:
+#  
+#  Input: arr = [2,6,4,1]
+#  Output: false
+#  Explanation: There are no three consecutive odds.
+#  
+#  Example 2:
+#  
+#  Input: arr = [1,2,34,3,4,5,7,23,12]
+#  Output: true
+#  Explanation: [5,7,23] are three consecutive odds.
+#  
+#   
+#  Constraints:
+#  
+#  1 <= arr.length <= 1000
+#  1 <= arr[i] <= 1000
+#  
+#  
+
+class Solution:
+    def threeConsecutiveOdds(self, arr: List[int]) -> bool:
+        count = 0
+        for x in arr:
+            if x % 2 == 1:
+                count += 1
+            else:
+                count = 0
+
+            if count == 3:
+                return True
+
+        return False

leetcode/1550.three-consecutive-odds.py

@@ -0,0 +1,70 @@
+//  Tag: Array, Two Pointers, Binary Search, Stack, Monotonic Stack
+//  Time: O(N)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+
+//  Given an integer array arr, remove a subarray (can be empty) from arr such that the remaining elements in arr are non-decreasing.
+//  Return the length of the shortest subarray to remove.
+//  A subarray is a contiguous subsequence of the array.
+//   
+//  Example 1:
+//  
+//  Input: arr = [1,2,3,10,4,2,3,5]
+//  Output: 3
+//  Explanation: The shortest subarray we can remove is [10,4,2] of length 3. The remaining elements after that will be [1,2,3,3,5] which are sorted.
+//  Another correct solution is to remove the subarray [3,10,4].
+//  
+//  Example 2:
+//  
+//  Input: arr = [5,4,3,2,1]
+//  Output: 4
+//  Explanation: Since the array is strictly decreasing, we can only keep a single element. Therefore we need to remove a subarray of length 4, either [5,4,3,2] or [4,3,2,1].
+//  
+//  Example 3:
+//  
+//  Input: arr = [1,2,3]
+//  Output: 0
+//  Explanation: The array is already non-decreasing. We do not need to remove any elements.
+//  
+//   
+//  Constraints:
+//  
+//  1 <= arr.length <= 105
+//  0 <= arr[i] <= 109
+//  
+//  
+
+class Solution {
+public:
+    int findLengthOfShortestSubarray(vector<int>& arr) {
+        int n = arr.size();
+        int l = 0;
+        int r = n - 1;
+        while (l < r && arr[l] <= arr[l + 1]) {
+            l += 1;
+        }
+
+        while (l < r && arr[r] >= arr[r - 1]) {
+            r -= 1;
+        }
+
+        if (l >= r) {
+            return 0;
+        }
+
+        int res = min(n - l - 1, r);
+        int i = 0;
+        int j = r;
+        while (i <= l && j <= n - 1) {
+            if (arr[i] <= arr[j]) {
+                res = min(res, j - i - 1);
+                i += 1;
+            } else {
+                j += 1;
+            }
+        }
+
+        return res;
+    }
+};

leetcode/1574.shortest-subarray-to-be-removed-to-make-array-sorted.cpp

@@ -0,0 +1,63 @@
+#  Tag: Array, Two Pointers, Binary Search, Stack, Monotonic Stack
+#  Time: O(N)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+
+#  Given an integer array arr, remove a subarray (can be empty) from arr such that the remaining elements in arr are non-decreasing.
+#  Return the length of the shortest subarray to remove.
+#  A subarray is a contiguous subsequence of the array.
+#   
+#  Example 1:
+#  
+#  Input: arr = [1,2,3,10,4,2,3,5]
+#  Output: 3
+#  Explanation: The shortest subarray we can remove is [10,4,2] of length 3. The remaining elements after that will be [1,2,3,3,5] which are sorted.
+#  Another correct solution is to remove the subarray [3,10,4].
+#  
+#  Example 2:
+#  
+#  Input: arr = [5,4,3,2,1]
+#  Output: 4
+#  Explanation: Since the array is strictly decreasing, we can only keep a single element. Therefore we need to remove a subarray of length 4, either [5,4,3,2] or [4,3,2,1].
+#  
+#  Example 3:
+#  
+#  Input: arr = [1,2,3]
+#  Output: 0
+#  Explanation: The array is already non-decreasing. We do not need to remove any elements.
+#  
+#   
+#  Constraints:
+#  
+#  1 <= arr.length <= 105
+#  0 <= arr[i] <= 109
+#  
+#  
+
+class Solution:
+    def findLengthOfShortestSubarray(self, arr: List[int]) -> int:
+        n = len(arr)
+        l = 0
+        r = n - 1
+
+        while l < r and arr[l] <= arr[l + 1]:
+            l += 1
+
+        while l < r and arr[r] >= arr[r - 1]:
+            r -= 1
+
+        if l >= r:
+            return 0
+
+        res = min(n - l - 1, r)
+        i = 0
+        j = r
+        while i <= l and j <= n - 1:
+            if arr[i] <= arr[j]:
+                res = min(res, j - i - 1)
+                i += 1
+            else:
+                j += 1
+
+        return res

leetcode/1574.shortest-subarray-to-be-removed-to-make-array-sorted.py

@@ -0,0 +1,76 @@
+//  Tag: Array, Hash Table, Sorting, Enumeration
+//  Time: O(1)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+//  Video: https://youtu.be/J_ODVpvGvUg
+
+//  You are given an integer array digits, where each element is a digit. The array may contain duplicates.
+//  You need to find all the unique integers that follow the given requirements:
+//  
+//  The integer consists of the concatenation of three elements from digits in any arbitrary order.
+//  The integer does not have leading zeros.
+//  The integer is even.
+//  
+//  For example, if the given digits were [1, 2, 3], integers 132 and 312 follow the requirements.
+//  Return a sorted array of the unique integers.
+//   
+//  Example 1:
+//  
+//  Input: digits = [2,1,3,0]
+//  Output: [102,120,130,132,210,230,302,310,312,320]
+//  Explanation: All the possible integers that follow the requirements are in the output array. 
+//  Notice that there are no odd integers or integers with leading zeros.
+//  
+//  Example 2:
+//  
+//  Input: digits = [2,2,8,8,2]
+//  Output: [222,228,282,288,822,828,882]
+//  Explanation: The same digit can be used as many times as it appears in digits. 
+//  In this example, the digit 8 is used twice each time in 288, 828, and 882. 
+//  
+//  Example 3:
+//  
+//  Input: digits = [3,7,5]
+//  Output: []
+//  Explanation: No even integers can be formed using the given digits.
+//  
+//   
+//  Constraints:
+//  
+//  3 <= digits.length <= 100
+//  0 <= digits[i] <= 9
+//  
+//  
+
+class Solution {
+public:
+    vector<int> findEvenNumbers(vector<int>& digits) {
+        vector<int> counter(10, 0);
+        for (auto &x: digits) {
+            counter[x] += 1;
+        }
+
+        vector<int> res;
+        helper(0, 0, res, counter);
+        return res;
+    }
+
+    void helper(int i, int ans, vector<int> &res, vector<int> &counter) {
+        if (i == 3) {
+            res.push_back(ans);
+            return;
+        }
+
+        for (int d = 0; d <= 9; d++) {
+            if ((i == 0 && d == 0) || (i == 2 && d % 2 == 1) || counter[d] == 0) {
+                continue;
+            }
+
+            counter[d] -= 1;
+            helper(i + 1, ans * 10 + d, res, counter);
+            counter[d] += 1;
+        }
+
+    }
+};

leetcode/2094.finding-3-digit-even-numbers.cpp

@@ -0,0 +1,66 @@
+#  Tag: Array, Hash Table, Sorting, Enumeration
+#  Time: O(1)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+#  Video: https://youtu.be/J_ODVpvGvUg
+
+#  You are given an integer array digits, where each element is a digit. The array may contain duplicates.
+#  You need to find all the unique integers that follow the given requirements:
+#  
+#  The integer consists of the concatenation of three elements from digits in any arbitrary order.
+#  The integer does not have leading zeros.
+#  The integer is even.
+#  
+#  For example, if the given digits were [1, 2, 3], integers 132 and 312 follow the requirements.
+#  Return a sorted array of the unique integers.
+#   
+#  Example 1:
+#  
+#  Input: digits = [2,1,3,0]
+#  Output: [102,120,130,132,210,230,302,310,312,320]
+#  Explanation: All the possible integers that follow the requirements are in the output array. 
+#  Notice that there are no odd integers or integers with leading zeros.
+#  
+#  Example 2:
+#  
+#  Input: digits = [2,2,8,8,2]
+#  Output: [222,228,282,288,822,828,882]
+#  Explanation: The same digit can be used as many times as it appears in digits. 
+#  In this example, the digit 8 is used twice each time in 288, 828, and 882. 
+#  
+#  Example 3:
+#  
+#  Input: digits = [3,7,5]
+#  Output: []
+#  Explanation: No even integers can be formed using the given digits.
+#  
+#   
+#  Constraints:
+#  
+#  3 <= digits.length <= 100
+#  0 <= digits[i] <= 9
+#  
+#  
+
+from collections import Counter
+class Solution:
+    def findEvenNumbers(self, digits: List[int]) -> List[int]:
+        n = len(digits)
+        counter = Counter(digits)
+        res = []
+        self.helper(0, counter, 0, res)
+        return res
+
+    def helper(self, i: int, counter: dict, ans: int, res: list):
+        if i == 3:
+            res.append(ans)
+            return
+
+        for d in range(0, 10):
+            if (i == 0 and d == 0) or (i == 2 and d % 2 == 1) or counter[d] == 0:
+                continue
+
+            counter[d] -= 1
+            self.helper(i + 1, counter, ans * 10 + d, res)
+            counter[d] += 1

leetcode/2094.finding-3-digit-even-numbers.py

@@ -140,7 +140,7 @@
 121. https://www.lintcode.com/problem/merge-operations-to-turn-array-into-a-palindrome/
 122. https://www.lintcode.com/problem/3sum-smaller/
 
-- https://leetcode.com/problems/shortest-subarray-to-be-removed-to-make-array-sorted/
+123. https://leetcode.com/problems/shortest-subarray-to-be-removed-to-make-array-sorted/ +Mark
 - https://leetcode.com/problems/count-the-number-of-incremovable-subarrays-ii/
 - https://leetcode.com/problems/recover-the-original-array/
 - https://leetcode.com/problems/minimize-connected-groups-by-inserting-interval/