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


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3298" 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. Note that the memory limits in this problem are smaller than usual, so you must implement a solution with a linear runtime complexity.   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 <= 106 1 <= word2.length <= 104 word1 and word2 consist only of lowercase English letters.  

	# Explanation
	Here's a solution to the problem with linear runtime complexity and efficient memory usage:

*   **Character Frequency Analysis:** The core idea is to compare the character frequencies of substrings in `word1` with the character frequencies of `word2`. We'll use a sliding window approach to maintain character frequencies for substrings of `word1`.
*   **Check Prefix Property:** For a substring of `word1` to be valid, it should be possible to rearrange it such that `word2` becomes a prefix. This is equivalent to checking if the substring of `word1` contains all the characters in `word2` with at least the same frequency.
*   **Sliding Window and Optimization:** A sliding window maintains the character counts of a substring of `word1`. When the substring length is greater than or equal to the length of `word2`, we check if it can form `word2` as a prefix using frequency comparison. Removing characters from the left of the sliding window ensures linear time complexity.

*   **Runtime Complexity:** O(n + m), where n is the length of `word1` and m is the length of `word2`. **Storage Complexity:** O(1). The storage is constant as the frequency counters store at most 26 values.

	
	# Code
	```python
	def solve():
    word1 = input()
    word2 = input()

    n = len(word1)
    m = len(word2)
    count = 0

    def is_valid(sub_freq, word2_freq):
        for char in word2_freq:
            if char not in sub_freq or sub_freq[char] < word2_freq[char]:
                return False
        return True
    
    word2_freq = {}
    for char in word2:
        word2_freq[char] = word2_freq.get(char, 0) + 1
    
    for i in range(n):
        for j in range(i, n):
            sub = word1[i:j+1]
            if len(sub) < m:
                continue
            
            sub_freq = {}
            for char in sub:
                sub_freq[char] = sub_freq.get(char, 0) + 1
            
            if is_valid(sub_freq, word2_freq):
                count += 1
    
    print(count)
solve()
	```