def make_array_zero_brute_force(numbers, window_size):
    def explore_paths(current_numbers):
        # If all numbers are zero, we have found a valid sequence of operations and exited the maze.
        if all(element == 0 for element in current_numbers):
            return True

        # Explore every possible move from the current state by selecting a starting position for the operation.
        for start_index in range(len(current_numbers) - window_size + 1):
            is_possible_move = all(current_numbers[index] > 0 for index in range(start_index, start_index + window_size))

            if is_possible_move:
                # Apply the operation to a copy so we can backtrack to the original state if this path fails.
                next_state_numbers = list(current_numbers)
                for index_in_window in range(window_size):
                    next_state_numbers[start_index + index_in_window] -= 1

                if explore_paths(next_state_numbers):
                    return True

        return False

    return explore_paths(list(numbers))

def make_array_elements_equal_to_zero(numbers_list, operation_length_k):
    # This running tally tracks the sum of all subtraction waves currently affecting an element.
    current_subtraction_tally = 0

    for current_index in range(len(numbers_list)):
        # A subtraction wave's effect is finite; we undo its contribution once we are past its end point.
        if current_index >= operation_length_k:
            current_subtraction_tally -= numbers_list[current_index - operation_length_k]

        effective_value = numbers_list[current_index] - current_subtraction_tally

        # An element's value must not become negative, as we can only ever subtract, not add.
        if effective_value < 0:
            return False

        # This effective value is the new subtraction wave we must start, so we add it to the tally.
        current_subtraction_tally += effective_value
        numbers_list[current_index] = effective_value

    # Any remaining tally implies operations would affect elements beyond the array, which is invalid.
    return current_subtraction_tally == 0