Removing the Nth Occurrence of a Word in a Python List

💡 Problem Formulation: The task is to create a Python program that efficiently removes the nth occurrence of a specific word in a list where words can be repeated. For instance, given the list ['apple', 'banana', 'apple', 'cherry', 'apple'] and the task to remove the second occurrence of ‘apple’, the resulting list should be ['apple', 'banana', 'cherry', 'apple'].

Method 1: Iterate and Count

This method involves iterating over the list, counting the occurrences of the specified word, and removing the nth occurrence by index. Function implementation requires looping through the list elements while tracking the count of the target word occurrences until it is time to remove the nth one.

Here’s an example:

def remove_nth_occurrence(words, target, n):
    count = 0
    for i, word in enumerate(words):
        if word == target:
            count += 1
            if count == n:
                del words[i]
                break
    return words

print(remove_nth_occurrence(['apple', 'banana', 'apple', 'cherry', 'apple'], 'apple', 2))

Output:

['apple', 'banana', 'cherry', 'apple']

This snippet defines a function that iterates over the list, checks for the target word, increments the counter upon finding an occurrence, and deletes the targeted nth occurrence. The use of enumerate() grants access to both the index and the word, facilitating deletion.

Method 2: Using List Comprehension with a Helper Function

In this approach, we utilize a helper function to maintain state during list comprehension. The helper function keeps track of occurrences and provides a flag when the nth occurrence is encountered allowing the main function to rebuild the list without the nth occurrence.

Here’s an example:

def should_remove(target, n, helper=dict()):
    def counter(word):
        if word == target:
            helper[word] = helper.get(word, 0) + 1
            return helper[word] == n
        return False
    return counter

def remove_nth_occurrence(words, target, n):
    counter = should_remove(target, n)
    return [word for word in words if not counter(word)]

lst = ['apple', 'banana', 'apple', 'cherry', 'apple']
print(remove_nth_occurrence(lst, 'apple', 2))

Output:

['apple', 'banana', 'cherry', 'apple']

The function should_remove() initializes a mutable default argument which acts as a closure to store the state, and then remove_nth_occurrence() uses it in a list comprehension to generate a new list without the nth occurrence.

Method 3: Remove with Slice Replacement

A slicing technique allows us to rebuild the list without the nth occurrence by creating slices before and after the target word and then concatenating them. It is a direct method requiring knowledge of slicing and concatenating lists.

Here’s an example:

def remove_nth_occurrence(words, target, n):
    count = 0
    for i, word in enumerate(words):
        if word == target:
            count += 1
            if count == n:
                return words[:i] + words[i+1:]
    return words

print(remove_nth_occurrence(['apple', 'banana', 'apple', 'cherry', 'apple'], 'apple', 2))

Output:

['apple', 'banana', 'cherry', 'apple']

This method searches for the nth occurrence and upon finding it, returns a new list created by slicing and concatenating parts of the original list, excluding the nth occurrence.

Method 4: Filtering with a Generator Expression

Generator expressions offer a means to filter items lazily. The same concept of counting occurrences can be used with a generator, yielding items to be included in the result and skipping the nth occurrence.

Here’s an example:

def remove_nth_occurrence(words, target, n):
    def gen():
        count = 0
        for word in words:
            if word == target:
                count += 1
                if count == n:
                    continue
            yield word
    return list(gen())

print(remove_nth_occurrence(['apple', 'banana', 'apple', 'cherry', 'apple'], 'apple', 2))

Output:

['apple', 'banana', 'cherry', 'apple']

A generator function is defined within remove_nth_occurrence() to keep track of occurrences and yield all but the nth occurrence. By calling list() on the generator, we get the final list.

Bonus One-Liner Method 5: Using filter()

The filter() function can be leveraged in conjunction with a lambda that calls a previously defined occurrence checking function. This makes for an elegant one-liner, albeit at the cost of readability.

Here’s an example:

words = ['apple', 'banana', 'apple', 'cherry', 'apple']
target = 'apple'
n = 2
count = {'val': 0}
filter_func = lambda word: word != target or (count.update(val=count['val']+1) or count['val']) != n
result = list(filter(filter_func, words))
print(result)

Output:

['apple', 'banana', 'cherry', 'apple']

The lambda function updates the count for each occurrence within a mutable object and filters out the nth occurrence using filter(), returning a new list without said occurrence.

Summary/Discussion

• Method 1: Iterate and Count. Strengths: Straightforward and easy to understand. Weaknesses: Manually handling indices can lead to errors.
• Method 2: Using List Comprehension with a Helper Function. Strengths: Makes the code cleaner with encapsulation of logic. Weaknesses: Requires understanding of closures and is less intuitive.
• Method 3: Remove with Slice Replacement. Strengths: Pythonic and concise. Weaknesses: May not be as clear to beginners, and the creation of new list slices can be inefficient for large lists.
• Method 4: Filtering with a Generator Expression. Strengths: Efficient memory usage with lazy evaluation. Weaknesses: Generator expressions can be confusing for those not used to them.
• Bonus One-Liner Method 5: Using filter(). Strengths: Very concise. Weaknesses: Poor readability and relies on side-effects within a lambda, which is not considered good practice.