# Solving Leetcode Interviews in Seconds with AI: Get Equal Substrings Within Budget


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1208" 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 two strings s and t of the same length and an integer maxCost. You want to change s to t. Changing the ith character of s to ith character of t costs |s[i] - t[i]| (i.e., the absolute difference between the ASCII values of the characters). Return the maximum length of a substring of s that can be changed to be the same as the corresponding substring of t with a cost less than or equal to maxCost. If there is no substring from s that can be changed to its corresponding substring from t, return 0.   Example 1:  Input: s = "abcd", t = "bcdf", maxCost = 3 Output: 3 Explanation: "abc" of s can change to "bcd". That costs 3, so the maximum length is 3.  Example 2:  Input: s = "abcd", t = "cdef", maxCost = 3 Output: 1 Explanation: Each character in s costs 2 to change to character in t,  so the maximum length is 1.  Example 3:  Input: s = "abcd", t = "acde", maxCost = 0 Output: 1 Explanation: You cannot make any change, so the maximum length is 1.    Constraints:  1 <= s.length <= 105 t.length == s.length 0 <= maxCost <= 106 s and t consist of only lowercase English letters.  

	# Explanation
	Here's the solution to the problem, explained with the requested format:

*   **Sliding Window:** Use a sliding window approach to maintain a window of characters in `s`.
*   **Cost Calculation:**  Calculate the cost of changing the current window in `s` to the corresponding window in `t`.
*   **Window Adjustment:**  Expand the window to the right if the cost is within `maxCost`. Shrink the window from the left if the cost exceeds `maxCost`.

*   **Runtime Complexity:** O(n) & **Storage Complexity:** O(1)

	
	# Code
	```python
	def equalSubstring(s: str, t: str, maxCost: int) -> int:
    """
    Finds the maximum length of a substring of s that can be changed to be the same as the
    corresponding substring of t with a cost less than or equal to maxCost.
    """

    n = len(s)
    left = 0
    cost = 0
    max_length = 0

    for right in range(n):
        cost += abs(ord(s[right]) - ord(t[right]))

        while cost > maxCost:
            cost -= abs(ord(s[left]) - ord(t[left]))
            left += 1

        max_length = max(max_length, right - left + 1)

    return max_length
	```