# Solving Leetcode Interviews in Seconds with AI: Find the Occurrence of First Almost Equal Substring


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3303" 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 pattern. A string x is called almost equal to y if you can change at most one character in x to make it identical to y. Return the smallest starting index of a substring in s that is almost equal to pattern. If no such index exists, return -1. A substring is a contiguous non-empty sequence of characters within a string.   Example 1:  Input: s = "abcdefg", pattern = "bcdffg" Output: 1 Explanation: The substring s[1..6] == "bcdefg" can be converted to "bcdffg" by changing s[4] to "f".  Example 2:  Input: s = "ababbababa", pattern = "bacaba" Output: 4 Explanation: The substring s[4..9] == "bababa" can be converted to "bacaba" by changing s[6] to "c".  Example 3:  Input: s = "abcd", pattern = "dba" Output: -1  Example 4:  Input: s = "dde", pattern = "d" Output: 0    Constraints:  1 <= pattern.length < s.length <= 105 s and pattern consist only of lowercase English letters.    Follow-up: Could you solve the problem if at most k consecutive characters can be changed?

	# Explanation
	Here's the solution to the problem:

*   **Sliding Window:** Iterate through the string `s` using a sliding window of the same length as `pattern`.
*   **Difference Count:** For each window, count the number of differing characters between the window and `pattern`.
*   **Early Exit:** If the difference count is at most 1, return the starting index of the window immediately. If after checking all substrings we didn't find a suitable starting index, return -1.

*   **Runtime Complexity:** O(n\*m), where n is the length of `s` and m is the length of `pattern`.
*   **Storage Complexity:** O(1)

	
	# Code
	```python
	def solve():
    s = input()
    pattern = input()

    n = len(s)
    m = len(pattern)

    for i in range(n - m + 1):
        diff_count = 0
        for j in range(m):
            if s[i+j] != pattern[j]:
                diff_count += 1

        if diff_count <= 1:
            print(i)
            return

    print(-1)

solve()
	```