Count The Repetitions - Practice Coding Problems

Count The Repetitions - Problem

Count The Repetitions - A fascinating string matching problem that challenges your understanding of pattern recognition and optimization!

Imagine you have two super strings created by repeating base strings multiple times:
• str1 = [s1, n1] means string s1 repeated n1 times
• str2 = [s2, n2] means string s2 repeated n2 times

Your mission: Find the maximum number m such that str2 repeated m times can be obtained as a subsequence from str1.

Key Insight: A subsequence means you can remove some characters (but keep the relative order) to transform one string into another.

Example: If s1="acb", n1=4 gives us "acbacbacbacb"
If s2="ab", n2=2 gives us "abab"
We need to find how many times "abab" can fit as a subsequence in the first string.

Input & Output

example_1.py — Basic Case

$ Input: s1 = "acb", n1 = 4, s2 = "ab", n2 = 2

› Output: 2

💡 Note: str1 = "acbacbacbacb" (acb repeated 4 times). We need str2 = "abab" (ab repeated 2 times). We can extract "abab" twice from str1: first 'a' from pos 0, first 'b' from pos 2, second 'a' from pos 3, second 'b' from pos 5, giving us one "abab". Similarly for the second "abab". Total = 2.

example_2.py — No Match Case

$ Input: s1 = "acb", n1 = 1, s2 = "acb", n2 = 1

› Output: 1

💡 Note: str1 = "acb" and str2 = "acb". Since they are identical, str2 appears exactly once as a subsequence of str1.

example_3.py — Impossible Case

$ Input: s1 = "abc", n1 = 4, s2 = "def", n2 = 1

› Output: 0

💡 Note: str1 = "abcabcabcabc" contains no characters from str2 = "def", so it's impossible to form str2 as a subsequence.

Visualization

Tap to expand

Understanding the Visualization

Initial Matching

Start matching characters from s2 within repeated s1 strings, tracking progress

State Recording

Record how many s1 repetitions used and s2 characters matched for each s2 position

Cycle Detection

When we see the same s2 position again, we've found a repeating cycle

Mathematical Skip

Calculate how many cycles fit in remaining repetitions and skip ahead

Key Takeaway

🎯 Key Insight: By detecting cycles in the matching pattern, we transform a potentially exponential character-by-character simulation into an efficient mathematical calculation, making the solution scalable for large inputs.

Time & Space Complexity

Time Complexity

⏱️

O(|s1| * |s2|)

In the worst case, we need to process at most |s1| * |s2| states before finding a cycle

✓ Linear Growth

Space Complexity

O(|s2|)

We store state information for at most |s2| different positions

✓ Linear Space

Constraints

1 ≤ s1.length, s2.length ≤ 100
1 ≤ n1, n2 ≤ 10⁶
s1 and s2 consist of lowercase English letters
Time limit: The solution must handle large n1, n2 values efficiently

Asked in

G Google 15 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal approach uses cycle detection to avoid simulating every character match. By tracking when we return to the same position in s2 after processing complete s1 strings, we can identify repeating patterns and calculate the answer mathematically. This reduces the time complexity from O(n1 × |s1| × |s2|) to O(|s1| × |s2|), making it efficient even for large values of n1 and n2.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(\|s1\| * n1 * \|s2\| * result)	O(\|s1\| * n1 + \|s2\| * n2)	Simulate the entire matching process character by character
Optimized Cycle Detection	O(\|s1\| * \|s2\|)	O(\|s2\|)	Detect repeating patterns to avoid simulating every character

Brute Force Simulation — Algorithm Steps

Create the full str1 by repeating s1 n1 times
Try to match str2 as many times as possible within str1
For each attempt, scan through str1 to find all characters of str2 in order
Count successful complete matches
Return the maximum number of complete str2 matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Complete Strings

Create str1 = s1 repeated n1 times

Sequential Matching

Scan str1 to find each character of str2 in order

Count Matches

Increment counter for each complete str2 match found

Code -

solution.c — C

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

int getMaxRepetitions(char* s1, int n1, char* s2, int n2) {
    int len1 = strlen(s1) * n1;
    int len2 = strlen(s2) * n2;
    
    char* str1 = (char*)malloc((len1 + 1) * sizeof(char));
    str1[0] = '\0';
    
    for (int i = 0; i < n1; i++) {
        strcat(str1, s1);
    }
    
    char* target = (char*)malloc((len2 + 1) * sizeof(char));
    target[0] = '\0';
    
    for (int i = 0; i < n2; i++) {
        strcat(target, s2);
    }
    
    int count = 0;
    int i = 0;
    
    while (1) {
        int startI = i;
        
        for (int j = 0; j < len2; j++) {
            while (i < len1 && str1[i] != target[j]) {
                i++;
            }
            if (i >= len1) {
                free(str1);
                free(target);
                return count;
            }
            i++;
        }
        
        count++;
    }
    
    free(str1);
    free(target);
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(|s1| * n1 * |s2| * result)

We potentially scan through the entire str1 for each match attempt, and there could be many matches

✓ Linear Growth

Space Complexity

O(|s1| * n1 + |s2| * n2)

We store the complete str1 and potentially str2 strings in memory

⚡ Linearithmic Space

Constraints

1 ≤ s1.length, s2.length ≤ 100
1 ≤ n1, n2 ≤ 10⁶
s1 and s2 consist of lowercase English letters
Time limit: The solution must handle large n1, n2 values efficiently

31.2K Views

Medium Frequency

~35 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler