Apr-14

Author: geemaple

README.md

@@ -0,0 +1,57 @@
+//  Tag: Array, Hash Table, Math, Sliding Window, Prefix Sum
+//  Time: O(N)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+
+//  Given an array of integers nums and an integer k. A continuous subarray is called nice if there are k odd numbers on it.
+//  Return the number of nice sub-arrays.
+//   
+//  Example 1:
+//  
+//  Input: nums = [1,1,2,1,1], k = 3
+//  Output: 2
+//  Explanation: The only sub-arrays with 3 odd numbers are [1,1,2,1] and [1,2,1,1].
+//  
+//  Example 2:
+//  
+//  Input: nums = [2,4,6], k = 1
+//  Output: 0
+//  Explanation: There are no odd numbers in the array.
+//  
+//  Example 3:
+//  
+//  Input: nums = [2,2,2,1,2,2,1,2,2,2], k = 2
+//  Output: 16
+//  
+//   
+//  Constraints:
+//  
+//  1 <= nums.length <= 50000
+//  1 <= nums[i] <= 10^5
+//  1 <= k <= nums.length
+//  
+//  
+
+class Solution {
+public:
+    int numberOfSubarrays(vector<int>& nums, int k) {
+        return count(nums, k) - count(nums, k - 1);
+    }
+
+    int count(vector<int>& nums, int k) {
+        int n = nums.size();
+        int i = 0;
+        int odd = 0;
+        int res = 0;
+        for (int j = 0; j < n; j++) {
+            odd += nums[j] % 2;
+            while (i <= j && odd > k) {
+                odd -= nums[i] % 2;
+                i += 1;
+            }
+            res += j - i + 1;
+        }
+        return res;
+    }
+};

leetcode/1248.count-number-of-nice-subarrays.cpp

@@ -0,0 +1,51 @@
+#  Tag: Array, Hash Table, Math, Sliding Window, Prefix Sum
+#  Time: O(N)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+
+#  Given an array of integers nums and an integer k. A continuous subarray is called nice if there are k odd numbers on it.
+#  Return the number of nice sub-arrays.
+#   
+#  Example 1:
+#  
+#  Input: nums = [1,1,2,1,1], k = 3
+#  Output: 2
+#  Explanation: The only sub-arrays with 3 odd numbers are [1,1,2,1] and [1,2,1,1].
+#  
+#  Example 2:
+#  
+#  Input: nums = [2,4,6], k = 1
+#  Output: 0
+#  Explanation: There are no odd numbers in the array.
+#  
+#  Example 3:
+#  
+#  Input: nums = [2,2,2,1,2,2,1,2,2,2], k = 2
+#  Output: 16
+#  
+#   
+#  Constraints:
+#  
+#  1 <= nums.length <= 50000
+#  1 <= nums[i] <= 10^5
+#  1 <= k <= nums.length
+#  
+#  
+
+class Solution:
+    def numberOfSubarrays(self, nums: List[int], k: int) -> int:
+        return self.count(nums, k) - self.count(nums, k - 1)
+
+    def count(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        res = 0
+        i = 0
+        odd = 0
+        for j in range(n):
+            odd += nums[j] % 2
+            while i <= j and odd > k:
+                odd -= nums[i] % 2
+                i += 1
+            res += j - i + 1
+        return res

leetcode/1248.count-number-of-nice-subarrays.py

@@ -0,0 +1,55 @@
+//  Tag: Array, Enumeration
+//  Time: O(N^3)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+//  Video: https://youtu.be/cNpiisOiQ1o
+
+//  Given an array of integers arr, and three integers a, b and c. You need to find the number of good triplets.
+//  A triplet (arr[i], arr[j], arr[k]) is good if the following conditions are true:
+//  
+//  0 <= i < j < k < arr.length
+//  |arr[i] - arr[j]| <= a
+//  |arr[j] - arr[k]| <= b
+//  |arr[i] - arr[k]| <= c
+//  
+//  Where |x| denotes the absolute value of x.
+//  Return the number of good triplets.
+//   
+//  Example 1:
+//  
+//  Input: arr = [3,0,1,1,9,7], a = 7, b = 2, c = 3
+//  Output: 4
+//  Explanation: There are 4 good triplets: [(3,0,1), (3,0,1), (3,1,1), (0,1,1)].
+//  
+//  Example 2:
+//  
+//  Input: arr = [1,1,2,2,3], a = 0, b = 0, c = 1
+//  Output: 0
+//  Explanation: No triplet satisfies all conditions.
+//  
+//   
+//  Constraints:
+//  
+//  3 <= arr.length <= 100
+//  0 <= arr[i] <= 1000
+//  0 <= a, b, c <= 1000
+//  
+
+class Solution {
+public:
+    int countGoodTriplets(vector<int>& arr, int a, int b, int c) {
+        int n = arr.size();
+        int res = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                for (int k = j + 1; k < n; k++) {
+                    if (abs(arr[i] - arr[j]) <= a && abs(arr[j] - arr[k]) <= b && abs(arr[i] - arr[k]) <= c) {
+                        res += 1;
+                    }
+                }
+            }
+        }
+        return res;
+    }
+};

leetcode/1534.count-good-triplets.cpp

@@ -0,0 +1,49 @@
+#  Tag: Array, Enumeration
+#  Time: O(N^3)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+#  Video: https://youtu.be/cNpiisOiQ1o
+
+#  Given an array of integers arr, and three integers a, b and c. You need to find the number of good triplets.
+#  A triplet (arr[i], arr[j], arr[k]) is good if the following conditions are true:
+#  
+#  0 <= i < j < k < arr.length
+#  |arr[i] - arr[j]| <= a
+#  |arr[j] - arr[k]| <= b
+#  |arr[i] - arr[k]| <= c
+#  
+#  Where |x| denotes the absolute value of x.
+#  Return the number of good triplets.
+#   
+#  Example 1:
+#  
+#  Input: arr = [3,0,1,1,9,7], a = 7, b = 2, c = 3
+#  Output: 4
+#  Explanation: There are 4 good triplets: [(3,0,1), (3,0,1), (3,1,1), (0,1,1)].
+#  
+#  Example 2:
+#  
+#  Input: arr = [1,1,2,2,3], a = 0, b = 0, c = 1
+#  Output: 0
+#  Explanation: No triplet satisfies all conditions.
+#  
+#   
+#  Constraints:
+#  
+#  3 <= arr.length <= 100
+#  0 <= arr[i] <= 1000
+#  0 <= a, b, c <= 1000
+#  
+
+class Solution:
+    def countGoodTriplets(self, arr: List[int], a: int, b: int, c: int) -> int:
+        n = len(arr)
+        res = 0
+        for i in range(n):
+            for j in range(i + 1, n):
+                for k in range(j + 1, n):
+                    if abs(arr[i] - arr[j]) <= a and abs(arr[j] - arr[k]) <= b and abs(arr[i] - arr[k]) <= c:
+                        res += 1
+
+        return res

leetcode/1534.count-good-triplets.py

@@ -43,6 +43,46 @@
 //  
 //  
 
+class Solution {
+public:
+    long long countOfSubstrings(string word, int k) {
+        return count(word, k) - count(word, k + 1);
+    }
+
+    long long count(string &word, int k) {
+        int n = word.size();
+        unordered_map<char, int> vowel;
+        int count = 0;
+        long long res = 0;
+        int i = 0;
+        for (int j = 0; j < n; j++) {
+            if (is_consonant(word[j])) {
+                vowel[word[j]] += 1;
+            } else {
+                count += 1;
+            }
+
+            while (vowel.size() == 5 && count >= k) {
+                res += n - j;
+                if (is_consonant(word[i])) {
+                    vowel[word[i]] -= 1;
+                    if (vowel[word[i]] == 0) {
+                        vowel.erase(word[i]);
+                    }
+                } else {
+                    count -= 1;
+                }
+                i += 1;
+            }
+        }
+        return res;
+    }
+
+    bool is_consonant(char ch) {
+        return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
+    }
+};
+
 class Solution {
 public:
     long long countOfSubstrings(string word, int k) {

leetcode/3306.count-of-substrings-containing-every-vowel-and-k-consonants-ii.cpp

@@ -43,6 +43,35 @@
 #  
 #  
 
+from collections import defaultdict
+class Solution:
+    def countOfSubstrings(self, word: str, k: int) -> int:
+        return self.count(word, k) - self.count(word, k + 1)
+
+    def count(self, word: str, k: int) -> int:
+        n = len(word)
+        vowel = defaultdict(int)
+        count = 0
+        i = 0
+        res = 0
+        for j in range(n):
+            if word[j] in 'aeiou':
+                vowel[word[j]] += 1
+            else:
+                count += 1
+
+            while len(vowel) == 5 and count >= k:
+                res += n - j
+                if word[i] in 'aeiou':
+                    vowel[word[i]] -= 1
+                    if vowel[word[i]] == 0:
+                        del vowel[word[i]]
+                else:
+                    count -= 1
+                i += 1
+                
+        return res
+
 from collections import defaultdict
 class Solution:
     def countOfSubstrings(self, word: str, k: int) -> int:

leetcode/3306.count-of-substrings-containing-every-vowel-and-k-consonants-ii.py

@@ -0,0 +1,58 @@
+//  Tag: Array, Hash Table, Sliding Window, Counting
+//  Time: O(N)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+
+//  Given an integer array nums and an integer k, return the number of good subarrays of nums.
+//  A good array is an array where the number of different integers in that array is exactly k.
+//  
+//  For example, [1,2,3,1,2] has 3 different integers: 1, 2, and 3.
+//  
+//  A subarray is a contiguous part of an array.
+//   
+//  Example 1:
+//  
+//  Input: nums = [1,2,1,2,3], k = 2
+//  Output: 7
+//  Explanation: Subarrays formed with exactly 2 different integers: [1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2]
+//  
+//  Example 2:
+//  
+//  Input: nums = [1,2,1,3,4], k = 3
+//  Output: 3
+//  Explanation: Subarrays formed with exactly 3 different integers: [1,2,1,3], [2,1,3], [1,3,4].
+//  
+//   
+//  Constraints:
+//  
+//  1 <= nums.length <= 2 * 104
+//  1 <= nums[i], k <= nums.length
+//  
+//  
+
+class Solution {
+public:
+    int subarraysWithKDistinct(vector<int>& nums, int k) {
+        return count(nums, k) - count(nums, k + 1);
+    }
+
+    int count(vector<int>& nums, int k) {
+        int n = nums.size();
+        int i = 0;
+        int res = 0;
+        unordered_map<int, int> counter;
+        for (int j = 0; j < n; j++) {
+            counter[nums[j]] += 1;
+            while (counter.size() >= k) {
+                res += n - j;
+                counter[nums[i]] -= 1;
+                if (counter[nums[i]] == 0) {
+                    counter.erase(nums[i]);
+                }
+                i += 1;
+            }
+        }
+        return res;
+    }
+};