Open In App
Related Articles

Python – Maximum Consecutive Substring Occurrence

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Sometimes, while working with Python, we can have a problem in which we must check for substrings occurring in consecutive repetition. This can have applications in data domains. Let us discuss a way in which this task can be performed. 

Method #1: Using max() + re.findall() 

A combination of the above methods can be used to perform this task. In this, we extract the substrings repetitions using findall() and the maximum of them using max(). 

Python3

# Python3 code to demonstrate working of
# Maximum Consecutive Substring Occurrence
# Using max() + re.findall()
import re
 
# Initializing string
test_str = 'geeksgeeks are geeks for all geeksgeeksgeeks'
 
# Printing original string
print("The original string is : " + str(test_str))
 
# Initializing subs
sub_str = 'geeks'
 
# Maximum Consecutive Substring Occurrence
# using max() + re.findall()
res = max(re.findall('((?:' + re.escape(sub_str) + ')*)', test_str), key=len)
 
# Printing result
print("The maximum run of Substring : " + res)

                    
Output : 
The original string is : geeksgeeks are geeks for all geeksgeeksgeeks
The maximum run of Substring : geeksgeeksgeeks

The Time and Space Complexity for all the methods is the same:

Time Complexity: O(n)
Auxiliary Space: O(n)

Method #2: Using list comprehension+ loop + max() + len()

Algorithm:

  1. Initialize a variable “sub_str” with the substring to be searched.
  2. Calculate the length of the input string “test_str” and the length of the substring “sub_str”.
  3. Initialize a variable “max_sub” with an empty string.
  4. Loop through a range of values from 0 to the quotient of the length of the input string divided by the length of the substring.
  5. Multiply the substring by the current value of the loop counter and check if it exists in the input string “test_str”.
  6. If the substring exists in the input string, update the “max_sub” variable with the current substring if its length is greater than the length of the previous “max_sub” substring.
  7. Return the “max_sub” variable.

Python3

# initializing string
test_str = 'geeksgeeks are geeks for all geeksgeeksgeeks'
# initializing subs
sub_str = 'geeks'
# printing original string
print("The original string is : " + str(test_str))
 
max_sub = max([sub_str * n for n in range(len(test_str)//len(sub_str)+1) if sub_str * n in test_str], key=len)
 
# printing result
print("The maximum run of Substring : " + max_sub)

                    

Output
The original string is : geeksgeeks are geeks for all geeksgeeksgeeks
The maximum run of Substring : geeksgeeksgeeks

Time complexity: O(n^2), where n is the length of the input string. This is because the nested loop runs for a maximum of n/len(sub_str) times and the inbuilt max() function also takes O(n) time.

Auxiliary Space: O(n), where n is the length of the input string. The space is used to store the input string, substring, and the “max_sub” variable.

Method #3: Using the lambda function

  1. In this method, we define a lambda function called max_substring that takes two arguments, a string s and a substring sub, and returns the maximum consecutive occurrence of the substring in the string.
  2. We then use the lambda function max_substring to find the maximum consecutive occurrence of the substring in the input string test_str. Finally, we print the result res.

Below is the code for the above method: 

Python3

# Python3 code to demonstrate working of
# Maximum Consecutive Substring Occurrence
import re
 
# initializing string
test_str = 'geeksgeeks are geeks for all geeksgeeksgeeks'
 
# printing original string
print("The original string is : " + str(test_str))
 
# initializing subs
sub_str = 'geeks'
 
# using lambda function to find maximum consecutive substring
max_substring = lambda s, sub: max(re.findall('((?:' + re.escape(sub) + ')*)', s), key=len)
 
# Maximum Consecutive Substring Occurrence
res = max_substring(test_str, sub_str)
 
# printing result
print("The maximum run of Substring : " + res)

                    

Output
The original string is : geeksgeeks are geeks for all geeksgeeksgeeks
The maximum run of Substring : geeksgeeksgeeks

Time complexity: O(n^2), where n is the length of the input string test_str.

Auxiliary Space: O(n^2)

Method 4:  Using Loops

  1. Initialize a variable, max_count, to 0 to keep track of the maximum count of the substring in any window.
  2. Initialize a variable, max_sub, to an empty string to keep track of the substring with the maximum count.
  3. Split the input string into a list of words using the split() method.
  4. Loop over the words in the list.
  5. For each word, count the number of occurrences of the given substring using the count() method.
  6. If the count is greater than or equal to max_count, update max_count and max_sub.
  7. Repeat steps 4-6 for all words in the list.
  8. Return the substring with the maximum count

Python3

# initializing string
test_str = 'geeksgeeks are geeks for all geeksgeeksgeeks'
# initializing subs
sub_str = 'geeks'
# printing original string
print("The original string is : " + str(test_str))
 
# initializing variables
max_count = 0
max_sub = ""
 
# split the input string into a list of words
words = test_str.split()
 
# loop over the words in the list
for word in words:
    # count the number of occurrences of the given substring in the word
    count = word.count(sub_str)
    # update max_count and max_sub if necessary
    if count >= max_count:
        max_count = count
        max_sub = sub_str * max_count
 
# printing result
print("The maximum run of Substring : " + max_sub)

                    

Output
The original string is : geeksgeeks are geeks for all geeksgeeksgeeks
The maximum run of Substring : geeksgeeksgeeks

Time complexity: O(NK), where n is the number of words in the input string and k is the length of the substring. The count() method has a time complexity of O(k), and it is called once for each word in the input string.
Auxiliary space: O(K), where k is the length of the substring. The max_sub variable can have at most k characters.



Last Updated : 08 May, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads