重叠出现的字符串计数

Posted 2023-02-23

【中文标题】重叠出现的字符串计数

【英文标题】：String count with overlapping occurrences

【发布时间】：2011-02-27 13:41:00

【问题描述】：

计算给定字符串出现次数的最佳方法是什么，包括 Python 中的重叠？这是一种方式：

def function(string, str_to_search_for):
      count = 0
      for x in xrange(len(string) - len(str_to_search_for) + 1):
           if string[x:x+len(str_to_search_for)] == str_to_search_for:
                count += 1
      return count


function('1011101111','11')

此方法返回 5。

在 Python 中有更好的方法吗？

【参考方案1】：

嗯，这个可能会更快，因为它在 C 中进行比较：

def occurrences(string, sub):
    count = start = 0
    while True:
        start = string.find(sub, start) + 1
        if start > 0:
            count+=1
        else:
            return count

【参考方案2】：

>>> import re
>>> text = '1011101111'
>>> len(re.findall('(?=11)', text))
5

如果您不想将整个匹配列表加载到内存中，这绝对不是问题！如果你真的想要，你可以这样做：

>>> sum(1 for _ in re.finditer('(?=11)', text))
5

作为一个函数（re.escape 确保子字符串不会干扰正则表达式）：

>>> def occurrences(text, sub):
        return len(re.findall('(?=0)'.format(re.escape(sub)), text))

>>> occurrences(text, '11')
5

【参考方案3】：

您也可以尝试使用支持重叠匹配的new Python regex module。

import regex as re

def count_overlapping(text, search_for):
    return len(re.findall(search_for, text, overlapped=True))

count_overlapping('1011101111','11')  # 5

【参考方案4】：

Python 的 str.count 计算不重叠的子字符串：

In [3]: "ababa".count("aba")
Out[3]: 1

这里有几种计算重叠序列的方法，我相信还有更多:)

前瞻正则表达式

How to find overlapping matches with a regexp?

In [10]: re.findall("a(?=ba)", "ababa")
Out[10]: ['a', 'a']

生成所有子字符串

In [11]: data = "ababa"
In [17]: sum(1 for i in range(len(data)) if data.startswith("aba", i))
Out[17]: 2

【讨论】：

更简洁sum(data.startswith("aba", i) for i, _ in enumerate(data)) :)

【参考方案5】：

def count_substring(string, sub_string):
    count = 0
    for pos in range(len(string)):
        if string[pos:].startswith(sub_string):
            count += 1
    return count

这可能是最简单的方法。

【参考方案6】：

s = "bobobob"
sub = "bob"
ln = len(sub)
print(sum(sub == s[i:i+ln] for i in xrange(len(s)-(ln-1))))

【参考方案7】：

如何在另一个字符串中找到重叠的模式

这个函数（另一种解决方案！）接收一个模式和一个文本。返回一个列表，其中包含所有位于 及其位置的子字符串。

def occurrences(pattern, text):
    """
    input: search a pattern (regular expression) in a text
    returns: a list of substrings and their positions 
    """
    p = re.compile('(?=(0))'.format(pattern))
    matches = re.finditer(p, text)
    return [(match.group(1), match.start()) for match in matches]

print (occurrences('ana', 'banana'))
print (occurrences('.ana', 'Banana-fana fo-fana'))

[('ana', 1), ('ana', 3)] [('Bana', 0), ('nana', 2), ('fana', 7), ('fana', 15)]

【参考方案8】：

我对课程中鲍勃问题的回答：

s = 'azcbobobegghaklbob'
total = 0
for i in range(len(s)-2):
    if s[i:i+3] == 'bob':
        total += 1
print 'number of times bob occurs is: ', total

【参考方案9】：

一种相当 Python 的方式是在这里使用列表推导，尽管它可能不是最有效的。

sequence = 'abaaadcaaaa'
substr = 'aa'

counts = sum([
    sequence.startswith(substr, i) for i in range(len(sequence))
])
print(counts)  # 5

列表将是[False, False, True, False, False, False, True, True, False, False]，因为它会检查字符串中的所有索引，因为int(True) == 1，sum 为我们提供了匹配的总数。

【参考方案10】：

这是我的 edX MIT "find bob"* 解决方案（*在名为 s 的字符串中查找 "bob" 出现的次数），它基本上计算给定 substing 的重叠出现次数：

s = 'azcbobobegghakl'
count = 0

while 'bob' in s:
    count += 1 
    s = s[(s.find('bob') + 2):]

print "Number of times bob occurs is: ".format(count)

【参考方案11】：

这可以使用正则表达式来解决。

import re
def function(string, sub_string):
    match = re.findall('(?='+sub_string+')',string)
    return len(match)

【参考方案12】：

def count_substring(string, sub_string):
    counter = 0
    for i in range(len(string)):
        if string[i:].startswith(sub_string):
        counter = counter + 1
    return counter

上面的代码只是在整个字符串中循环一次，并不断检查是否有任何字符串以正在计算的特定子字符串开头。

【参考方案13】：

def count_overlaps (string, look_for):
    start   = 0
    matches = 0

    while True:
        start = string.find (look_for, start)
        if start < 0:
            break

        start   += 1
        matches += 1

    return matches

print count_overlaps ('abrabra', 'abra')

【参考方案14】：

将两个字符串作为输入并计算 sub 在字符串中出现的次数（包括重叠）的函数。为了检查 sub 是否是子字符串，我使用了in 运算符。

def count_Occurrences(string, sub):
    count=0
    for i in range(0, len(string)-len(sub)+1):
        if sub in string[i:i+len(sub)]:
            count=count+1
    print 'Number of times sub occurs in string (including overlaps): ', count

【参考方案15】：

对于重复的question，我决定将其计数为 3 乘 3 并比较字符串，例如

counted = 0

for i in range(len(string)):

    if string[i*3:(i+1)*3] == 'xox':
       counted = counted +1

print counted

【参考方案16】：

另一种非常接近接受的答案，但使用while 作为if 测试，而不是在循环中包含if：

def countSubstr(string, sub):
    count = 0
    while sub in string:
        count += 1
        string = string[string.find(sub) + 1:]
    return count;

这避免了while True:，在我看来更干净一些

【参考方案17】：

如果字符串很大，你想使用Rabin-Karp，总结一下：

子字符串大小的滚动窗口，在字符串上移动 添加和删除开销为 O(1) 的哈希（即移动 1 个字符） 用 C 实现或依赖 pypy

【参考方案18】：

这是另一个使用 str.find() 的例子，但很多答案使它变得比必要的复杂：

def occurrences(text, sub):
    c, n = 0, text.find(sub)
    while n != -1:
        c += 1
        n = text.find(sub, n+1)
    return c

In []:
occurrences('1011101111', '11')

Out[]:
5

【参考方案19】：

给定

sequence = '1011101111'
sub = "11"

代码

在这种特殊情况下：

sum(x == tuple(sub) for x in zip(sequence, sequence[1:]))
# 5

一般来说，这个

windows = zip(*([sequence[i:] for i, _ in enumerate(sequence)][:len(sub)]))
sum(x == tuple(sub) for x in windows)
# 5

或扩展到生成器：

import itertools as it


iter_ = (sequence[i:] for i, _ in enumerate(sequence))
windows = zip(*(it.islice(iter_, None, len(sub))))
sum(x == tuple(sub) for x in windows)

---

替代方案

你可以使用more_itertools.locate:

import more_itertools as mit


len(list(mit.locate(sequence, pred=lambda *args: args == tuple(sub), window_size=len(sub))))
# 5

【参考方案20】：

计算子字符串出现次数的一种简单方法是使用count()：

>>> s = 'bobob'
>>> s.count('bob')
1

如果您知道哪一部分会重叠，您可以使用replace () 查找重叠字符串：

>>> s = 'bobob'
>>> s.replace('b', 'bb').count('bob')
2

请注意，除了静态之外，还有其他限制：

>>> s = 'aaa'
>>> count('aa') # there must be two occurrences
1 
>>> s.replace('a', 'aa').count('aa')
3

【参考方案21】：

def occurance_of_pattern(text, pattern):
    text_len , pattern_len = len(text), len(pattern)
    return sum(1 for idx in range(text_len - pattern_len + 1) if text[idx: idx+pattern_len] == pattern) 

【参考方案22】：

re.subn 尚未被提及：

>>> import re
>>> re.subn('(?=11)', '', '1011101111')[1]
5

【参考方案23】：

我想看看相同前缀字符的输入数量是否相同后缀，例如"foo"和"""foo""但在"""bar""上失败：

from itertools import count, takewhile
from operator import eq


# From https://***.com/a/15112059
def count_iter_items(iterable):
    """
    Consume an iterable not reading it into memory; return the number of items.

    :param iterable: An iterable
    :type iterable: ```Iterable```

    :return: Number of items in iterable
    :rtype: ```int```
    """
    counter = count()
    deque(zip(iterable, counter), maxlen=0)
    return next(counter)


def begin_matches_end(s):
    """
    Checks if the begin matches the end of the string

    :param s: Input string of length > 0
    :type s: ```str```

    :return: Whether the beginning matches the end (checks first match chars
    :rtype: ```bool```
    """
    return (count_iter_items(takewhile(partial(eq, s[0]), s)) ==
            count_iter_items(takewhile(partial(eq, s[0]), s[::-1])))

【参考方案24】：

如果您想计算长度为 5 的排列计数（如果需要，可以针对不同的长度进行调整）：

def MerCount(s):
  for i in xrange(len(s)-4):
    d[s[i:i+5]] += 1
return d

【讨论】：

'count permutation counts' 对我来说没有多大意义。 d 不是定义的名称。如果代码确实运行，它不会回答问题。