# Solving Leetcode Interviews in Seconds with AI: Find Special Substring of Length K


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3456" 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 and an integer k. Determine if there exists a substring of length exactly k in s that satisfies the following conditions:  The substring consists of only one distinct character (e.g., "aaa" or "bbb"). If there is a character immediately before the substring, it must be different from the character in the substring. If there is a character immediately after the substring, it must also be different from the character in the substring.  Return true if such a substring exists. Otherwise, return false.   Example 1:  Input: s = "aaabaaa", k = 3 Output: true Explanation: The substring s[4..6] == "aaa" satisfies the conditions.  It has a length of 3. All characters are the same. The character before "aaa" is 'b', which is different from 'a'. There is no character after "aaa".   Example 2:  Input: s = "abc", k = 2 Output: false Explanation: There is no substring of length 2 that consists of one distinct character and satisfies the conditions.    Constraints:  1 <= k <= s.length <= 100 s consists of lowercase English letters only.  

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

*   **High-Level Approach:**
    *   Iterate through the string `s` using a sliding window of size `k`.
    *   For each window (substring), check if all characters within the window are the same.
    *   If the characters are the same, check if the characters immediately before and after the window (if they exist) are different from the repeating character within the window.

*   **Complexity:**
    *   Runtime Complexity: O(n), where n is the length of the string `s`.
    *   Storage Complexity: O(1)

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

    n = len(s)

    for i in range(n - k + 1):
        substring = s[i:i+k]
        
        # Check if all characters in the substring are the same
        if len(set(substring)) == 1:
            
            valid = True
            
            # Check character before the substring
            if i > 0:
                if s[i-1] == substring[0]:
                    valid = False
            
            # Check character after the substring
            if i + k < n:
                if s[i+k] == substring[0]:
                    valid = False
            
            if valid:
                return True
    
    return False

print(solve())
	```