Given a String, the task is to write a Python program to extract the mid occurrence of a character.
Input : test_str = “neveropen is best for allneveropen”, K = ‘e’
Output : 10
Explanation : 7 occurrences of e. The 4th occurrence [mid] is at 10th index.
Input : test_str = “neveropen is best for allneveropen”, K = ‘g’
Output : 8
Explanation : 3 occurrences of g. The 2nd occurrence [mid] is at 8th index.
Method #1 : Using enumerate() + list comprehension
In this, we perform the task of getting all occurrences using list comprehension and enumerate gets all indices. Post that the middle element of the list is printed to get mid occurrence of a character.
Python3
# Python3 code to demonstrate working of# Mid occurrence of K in string# Using find() + max() + slice# initializing stringtest_str = "neveropen is best for allneveropen"# printing original stringprint("The original string is : " + str(test_str))# initializing KK = 'e'# getting all the indices of Kindices = [idx for idx, ele in enumerate(test_str) if ele == K]# getting mid indexres = indices[len(indices) // 2]# printing resultprint("Mid occurrence of K : " + str(res)) |
Output:
The original string is :neveropen is best for allneveropen Mid occurrence of K : 10
Time Complexity: O(n)
Space Complexity: O(n)
Method #2 : Using finditer() + list comprehension + regex
In this, the character is found using regex and finditer(). The mid occurrence is the mid element of the indices list.
Python3
# Python3 code to demonstrate working of# Mid occurrence of K in string# Using finditer() + list comprehension + regeximport re# initializing stringtest_str = "neveropen is best for allneveropen"# printing original stringprint("The original string is : " + str(test_str))# initializing KK = 'e'# getting all the indices of K# using regexindices = [ele.start() for ele in re.finditer(K, test_str)]# getting mid indexres = indices[len(indices) // 2]# printing resultprint("Mid occurrence of K : " + str(res)) |
Output:
The original string is :neveropen is best for allneveropen Mid occurrence of K : 10
Time Complexity: O(n)
Auxiliary Space: O(n)
Approach#3: Using a loop to count the occurrences of K
This approach first counts the total number of occurrences of the character K in the given string. Then, it calculates the mid index by dividing the count by 2 and taking the ceiling value. Finally, it iterates over the string again and counts the occurrences of K until it reaches the mid index, and returns the index of that mid occurrence. If there is no mid occurrence, it returns -1.
Algorithm
1. Initialize a count variable to 0.
2. Traverse the string character by character and increment the count variable by 1 if the character is equal to K.
3. Compute the mid occurrence of K by dividing the count variable by 2 and rounding up.
4. Traverse the string again and keep track of the number of occurrences of K seen so far.
5. If the number of occurrences seen so far is equal to the mid occurrence, return the current index.
6. Return -1 if the mid occurrence is not found.
Python3
import mathdef mid_occurrence(str_, K): count = 0 for i in range(len(str_)): if str_[i] == K: count += 1 mid = math.ceil(count / 2) count = 0 for i in range(len(str_)): if str_[i] == K: count += 1 if count == mid: return i return -1str_ = "neveropen is best for allneveropen"K='e'print(mid_occurrence(str_, K)) |
10
Time complexity: O(n), where n is the length of the string.
Auxiliary Space: O(1).
Approach#4: Using the lambda function
In this approach, the lambda function takes two arguments test_str and K, which are the string and the character to be searched for, respectively.
The lambda function uses a generator expression [ele.start() for ele in re.finditer(K, test_str)] to find all the indices of the character K in the string test_str using regex.
The lambda function then calculates the middle index of the indices list indices using (lambda indices: indices[len(indices) // 2] if indices else -1)(…). If the indices list is not empty, it returns the middle index, otherwise, it returns -1.
Below is the code for the above approach:
Python3
import remid_occurrence = lambda test_str, K: (lambda indices: indices[len(indices) // 2] if indices else -1)([ele.start() for ele in re.finditer(K, test_str)])# initializing stringtest_str = "neveropen is best for allneveropen"# printing original stringprint("The original string is : " + str(test_str))# initializing KK = 'e'# getting mid indexres = mid_occurrence(test_str, K)# printing resultprint("Mid occurrence of K : " + str(res)) |
The original string is :neveropen is best for allneveropen Mid occurrence of K : 10
Time complexity: O(n)
Auxiliary Space: O(m), where m is the number of occurrences of the character K in the string test_str.
METHOD 5:
APPROACH: Using for loop and counter variable.
The given problem can be solved using a simple iteration over the string while keeping track of the count of the character K. Once the count reaches the mid occurrence of K in the string, the index of that occurrence can be returned.
ALGORITHM:
1.Initialize a counter variable to 0.
2.Iterate over the string using a for loop and an index variable.
3.If the character at the current index is equal to the given character K, increment the counter variable.
4.Check if the counter is equal to the mid occurrence of K in the string, which can be calculated by dividing the total count of K by 2 and adding 1. 5.If the condition is true, return the current index.
6.If the loop completes without finding the mid occurrence of K, return -1.
Python3
test_str = "neveropen is best for allneveropen"K = 'e'count = 0for i in range(len(test_str)): if test_str[i] == K: count += 1 if count == (test_str.count(K) // 2 + 1): print(i) break |
10
Time Complexity:
The time complexity of this approach is O(n), where n is the length of the input string. This is because we are iterating over the string once.
Auxiliary Space:
The space complexity of this approach is O(1), because we are only using a constant amount of extra space for the counter variable and the loop variable.
