Finding the n-th Occurrence of a Substring in a String

Identifying the index corresponding to the n-th occurrence of a substring is a task that often arises in various programming scenarios. In Python, there is no built-in function specifically designed for this purpose. However, there are several approaches that can be employed to achieve this result.

One straightforward approach is to use a loop to iterate through the string and count the occurrences of the substring. The starting index is initialized to the result of the first occurrence, and the loop continues until the n-th occurrence is found.

def find_nth_occurrence(haystack, needle, n):
    index = haystack.find(needle)
    while index >= 0 and n > 1:
        index = haystack.find(needle, index   len(needle))
        n -= 1
    return index

This method is efficient and easy to understand, but it requires multiple passes through the string, which can be time-consuming for large strings.

Another more Pythonic approach is to use regular expressions. Regular expressions provide a powerful and concise way to search and manipulate strings. The following function uses the re.findall() method to find all occurrences of the substring and then retrieves the n-th index:

import re

def find_nth_occurrence_regex(haystack, needle, n):
    occurrences = re.findall(needle, haystack)
    if len(occurrences) >= n:
        return haystack.index(occurrences[n - 1])
    else:
        return -1

This method is faster than the iterative approach for large strings, but it requires the import of an additional module (re). Additionally, it may be less readable than the iterative approach for some users.

The choice between the iterative and regular expression approaches ultimately depends on the specific requirements of the task at hand. For small strings, the iterative approach may be sufficient, while for large strings, the regular expression approach may offer better performance.