关于python函数重叠的问题

Estinien

编写函数overlapping(start, end），对于两个给定的字符串，确定开始结束的字符与结束开始的字符重叠的数量。例如，“hell”和“llo”的重叠为 2，因为第一个以“ll”结尾，第二个以“ll”开头。更多示例在下面的测试单元中。

我写的：
def overlapping(start, end):
    prefits=set()
    postfits=set()
    prefitt=set()
    postfitt=set()
    for i in range(1,len(start)+1):
        prefits.add(start[:i])
    for i in range(len(start)):
        postfits.add(start[i:])
    for i in range(1,len(end)+1):
        prefitt.add(end[:i])
    for i in range(len(end)):
        postfitt.add(end[i:])
    result=list((prefits&postfitt)|(postfits&prefitt))
    if len(result)==0:
        return 0
    else:
        max_overlap=result[0]
        max_length=len(result[0])
        for i in range(len(result)):
             if len(result[i])>max_length:
                 max_length=len(result[i])
                 max_overlap=result[i]
        return len(max_overlap)


测试：
assert overlapping("hell", "llo") == 2
assert overlapping("abracadabra", "abrasive") == 4
assert overlapping("hello", "goodbye") == 0
assert overlapping("hello", "hell") == 0
assert overlapping("hell", "smell") == 0

请问测试我这个为什么是错的

逃兵

有start和end之分这里不能为4

1. >>> overlapping("hello", "hell")
   
2. 4

复制代码

阿奇_o

你为什么会用集合呢？ 集合里元素是唯一的、是去重复的！

1. >>> set(list('hell'))
   
2. {'l', 'e', 'h'}
   
3. >>> set(list('hell')) | set(list('lloo'))
   
4. {'l', 'e', 'o', 'h'}
   
5. >>> set(list('hell')) & set(list('lloo'))
   
6. {'l'}
   
7. >>>

复制代码

根据题意，你只需要分别对两个字符串切片（切尾，切头），
切1个 比较看是否相等，相等 就计数器+1，然后继续切到第二个字符，直到不相等而停止。
比如：

1. 
   
2. >>> s1, s2 = 'hell', 'lloo'
   
3. >>> def overlap(s1, s2):
   
4.         cnt = 0
   
5.         for i in range(len(s1)):
   
6.                 if s1[-(i+1):] == s2[:i+1]:
   
7.                         cnt += 1
   
8.                 else:
   
9.                         break
   
10.         return cnt
    
11. 
    
12. >>> overlap(s1, s2)
    
13. 2
    
14. >>> overlap('hello', 'good')
    
15. 0
    
16. >>>

复制代码

白two

看了一下你的需求，是 第一个字符 结束的字符 和 第二个字符 开始的字符重叠的数量吧
那么只需要两个集合，第一个集合存放第一个字符结束所有的情况第二个集合存放第二个字符开始的所有情况

代码如下：

1. def overlapping(start, end):
   
2.     postfits=set()
   
3.     prefitt=set()
   
4.     for i in range(len(start)):
   
5.         postfits.add(start[i:])
   
6.     for i in range(1,len(end)+1):
   
7.         prefitt.add(end[:i])
   
8.     result=list(postfits&prefitt)
   
9.     if len(result)==0:
   
10.         return 0
    
11.     else:
    
12.         max_overlap=result[0]
    
13.         max_length=len(result[0])
    
14.         for i in range(len(result)):
    
15.              if len(result[i])>max_length:
    
16.                  max_length=len(result[i])
    
17.                  max_overlap=result[i]
    
18.         return len(max_overlap)
    
19. print (overlapping("hell", "llo") == 2)
    
20. print (overlapping("abracadabra", "abrasive") == 4)
    
21. print (overlapping("hello", "goodbye") == 0)
    
22. print (overlapping("hello", "hell") == 0)
    
23. print (overlapping("hell", "smell") == 0)
    

复制代码

运行结果：

1. True
   
2. True
   
3. True
   
4. True
   
5. True

复制代码

你的错误在于把第一个字符开始的情况，第二个字符结束的情况也纳入进去了
就导致两个字符开始或者结尾只要有重叠的字符串都会被算进去