Constraints

• 0 <= len(nums) <= 200000
• -10^9 <= nums[i] <= 10^9
• nums is sorted in non-decreasing order
• 1 <= k <= 200000

Examples

Solution

def solution(nums, k):
    if k <= 0:
        return 0, []

    write = 0
    for read in range(len(nums)):
        x = nums[read]
        if write < k or nums[write - k] != x:
            nums[write] = x
            write += 1

    return write, nums[:write]

Time complexity: O(n). Space complexity: O(1) auxiliary space, excluding the returned output slice used for testing.

Hints

1. Use one pointer to read the original array and another pointer to write the kept values.
2. Once you have already written k elements, compare the current value with the element k positions behind the write pointer.

Constraints

• 0 <= len(s), len(t) <= 200000
• Characters may repeat in t and must be matched with multiplicity
• Expected solution should run in O(len(s) + len(t)) time

Examples

Solution

from collections import Counter

def solution(s, t):
    if not t or not s or len(t) > len(s):
        return ""

    need = Counter(t)
    missing = len(t)
    left = 0
    best_start = 0
    best_len = float("inf")

    for right, ch in enumerate(s):
        if ch in need:
            if need[ch] > 0:
                missing -= 1
            need[ch] -= 1

        while missing == 0:
            window_len = right - left + 1
            if window_len < best_len:
                best_len = window_len
                best_start = left

            left_ch = s[left]
            if left_ch in need:
                need[left_ch] += 1
                if need[left_ch] > 0:
                    missing += 1
            left += 1

    if best_len == float("inf"):
        return ""
    return s[best_start:best_start + best_len]

Time complexity: O(len(s) + len(t)). Space complexity: O(u), where u is the number of distinct characters required by t.

Hints

1. Maintain character requirements from t and expand a right pointer until the window becomes valid.
2. Once the window is valid, move the left pointer rightward while the window still covers t.

Constraints

• 0 <= len(s) <= 200000
• Digits to replace are ASCII only: '0' through '9'
• The algorithm should process the string in one left-to-right pass

Examples

Solution

def solution(s):
    out = []
    pending_space = False
    in_digit_run = False

    for ch in s:
        if ch.isspace():
            if out:
                pending_space = True
            in_digit_run = False
            continue

        if pending_space and out:
            out.append(' ')
            pending_space = False

        if '0' <= ch <= '9':
            if not in_digit_run:
                out.append('#')
                in_digit_run = True
        else:
            out.append(ch)
            in_digit_run = False

    return ''.join(out)

Time complexity: O(n). Space complexity: O(n) for the returned string in Python; O(1) auxiliary working space excluding output.

Hints

1. Do not emit a space immediately when you see whitespace; delay it until you know another non-whitespace character is coming.
2. Track whether you are currently inside a digit run so you only append one '#'.