This content originally appeared on DEV Community and was authored by Ertugrul
Problems Solved:
- #3065 Minimum Operations to Exceed Threshold Value I
- #283 Move Zeroes
This continues my daily series (Day 17: Count-Below-Threshold + Inâplace Zero Push). Today I focused on two array problems: counting how many elements are below a threshold when we repeatedly remove the global minimum, and moving all zeros to the end while preserving order.
đĄ What I Learned
- For Minimum Operations to Exceed Threshold Value I, the operation âremove one occurrence of the smallest elementâ implies we must eliminate every value
< kexactly once. Thus, after sorting, the answer is simply the count of values< k. (Sorting is optional; we can also count directly.) - For Move Zeroes, implementing it by erasing zeros in place and pushing them to the back preserves order but causes O(n²) behavior due to repeated middle erases on a vector/array. It still solves the problem correctly and demonstrates inâplace stability, but is not optimal versus the twoâpointer linear approach.
- Both tasks highlight how problem constraints map to simple invariants: removeâmin step â all
< kmust go; stable inâplace reordering â zeros migrate without disturbing nonâzero relative order.
𧊠#3065 â Minimum Operations to Exceed Threshold Value I
C++ (Sort + Count Below k)
class Solution {
public:
int minOperations(vector<int>& nums, int k) {
sort(nums.begin(), nums.end());
int i = 0;
while (i < nums.size() && nums[i] < k){
i += 1;
}
return i;
}
};
Python (Sort + Count Below k)
class Solution:
def minOperations(self, nums: List[int], k: int) -> int:
nums.sort()
i = 0
while i < len(nums) and nums[i] < k:
i += 1
return i
Why it works: each operation always removes the current global minimum. As long as any element < k remains, that minimum is < k and must be removed once. Therefore, the minimal number of operations equals the number of elements < k.
Time: O(n log n) due to sort (a countingâonly variant can be O(n)).
Space: O(1) extra (inâplace sort).
𧊠#283 â Move Zeroes
C++ (Inâplace erase + push_back)
class Solution {
public:
void moveZeroes(vector<int>& nums) {
int start= 0, end = nums.size()-1;
while (start < end){
if (nums[start] == 0){
nums.push_back(nums[start]);
nums.erase(nums.begin() + start);
end--;
}else{
start++;
}
}
}
};
Python (Inâplace pop/append)
class Solution:
def moveZeroes(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
start = 0
end = len(nums)-1
while start < end:
if nums[start] == 0:
nums.append(nums[start])
nums.pop(start)
end -= 1
else:
start += 1
Why it works: whenever a zero is found, it is relocated to the end. Elements already processed keep their relative order, so stability is preserved.
Time: worstâcase O(n²) (due to middle erases/pops).
Space: O(1) extra.
Note: A twoâpointer O(n) alternative writes nonâzeros forward then fills trailing zeros. I kept the implementations above consistent with todayâs code to reflect the approach I used.
đ¸ Achievements
- Implemented thresholdâremoval counting cleanly in both Python and C++.
- Demonstrated an inâplace, stable zeroâmover using erase/pop mechanics.
đŚ Complexity Recap
-
Minimum Operations to Exceed Threshold Value I:
O(n log n)time (with sort),O(1)extra space. -
Move Zeroes:
O(n²)time with erase/pop,O(1)extra space. (Twoâpointer variant would beO(n).)
đŁ Join the Journey
Iâm solving and documenting problems daily in both Python and C++, covering arrays, linked lists, dynamic programming, and more. Follow along if youâre interested in systematic problem solving.
Links
- LinkedIn: https://www.linkedin.com/in/ertugrul-mutlu
- GitHub Series: https://github.com/Ertugrulmutlu/leetcode-series
This content originally appeared on DEV Community and was authored by Ertugrul
Ertugrul | Sciencx (2025-09-04T09:14:22+00:00) đ Daily LeetCode Progress â Day 17. Retrieved from https://www.scien.cx/2025/09/04/%f0%9f%97%93-daily-leetcode-progress-day-17/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.