This code defines a method `maxRepeating` that determines the maximum...

August 30, 2025 at 06:23 AM

public int maxRepeating(String sequence, String word) {
        int max = 0;
        String ans = "";
        int i=0;
        while(i<sequence.length()){
            int end = i+word.length();
            if(end>sequence.length()){
                if(ans.length()>max){
                    max = ans.length();
                }
                break;
            }
            String substr = sequence.substring(i,end);
            if(substr.equals(word)){
                ans = ans+substr;
                i = end;
            }
            else{
                if(ans.length()>max){
                    max = ans.length();
                }
                ans="";
                i++;
            }
        }
        if(!ans.isEmpty() && ans.length()>max){
            max = ans.length();
        }
        int len = word.length();
        return max/len;
    }

This code defines a method maxRepeating that determines the maximum number of times the string word repeats consecutively in the string sequence. Here's what it does step by step:

Input:

sequence: A string in which the algorithm will look for repeated patterns of word.
word: A string that the algorithm will check for consecutive repetitions.

Logic:

Initialize variables:
- max: This keeps track of the maximum length of a consecutive repetition of the word found so far.
- ans: This accumulates the repeated instances of word while traversing the sequence.
- i: An index to iterate over the sequence.
Iterate over the sequence (while loop):
- Calculate the end index as i + word.length() for extracting a substring from the sequence.
- If the end index exceeds the length of the sequence, the loop stops (or breaks after final checks).
- Extract a substring (substr) from the current position i to the end.
Check if the substring matches word:
- If substr equals word:
  - It appends substr to ans (indicating a repeated match).
  - It advances the i index by the length of word to continue checking for more consecutive repetitions.
- If substr does not equal word:
  - It compares ans.length() to max. If ans is longer than max, it updates max.
  - Resets ans to an empty string and increments i by 1 to continue checking from the next position.
Final Check:
- After the loop, if ans is still non-empty (indicating a match at the end of the string) and its length exceeds max, update max.
Return Result:
- Since word has a length of len, the maximum number of consecutive repetitions is max / len. The method returns this value.

Return Value:

The method returns an integer representing the maximum number of consecutive repetitions of word in sequence.

Example:

Input:

String sequence = "abababab";
String word = "ab";

Execution:

The method identifies that "ab" repeats 4 times consecutively in "abababab".
It calculates max = 8 (the total length of "abababab") and divides it by the length of "ab" (2).
The result is 4.

Output:

Complexity:

Time Complexity: O(n * m), where n is the length of sequence and m is the length of word, due to the substring checks.
Space Complexity: O(m) for the concatenated ans string.

This code efficiently finds how many times word repeats consecutively in sequence.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr