Detect Pattern of Length M Repeated K or More Times

Detect Pattern of Length M Repeated K or More Times - Problem

Array Enumeration Easy

Imagine you're analyzing data streams and need to identify repeating patterns to detect anomalies or trends. Given an array of positive integers arr, your task is to find if there exists a pattern of length m that repeats k or more times consecutively.

A pattern is a contiguous subarray that appears multiple times back-to-back without any gaps or overlaps. For example, in the array [1,2,4,4,4,4], the pattern [4] of length 1 repeats 4 times consecutively.

Goal: Return true if such a pattern exists, false otherwise.

Key Points:

Patterns must be consecutive (no gaps between repetitions)
Patterns cannot overlap with themselves
You need at least k repetitions of the pattern

Input & Output

example_1.py — Basic Pattern

$ Input: arr = [1,2,4,4,4,4], m = 1, k = 3

› Output: true

💡 Note: The pattern [4] of length 1 repeats 4 times consecutively, which is ≥ 3 times required.

example_2.py — Multi-element Pattern

$ Input: arr = [1,2,1,2,1,1,1,3], m = 2, k = 2

› Output: true

💡 Note: The pattern [1,2] of length 2 repeats exactly 2 times consecutively at the beginning.

example_3.py — No Valid Pattern

$ Input: arr = [1,2,3,1,2], m = 2, k = 3

› Output: false

💡 Note: No pattern of length 2 can repeat 3 times in an array of only 5 elements (would need 6+ elements).

Visualization

Tap to expand

Understanding the Visualization

Identify candidate position

Start checking from each valid position in the array

Verify pattern repetition

Use modular arithmetic to check if elements repeat every m positions

Count consecutive matches

If we get m×k matches, we found a valid pattern

Key Takeaway

🎯 Key Insight: Instead of creating and comparing subarrays, we can efficiently verify pattern repetitions by checking if elements at distance m apart are equal throughout the sequence.

Time & Space Complexity

Time Complexity

⏱️

O(n * m * k)

We iterate through n positions and for each position check up to m*k elements

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and indices

✓ Linear Space

Constraints

2 ≤ arr.length ≤ 100
1 ≤ arr[i] ≤ 100
1 ≤ m ≤ 100
2 ≤ k ≤ 100
Key constraint: arr.length ≥ m × k (otherwise impossible)

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal approach uses modular arithmetic to efficiently detect patterns. Instead of creating subarrays, we check if arr[i+j] == arr[i + (j%m)] for all positions in the potential pattern sequence. This gives us O(n×m×k) time complexity with O(1) space, making it efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass	O(n * m * k)	O(1)	Use string matching technique to check patterns efficiently in one pass
Brute Force (Check All Patterns)	O(n * m * k)	O(1)	Check every possible pattern of length m at every position

Optimized Single Pass — Algorithm Steps

Iterate through each possible starting position
For each position, check if arr[i] == arr[i+m] for m*k consecutive elements
Use a counter to track consecutive matches
If counter reaches m*k, we found a valid pattern
Reset counter when mismatch occurs

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare with modulo

arr[i+j] should equal arr[i + (j%m)] for pattern repetition

Count matches

If we get m*k consecutive matches, pattern repeats k times

Early termination

Stop checking as soon as we find a mismatch

Code -

solution.c — C

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

int containsPattern(int* arr, int arrSize, int m, int k) {
    int n = arrSize;
    
    // Need at least m*k elements to have k repetitions
    if (n < m * k) {
        return 0;
    }
    
    for (int i = 0; i <= n - m * k; i++) {
        // Check if pattern starting at i repeats k times
        int matches = 0;
        
        // Compare elements at distance m apart
        for (int j = 0; j < m * k; j++) {
            if (arr[i + j] == arr[i + (j % m)]) {
                matches++;
            } else {
                break;
            }
        }
        
        // If all m*k elements match the pattern, we found it
        if (matches == m * k) {
            return 1;
        }
    }
    
    return 0;
}

int main() {
    int arr[] = {1,2,4,4,4,4};
    int arrSize = 6;
    int m = 1, k = 3;
    printf("%d\n", containsPattern(arr, arrSize, m, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * k)

We iterate through n positions and for each position check up to m*k elements

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and indices

✓ Linear Space

Constraints

2 ≤ arr.length ≤ 100
1 ≤ arr[i] ≤ 100
1 ≤ m ≤ 100
2 ≤ k ≤ 100
Key constraint: arr.length ≥ m × k (otherwise impossible)

28.5K Views

Medium Frequency

~15 min Avg. Time

1.2K 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

Optimized Single Pass — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler