This card keeps the stack from Next Greater Element and changes what a pop means. In Next Greater Element, a larger item arrives and every smaller item on top of stack is popped for free. Here, a pop deletes a digit from the answer, so each pop uses one removal from the budget k. When k is 0, no digit can be popped, even if it is bigger than the new digit.

Why pop a bigger digit when a smaller digit arrives? Two numbers with the same number of digits are compared from the left. The first place where they differ decides which one is smaller. Suppose stack[-1] is bigger than digit. Deleting stack[-1] moves digit into that place, and a smaller digit now sits in the earliest place that can still change. No other removal can lower that place more, so the pop never has to be undone.

The pop uses > and not >=. If stack[-1] equals digit, deleting it changes nothing at that place. It only spends one removal. For "1121" with k = 1, the first two 1 digits are not popped, because each one equals the digit after it. The 2 is popped when the last 1 arrives, and the answer is "111". With >=, the second 1 would be popped instead, and the answer would be "121".

Example: in Remove K Digits (LC 402), num = "1432219" and k = 3 give "1219". The 4 is popped by the 3, the 3 is popped by the first 2, and the second 2 is popped by the 1. That is three pops, so k reaches 0. Then the 9 is pushed.

The board replays num = "10234" with k = 2. The top row is num. The bottom row is stack.

The digit 0 arrives while stack holds 1. The 1 is bigger, so it is popped and k becomes 1. Then 0, 2, 3 and 4 are pushed. No pop is possible for them, because each new digit is not smaller than the top.

After the loop, k is still 1. The tail step cuts the last digit with stack[:len(stack) - k]. The digits in stack rise from left to right, so the last digit is the biggest. stack becomes 0 2 3.

The kept digits read "023". A number does not start with a zero, so lstrip("0") removes it and the result is "23". This is the step marked as the trap on the board. Every other choice of two digits to delete gives a larger number. For example, deleting 1 and 0 gives "234".

If every digit is removed or stripped, the result is the empty string. result or "0" returns "0" instead. For "10" with k = 2, the answer is "0".

Some problems have no budget k. Instead, a pop is allowed only when the popped item appears again later, so removing it now loses nothing. This is the other rule that the card adds on top of Next Greater Element.

Remove Duplicate Letters (LC 316) keeps one copy of each letter in the smallest order. Store last[c], the last index of each letter in s. At index i, skip the letter if it is already in stack. Otherwise pop stack[-1] while stack[-1] > c and last[stack[-1]] > i, then push c.

Example: for s = "bcabc", the letter a at index 2 pops c, because last["c"] is 4. It then pops b, because last["b"] is 3. Both letters come back later. The stack ends as "abc". Without the last test, the loop would also pop a letter that never comes back, and that letter would be lost.

Find the Most Competitive Subsequence (LC 1673) uses the digit rule with a different budget. The number of items that may be removed is len(nums) - k, and the stack may not grow past k items. For nums = [3, 5, 2, 6] and k = 2, the answer is [2, 6].

Every digit is pushed once and popped at most once. The tail cut, join and lstrip each pass over stack once. So the time is O(N) for N digits, and stack holds at most N digits, so the space is O(N).

The inner while loop does not make the time O(N^2). The total number of pops over the whole run can never be more than the number of pushes, which is N.

When num already rises, as in "123456789" with k = 3, the loop pops nothing. The three removals are spent on the tail, and the answer is "123456". When num falls, as in "9991" with k = 3, the 1 pops three 9 digits and the answer is "1".

Use stack[:len(stack) - k] and not stack[:-k]. When k is 0 after the loop, stack[:-0] is stack[:0], which is empty, and every kept digit is lost.