# Solving Leetcode Interviews in Seconds with AI: Longest Substring with At Least K Repeating Characters


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "395" 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
	> Given a string s and an integer k, return the length of the longest substring of s such that the frequency of each character in this substring is greater than or equal to k. if no such substring exists, return 0.   Example 1:  Input: s = "aaabb", k = 3 Output: 3 Explanation: The longest substring is "aaa", as 'a' is repeated 3 times.  Example 2:  Input: s = "ababbc", k = 2 Output: 5 Explanation: The longest substring is "ababb", as 'a' is repeated 2 times and 'b' is repeated 3 times.    Constraints:  1 <= s.length <= 104 s consists of only lowercase English letters. 1 <= k <= 105  

	# Explanation
	Here's the solution to the problem, combining efficiency, correctness, and clarity.

*   **Divide and Conquer:** The core idea is to recursively divide the string into substrings based on characters whose frequency is less than *k*. Any valid substring cannot contain such characters.
*   **Frequency Check:** For each substring, we first check the frequency of all characters. If all characters have a frequency of at least *k*, the length of the substring is the answer.
*   **Recursive Calls:** If a character exists with frequency less than *k*, we split the string at each occurrence of that character and recursively call the function on each resulting substring.

*   **Time Complexity:** O(N), where N is the length of the string.
*   **Space Complexity:** O(N) in the worst case due to recursion depth.

	
	# Code
	```python
	def longestSubstring(s: str, k: int) -> int:
    """
    Finds the length of the longest substring of s such that the frequency of each character in this substring is greater than or equal to k.

    Args:
        s: The input string.
        k: The minimum frequency required for each character.

    Returns:
        The length of the longest substring that satisfies the condition.
    """
    def solve(s, k):
        if not s:
            return 0

        counts = {}
        for char in s:
            counts[char] = counts.get(char, 0) + 1

        invalid_chars = [char for char, count in counts.items() if count < k]

        if not invalid_chars:
            return len(s)

        max_len = 0
        start = 0
        for i in range(len(s)):
            if s[i] in invalid_chars:
                max_len = max(max_len, solve(s[start:i], k))
                start = i + 1

        max_len = max(max_len, solve(s[start:], k))
        return max_len

    return solve(s, k)
	```