Mar-3

Author: geemaple

README.md

@@ -0,0 +1,78 @@
+//  Tag: Array, Binary Search, Greedy, Sliding Window, Sorting, Prefix Sum
+//  Time: O(NlogN)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+
+//  The frequency of an element is the number of times it occurs in an array.
+//  You are given an integer array nums and an integer k. In one operation, you can choose an index of nums and increment the element at that index by 1.
+//  Return the maximum possible frequency of an element after performing at most k operations.
+//   
+//  Example 1:
+//  
+//  Input: nums = [1,2,4], k = 5
+//  Output: 3
+//  Explanation: Increment the first element three times and the second element two times to make nums = [4,4,4].
+//  4 has a frequency of 3.
+//  Example 2:
+//  
+//  Input: nums = [1,4,8,13], k = 5
+//  Output: 2
+//  Explanation: There are multiple optimal solutions:
+//  - Increment the first element three times to make nums = [4,4,8,13]. 4 has a frequency of 2.
+//  - Increment the second element four times to make nums = [1,8,8,13]. 8 has a frequency of 2.
+//  - Increment the third element five times to make nums = [1,4,13,13]. 13 has a frequency of 2.
+//  
+//  Example 3:
+//  
+//  Input: nums = [3,9,6], k = 2
+//  Output: 1
+//  
+//   
+//  Constraints:
+//  
+//  1 <= nums.length <= 105
+//  1 <= nums[i] <= 105
+//  1 <= k <= 105
+//  
+//  
+
+class Solution {
+public:
+    int maxFrequency(vector<int>& nums, int k) {
+        int n = nums.size();
+        sort(nums.begin(), nums.end());
+        int i = 0;
+        long long total = 0;
+        int res = 0;
+        for (int j = 0; j < n; j++) {
+            total += nums[j];
+            while (nums[j] * (j - i + 1L) - total > k) {
+                total -= nums[i];
+                i += 1;
+            }
+
+            res = max(res, j - i + 1);
+        }
+        return res;
+    }
+};
+
+class Solution {
+public:
+    int maxFrequency(vector<int>& nums, int k) {
+        int n = nums.size();
+        sort(nums.begin(), nums.end());
+        int i = 0;
+        int j = 0;
+        long long total = 0;
+        for (j = 0; j < n; j++) {
+            total += nums[j];
+            if (nums[j] * (j - i + 1L) - total > k) {
+                total -= nums[i];
+                i += 1;
+            }
+        }
+        return j - i;
+    }
+};

leetcode/1838.frequency-of-the-most-frequent-element.cpp

@@ -0,0 +1,69 @@
+#  Tag: Array, Binary Search, Greedy, Sliding Window, Sorting, Prefix Sum
+#  Time: O(NlogN)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+
+#  The frequency of an element is the number of times it occurs in an array.
+#  You are given an integer array nums and an integer k. In one operation, you can choose an index of nums and increment the element at that index by 1.
+#  Return the maximum possible frequency of an element after performing at most k operations.
+#   
+#  Example 1:
+#  
+#  Input: nums = [1,2,4], k = 5
+#  Output: 3
+#  Explanation: Increment the first element three times and the second element two times to make nums = [4,4,4].
+#  4 has a frequency of 3.
+#  Example 2:
+#  
+#  Input: nums = [1,4,8,13], k = 5
+#  Output: 2
+#  Explanation: There are multiple optimal solutions:
+#  - Increment the first element three times to make nums = [4,4,8,13]. 4 has a frequency of 2.
+#  - Increment the second element four times to make nums = [1,8,8,13]. 8 has a frequency of 2.
+#  - Increment the third element five times to make nums = [1,4,13,13]. 13 has a frequency of 2.
+#  
+#  Example 3:
+#  
+#  Input: nums = [3,9,6], k = 2
+#  Output: 1
+#  
+#   
+#  Constraints:
+#  
+#  1 <= nums.length <= 105
+#  1 <= nums[i] <= 105
+#  1 <= k <= 105
+#  
+#  
+
+class Solution:
+    def maxFrequency(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        nums.sort()
+        i = 0
+        res = 0
+        total = 0
+        for j in range(n):
+            total += nums[j]
+            while nums[j] * (j - i + 1) - total > k:
+                total -= nums[i]
+                i += 1
+
+            res = max(res, j - i + 1)
+
+        return res
+    
+class Solution:
+    def maxFrequency(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        nums.sort()
+        i = 0
+        total = 0
+        for j in range(n):
+            total += nums[j]
+            if nums[j] * (j - i + 1) - total > k:
+                total -= nums[i]
+                i += 1
+
+        return j - i + 1

leetcode/1838.frequency-of-the-most-frequent-element.py

@@ -0,0 +1,68 @@
+//  Tag: Array, Two Pointers, Simulation
+//  Time: O(N)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+
+//  You are given a 0-indexed integer array nums and an integer pivot. Rearrange nums such that the following conditions are satisfied:
+//  
+//  Every element less than pivot appears before every element greater than pivot.
+//  Every element equal to pivot appears in between the elements less than and greater than pivot.
+//  The relative order of the elements less than pivot and the elements greater than pivot is maintained.
+//  	
+//  More formally, consider every pi, pj where pi is the new position of the ith element and pj is the new position of the jth element. If i < j and both elements are smaller (or larger) than pivot, then pi < pj.
+//  
+//  
+//  
+//  Return nums after the rearrangement.
+//   
+//  Example 1:
+//  
+//  Input: nums = [9,12,5,10,14,3,10], pivot = 10
+//  Output: [9,5,3,10,10,12,14]
+//  Explanation: 
+//  The elements 9, 5, and 3 are less than the pivot so they are on the left side of the array.
+//  The elements 12 and 14 are greater than the pivot so they are on the right side of the array.
+//  The relative ordering of the elements less than and greater than pivot is also maintained. [9, 5, 3] and [12, 14] are the respective orderings.
+//  
+//  Example 2:
+//  
+//  Input: nums = [-3,4,3,2], pivot = 2
+//  Output: [-3,2,4,3]
+//  Explanation: 
+//  The element -3 is less than the pivot so it is on the left side of the array.
+//  The elements 4 and 3 are greater than the pivot so they are on the right side of the array.
+//  The relative ordering of the elements less than and greater than pivot is also maintained. [-3] and [4, 3] are the respective orderings.
+//  
+//   
+//  Constraints:
+//  
+//  1 <= nums.length <= 105
+//  -106 <= nums[i] <= 106
+//  pivot equals to an element of nums.
+//  
+//  
+
+class Solution {
+public:
+    vector<int> pivotArray(vector<int>& nums, int pivot) {
+        int n = nums.size();
+        vector<int> res(n, pivot);
+        int l = 0;
+        for (int i = 0; i < n; i++) {
+            if (nums[i] < pivot) {
+                res[l] = nums[i];
+                l += 1;
+            }
+        }
+
+        int r = n - 1;
+        for (int i = n - 1; i >= 0; i--) {
+            if (nums[i] > pivot) {
+                res[r] = nums[i];
+                r -= 1;
+            }
+        }
+        return res;
+    }
+};

leetcode/2161.partition-array-according-to-given-pivot.cpp

@@ -0,0 +1,63 @@
+#  Tag: Array, Two Pointers, Simulation
+#  Time: O(N)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+#  Video: https://youtu.be/_tyJM7UjGlo
+
+#  You are given a 0-indexed integer array nums and an integer pivot. Rearrange nums such that the following conditions are satisfied:
+#  
+#  Every element less than pivot appears before every element greater than pivot.
+#  Every element equal to pivot appears in between the elements less than and greater than pivot.
+#  The relative order of the elements less than pivot and the elements greater than pivot is maintained.
+#  	
+#  More formally, consider every pi, pj where pi is the new position of the ith element and pj is the new position of the jth element. If i < j and both elements are smaller (or larger) than pivot, then pi < pj.
+#  
+#  
+#  
+#  Return nums after the rearrangement.
+#   
+#  Example 1:
+#  
+#  Input: nums = [9,12,5,10,14,3,10], pivot = 10
+#  Output: [9,5,3,10,10,12,14]
+#  Explanation: 
+#  The elements 9, 5, and 3 are less than the pivot so they are on the left side of the array.
+#  The elements 12 and 14 are greater than the pivot so they are on the right side of the array.
+#  The relative ordering of the elements less than and greater than pivot is also maintained. [9, 5, 3] and [12, 14] are the respective orderings.
+#  
+#  Example 2:
+#  
+#  Input: nums = [-3,4,3,2], pivot = 2
+#  Output: [-3,2,4,3]
+#  Explanation: 
+#  The element -3 is less than the pivot so it is on the left side of the array.
+#  The elements 4 and 3 are greater than the pivot so they are on the right side of the array.
+#  The relative ordering of the elements less than and greater than pivot is also maintained. [-3] and [4, 3] are the respective orderings.
+#  
+#   
+#  Constraints:
+#  
+#  1 <= nums.length <= 105
+#  -106 <= nums[i] <= 106
+#  pivot equals to an element of nums.
+#  
+#  
+
+class Solution:
+    def pivotArray(self, nums: List[int], pivot: int) -> List[int]:
+        n = len(nums)
+        res = [pivot for i in range(n)]
+        l = 0
+        for i in range(n):
+            if nums[i] < pivot:
+                res[l] = nums[i]
+                l += 1
+
+        r = n - 1
+        for i in range(n - 1, -1, -1):
+            if nums[i] > pivot:
+                res[r] = nums[i]
+                r -= 1
+
+        return res

leetcode/2161.partition-array-according-to-given-pivot.py

@@ -0,0 +1,66 @@
+//  Tag: Hash Table, String, Sliding Window
+//  Time: -
+//  Space: -
+//  Ref: -
+//  Note: -
+//  Video: https://youtu.be/_tyJM7UjGlo
+
+//  You are given a string s consisting of the characters 'a', 'b', and 'c' and a non-negative integer k. Each minute, you may take either the leftmost character of s, or the rightmost character of s.
+//  Return the minimum number of minutes needed for you to take at least k of each character, or return -1 if it is not possible to take k of each character.
+//   
+//  Example 1:
+//  
+//  Input: s = "aabaaaacaabc", k = 2
+//  Output: 8
+//  Explanation: 
+//  Take three characters from the left of s. You now have two 'a' characters, and one 'b' character.
+//  Take five characters from the right of s. You now have four 'a' characters, two 'b' characters, and two 'c' characters.
+//  A total of 3 + 5 = 8 minutes is needed.
+//  It can be proven that 8 is the minimum number of minutes needed.
+//  
+//  Example 2:
+//  
+//  Input: s = "a", k = 1
+//  Output: -1
+//  Explanation: It is not possible to take one 'b' or 'c' so return -1.
+//  
+//   
+//  Constraints:
+//  
+//  1 <= s.length <= 105
+//  s consists of only the letters 'a', 'b', and 'c'.
+//  0 <= k <= s.length
+//  
+//  
+
+class Solution {
+public:
+    int takeCharacters(string s, int k) {
+        int n = s.size();
+        vector<int> counter(3, 0);
+        for (char x: s) {
+            counter[x - 'a'] += 1;
+        }
+
+        for (int i = 0; i < 3; i++) {
+            if (counter[i] < k) {
+                return -1;
+            }
+            counter[i] -= k;
+        }
+ 
+        int i = 0;
+        int res = 0;
+        vector<int> tmp(3, 0);
+        for(int j = 0; j < n; j++) {
+            tmp[s[j] - 'a'] += 1;
+            while (tmp[s[j] - 'a'] > counter[s[j] - 'a']) {
+                tmp[s[i] - 'a'] -= 1;
+                i += 1;
+            }
+            res = max(res, j - i + 1);
+        }
+
+        return n - res;
+    }
+};