Number of Subarrays That Match a Pattern II

Number of Subarrays That Match a Pattern II - Problem

Pattern Matching in Subarrays

Imagine you're analyzing stock market trends! You have an array of stock prices nums and a pattern that describes the desired trend behavior. Your task is to find how many consecutive subsequences of prices match this exact trend pattern.

Given:
• A nums array of size n representing values
• A pattern array of size m with values -1, 0, or 1

A subarray nums[i..j] of size m + 1 matches the pattern if:
• pattern[k] = 1: next value is greater (upward trend)
• pattern[k] = 0: next value is equal (flat trend)
• pattern[k] = -1: next value is smaller (downward trend)

Return the count of matching subarrays.

Input & Output

example_1.py — Basic Pattern Match

$ Input: nums = [1, 2, 3, 4, 5, 6], pattern = [1, 1]

› Output: 4

💡 Note: Subarrays [1,2,3], [2,3,4], [3,4,5], [4,5,6] all match pattern [1,1] as each has consecutive increasing elements

example_2.py — Mixed Pattern

$ Input: nums = [1, 4, 4, 1, 3, 5, 5, 3], pattern = [1, 0, -1]

› Output: 2

💡 Note: Subarrays [1,4,4,1] and [3,5,5,3] match pattern [1,0,-1]: increase, stay same, then decrease

example_3.py — No Matches

$ Input: nums = [1, 2, 3, 4], pattern = [-1, -1]

› Output: 0

💡 Note: No subarray has two consecutive decreasing transitions since nums is strictly increasing

Visualization

Tap to expand

Understanding the Visualization

Analyze Transitions

Convert consecutive number comparisons to trend symbols

Pattern Recognition

Use string matching algorithms to find trend pattern occurrences

Count Matches

Return the total count of matching subsequences

Key Takeaway

🎯 Key Insight: Transform numeric comparisons into string patterns, then leverage efficient string matching algorithms like KMP for optimal O(n+m) performance.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Building trend string takes O(n), KMP preprocessing takes O(m), and matching takes O(n)

✓ Linear Growth

Space Complexity

O(n + m)

Space for trend string O(n) and failure function O(m)

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 10⁶
1 ≤ nums[i] ≤ 10⁹
1 ≤ pattern.length ≤ 10⁶
pattern[i] is -1, 0, or 1
The pattern array describes transitions between consecutive elements

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 24

The optimal approach transforms this into a string pattern matching problem. Convert the numeric array into a trend string representing transitions, then use the KMP algorithm to efficiently find all pattern occurrences in O(n + m) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ KMP String Matching Algorithm	O(n + m)	O(n + m)	Convert to string pattern matching problem and use KMP algorithm
Brute Force (Check Every Subarray)	O(n*m)	O(1)	Check each possible subarray of size m+1 against the pattern

KMP String Matching Algorithm — Algorithm Steps

Convert nums array to trend string by comparing consecutive elements
Build KMP failure function for the pattern
Use KMP algorithm to find all pattern occurrences in the trend string
Return the count of matches found

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to trend string

Transform numeric comparisons into a pattern string

Build failure function

Preprocess pattern to avoid redundant comparisons

KMP search

Efficiently find all pattern occurrences using the failure function

Code -

solution.c — C

int* buildLPS(int* pattern, int m) {
    int* lps = (int*)calloc(m, sizeof(int));
    int length = 0, i = 1;
    
    while (i < m) {
        if (pattern[i] == pattern[length]) {
            length++;
            lps[i] = length;
            i++;
        } else {
            if (length != 0) {
                length = lps[length - 1];
            } else {
                lps[i] = 0;
                i++;
            }
        }
    }
    return lps;
}

int countMatchingSubarrays(int* nums, int numsSize, int* pattern, int patternSize) {
    // Convert to trend array
    int* trend = (int*)malloc((numsSize - 1) * sizeof(int));
    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i + 1] > nums[i]) trend[i] = 1;
        else if (nums[i + 1] == nums[i]) trend[i] = 0;
        else trend[i] = -1;
    }
    
    int n = numsSize - 1, m = patternSize;
    if (m == 0) {
        free(trend);
        return n + 1;
    }
    if (n < m) {
        free(trend);
        return 0;
    }
    
    int* lps = buildLPS(pattern, m);
    int count = 0, i = 0, j = 0;
    
    while (i < n) {
        if (trend[i] == pattern[j]) {
            i++;
            j++;
        }
        
        if (j == m) {
            count++;
            j = lps[j - 1];
        } else if (i < n && trend[i] != pattern[j]) {
            if (j != 0) {
                j = lps[j - 1];
            } else {
                i++;
            }
        }
    }
    
    free(trend);
    free(lps);
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Building trend string takes O(n), KMP preprocessing takes O(m), and matching takes O(n)

✓ Linear Growth

Space Complexity

O(n + m)

Space for trend string O(n) and failure function O(m)

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 10⁶
1 ≤ nums[i] ≤ 10⁹
1 ≤ pattern.length ≤ 10⁶
pattern[i] is -1, 0, or 1
The pattern array describes transitions between consecutive elements

37.2K Views

High Frequency

~25 min Avg. Time

1.6K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

KMP String Matching Algorithm — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler