# Solving Leetcode Interviews in Seconds with AI: Find Maximum Removals From Source String


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3316" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given a string source of size n, a string pattern that is a subsequence of source, and a sorted integer array targetIndices that contains distinct numbers in the range [0, n - 1]. We define an operation as removing a character at an index idx from source such that:  idx is an element of targetIndices. pattern remains a subsequence of source after removing the character.  Performing an operation does not change the indices of the other characters in source. For example, if you remove 'c' from "acb", the character at index 2 would still be 'b'. Return the maximum number of operations that can be performed.   Example 1:  Input: source = "abbaa", pattern = "aba", targetIndices = [0,1,2] Output: 1 Explanation: We can't remove source[0] but we can do either of these two operations:  Remove source[1], so that source becomes "a_baa". Remove source[2], so that source becomes "ab_aa".   Example 2:  Input: source = "bcda", pattern = "d", targetIndices = [0,3] Output: 2 Explanation: We can remove source[0] and source[3] in two operations.  Example 3:  Input: source = "dda", pattern = "dda", targetIndices = [0,1,2] Output: 0 Explanation: We can't remove any character from source.  Example 4:  Input: source = "yeyeykyded", pattern = "yeyyd", targetIndices = [0,2,3,4] Output: 2 Explanation: We can remove source[2] and source[3] in two operations.    Constraints:  1 <= n == source.length <= 3 * 103 1 <= pattern.length <= n 1 <= targetIndices.length <= n targetIndices is sorted in ascending order. The input is generated such that targetIndices contains distinct elements in the range [0, n - 1]. source and pattern consist only of lowercase English letters. The input is generated such that pattern appears as a subsequence in source.  

	# Explanation
	Here's the solution, addressing the problem's core aspects for efficiency and clarity:

*   **Greedy Approach with Two Pointers:** Iterate through `targetIndices`. For each index, tentatively remove the character at that index from `source`. Then, use two pointers to check if `pattern` is still a subsequence of the modified `source`.
*   **Subsequence Check Optimization:** The subsequence check is done efficiently by incrementing the `pattern` pointer only when a match is found in the `source`.
*   **Early Exit:** If removing a character makes `pattern` *not* a subsequence, skip to the next index in `targetIndices`.

*   **Time Complexity:** O(m * n), where n is the length of `targetIndices` and m is the length of `source`.
*   **Space Complexity:** O(m), where m is the length of `source` (due to string slicing).

	
	# Code
	```python
	def max_operations(source: str, pattern: str, targetIndices: list[int]) -> int:
    """
    Calculates the maximum number of operations (removals) that can be performed such that
    the pattern remains a subsequence of the source after each removal.
    """
    count = 0
    n = len(source)

    for index in targetIndices:
        temp_source = source[:index] + source[index + 1:]
        
        pattern_ptr = 0
        source_ptr = 0
        
        while pattern_ptr < len(pattern) and source_ptr < len(temp_source):
            if pattern[pattern_ptr] == temp_source[source_ptr]:
                pattern_ptr += 1
            source_ptr += 1
        
        if pattern_ptr == len(pattern):
            source = temp_source
            count += 1
        else:
            pass # Pattern is not a subsequence after removal, so skip

    return count
	```