Question

条目需要更低，最后程序必须打印出现次数。例如mem。

smthing = str(input())
if (smthing == smthing.lower()):
    smthing.find(mem)

我完全沉溺于此，所以我无法走远。

我忘了告诉我不能使用计数或列表。

Answer 1

像

这样的东西

string = "hello world hello".lower()
replace = "hello".lower()
count = 0

while string.find(replace) != -1:
    string = string.replace(replace, "", 1)
    count += 1

print count
# => Output
# => 2

要处理重叠的字符串，而不是替换整个子字符串，我们只需要替换单个字符，最好是原始字符串中的第一个字符replace[0]

string = "boboobobobobob".lower()
replace = "bob".lower()
count = 0 

while string.find(replace) != -1:
    string = string.replace(replace[0], "", 1)
    count += 1

print count
# Output
# => 6

Answer 2

如果你有重叠的字符串，你需要一次更换一个字符：

sub = "bob"
smthing = input()
count = 0

for i in iter(lambda: smthing.find(sub), -1):
    smthing = smthing.replace(sub[0], "", 1)
    count += 1
print(count)

因此，对于boboobobobobob，您将获得6而不是3。

如果您不能使用计数但可以使用其中任何一种，您可以单独使用替换，但这不会包含重叠：

print((len(smthing) - len(smthing.replace(sub,""))) / len(sub))

Answer 3

试试这段代码：

smthing = "blablabla"
mem = "bl"
count = 0
if (smthing == smthing.lower()):
    bkpsmthing = smthing # maybe you'll need it later
    while (smthing.find(mem) > -1):
        smthing = smthing.replace(mem, '', 1)
        count += 1
print count

它使用str.find在没有找到任何内容时返回-1的事实，或者指向要停止的最低条目的索引：

返回找到子字符串sub的s中的最低索引，使得sub完全包含在s [start：end]中。失败时返回-1。

它还使用str.replace可以使用thrid参数（maxreplace）删除单个条目（最低）的事实。这样我们就会不断删除我们计算过的条目：

...如果给出了可选参数maxreplace，则替换第一个maxreplace事件。

这个过程可以这样描述：

find "bl" in "blablabla" -> found at index 0
replace "bl" in "blablabla" -> gives "ablabla"
find "bl" in "ablabla" -> found at index 1
replace "bl" in "ablabla" -> gives "aabla"
find "bl" in "aabla" -> found at index 2
replace "bl" in "aabla" -> gives "aaa"
find "bl" in "aaa" -> not found, returns -1
stop

要对count变量执行相同操作，请使用此简单递归（确保在使用my_count之前验证字符串是小写的）：

def my_count(my_string, my_substring):
    if my_string.find(my_substring) > -1:
        new_string = my_string.replace(my_substring, '', 1)
        return my_count(new_string, my_substring) + 1
    return 0

输出：

>>> my_count("blablabla", "bl")
3

递归展开如下：

my_count("blablabla", "bl") =
= my_count("ablabla", "bl") + 1 =
= my_count("aabla", "bl") + 1 + 1 =
= my_count("aaa", "bl") + 1 + 1 + 1 =
= 0 + 1 + 1 + 1 = 3

Answer 4

你没有;你需要额外的工具，可能只需要基本算法。例如，如果使用不同长度的子字符串替换子字符串，则可以将结果的长度与原始字符串进行比较，以计算出现的次数。另一种选择是使用start参数来查找其他出现的情况。我很想知道你尝试了什么;您显示的代码不会产生任何结果。

Answer 5

对于记录，您可以仅使用string.replace()执行此操作：

smthing = str(input())  
word='mem'
x=0

while word in smthing:
    smthing=smthing.replace(word,'',1)
    x+=1

print x

演示：

>>> 
memory memory memory
3

Answer 6

您的问题 - 查找和计算字符串中所有出现的子字符串 - 无需按定义进行替换。

您应该能够接受输入，强制降低输入，并使用count方法查找子串。

num_substrings = input().lower().count(substring)

Answer 7

我还没有看到这种方法，只是循环查找计数出现次数：

a='this is a test aaaa'
count =0
loc = a.find('is')
while loc > -1:
    count += 1
    loc = a.find('is',loc+1)
print count -1

如何仅使用find和replace查找并计算字符串中所有子字符串的出现次数？

7 个答案: