[已解决]29讲动手1和动手2 没有理解代码

TJ0929

1. # 动手0 重叠的判断不了
   
2. text = input("What text:")
   
3. words = input("What words:")
   
4. words = words.split()
   
5. ans = []
   
6. w0 = words[0]
   
7. len1 = len(text)
   
8. len2 = 0
   
9. i_copy = 0
   
10. for each in words:
    
11.     len2 = len(each)
    
12.     w0 = each[0]
    
13.     for i in range (0,len1):
    
14.         len0 = 1
    
15.         if text[i] == w0:
    
16.             i_copy = i
    
17.             for j in range(1,len2):
    
18.                 i = i + 1
    
19.                 if each[j] == text[i]:
    
20.                     len0 += 1
    
21.                     if len0 == len2:
    
22.                         ans.append([i_copy,i_copy+len2-1])
    
23.                 else:
    
24.                     break
    
25.         else:
    
26.             continue
    
27. print(ans)

复制代码

动手0 的代码我直接用循环判断了，确实很复杂，但是没有想到答案用find的方法，一下子忘记这个函数了，想问问如果就是单纯用循环的话，应该怎么做呢？目前这个代码可以判断前两种情况，但是没有办法判断那种重复出现的代码就是第三种情况，请问应该怎么修改呢？

1. # 动手1 答案
   
2. s = input("请输入一个由字母构成的字符串：")
   
3. 
   
4.    
   
5. 
   
6. n = len(s)
   
7. 
   
8. for i in range(1, n//2+1):
   
9. 
   
10.     # 如果子字符串的长度为i，则n必须可以被i整除才行
    
11. 
    
12.     if n % i == 0:
    
13. 
    
14.         # 如果子字符串的长度为i，则i到i*2之间是一个重复的子字符串
    
15. 
    
16.         if s.startswith(s[i:i*2]) and s.count(s[i:i*2]) == n/i:
    
17. 
    
18.             print(True)
    
19. 
    
20.             break
    
21. 
    
22. # for...else的用法，小甲鱼希望大家还没有忘记哦^o^
    
23. 
    
24. else:
    
25. 
    
26.     print(False)

复制代码

动手1完全不太理解，可以详细解释一下代码吗？

最佳答案

月排行榜 / 总排行榜

FishC

2025-3-8 14:12:09

29讲 动手0: 重叠判断代码说明

下面是一个用于判断文本中是否存在重复单词的简单示例：

1. text = input("What text: ")
   
2. words = input("What words: ")
   
3. words = words.split()
   
4. ans = []
   
5. len1 = len(text)
   
6. 
   
7. for each in words:
   
8.     index = 0
   
9.     while index < len1:
   
10.         index = text.find(each, index)
    
11.         if index == -1:
    
12.             break
    
13.         else:
    
14.             ans.append((each, index))
    
15.             index += len(each)  # 更新索引以继续搜索下一个可能的重复
    
16. 
    
17. print(ans)

复制代码

解释：

• text.find(each, index) 用于在字符串 text 中从位置 index 开始查找子串 each。
• 每找到一个匹配的起始索引后，将其添加到 ans 列表，同时更新 index 以绕过当前匹配继续查找。
• 这种方法较易处理字符串中单词的重叠和重复问题。
  

29讲 动手1: 字符串重复子串问题代码解释

下面是代码的详细解释：

1. s = input("请输入一个由字母构成的字符串：")
   
2. n = len(s)
   
3. 
   
4. for i in range(1, n//2+1):
   
5.     # 如果子字符串的长度为i，则n必须可以被i整除才行
   
6.     if n % i == 0:
   
7.         sub = s[:i]  # 取得可能的重复子串
   
8.         # 如果子字符串的长度为i，则i到i*2之间是一个重复的子字符串
   
9.         if s.startswith(sub) and s.count(sub) == n // i:
   
10.             print(True)
    
11.             break
    
12. else:
    
13.     print(False)

复制代码

解释：

• 首先读取输入字符串并计算其长度 n。
• for i in range(1, n//2+1): 内循环从长度为1的子串开始检查，遍历可能的子串长度，直到一半长度位置。
• 仅当字符串总长度能均分为若干子串时，才有可能存在完整重复子串。if n % i == 0: 检查能否整除。
• sub = s[:i] 取出一个可能的子串。
• s.startswith(sub) and s.count(sub) == n // i 检查子串是否为字符串开头部分，且该子串出现次数应能覆盖整个字符串。
• 找到合法的子串马上返回 True 并 break。
• 如果遍历所有可能且没找到，最终执行 else 的 print(False)。
  

这种结构效率较高，因为只在可能的周期长度情况下深入验证子串。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

跳转到最佳答案楼层

FishC

29讲 动手0: 重叠判断代码说明

下面是一个用于判断文本中是否存在重复单词的简单示例：

1. text = input("What text: ")
   
2. words = input("What words: ")
   
3. words = words.split()
   
4. ans = []
   
5. len1 = len(text)
   
6. 
   
7. for each in words:
   
8.     index = 0
   
9.     while index < len1:
   
10.         index = text.find(each, index)
    
11.         if index == -1:
    
12.             break
    
13.         else:
    
14.             ans.append((each, index))
    
15.             index += len(each)  # 更新索引以继续搜索下一个可能的重复
    
16. 
    
17. print(ans)

复制代码

解释：

• text.find(each, index) 用于在字符串 text 中从位置 index 开始查找子串 each。
• 每找到一个匹配的起始索引后，将其添加到 ans 列表，同时更新 index 以绕过当前匹配继续查找。
• 这种方法较易处理字符串中单词的重叠和重复问题。
  

29讲 动手1: 字符串重复子串问题代码解释

下面是代码的详细解释：

1. s = input("请输入一个由字母构成的字符串：")
   
2. n = len(s)
   
3. 
   
4. for i in range(1, n//2+1):
   
5.     # 如果子字符串的长度为i，则n必须可以被i整除才行
   
6.     if n % i == 0:
   
7.         sub = s[:i]  # 取得可能的重复子串
   
8.         # 如果子字符串的长度为i，则i到i*2之间是一个重复的子字符串
   
9.         if s.startswith(sub) and s.count(sub) == n // i:
   
10.             print(True)
    
11.             break
    
12. else:
    
13.     print(False)

复制代码

解释：

• 首先读取输入字符串并计算其长度 n。
• for i in range(1, n//2+1): 内循环从长度为1的子串开始检查，遍历可能的子串长度，直到一半长度位置。
• 仅当字符串总长度能均分为若干子串时，才有可能存在完整重复子串。if n % i == 0: 检查能否整除。
• sub = s[:i] 取出一个可能的子串。
• s.startswith(sub) and s.count(sub) == n // i 检查子串是否为字符串开头部分，且该子串出现次数应能覆盖整个字符串。
• 找到合法的子串马上返回 True 并 break。
• 如果遍历所有可能且没找到，最终执行 else 的 print(False)。
  

这种结构效率较高，因为只在可能的周期长度情况下深入验证子串。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

jackz007

         使用 find() 的版本

1. text  = input(" What text : ")
   
2. words = input("What words : ")
   
3. e = []
   
4. for w in words . split(' ') :
   
5.     k = text . find(w , 0)
   
6.     while k != -1 :
   
7.         e . append([k , k + len(w) - 1])
   
8.         k = text . find(w , k + 1)
   
9. if e:
   
10.     e . sort()
    
11.     print(e)

复制代码

        不使用 find() 的版本：

1. text  = input(" What text : ")
   
2. words = input("What words : ")
   
3. e = []
   
4. for w in words . split(' ') :
   
5.     for k in range(len(text) - len(w) + 1) :
   
6.         if text[k : k + len(w)] == w :
   
7.             e . append([k , k + len(w) - 1])
   
8. if e:
   
9.     e . sort()
   
10.     print(e)

复制代码

运行实况;

1. D:\[00.Exercise]\[Python]>python x.py
   
2. What text : I love FishC and FishC love me
   
3. What words : FishC
   
4. [[7, 11], [17, 21]]
   
5. 
   
6. D:\[00.Exercise]\[Python]>python x.py
   
7. What text : I love FishC and FishC love me
   
8. What words : FishC love
   
9. [[2, 5], [7, 11], [17, 21], [23, 26]]
   
10. 
    
11. D:\[00.Exercise]\[Python]>python x.py
    
12. What text : FCFCF
    
13. What words : FCF FC
    
14. [[0, 1], [0, 2], [2, 3], [2, 4]]
    
15. 
    
16. D:\[00.Exercise]\[Python]>

复制代码

TJ0929

jackz007 发表于 2025-3-8 16:23
使用 find() 的版本

谢谢回复，就是您的代码每次都非常简洁，所以我有一些些没有理解，谢谢