Number of Subarrays That Match a Pattern I

Number of Subarrays That Match a Pattern I - Problem

You are given two arrays: an integer array nums of size n and a pattern array pattern of size m containing only the values -1, 0, and 1.

Your task is to find how many subarrays of nums match the given pattern. A subarray nums[i..j] of length m + 1 matches the pattern if:

When pattern[k] == 1: nums[i + k + 1] > nums[i + k] (increasing)
When pattern[k] == 0: nums[i + k + 1] == nums[i + k] (equal)
When pattern[k] == -1: nums[i + k + 1] < nums[i + k] (decreasing)

For example, if pattern is [1, 0, -1], you're looking for subarrays where the first pair increases, the second pair stays equal, and the third pair decreases.

Return the count of all such matching subarrays.

Input & Output

example_1.py — Basic Pattern Matching

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

› Output: 4

💡 Note: The pattern [1,1] means we need two consecutive increases. Matching subarrays are: [1,2,3], [2,3,4], [3,4,5], [4,5,6]

example_2.py — Mixed Pattern

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

› Output: 1

💡 Note: Pattern [1,0,-1] means increase, stay same, decrease. Only [1,4,4,1] matches: 1<4 (increase), 4==4 (same), 4>1 (decrease)

example_3.py — No Matches

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

› Output: 0

💡 Note: Pattern [-1,-1] requires two consecutive decreases, but the array [1,2,3,4] is strictly increasing, so no subarrays match

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Understanding what relationships between consecutive elements we're looking for

Slide Through Array

Check each possible starting position for a subarray of the required length

Verify Relationships

For each position, compare consecutive pairs against the pattern requirements

Count Matches

Increment counter for each subarray that perfectly matches the pattern

Key Takeaway

🎯 Key Insight: Pattern matching requires checking consecutive element relationships sequentially - we slide through possible starting positions and verify each pattern element matches the corresponding pair relationship.

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

We check n-m possible starting positions, and for each position we verify m pattern elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting and iteration, no additional data structures needed

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁶
0 ≤ pattern.length < nums.length
1 ≤ nums[i] ≤ 10⁹
pattern[i] ∈ {-1, 0, 1}

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal approach uses pattern matching by sliding through the array and checking each possible starting position. For each position, we verify if the consecutive elements satisfy the pattern relationships. The brute force solution has O(n*m) time complexity, which is efficient enough for this problem since we need to examine each potential match sequentially.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Pattern Matching	O(n*m)	O(1)	Check every possible subarray of length m+1 against the pattern

Brute Force Pattern Matching — Algorithm Steps

Iterate through all possible starting positions (0 to n-m-1)
For each starting position, extract subarray of length m+1
Compare each consecutive pair in the subarray against the pattern
If all pairs match their corresponding pattern element, increment counter
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Check if subarray starting at index 0 matches the pattern

Compare adjacent pairs

For each pattern element, verify the relationship between consecutive numbers

Move to next position

If match found, increment counter. Move to next starting position

Repeat until end

Continue until all possible positions are checked

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int countMatchingSubarrays(int* nums, int numsSize, int* pattern, int patternSize) {
    int count = 0;
    
    // Check each possible starting position
    for (int i = 0; i <= numsSize - patternSize - 1; i++) {
        bool match = true;
        
        // Check if subarray starting at i matches the pattern
        for (int j = 0; j < patternSize; j++) {
            if (pattern[j] == 1 && nums[i + j + 1] <= nums[i + j]) {
                match = false;
                break;
            } else if (pattern[j] == 0 && nums[i + j + 1] != nums[i + j]) {
                match = false;
                break;
            } else if (pattern[j] == -1 && nums[i + j + 1] >= nums[i + j]) {
                match = false;
                break;
            }
        }
        
        if (match) count++;
    }
    
    return count;
}

int main() {
    int nums[] = {1, 2, 3, 4, 5, 6};
    int pattern[] = {1, 1};
    printf("%d\n", countMatchingSubarrays(nums, 6, pattern, 2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

We check n-m possible starting positions, and for each position we verify m pattern elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting and iteration, no additional data structures needed

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁶
0 ≤ pattern.length < nums.length
1 ≤ nums[i] ≤ 10⁹
pattern[i] ∈ {-1, 0, 1}

28.4K Views

Medium Frequency

~18 min Avg. Time

890 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

Brute Force Pattern Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler