# Solving Leetcode Interviews in Seconds with AI: Count Substrings That Can Be Rearranged to Contain a String I


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3297" 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 word1 and word2. A string x is called valid if x can be rearranged to have word2 as a prefix. Return the total number of valid substrings of word1.   Example 1:  Input: word1 = "bcca", word2 = "abc" Output: 1 Explanation: The only valid substring is "bcca" which can be rearranged to "abcc" having "abc" as a prefix.  Example 2:  Input: word1 = "abcabc", word2 = "abc" Output: 10 Explanation: All the substrings except substrings of size 1 and size 2 are valid.  Example 3:  Input: word1 = "abcabc", word2 = "aaabc" Output: 0    Constraints:  1 <= word1.length <= 105 1 <= word2.length <= 104 word1 and word2 consist only of lowercase English letters.  

	# Explanation
	Here's a solution to the problem, incorporating efficiency and optimality considerations.

*   **Core Idea:** Iterate through all possible substrings of `word1`. For each substring, check if it can be rearranged to have `word2` as a prefix. This check involves comparing the character frequencies of `word2` with the character frequencies of the substring.

*   **Frequency Comparison:** Use dictionaries (or arrays for optimal constant-time access since we're dealing with lowercase letters) to store character frequencies.  If the frequency of each character in `word2` is less than or equal to its frequency in the substring, we can potentially rearrange the substring to have `word2` as a prefix.

*   **Optimization:** Avoid unnecessary computations. If the substring's length is less than `word2`'s length, it cannot possibly have `word2` as a prefix. Early exit conditions improve performance.

*   **Runtime and Space Complexity:**
    *   Runtime Complexity: O(n\*m), where n is the length of `word1` and m is the length of `word2`.
    *   Space Complexity: O(1), since the frequency arrays/dictionaries have a fixed size (26 for lowercase English letters).

	
	# Code
	```python
	def count_valid_substrings(word1: str, word2: str) -> int:
    """
    Counts the number of valid substrings of word1 that can be rearranged to have word2 as a prefix.
    """
    n1 = len(word1)
    n2 = len(word2)
    count = 0

    for i in range(n1):
        for j in range(i, n1):
            substring = word1[i:j + 1]
            if len(substring) >= n2:
                if can_be_arranged_with_prefix(substring, word2):
                    count += 1

    return count


def can_be_arranged_with_prefix(substring: str, prefix: str) -> bool:
    """
    Checks if a substring can be rearranged to have a given prefix.
    """
    freq_substring = [0] * 26
    freq_prefix = [0] * 26

    for char in substring:
        freq_substring[ord(char) - ord('a')] += 1
    for char in prefix:
        freq_prefix[ord(char) - ord('a')] += 1

    for i in range(26):
        if freq_prefix[i] > freq_substring[i]:
            return False

    return True
	```