[已解决]Python判断密码强度问题

icecocotea

如果满足以下条件，一个密码被认为是强大的。
它至少有6个字符，最多有20个字符。
它至少包含一个小写字母，至少一个大写字母，以及至少一个数字。
它不包含三个连续的重复字符（例如，"...aaa... "是弱的，但"...aa...a... "是强的，假设其他条件都满足）。
给定一个字符串密码，返回使密码变强所需的最少步骤。如果密码已经很强，返回0。
在一个步骤中，你可以
在密码中插入一个字符。
从密码中删除一个字符，
或用另一个字符替换密码中的一个字符。

例1:
输入：密码 = "a"
输出。5
例2:
输入：密码 = "aA1"
输出。3
例子3:
输入：密码 = "1337C0d3"
输出。0


刚学一个月，就遇到这样的难题，希望大佬们的帮助。

最佳答案

月排行榜 / 总排行榜

qq1151985918

2021-10-17 17:52:06

icecocotea 发表于 2021-10-17 07:40
十分感谢层主的回答，您的代码我测试过，已经十分完美了。但好像还是有BUG。
比如我输入30个字母a:

我又修改了，你再试试看

1. def isLengthEnough(s):
   
2.     if 6 <= len(s) <= 20:
   
3.         return True
   
4.     else:
   
5.         return False
   
6. 
   
7. def isNumIn(s):
   
8.     for i in s:
   
9.         if i.isdigit():
   
10.             return True
    
11.     else:
    
12.         return False
    
13.    
    
14. def isLowIn(s):
    
15.     for i in s:
    
16.         if i.islower():
    
17.             return True
    
18.     else:
    
19.         return False
    
20. 
    
21. def isCapIn(s):
    
22.     for i in s:
    
23.         if i.isupper():
    
24.             return True
    
25.     else:
    
26.         return False
    
27. 
    
28. def isNotRepeat3(s):
    
29.     for i in set(s):
    
30.         if i * 3 in s:
    
31.             return False
    
32.     else:
    
33.         return True
    
34. 
    
35. def allRepeat3(s):
    
36.     r = []
    
37.     while not isNotRepeat3(s):
    
38.         for i in s:
    
39.             for j in range(len(s), 2, -1):
    
40.                 if i * j in s:
    
41.                     for k in range(s.count(i * j)):
    
42.                         r.append(i * j)
    
43.                     s = s.replace(i * j, "")
    
44.                     break
    
45.     return sorted(r, key=lambda x:len(x), reverse=True)
    
46. 
    
47. def run(s):
    
48.     r = sum([isLengthEnough(s), isNumIn(s), isLowIn(s), isCapIn(s), isNotRepeat3(s)])
    
49.     if r == 5:
    
50.         result = 0
    
51.     elif sum([isLengthEnough(s), isNotRepeat3(s)]) == 0:
    
52.         res1 = 6 - len(s) if len(s) < 6 else len(s) - 20
    
53.         t, flg, allR = 0, False, allRepeat3(s)
    
54.         for i in allR:
    
55.             if flg:
    
56.                 t += len(s) - len(allR[0])
    
57.                 break
    
58.             elif not flg and len(i) > 20:
    
59.                 flg = True
    
60.                 t += len(i) - 20 + (20 // 3)
    
61.             else:
    
62.                 t += len(i) // 3
    
63.         res2 = t if t > 3 - r else 3 - r
    
64.         result = res1 if res1 > res2 else res2
    
65.     elif not isLengthEnough(s):
    
66.         t = 6 - len(s) if len(s) < 6 else len(s) - 20
    
67.         result = t if t > 4 - r else 4 - r
    
68.     elif not isNotRepeat3(s):
    
69.         t = 0
    
70.         for i in allRepeat3(s):
    
71.             t += len(i) // 3
    
72.         result = t if t > 4 - r else 4 - r
    
73.     else:
    
74.         result = 5 - r
    
75.     return result
    
76. 
    
77. if __name__ == "__main__":
    
78.     password = input("输入密码：")
    
79.     print("密码变强所需的最少步骤：", run(password))
    

复制代码

跳转到最佳答案楼层

Stubborn

乍看很简单，其实很难 输入数据无限制吗？提的问题没有漏什么东西把

傻眼貓咪

我的代码仅供参考，你的题目相当有水准，我喜欢

1. def isRepeating(password: str) -> int:
   
2.         res = 0
   
3.         a = password[0]
   
4.         temp = -1
   
5.         for n, p in enumerate(password):
   
6.                 if n:
   
7.                         if a == p:
   
8.                                 temp += 1
   
9.                         elif temp > 0:
   
10.                                 res += temp
    
11.                                 temp = -1
    
12.                                 a = p
    
13.                         else:
    
14.                                 temp = -1
    
15.                                 a = p
    
16.         return res if temp < 1 else res+temp
    
17. 
    
18. def isInsufficient(password: str) -> int:
    
19.         res = 0
    
20.         return res if len(password) >= 6 and len(password) <= 20 else 6-len(password) if len(password) < 6 else len(password)-20
    
21. 
    
22. def isConditional(password: str) -> int:
    
23.         if len(password) < 4: return 0
    
24.         digit = False
    
25.         bigCap = False
    
26.         smallCap = False
    
27.         for i in password:
    
28.                 if i.isdigit():
    
29.                         digit = True
    
30.                 elif i.islower():
    
31.                         smallCap = True
    
32.                 elif i.isupper():
    
33.                         bigCap = True
    
34.         return 0 if all([digit, bigCap, smallCap]) else\
    
35.                 1 if all([digit, bigCap]) or\
    
36.                         all([bigCap, smallCap]) or\
    
37.                                 all([digit, smallCap]) else\
    
38.                                         2 if digit or bigCap or smallCap else 3
    
39. 
    
40. def main():
    
41.         password = input("输入密码：")
    
42.         res = isRepeating(password) + isInsufficient(password) + isConditional(password)
    
43.         print(f"密码变强所需的最少步骤：{res}")
    
44. 
    
45. if __name__ == "__main__":
    
46.         main()

复制代码

1. 输入密码：a
   
2. 密码变强所需的最少步骤：5
   
3. 
   
4. 输入密码：aA1
   
5. 密码变强所需的最少步骤：3
   
6. 
   
7. 输入密码：1337C0d3
   
8. 密码变强所需的最少步骤：0
   

复制代码

qq1151985918

这题目非常弯弯绕，即使我几经修改仍然认为可能存在BUG，如果错误请提供案例

1. def isLengthEnough(s):
   
2.     if 6 <= len(s) <= 20:
   
3.         return True
   
4.     else:
   
5.         return False
   
6. 
   
7. def isNumIn(s):
   
8.     for i in s:
   
9.         if i.isdigit():
   
10.             return True
    
11.     else:
    
12.         return False
    
13.    
    
14. def isLowIn(s):
    
15.     for i in s:
    
16.         if i.islower():
    
17.             return True
    
18.     else:
    
19.         return False
    
20. 
    
21. def isCapIn(s):
    
22.     for i in s:
    
23.         if i.isupper():
    
24.             return True
    
25.     else:
    
26.         return False
    
27. 
    
28. def isNotRepeat3(s):
    
29.     for i in set(s):
    
30.         if i * 3 in s:
    
31.             return False
    
32.     else:
    
33.         return True
    
34. 
    
35. def allRepeat3(s):
    
36.     r = []
    
37.     while not isNotRepeat3(s):
    
38.         for i in s:
    
39.             for j in range(len(s), 2, -1):
    
40.                 if i * j in s:
    
41.                     for k in range(s.count(i * j)):
    
42.                         r.append(i * j)
    
43.                     s = s.replace(i * j, "")
    
44.                     break
    
45.     return sorted(r, key=lambda x:len(x), reverse=True)
    
46. 
    
47. def run(s):
    
48.     r = sum([isLengthEnough(s), isNumIn(s), isLowIn(s), isCapIn(s), isNotRepeat3(s)])
    
49.     if r == 5:
    
50.         result = 0
    
51.     elif sum([isLengthEnough(s), isNotRepeat3(s)]) == 0:
    
52.         res1 = 6 - len(s) if len(s) < 6 else len(s) - 20
    
53.         t, flg, allR = 0, False, allRepeat3(s)
    
54.         for i in allR:
    
55.             if flg:
    
56.                 t += len(s) - len(allR[0])
    
57.                 break
    
58.             elif not flg and len(i) > 20:
    
59.                 flg = True
    
60.                 t += len(i) - 20 + (20 // 3)
    
61.             else:
    
62.                 t += len(i) // 3
    
63.         res2 = t if t > 3 - r else 3 - r
    
64.         result = res1 if res1 > res2 else res2
    
65.     elif not isLengthEnough(s):
    
66.         t = 6 - len(s) if len(s) < 6 else len(s) - 20
    
67.         result = t if t > 4 - r else 4 - r
    
68.     elif not isNotRepeat3(s):
    
69.         t = 0
    
70.         for i in allRepeat3(s):
    
71.             t += len(i) // 3
    
72.         result = t if t > 4 - r else 4 - r
    
73.     else:
    
74.         result = 5 - r
    
75.     return result
    
76. 
    
77. if __name__ == "__main__":
    
78.     password = input("输入密码：")
    
79.     print("密码变强所需的最少步骤：", run(password))
    

复制代码

qq1151985918

傻眼貓咪 发表于 2021-10-16 19:57
我的代码仅供参考，你的题目相当有水准，我喜欢

我测试楼主代码，发现一些BUG，提供案例如下
另外希望楼主从你的角度看下我代码是否还有BUG
我已经修改七八次了，仍然感觉可能会有BUG，但是没找出，希望楼主看看
如果发现BUG请提供下案例

1. 输入密码：aaaaa
   
2. 密码变强所需的最少步骤：6
   
3. 输入密码：aaaa
   
4. 密码变强所需的最少步骤：6
   
5. 输入密码：aaa
   
6. 密码变强所需的最少步骤：4
   
7. 输入密码：aaabbbbbb111111
   
8. 密码变强所需的最少步骤：10

复制代码

icecocotea

qq1151985918 发表于 2021-10-16 23:14
我测试楼主代码，发现一些BUG，提供案例如下
另外希望楼主从你的角度看下我代码是否还有BUG
我已经修改 ...

十分感谢层主的回答，您的代码我测试过，已经十分完美了。但好像还是有BUG。
比如我输入30个字母a:

输入密码：aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
密码变强所需的最少步骤： 10

貌似，修改密码的步骤不止10步，因为除了删除10个多余字符，还要改变成数字，大写。
望层主能解答。

icecocotea

傻眼貓咪 发表于 2021-10-16 19:57
我的代码仅供参考，你的题目相当有水准，我喜欢

谢谢这位层主的解答

icecocotea

Stubborn 发表于 2021-10-16 18:30
乍看很简单，其实很难 输入数据无限制吗？提的问题没有漏什么东西把

对啊，乍一看不难，但是细想下有很多条件要考虑。题上给的条件就这么多。。。

qq1151985918

icecocotea 发表于 2021-10-17 07:40
十分感谢层主的回答，您的代码我测试过，已经十分完美了。但好像还是有BUG。
比如我输入30个字母a:

我又修改了，你再试试看

1. def isLengthEnough(s):
   
2.     if 6 <= len(s) <= 20:
   
3.         return True
   
4.     else:
   
5.         return False
   
6. 
   
7. def isNumIn(s):
   
8.     for i in s:
   
9.         if i.isdigit():
   
10.             return True
    
11.     else:
    
12.         return False
    
13.    
    
14. def isLowIn(s):
    
15.     for i in s:
    
16.         if i.islower():
    
17.             return True
    
18.     else:
    
19.         return False
    
20. 
    
21. def isCapIn(s):
    
22.     for i in s:
    
23.         if i.isupper():
    
24.             return True
    
25.     else:
    
26.         return False
    
27. 
    
28. def isNotRepeat3(s):
    
29.     for i in set(s):
    
30.         if i * 3 in s:
    
31.             return False
    
32.     else:
    
33.         return True
    
34. 
    
35. def allRepeat3(s):
    
36.     r = []
    
37.     while not isNotRepeat3(s):
    
38.         for i in s:
    
39.             for j in range(len(s), 2, -1):
    
40.                 if i * j in s:
    
41.                     for k in range(s.count(i * j)):
    
42.                         r.append(i * j)
    
43.                     s = s.replace(i * j, "")
    
44.                     break
    
45.     return sorted(r, key=lambda x:len(x), reverse=True)
    
46. 
    
47. def run(s):
    
48.     r = sum([isLengthEnough(s), isNumIn(s), isLowIn(s), isCapIn(s), isNotRepeat3(s)])
    
49.     if r == 5:
    
50.         result = 0
    
51.     elif sum([isLengthEnough(s), isNotRepeat3(s)]) == 0:
    
52.         res1 = 6 - len(s) if len(s) < 6 else len(s) - 20
    
53.         t, flg, allR = 0, False, allRepeat3(s)
    
54.         for i in allR:
    
55.             if flg:
    
56.                 t += len(s) - len(allR[0])
    
57.                 break
    
58.             elif not flg and len(i) > 20:
    
59.                 flg = True
    
60.                 t += len(i) - 20 + (20 // 3)
    
61.             else:
    
62.                 t += len(i) // 3
    
63.         res2 = t if t > 3 - r else 3 - r
    
64.         result = res1 if res1 > res2 else res2
    
65.     elif not isLengthEnough(s):
    
66.         t = 6 - len(s) if len(s) < 6 else len(s) - 20
    
67.         result = t if t > 4 - r else 4 - r
    
68.     elif not isNotRepeat3(s):
    
69.         t = 0
    
70.         for i in allRepeat3(s):
    
71.             t += len(i) // 3
    
72.         result = t if t > 4 - r else 4 - r
    
73.     else:
    
74.         result = 5 - r
    
75.     return result
    
76. 
    
77. if __name__ == "__main__":
    
78.     password = input("输入密码：")
    
79.     print("密码变强所需的最少步骤：", run(password))
    

复制代码

qq1151985918

抱歉，上边的代码我又修改了四五次，仍然发现有BUG，待我再考虑一下，这是哪里的题目？

icecocotea

qq1151985918 发表于 2021-10-17 18:28
抱歉，上边的代码我又修改了四五次，仍然发现有BUG，待我再考虑一下，这是哪里的题目？

辛苦了哥们儿，这个题目是我一个老师给的习题集里面的。

Stubborn

icecocotea 发表于 2021-10-17 07:42
对啊，乍一看不难，但是细想下有很多条件要考虑。题上给的条件就这么多。。。

越想越复杂，如 aa + c*20 + bbd 和 bbd + c*20 + a，这种情况，就面临一个问题，程序应该如何判断通过最少步骤 去“操作”一段适合的密码，从前面，后面，还是中间“操作”一部分呢？


我觉得，这边问题，首先要解决的是种类的检查，其次最重要的是如何处理重复问题
并且我们对密码的操作优先度，应该是替换（替换步骤大于2，可以不用考虑种类问题），删减


其次需要检查密码的有效最大长度。根据密码有效的最大长度已经种类的检查的结果进行操作

假如，我有的程序对一串字符串（aaccccccccccccccccccccbbdaacccccccvbcdeeeeeffff）处理后，可以得到两个列表

1. 
   
2. a = [2, 20, 5, 7, 4, 5, 4]
   
3. b = [0, 6, 0, 2, 0, 1, 1]
   

复制代码

第一列，有效和无效长度，aa ,  ccccccc, vbcd, eeee, ffff
第二列，如果是有效长度则不需要操作，如果是无效长度，需要操作多少步才能变为有效长度。


这样一来，问题转化成了，寻找一个连续数组，什么样的连续数组是我们的想要的？

从我们看来，这个字符串最短步骤应该是，进行3次替换，即取 5+ 7 + 4 +5，可以获取足够合适的密码长度，其他的字符都可以删减。

Stubborn

icecocotea 发表于 2021-10-17 07:40
十分感谢层主的回答，您的代码我测试过，已经十分完美了。但好像还是有BUG。
比如我输入30个字母a:

应该是替换6个，以及删除10个，总计16步骤