Mar-9

Author: geemaple

README.md

@@ -0,0 +1,79 @@
+//  Tag: Array, Hash Table, Binary Search, Sliding Window
+//  Time: O(NlogN)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+
+//  You are given an integer array nums. In one operation, you can replace any element in nums with any integer.
+//  nums is considered continuous if both of the following conditions are fulfilled:
+//  
+//  All elements in nums are unique.
+//  The difference between the maximum element and the minimum element in nums equals nums.length - 1.
+//  
+//  For example, nums = [4, 2, 5, 3] is continuous, but nums = [1, 2, 3, 5, 6] is not continuous.
+//  Return the minimum number of operations to make nums continuous.
+//   
+//  Example 1:
+//  
+//  Input: nums = [4,2,5,3]
+//  Output: 0
+//  Explanation: nums is already continuous.
+//  
+//  Example 2:
+//  
+//  Input: nums = [1,2,3,5,6]
+//  Output: 1
+//  Explanation: One possible solution is to change the last element to 4.
+//  The resulting array is [1,2,3,5,4], which is continuous.
+//  
+//  Example 3:
+//  
+//  Input: nums = [1,10,100,1000]
+//  Output: 3
+//  Explanation: One possible solution is to:
+//  - Change the second element to 2.
+//  - Change the third element to 3.
+//  - Change the fourth element to 4.
+//  The resulting array is [1,2,3,4], which is continuous.
+//  
+//   
+//  Constraints:
+//  
+//  1 <= nums.length <= 105
+//  1 <= nums[i] <= 109
+//  
+//  
+
+class Solution {
+public:
+    int minOperations(vector<int>& nums) {
+        int n = nums.size();
+        sort(nums.begin(), nums.end());
+        nums.erase(unique(nums.begin(), nums.end()), nums.end());
+        int res = n;
+        for (int i = 0, j = 0; i < nums.size(); i++) {
+            while (j < nums.size() && nums[j] < nums[i] + n) {
+                int unique = j - i + 1;
+                res = min(res, n - unique);
+                j += 1;
+            }
+        }
+        return res;
+    }
+};
+
+class Solution {
+public:
+    int minOperations(vector<int>& nums) {
+        int n = nums.size();
+        sort(nums.begin(), nums.end());
+        nums.erase(unique(nums.begin(), nums.end()), nums.end());
+        int res = n;
+        for (int i = 0; i < nums.size(); i++) {
+            int j = upper_bound(nums.begin(), nums.end(), nums[i] + n - 1) - nums.begin();
+            int unique = j - i;
+            res = min(res, n - unique);
+        }
+        return res;
+    }
+};

leetcode/2009.minimum-number-of-operations-to-make-array-continuous.cpp

@@ -0,0 +1,73 @@
+#  Tag: Array, Hash Table, Binary Search, Sliding Window
+#  Time: O(NlogN)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+
+#  You are given an integer array nums. In one operation, you can replace any element in nums with any integer.
+#  nums is considered continuous if both of the following conditions are fulfilled:
+#  
+#  All elements in nums are unique.
+#  The difference between the maximum element and the minimum element in nums equals nums.length - 1.
+#  
+#  For example, nums = [4, 2, 5, 3] is continuous, but nums = [1, 2, 3, 5, 6] is not continuous.
+#  Return the minimum number of operations to make nums continuous.
+#   
+#  Example 1:
+#  
+#  Input: nums = [4,2,5,3]
+#  Output: 0
+#  Explanation: nums is already continuous.
+#  
+#  Example 2:
+#  
+#  Input: nums = [1,2,3,5,6]
+#  Output: 1
+#  Explanation: One possible solution is to change the last element to 4.
+#  The resulting array is [1,2,3,5,4], which is continuous.
+#  
+#  Example 3:
+#  
+#  Input: nums = [1,10,100,1000]
+#  Output: 3
+#  Explanation: One possible solution is to:
+#  - Change the second element to 2.
+#  - Change the third element to 3.
+#  - Change the fourth element to 4.
+#  The resulting array is [1,2,3,4], which is continuous.
+#  
+#   
+#  Constraints:
+#  
+#  1 <= nums.length <= 105
+#  1 <= nums[i] <= 109
+#  
+#  
+
+class Solution:
+    def minOperations(self, nums: List[int]) -> int:
+        n = len(nums)
+        nums = sorted(set(nums))
+        res = n
+        j = 0
+        for i in range(len(nums)):
+            while j < len(nums) and nums[j] < nums[i] + n:
+                unique = j - i + 1
+                res = min(res, n - unique)     
+                j += 1       
+
+        return res
+
+import bisect
+class Solution:
+    def minOperations(self, nums: List[int]) -> int:
+        n = len(nums)
+        nums = sorted(set(nums))
+        res = n
+
+        for i in range(len(nums)):
+            j = bisect.bisect_right(nums, nums[i] + n - 1)
+            unique = j - i
+            res = min(res, n - unique)
+
+        return res

leetcode/2009.minimum-number-of-operations-to-make-array-continuous.py

@@ -0,0 +1,56 @@
+//  Tag: Array, Binary Search, Sliding Window, Dynamic Programming
+//  Time: O(N)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+
+//  There are some prizes on the X-axis. You are given an integer array prizePositions that is sorted in non-decreasing order, where prizePositions[i] is the position of the ith prize. There could be different prizes at the same position on the line. You are also given an integer k.
+//  You are allowed to select two segments with integer endpoints. The length of each segment must be k. You will collect all prizes whose position falls within at least one of the two selected segments (including the endpoints of the segments). The two selected segments may intersect.
+//  
+//  For example if k = 2, you can choose segments [1, 3] and [2, 4], and you will win any prize i that satisfies 1 <= prizePositions[i] <= 3 or 2 <= prizePositions[i] <= 4.
+//  
+//  Return the maximum number of prizes you can win if you choose the two segments optimally.
+//   
+//  Example 1:
+//  
+//  Input: prizePositions = [1,1,2,2,3,3,5], k = 2
+//  Output: 7
+//  Explanation: In this example, you can win all 7 prizes by selecting two segments [1, 3] and [3, 5].
+//  
+//  Example 2:
+//  
+//  Input: prizePositions = [1,2,3,4], k = 0
+//  Output: 2
+//  Explanation: For this example, one choice for the segments is [3, 3] and [4, 4], and you will be able to get 2 prizes. 
+//  
+//   
+//  Constraints:
+//  
+//  1 <= prizePositions.length <= 105
+//  1 <= prizePositions[i] <= 109
+//  0 <= k <= 109 
+//  prizePositions is sorted in non-decreasing order.
+//  
+//   
+//  
+//  
+
+class Solution {
+public:
+    int maximizeWin(vector<int>& prizePositions, int k) {
+        int n = prizePositions.size();
+        vector<int> dp(n + 1, 0);
+        int res = 0;
+        int i = 0;
+        for (int j = 0; j < n; j++) {
+            while (prizePositions[j] - prizePositions[i] > k) {
+                i += 1;
+            }
+            
+            dp[j + 1] = max(dp[j], j - i + 1);
+            res = max(res, j - i + 1 + dp[i]);
+        }
+       
+        return res;
+    }
+};

leetcode/2555.maximize-win-from-two-segments.cpp

@@ -0,0 +1,51 @@
+#  Tag: Array, Binary Search, Sliding Window, Dynamic Programming
+#  Time: O(N)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+
+#  There are some prizes on the X-axis. You are given an integer array prizePositions that is sorted in non-decreasing order, where prizePositions[i] is the position of the ith prize. There could be different prizes at the same position on the line. You are also given an integer k.
+#  You are allowed to select two segments with integer endpoints. The length of each segment must be k. You will collect all prizes whose position falls within at least one of the two selected segments (including the endpoints of the segments). The two selected segments may intersect.
+#  
+#  For example if k = 2, you can choose segments [1, 3] and [2, 4], and you will win any prize i that satisfies 1 <= prizePositions[i] <= 3 or 2 <= prizePositions[i] <= 4.
+#  
+#  Return the maximum number of prizes you can win if you choose the two segments optimally.
+#   
+#  Example 1:
+#  
+#  Input: prizePositions = [1,1,2,2,3,3,5], k = 2
+#  Output: 7
+#  Explanation: In this example, you can win all 7 prizes by selecting two segments [1, 3] and [3, 5].
+#  
+#  Example 2:
+#  
+#  Input: prizePositions = [1,2,3,4], k = 0
+#  Output: 2
+#  Explanation: For this example, one choice for the segments is [3, 3] and [4, 4], and you will be able to get 2 prizes. 
+#  
+#   
+#  Constraints:
+#  
+#  1 <= prizePositions.length <= 105
+#  1 <= prizePositions[i] <= 109
+#  0 <= k <= 109 
+#  prizePositions is sorted in non-decreasing order.
+#  
+#   
+#  
+#  
+
+class Solution:
+    def maximizeWin(self, prizePositions: List[int], k: int) -> int:
+        n = len(prizePositions)
+        dp = [0 for i in range(n + 1)]
+        i = 0
+        res = 0
+        for j in range(n):
+            while prizePositions[j] - prizePositions[i] > k:
+                i += 1
+
+            dp[j + 1] = max(dp[j], j - i + 1)
+            res = max(res, j - i + 1 + dp[i])
+
+        return res

leetcode/2555.maximize-win-from-two-segments.py

@@ -0,0 +1,59 @@
+//  Tag: Array, Sliding Window
+//  Time: O(N)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+
+//  There is a circle of red and blue tiles. You are given an array of integers colors. The color of tile i is represented by colors[i]:
+//  
+//  colors[i] == 0 means that tile i is red.
+//  colors[i] == 1 means that tile i is blue.
+//  
+//  Every 3 contiguous tiles in the circle with alternating colors (the middle tile has a different color from its left and right tiles) is called an alternating group.
+//  Return the number of alternating groups.
+//  Note that since colors represents a circle, the first and the last tiles are considered to be next to each other.
+//   
+//  Example 1:
+//  
+//  Input: colors = [1,1,1]
+//  Output: 0
+//  Explanation:
+//  
+//  
+//  Example 2:
+//  
+//  Input: colors = [0,1,0,0,1]
+//  Output: 3
+//  Explanation:
+//  
+//  Alternating groups:
+//  
+//  
+//   
+//  Constraints:
+//  
+//  3 <= colors.length <= 100
+//  0 <= colors[i] <= 1
+//  
+//  
+
+class Solution {
+public:
+    int numberOfAlternatingGroups(vector<int>& colors) {
+        int n = colors.size();
+        int k = 3;
+        int i = 0;
+        int res = 0;
+        for (int j = 1; i < n; j++) {
+            if (colors[j % n] == colors[(j - 1) % n]) {
+                i = j;
+            }
+
+            if (j - i + 1 == k) {
+                res += 1;
+                i += 1;
+            }
+        }
+        return res;
+    }
+};

leetcode/3206.alternating-groups-i.cpp

@@ -0,0 +1,57 @@
+#  Tag: Array, Sliding Window
+#  Time: O(N)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+
+#  There is a circle of red and blue tiles. You are given an array of integers colors. The color of tile i is represented by colors[i]:
+#  
+#  colors[i] == 0 means that tile i is red.
+#  colors[i] == 1 means that tile i is blue.
+#  
+#  Every 3 contiguous tiles in the circle with alternating colors (the middle tile has a different color from its left and right tiles) is called an alternating group.
+#  Return the number of alternating groups.
+#  Note that since colors represents a circle, the first and the last tiles are considered to be next to each other.
+#   
+#  Example 1:
+#  
+#  Input: colors = [1,1,1]
+#  Output: 0
+#  Explanation:
+#  
+#  
+#  Example 2:
+#  
+#  Input: colors = [0,1,0,0,1]
+#  Output: 3
+#  Explanation:
+#  
+#  Alternating groups:
+#  
+#  
+#   
+#  Constraints:
+#  
+#  3 <= colors.length <= 100
+#  0 <= colors[i] <= 1
+#  
+#  
+
+class Solution:
+    def numberOfAlternatingGroups(self, colors: List[int]) -> int:
+        n = len(colors)
+        k = 3
+        i = 0
+        j = 1
+        res = 0
+        while i < n:
+            if colors[j % n] == colors[(j - 1) % n]:
+                i = j
+
+            if j - i + 1 == k:
+                res += 1
+                i += 1
+
+            j += 1
+
+        return res