Mar-1

Author: geemaple

README.md

@@ -0,0 +1,65 @@
+//  Tag: Array, Two Pointers, Simulation
+//  Time: O(N)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+//  Video: https://youtu.be/l-KC4smk5sM
+
+//  You are given a 0-indexed array nums of size n consisting of non-negative integers.
+//  You need to apply n - 1 operations to this array where, in the ith operation (0-indexed), you will apply the following on the ith element of nums:
+//  
+//  If nums[i] == nums[i + 1], then multiply nums[i] by 2 and set nums[i + 1] to 0. Otherwise, you skip this operation.
+//  
+//  After performing all the operations, shift all the 0's to the end of the array.
+//  
+//  For example, the array [1,0,2,0,0,1] after shifting all its 0's to the end, is [1,2,1,0,0,0].
+//  
+//  Return the resulting array.
+//  Note that the operations are applied sequentially, not all at once.
+//   
+//  Example 1:
+//  
+//  Input: nums = [1,2,2,1,1,0]
+//  Output: [1,4,2,0,0,0]
+//  Explanation: We do the following operations:
+//  - i = 0: nums[0] and nums[1] are not equal, so we skip this operation.
+//  - i = 1: nums[1] and nums[2] are equal, we multiply nums[1] by 2 and change nums[2] to 0. The array becomes [1,4,0,1,1,0].
+//  - i = 2: nums[2] and nums[3] are not equal, so we skip this operation.
+//  - i = 3: nums[3] and nums[4] are equal, we multiply nums[3] by 2 and change nums[4] to 0. The array becomes [1,4,0,2,0,0].
+//  - i = 4: nums[4] and nums[5] are equal, we multiply nums[4] by 2 and change nums[5] to 0. The array becomes [1,4,0,2,0,0].
+//  After that, we shift the 0's to the end, which gives the array [1,4,2,0,0,0].
+//  
+//  Example 2:
+//  
+//  Input: nums = [0,1]
+//  Output: [1,0]
+//  Explanation: No operation can be applied, we just shift the 0 to the end.
+//  
+//   
+//  Constraints:
+//  
+//  2 <= nums.length <= 2000
+//  0 <= nums[i] <= 1000
+//  
+//  
+
+class Solution {
+public:
+    vector<int> applyOperations(vector<int>& nums) {
+        int n = nums.size();
+        for (int i = 0; i < n - 1; i++) {
+            if (nums[i] == nums[i + 1]) {
+                nums[i] *= 2;
+                nums[i + 1] = 0;
+            }
+        }
+        int j = 0;
+        for (int i = 0; i < n; i++) {
+            if (nums[i]) {
+                swap(nums[i], nums[j]);
+                j += 1;
+            }
+        }
+        return nums;
+    }
+};

leetcode/2460.apply-operations-to-an-array.cpp

@@ -0,0 +1,60 @@
+#  Tag: Array, Two Pointers, Simulation
+#  Time: O(N)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+#  Video: https://youtu.be/l-KC4smk5sM
+
+#  You are given a 0-indexed array nums of size n consisting of non-negative integers.
+#  You need to apply n - 1 operations to this array where, in the ith operation (0-indexed), you will apply the following on the ith element of nums:
+#  
+#  If nums[i] == nums[i + 1], then multiply nums[i] by 2 and set nums[i + 1] to 0. Otherwise, you skip this operation.
+#  
+#  After performing all the operations, shift all the 0's to the end of the array.
+#  
+#  For example, the array [1,0,2,0,0,1] after shifting all its 0's to the end, is [1,2,1,0,0,0].
+#  
+#  Return the resulting array.
+#  Note that the operations are applied sequentially, not all at once.
+#   
+#  Example 1:
+#  
+#  Input: nums = [1,2,2,1,1,0]
+#  Output: [1,4,2,0,0,0]
+#  Explanation: We do the following operations:
+#  - i = 0: nums[0] and nums[1] are not equal, so we skip this operation.
+#  - i = 1: nums[1] and nums[2] are equal, we multiply nums[1] by 2 and change nums[2] to 0. The array becomes [1,4,0,1,1,0].
+#  - i = 2: nums[2] and nums[3] are not equal, so we skip this operation.
+#  - i = 3: nums[3] and nums[4] are equal, we multiply nums[3] by 2 and change nums[4] to 0. The array becomes [1,4,0,2,0,0].
+#  - i = 4: nums[4] and nums[5] are equal, we multiply nums[4] by 2 and change nums[5] to 0. The array becomes [1,4,0,2,0,0].
+#  After that, we shift the 0's to the end, which gives the array [1,4,2,0,0,0].
+#  
+#  Example 2:
+#  
+#  Input: nums = [0,1]
+#  Output: [1,0]
+#  Explanation: No operation can be applied, we just shift the 0 to the end.
+#  
+#   
+#  Constraints:
+#  
+#  2 <= nums.length <= 2000
+#  0 <= nums[i] <= 1000
+#  
+#  
+
+class Solution:
+    def applyOperations(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        for i in range(n - 1):
+            if nums[i] == nums[i + 1]:
+                nums[i] *= 2
+                nums[i + 1] = 0
+
+        j = 0
+        for i in range(n):
+            if nums[i] > 0:
+                nums[i], nums[j] = nums[j], nums[i]
+                j += 1
+
+        return nums

leetcode/2460.apply-operations-to-an-array.py

@@ -0,0 +1,75 @@
+//  Tag: Array, Binary Search, Sliding Window, Sorting
+//  Time: O(NlogN)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+
+//  You are given a 0-indexed array nums and a non-negative integer k.
+//  In one operation, you can do the following:
+//  
+//  Choose an index i that hasn't been chosen before from the range [0, nums.length - 1].
+//  Replace nums[i] with any integer from the range [nums[i] - k, nums[i] + k].
+//  
+//  The beauty of the array is the length of the longest subsequence consisting of equal elements.
+//  Return the maximum possible beauty of the array nums after applying the operation any number of times.
+//  Note that you can apply the operation to each index only once.
+//  A subsequence of an array is a new array generated from the original array by deleting some elements (possibly none) without changing the order of the remaining elements.
+//   
+//  Example 1:
+//  
+//  Input: nums = [4,6,1,2], k = 2
+//  Output: 3
+//  Explanation: In this example, we apply the following operations:
+//  - Choose index 1, replace it with 4 (from range [4,8]), nums = [4,4,1,2].
+//  - Choose index 3, replace it with 4 (from range [0,4]), nums = [4,4,1,4].
+//  After the applied operations, the beauty of the array nums is 3 (subsequence consisting of indices 0, 1, and 3).
+//  It can be proven that 3 is the maximum possible length we can achieve.
+//  
+//  Example 2:
+//  
+//  Input: nums = [1,1,1,1], k = 10
+//  Output: 4
+//  Explanation: In this example we don't have to apply any operations.
+//  The beauty of the array nums is 4 (whole array).
+//  
+//   
+//  Constraints:
+//  
+//  1 <= nums.length <= 105
+//  0 <= nums[i], k <= 105
+//  
+//  
+
+class Solution {
+public:
+    int maximumBeauty(vector<int>& nums, int k) {
+        int n = nums.size();
+        sort(nums.begin(), nums.end());
+        int i = 0;
+        int res = 0;
+        for (int j = 0; j < n; j++) {
+            while (nums[j] - nums[i] > 2 * k) {
+                i += 1;
+            }
+
+            res = max(res, j - i + 1);
+        }
+        return res;
+    }
+};
+
+class Solution {
+public:
+    int maximumBeauty(vector<int>& nums, int k) {
+        int n = nums.size();
+        sort(nums.begin(), nums.end());
+        int i = 0;
+        int j = 0;
+        for (j = 0; j < n; j++) {
+            if (nums[j] - nums[i] > 2 * k) {
+                i += 1;
+            }
+        }
+        return j - i;
+    }
+};

leetcode/2779.maximum-beauty-of-an-array-after-applying-operation.cpp

@@ -0,0 +1,66 @@
+#  Tag: Array, Binary Search, Sliding Window, Sorting
+#  Time: O(NlogN)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+
+#  You are given a 0-indexed array nums and a non-negative integer k.
+#  In one operation, you can do the following:
+#  
+#  Choose an index i that hasn't been chosen before from the range [0, nums.length - 1].
+#  Replace nums[i] with any integer from the range [nums[i] - k, nums[i] + k].
+#  
+#  The beauty of the array is the length of the longest subsequence consisting of equal elements.
+#  Return the maximum possible beauty of the array nums after applying the operation any number of times.
+#  Note that you can apply the operation to each index only once.
+#  A subsequence of an array is a new array generated from the original array by deleting some elements (possibly none) without changing the order of the remaining elements.
+#   
+#  Example 1:
+#  
+#  Input: nums = [4,6,1,2], k = 2
+#  Output: 3
+#  Explanation: In this example, we apply the following operations:
+#  - Choose index 1, replace it with 4 (from range [4,8]), nums = [4,4,1,2].
+#  - Choose index 3, replace it with 4 (from range [0,4]), nums = [4,4,1,4].
+#  After the applied operations, the beauty of the array nums is 3 (subsequence consisting of indices 0, 1, and 3).
+#  It can be proven that 3 is the maximum possible length we can achieve.
+#  
+#  Example 2:
+#  
+#  Input: nums = [1,1,1,1], k = 10
+#  Output: 4
+#  Explanation: In this example we don't have to apply any operations.
+#  The beauty of the array nums is 4 (whole array).
+#  
+#   
+#  Constraints:
+#  
+#  1 <= nums.length <= 105
+#  0 <= nums[i], k <= 105
+#  
+#  
+
+class Solution:
+    def maximumBeauty(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        nums.sort()
+        i = 0
+        res = 0
+        for j in range(n):
+            while nums[j] - nums[i] > 2 * k:
+                i += 1
+
+            res = max(res, j - i + 1)
+
+        return res
+    
+class Solution:
+    def maximumBeauty(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        nums.sort()
+        i = 0
+        for j in range(n):
+            if nums[j] - nums[i] > 2 * k:
+                i += 1
+
+        return j - i + 1

leetcode/2779.maximum-beauty-of-an-array-after-applying-operation.py

@@ -0,0 +1,76 @@
+//  Tag: Array, Greedy, Sliding Window
+//  Time: O(N)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+
+//  You are given an integer eventTime denoting the duration of an event, where the event occurs from time t = 0 to time t = eventTime.
+//  You are also given two integer arrays startTime and endTime, each of length n. These represent the start and end time of n non-overlapping meetings, where the ith meeting occurs during the time [startTime[i], endTime[i]].
+//  You can reschedule at most k meetings by moving their start time while maintaining the same duration, to maximize the longest continuous period of free time during the event.
+//  The relative order of all the meetings should stay the same and they should remain non-overlapping.
+//  Return the maximum amount of free time possible after rearranging the meetings.
+//  Note that the meetings can not be rescheduled to a time outside the event.
+//   
+//  Example 1:
+//  
+//  Input: eventTime = 5, k = 1, startTime = [1,3], endTime = [2,5]
+//  Output: 2
+//  Explanation:
+//  
+//  Reschedule the meeting at [1, 2] to [2, 3], leaving no meetings during the time [0, 2].
+//  
+//  Example 2:
+//  
+//  Input: eventTime = 10, k = 1, startTime = [0,2,9], endTime = [1,4,10]
+//  Output: 6
+//  Explanation:
+//  
+//  Reschedule the meeting at [2, 4] to [1, 3], leaving no meetings during the time [3, 9].
+//  
+//  Example 3:
+//  
+//  Input: eventTime = 5, k = 2, startTime = [0,1,2,3,4], endTime = [1,2,3,4,5]
+//  Output: 0
+//  Explanation:
+//  There is no time during the event not occupied by meetings.
+//  
+//   
+//  Constraints:
+//  
+//  1 <= eventTime <= 109
+//  n == startTime.length == endTime.length
+//  2 <= n <= 105
+//  1 <= k <= n
+//  0 <= startTime[i] < endTime[i] <= eventTime
+//  endTime[i] <= startTime[i + 1] where i lies in the range [0, n - 2].
+//  
+//  
+
+class Solution {
+public:
+    int maxFreeTime(int eventTime, int k, vector<int>& startTime, vector<int>& endTime) {
+        int start = 0;
+        vector<int> slots;
+        for (int i = 0; i < startTime.size(); i++) {
+            slots.push_back(startTime[i] - start);
+            start = endTime[i];
+        }
+        slots.push_back(eventTime - start);
+        if (k + 1 >= slots.size()) {
+            return accumulate(slots.begin(), slots.end(), 0);
+        } 
+
+        int res = 0;
+        int tmp = 0;
+        for (int i = 0; i < slots.size(); i++) {
+            tmp += slots[i];
+            if (i >= k) {
+                res = max(res, tmp);
+                tmp -= slots[i - k];
+            }
+
+        }
+
+        return res;
+    }
+};