获取一个包含字符串元素的列表，该字符串元素不包括初始列表中以任何其他元素为前缀的元素

Question

我在过滤字符串列表时遇到了一些麻烦。 我在这里找到了类似的问题，但不是我所需要的。

输入列表是：

l = ['ab', 'xc', 'abb', 'abed', 'sdfdg', 'abfdsdg', 'xccc']

预期结果是

['ab', 'xc', 'sdfdg']

结果中项目的顺序并不重要

筛选器功能必须快速，因为列表很大

我当前的解决方案是

l = ['ab', 'xc', 'abb', 'abed', 'sdfdg', 'abfdsdg', 'xccc']
for i in range(0, len(l) - 1):
    for j in range(i + 1, len(l)):
        if l[j].startswith(l[i]):
            l[j] = l[i]
        else:
            if l[i].startswith(l[j]):
                l[i] = l[j]

print list(set(l)) 

编辑

在使用大输入数据进行多次测试之后，列出1500000个字符串，对此的最佳解决方案是：

def filter(l):
    if l==[]:
        return []
    l2=[]
    l2.append(l[0])
    llen = len(l)
    k=0
    itter = 0
    while k<llen:
        addkelem = ''
        j=0
        l2len = len(l2)
        while j<l2len:
            if (l2[j].startswith(l[k]) and l[k]!= l2[j]):
                l2[j]=l[k]
                l.remove(l[k])
                llen-=1
                j-=1
                addkelem = ''
                continue
            if (l[k].startswith(l2[j])):
                addkelem = ''
                break
            elif(l[k] not in l2):
                addkelem = l[k]
            j+=1
        if addkelem != '':
            l2.append(addkelem)
            addkelem = ''
        k+=1
    return l2

执行时间约为213秒

输入数据样本 -每一行都是列表中的一个字符串

Answer 1

此算法使用作者提交的输入文件（154MB）在我的计算机上在0.97秒内完成了任务：

l.sort()

last_str = l[0]
filtered = [last_str]
app      = filtered.append

for str in l:
    if not str.startswith(last_str):
        last_str = str
        app(str)

# Commented because of the massive amount of data to print.
# print filtered

该算法很简单：首先按字典顺序对列表进行排序，然后搜索列表的第一个没有前缀的字符串，然后搜索下一个没有最后一个前缀的字符串，等等。

如果列表已经排序（示例文件似乎已经排序），则可以删除l.sort()行，这将导致时间和内存复杂度为O（n）。

Answer 2

您可以按首字母对项目进行分组，然后仅搜索子列表，除非字符串具有至少相同的首字母，否则任何字符串都不能以子字符串开头：

from collections import defaultdict

def find(l):
    d = defaultdict(list)
    # group by first letter
    for ele in l:
        d[ele[0]].append(ele)
    for val in d.values():
        for v in val:
            # check each substring in the sublist
            if not any(v.startswith(s) and v != s  for s in val):
                yield v

print(list(find(l)))
['sdfdg', 'xc', 'ab']

正如下面的代码所示，这正确地过滤了单词，如reduce函数所没有， 'tool'不应出现在输出中：

In [56]: l = ["tool",'ab',"too", 'xc', 'abb',"toot", 'abed',"abel", 'sdfdg', 'abfdsdg', 'xccc',"xcew","xrew"]

In [57]: reduce(r,l)
Out[57]: ['tool', 'ab', 'too', 'xc', 'sdfdg', 'xrew']

In [58]: list(find(l))
Out[58]: ['sdfdg', 'too', 'xc', 'xrew', 'ab']

它还有效地做到了：

In [59]: l = ["".join(sample(ascii_lowercase, randint(2,25))) for _ in range(5000)]

In [60]: timeit reduce(r,l)
1 loops, best of 3: 2.12 s per loop

In [61]: timeit list(find(l))
1 loops, best of 3: 203 ms per loop

In [66]: %%timeit
..... result = []
....: for element in lst:
....:   is_prefixed = False
....:   for possible_prefix in lst:
....:     if element is not possible_prefix and  element.startswith(possible_prefix):
....:       is_prefixed = True
....:       break
....:   if not is_prefixed:
....:     result.append(element)
....: 
1 loops, best of 3: 4.39 s per loop

In [92]: timeit list(my_filter(l))
1 loops, best of 3: 2.94 s per loop

如果您知道最小字符串长度始终> 1，则可以进一步优化，如果最小长度字符串为2则一个单词必须至少具有前两个字母的共同点：

def find(l):
    d = defaultdict(list)
    # find shortest length string to use as key length
    mn = len(min(l, key=len))
    for ele in l:
        d[ele[:mn]].append(ele)

    for val in d.values():
        for v in val:
            if not any(v.startswith(s) and v != s for s in val):
                yield v


In [84]: timeit list(find(l))
100 loops, best of 3: 14.6 ms per loop

最后，如果您有欺骗，则可能要从列表中过滤掉重复的单词，但需要让它们进行比较：

from collections import defaultdict,Counter

def find(l):
    d = defaultdict(list)
    mn = len(min(l, key=len))
    cn = Counter(l)
    for ele in l:
        d[ele[:mn]].append(ele)
    for val in d.values():
        for v in val:
            if not any(v.startswith(s) and v != s for s in val): 
                # make sure v is not a dupe
                if cn[v] == 1:
                    yield v

因此，如果速度很重要，则使用上述代码的某些变体的实现将比您的幼稚方法快得多。 内存中还存储了更多数据，因此您也应该考虑到这一点。

为了节省内存，我们可以为每个val / sublist创建一个计数器，因此我们一次只存储一个单词的计数器dict：

def find(l):
    d = defaultdict(list)
    mn = len(min(l, key=len))
    for ele in l:
        d[ele[:mn]].append(ele)
    for val in d.values():
        # we only need check each grouping of words for dupes
        cn = Counter(val)
        for v in val:
            if not any(v.startswith(s) and v != s for s in val):
                if cn[v] == 1:
                    yield v

创建一个dict，每个循环会增加5毫秒，因此对于5k字来说，仍然<20毫秒。

如果对数据进行排序，则reduce方法应该起作用：

 reduce(r,sorted(l)) # -> ['ab', 'sdfdg', 'too', 'xc', 'xrew']

为了使行为之间的区别清楚：

In [202]: l = ["tool",'ab',"too", 'xc', 'abb',"toot", 'abed',
             "abel", 'sdfdg', 'abfdsdg', 'xccc',"xcew","xrew","ab"]

In [203]: list(filter_list(l))
Out[203]: ['ab', 'too', 'xc', 'sdfdg', 'xrew', 'ab']

In [204]: list(find(l))
Out[204]: ['sdfdg', 'too', 'xc', 'xrew', 'ab', 'ab']

In [205]: reduce(r,sorted(l))
Out[205]: ['ab', 'sdfdg', 'too', 'xc', 'xrew']

In [206]: list(find_dupe(l))
Out[206]: ['too', 'xrew', 'xc', 'sdfdg']

In [207]: list(my_filter(l))
Out[207]: ['sdfdg', 'xrew', 'too', 'xc']
In [208]: "ab".startswith("ab")
Out[208]: True

因此ab重复了两次，因此使用set或dict而不跟踪ab出现的时间意味着我们认为没有其他元素满足ab "ab".startswith(other ) == True ，可以看到是不正确的。

您还可以使用itertools.groupby根据最小索引大小进行分组：

def find_dupe(l):
    l.sort()
    mn = len(min(l, key=len))
    for k, val in groupby(l, key=lambda x: x[:mn]):
        val = list(val)
        for v in val:
            cn = Counter(val)
            if not any(v.startswith(s) and v != s for s in val) and cn[v] == 1:
                yield v

根据您的评论，如果您认为"dd".startswith("dd")不包含重复元素，则我们可以调整我的第一个代码：

l = ['abbb', 'xc', 'abb', 'abed', 'sdfdg', 'xc','abfdsdg', 'xccc', 'd','dd','sdfdg', 'xc','abfdsdg', 'xccc', 'd','dd']


def find_with_dupe(l):
    d = defaultdict(list)
    # group by first letter
    srt = sorted(set(l))
    ind = len(srt[0])
    for ele in srt:
        d[ele[:ind]].append(ele)
    for val in d.values():
        for v in val:
            # check each substring in the sublist
            if not any(v.startswith(s) and v != s for s in val):
                yield v


print(list(find_with_dupe(l)))

['abfdsdg', 'abed', 'abb', 'd', 'sdfdg', 'xc']

在您自己的代码执行的时间的一小部分中，运行在随机文本样本上的运行时间为：

In [15]: l = open("/home/padraic/Downloads/sample.txt").read().split()

In [16]: timeit list(find(l))                                         
100 loops, best of 3: 19 ms per loop

In [17]: %%timeit
   ....: l = open("/home/padraic/Downloads/sample.txt").read().split()
   ....: for i in range(0, len(l) - 1):
   ....:     for j in range(i + 1, len(l)):
   ....:         if l[j].startswith(l[i]):
   ....:             l[j] = l[i]
   ....:         else:
   ....:             if l[i].startswith(l[j]):
   ....:                 l[i] = l[j]
   ....: 

1 loops, best of 3: 4.92 s per loop

两者返回相同的输出：

In [41]: l = open("/home/padraic/Downloads/sample.txt").read().split()

In [42]:  
for i in range(0, len(l) - 1):
    for j in range(i + 1, len(l)):
        if l[j].startswith(l[i]):
            l[j] = l[i]
        else:
            if l[i].startswith(l[j]):
                l[i] = l[j]
   ....:                 


In [43]: 

In [43]: l2 = open("/home/padraic/Downloads/sample.txt").read().split()

In [44]: sorted(set(l)) == sorted(find(l2))
Out[44]: True

Answer 3

Edit3经过沉思后，我编写了此算法。 这是更快，1K倍，比reduce基于由帕德里克·坎宁安（感谢集）提供的大随机数据集为基础的方法。 该算法的复杂度约为O（nlogn），尽管还有一些空间可以进行次要的优化。 它的存储效率也很高。 它大约需要n个额外空间。

def my_filter(l):
    q = sorted(l, reverse=True)
    first = q.pop()
    addfirst = True
    while q:
        candidate = q.pop()
        if candidate == first:
            addfirst = False
            continue
        if not candidate.startswith(first):
            if addfirst:
                yield first
            first, addfirst = candidate, True
    if addfirst:
        yield first

Edit2这件事与我的测试中基于reduce的算法一样快，但是这种比较取决于所使用的数据集。 我只是将教科书页面解析为单词。 该算法基于以下观察。 假设A，B和C为字符串，len（A）<min（len（B），len（C））。 观察一下，如果A是B的前缀，那么只需检查A是否是C的前缀就可以说存在C的前缀。

def my_filter(l):
    q = sorted(l, key=len)
    prefixed = []
    while q:
        candidate = q.pop()
        if any(candidate.startswith(prefix) for prefix in prefixed):
            continue
        if any(candidate.startswith(string) for string in q):
            prefixed.append(candidate)
        else:
           yield candidate

原始帖子这是我提出的原始算法。 实际上，它是算法的简洁版本。

l = ['ab', 'xc', 'abb', 'abed', 'sdfdg', 'abfdsdg', 'xccc']

res = [string for string in l if sum(not string.startswith(prefix) for prefix in l) == len(l)-1]

演示>>>

print res
# ['ab', 'xc', 'sdfdg']

Answer 4

lst = ['ab', 'xc', 'abb', 'abed', 'sdfdg', 'abfdsdg', 'xccc']
result = []

for element in lst:
  is_prefixed = False
  for possible_prefix in lst:
    if element is not possible_prefix and element.startswith(possible_prefix):
      is_prefixed = True
      break
  if not is_prefixed:
    result.append(element)

这是一些实验性的多线程版本：

测试好！

import thread
import math
import multiprocessing

list = ['ab', 'xc', 'abb', 'abed', 'sdfdg', 'abfdsdg', 'xccc']

def get_results(list, thread_num, num_of_threads):  
  result = []
  part_size = int(math.ceil(len(list) * 1.0 / num_of_threads))
  for element in list[part_size * thread_num: part_size * (thread_num + 1)]:    
    is_prefixed = False
    for possible_prefix in list:
      if element is not possible_prefix and     element.startswith(possible_prefix):
    is_prefixed = True
    if not is_prefixed:
      result.append(element)
  return result

num_of_threads = multiprocessing.cpu_count()
results = []
for t in xrange(num_of_threads):  
  thread.start_new_thread(lambda list: results.extend(get_results(list, t, num_of_threads)), (list,))

Answer 5

from collections import Counter


def filter_list(mylist):

    longest_string = len(max(mylist, key=len))

    set_list = [set(filter(lambda x: len(x) == i, mylist))
                for i in range(1, longest_string)]

    def unique_starts_with_filter(string):
        for i in range(1, len(string)):
            if string[:i] in set_list[i-1]: return False
        return True

    cn = Counter(mylist)
    mylist = filter(lambda x: cn[x] == 1, mylist)

    return filter(unique_starts_with_filter, mylist)

（再次）编辑样式和非常小的优化

Answer 6

解决方案1 （使用LinkedList）

这是使用排序（ O(n * log(n)) ）和LinkedList迭代（ O(n) ）并删除元素（ O(1) ）的非常简单的解决方案。 如果对初始数据进行排序，则将按以下方式对元素进行排序：另一个元素的最长前缀元素将与后面的元素相邻。 因此，该元件可以被去除。

这是一个过滤掉排序的LinkedList的代码：

def filter_out(the_list):
    for element in the_list:
        if element.prev_node and element.get_data().startswith(element.prev_node.get_data()):
            the_list.remove(element)

    return the_list

并像这样使用它：

linked_list = LinkedList(sorted(l))
filter_out(linked_list)

然后，您的linked_list将包含过滤的数据。

该解决方案将采用O(n * log(n))

这是LinkedList的实现：

class Node(object):
    def __init__(self, data=None, next_node=None, prev_node=None):
        self.data = data
        self._next_node = next_node
        self._prev_node = prev_node

    def get_data(self):
        return self.data

    @property
    def next_node(self):
        return self._next_node

    @next_node.setter
    def next_node(self, node):
        self._next_node = node

    @property
    def prev_node(self):
        return self._prev_node

    @prev_node.setter
    def prev_node(self, node):
        self._prev_node = node

    def __repr__(self):
        return repr(self.get_data())


class LinkedList(object):
    def __init__(self, iterable=None):
        super(LinkedList, self).__init__()

        self.head = None
        self.tail = None
        self.size = 0

        if iterable:
            for element in iterable:
                self.insert(Node(element))

    def insert(self, node):
        if self.head:
            self.tail.next_node = node
            node.prev_node = self.tail
            self.tail = node
        else:
            self.head = node
            self.tail = node

        self.size += 1

    def remove(self, node):
        if self.size > 1:
            prev_node = node.prev_node
            next_node = node.next_node

            if prev_node:
                prev_node.next_node = next_node
            if next_node:
                next_node.prev_node = prev_node
        else:
            self.head = None
            self.tail = None

    def __iter__(self):
        return LinkedListIter(self.head)

    def __repr__(self):
        result = ''
        for node in self:
            result += str(node.get_data()) + ', '
        if result:
            result = result[:-2]
        return "[{}]".format(result)


class LinkedListIter(object):
    def __init__(self, start):
        super(LinkedListIter, self).__init__()

        self.node = start

    def __iter__(self):
        return self

    def next(self):
        this_node = self.node

        if not this_node:
            raise StopIteration

        self.node = self.node.next_node
        return this_node

解决方案2 （使用集）

如果不需要算法稳定，即结果列表不需要保持元素的原始顺序，这是使用set的解决方案。

因此，让我们做出一些定义：

n列表的大小，即元素数

m列表中字符串元素的最大可能长度

首先，INITIALISE一个新的set inter你原有的list l ：

inter = set(l)

这样，我们将删除所有重复的元素，这将简化我们的进一步工作。 同样，此操作将平均采用O(n)复杂度，而在最坏情况下将采用O(n) O(n^2) 。

然后制作另一个空set ，以保留结果：

result = set()

现在，让我们检查一下每个元素，在我们的inter集中是否有后缀：

for elem in inter:                   # This will take at most O(n)
    no_prefix = True
    for i in range(1, len(elem)):    # This will take at most O(m)
        if elem[:i] in inter:        # This will take avg: O(1), worst: O(n)
            no_prefix = False
            continue

    if no_prefix:
        result.add(elem)             # This will take avg: O(1), worst: O(n)

因此，现在您已经获得了想要的result 。

最后的核心步骤将平均取O(n * (1 * m + 1)) = O(n * m)和O(n * (m * n + n)) = O(n^2 * (m + 1))在最坏的情况下，因此，如果m相比是微不足道的n那么你有O(n)平均和O(n ^ 2)在最坏的情况。

复杂度是根据Python为set数据结构提供的内容来计算的。 为了进一步优化算法，您可以实现自己tree-based set并获得O(n * log(n))复杂度。

Answer 7

我相信以下内容很有可能是最有效的。

from sortedcontainers import SortedSet
def prefixes(l) :
    rtn = SortedSet()
    for s in l:
        rtn.add(s)
        i = rtn.index(s)
        if (i > 0 and s.startswith(rtn[i-1])):
            rtn.remove(s)
        else :
            j = i+1
            while (j < len(rtn) and rtn[j].startswith(s)):
                j+=1
            remove = rtn[i+1:j]
            for r in remove:
                rtn.remove(r)
    return list(rtn)

我认为最重要的情况是输入文件可能很长，而输出文件要小得多。 该解决方案避免了将整个输入文件保存在内存中。 如果对输入文件进行了排序，则它保存的rtn参数永远不会比最终返回的文件长。 此外，它演示了“保持对迄今为止已看到的数据有效的解决方案，并将该解决方案扩展到对每个新数据有效的模式”的模式。 这是一个熟悉的不错的模式。

Answer 8

使用reduce函数的解决方案：

def r(a, b):
    if type(a) is list:
        if len([z for z in a if b.startswith(z)]) == 0:
            a.append(b)
        return a
    if a.startswith(b):
        return b
    if b.startswith(a):
        return a
    return [a, b]

print reduce(r, l)

可能可以进一步优化[z for z in a if b.startswith(z)] 。

Answer 9

您可以尝试这种简短的解决方案。

import re
l = ['ab', 'xc', 'abb', 'abed', 'sdfdg', 'abfdsdg', 'xccc']
newl=[]
newl.append(l[0])
con=re.escape(l[0])

for i in l[1:]:
    pattern=r"^(?!(?:"+con+r")).*$"
    if re.match(pattern,i):
        newl.append(i)
        con=con+"|"+re.escape(i)


print newl

编辑：用于长列表

import re
l = ['ab', 'xc', 'abb', 'abed', 'sdfdg', 'abfdsdg', 'xccc']
newl=[]
newl.append(l[0])
con=re.escape(l[0])

for i in l[1:]:
    for x in re.split("\|",con):
        pattern=r"^(?="+x+r").*$"
        if re.match(pattern,i):
            break
    else:
        newl.append(i)
        con=con+"|"+re.escape(i)


print newl