是否在不更改列表原始顺序的情况下删除列表中其他字符串的子字符串的字符串？

Question

I have a list.

the_list = ['Donald Trump has', 'Donald Trump has small fingers', 'What is going on?']

I'd like to remove "Donald Trump has" from the_list because it's a substring of other list element.

Here is an important part. I want to do this without distoring the order of the original list.

The function I have (below) distorts the order of the original list. Because it sorts the list items by its length first.

def substr_sieve(list_of_strings):  
    dups_removed = list_of_strings[:]
    for i in xrange(len(list_of_strings)):
        list_of_strings.sort(key = lambda s: len(s))
        j=0
        j=i+1
        while j <= len(list_of_strings)-1:
            if list_of_strings[i] in list_of_strings[j]:
                try:
                    dups_removed.remove(list_of_strings[i])
                except:
                    pass
            j+=1
    return dups_removed

Answer 1

A simple solution.

But first, let's also add ' Donald Trump ', 'Donald' and 'Trump' in the end to make it a better test case.

>>> forbidden_text = "\nX08y6\n" # choose a text that will hardly appear in any sensible string
>>> the_list = ['Donald Trump has', 'Donald Trump has small fingers', 'What is going on?',
        'Donald Trump', 'Donald', 'Trump']
>>> new_list = [item for item in the_list if forbidden_text.join(the_list).count(item) == 1]
>>> new_list
['Donald Trump has small fingers', 'What is going on?']

Logic:

1. Concatenate all list element to form a single string. forbidden_text.join(the_list) .
2. Search if an item in the list has occurred only once. If it occurs more than once it is a sub-string. count(item) == 1

str.count(sub[, start[, end]])

Return the number of non-overlapping occurrences of substring sub in the range [start, end] . Optional arguments start and end are interpreted as in slice notation.

---

forbidden_text is used instead of "" (blank string), to handle a case like these :

>>> the_list = ['DonaldTrump', 'Donald', 'Trump']

---

As correctly pointed by Nishant, above code fails for the_list = ['Donald', 'Donald']

Using a set(the_list) instead of the_list solves the problem.
>>> new_list = [item for item in the_list if forbidden_text.join(set(the_list)).count(item) == 1]

Answer 2

You can do this without sorting:

the_list = ['Donald Trump has', "I've heard Donald Trump has small fingers",
            'What is going on?']

def winnow(a_list):
    keep = set()
    for item in a_list:
        if not any(item in other for other in a_list if item != other):
            keep.add(item)
    return [ item for item in a_list if item in keep ]

winnow(the_list)

Sorting may allow fewer comparisons overall, but that seems highly data-dependent, and could be a premature optimization.

Answer 3

You can just recursively reduce the items.

Algorithm:

Loop over each item by popping it, decide if it needs to be kept or not. Call the same function recursively with the reduced list. Base condition is if the list has at-least one item (or two?).

Efficiency: It might not be the most efficient. I think some Divide and Conquer methods would be more apt?

the_list = ['Donald Trump has', 'Donald Trump has small fingers',\
            'What is going on?']

final_list = []

def remove_or_append(input):
    if len(input):
        first_value = input.pop(0)
        found = False
        for each in input:
            if first_value in each:
                found = True
                break
            else:
                continue
        for each in final_list:
            if first_value in each:
                found = True
                break
            else:
                continue
        if not found:
            final_list.append(first_value)
        remove_or_append(input)

remove_or_append(the_list)

print(final_list)

A slightly different version is:

def substring_of_anything_else(item, list):
    for idx, each in enumerate(list):
        if idx == item[0]:
            continue
        else:
            if item[1] in each:
                return True
        return False

final_list = [item for idx, item in enumerate(the_list)\ 
              if not substring_of_anything_else((idx, item), the_list)]