# Solving Leetcode Interviews in Seconds with AI: Minimum Length of String After Operations


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3223" 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 s. You can perform the following process on s any number of times:  Choose an index i in the string such that there is at least one character to the left of index i that is equal to s[i], and at least one character to the right that is also equal to s[i]. Delete the closest occurrence of s[i] located to the left of i. Delete the closest occurrence of s[i] located to the right of i.  Return the minimum length of the final string s that you can achieve.   Example 1:  Input: s = "abaacbcbb" Output: 5 Explanation: We do the following operations:  Choose index 2, then remove the characters at indices 0 and 3. The resulting string is s = "bacbcbb". Choose index 3, then remove the characters at indices 0 and 5. The resulting string is s = "acbcb".   Example 2:  Input: s = "aa" Output: 2 Explanation: We cannot perform any operations, so we return the length of the original string.    Constraints:  1 <= s.length <= 2 * 105 s consists only of lowercase English letters.  

	# Explanation
	Here's a breakdown of the approach and the code:

*   **Identify Removable Sections:** The core idea is to efficiently identify and remove sections of the string that meet the removal criteria. A section can be removed if it's surrounded by identical characters.

*   **Iterative Removal:** We repeatedly scan the string, identifying and removing these sections. The process continues until no more removable sections are found.

*   **Optimization:** The key optimization is to maintain left and right pointers for each character in the string. This avoids redundant searches for matching characters during the removal process.

*   **Runtime & Storage Complexity:** O(N) for runtime complexity and O(N) for storage complexity, where N is the length of the string.

	
	# Code
	```python
	def min_length(s: str) -> int:
    """
    Given a string s, return the minimum length of the final string s that you can achieve.
    """
    n = len(s)
    left = list(range(-1, n - 1))
    right = list(range(1, n + 1))
    alive = [True] * n
    q = []

    for i in range(n):
        if left[i] >= 0 and right[i] < n and s[left[i]] == s[i] == s[right[i]]:
            q.append(i)

    while q:
        i = q.pop(0)
        if not alive[i]:
            continue

        l, r = left[i], right[i]
        if l >= 0 and r < n and s[l] == s[i] == s[r]:
            alive[i] = False
            alive[l] = False
            alive[r] = False
            right[l] = right[r]
            left[right[r]] = left[l]

            if left[l] >= 0 and right[right[r]] < n and s[left[l]] == s[right[r]]:
                q.append(right[r])
            if left[l] >= 0 and right[l] < n and s[left[l]] == s[l] == s[right[l]]:
                q.append(l)
                
    return sum(alive)
	```