在本文中，我将解决 perl weekly challenge #287 中的两个挑战：加强弱密码和验证数字。我将为这两项任务提供解决方案，展示 perl 和 go 中的实现。
目录
- 加强弱密码
- 验证数字
- 结论
加强弱密码
第一个任务是确定使密码更安全所需的最少更改次数。强密码的标准是：
- 至少有 6 个字符。
- 至少包含 1 个小写字母、1 个大写字母和 1 个数字。
- 不包含三个连续相同的字符。
示例
- 输入：“a”→输出：5
- 输入：“ab2”→ 输出：3
- 输入：“paasw0rd”→输出：0
- 输入：“paaasw0rd”→输出：1
- 输入：“aaaaa”→输出：2
解决方案
perl 实现
#!/usr/bin/perl
use strict;
use warnings;
use list::util 'max';
# function to count groups of three or more repeating characters
sub count_repeats {
my ($str) = @_;
my $repeats = 0;
# find repeating characters and count the required changes
while ($str =~ /(.)\1{2,}/g) {
$repeats += int(length($&) / 3);
}
return $repeats;
}
# function to calculate the minimum steps to create a strong password
sub minimum_steps_to_strong_password {
my ($str) = @_;
my $length = length($str);
# check if the password contains the required character types
my $has_lower = $str =~ /[a-z]/;
my $has_upper = $str =~ /[a-z]/;
my $has_digit = $str =~ /\d/;
# calculate the number of types needed
my $types_needed = !$has_lower + !$has_upper + !$has_digit;
my $repeats = count_repeats($str);
# return the minimum steps based on the length of the password
return ($length < 6) ? max(6 - $length, $types_needed) : $types_needed + $repeats;
}
1;
perl 实现的测试
use strict;
use warnings;
use test::more;
require "./ch-1.pl";
my @tests = (
["a", 5],
["ab2", 3],
["paasw0rd", 0],
["paaasw0rd", 1],
["aaaaa", 2],
);
foreach my $test (@tests) {
my ($input, $expected) = @$test;
my $result = minimum_steps_to_strong_password($input);
is($result, $expected, "input: '$input'");
}
done_testing();
实施
package main
import (
"regexp"
)
func countrepeats(password string) int {
repeats := 0
count := 1
for i := 1; i < len(password); i++ {
if password[i] == password[i-1] {
count++
} else {
repeats += count / 3
count = 1
}
}
repeats += count / 3
return repeats
}
func minimumstepstostrongpassword(password string) int {
length := len(password)
// use regex to check for character types
haslower := regexp.mustcompile(`[a-z]`).matchstring(password)
hasupper := regexp.mustcompile(`[a-z]`).matchstring(password)
hasdigit := regexp.mustcompile(`\d`).matchstring(password)
// calculate the number of types needed
typesneeded := booltoint(!haslower) + booltoint(!hasupper) + booltoint(!hasdigit)
repeats := countrepeats(password)
// return the minimum steps based on the length of the password
if length < 6 {
return max(6-length, typesneeded)
}
return typesneeded + repeats
}
func booltoint(b bool) int {
if b {
return 1
}
return 0
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
go 实现的测试
package main
import (
"testing"
)
func testminimumstepstostrongpassword(t *testing.t) {
tests := []struct {
password string
expected int
}{
{"a", 5},
{"ab2", 3},
{"paasw0rd", 0},
{"paaasw0rd", 1},
{"aaaaa", 2},
}
for _, test := range tests {
result := minimumstepstostrongpassword(test.password)
if result != test.expected {
t.errorf("for password '%s', expected %d but got %d", test.password, test.expected, result)
}
}
}
验证数字
第二个任务涉及验证数字。目标是确定给定的字符串是否代表有效的数字。有效号码的标准是：
- 一个整数（可选后跟指数表示法）。
- 十进制数（可选后跟指数表示法）。
- 整数可以选择带有符号（- 或 +），后跟数字。
示例
- 输入：“1”→输出：true
- 输入：“a”→输出：false
- 输入：“。” → 输出：假
- 输入：“1.2e4.2”→输出：false
- 输入：“-1”。 → 输出：真
- 输入：“+1e-8”→ 输出：true
- 输入：“.44”→ 输出：true
解决方案
perl 实现
#!/usr/bin/perl
use strict;
use warnings;
sub is_valid_number {
my ($str) = @_;
# regex for valid numbers
my $regex = qr{
^ # start of the string
[+-]? # optional sign
(?: # start of the number group
\d+ # integer: at least one digit
(?: # start of the optional decimal part
\. # decimal point
\d* # followed by zero or more digits
)? # group is optional
| # or
\. # just a decimal point
\d+ # followed by one or more digits
) # end of the number group
(?: # start of the optional exponent group
[ee] # 'e' or 'e'
[+-]? # optional sign
\d+ # followed by one or more digits
)? # exponent is optional
$ # end of the string
}x;
# return 1 for valid, 0 for invalid
return $str =~ $regex ? 1 : 0;
}
1;
perl 实现的测试
#!/usr/bin/perl
use strict;
use warnings;
use test::more;
require './ch-2.pl';
# define test cases
my @test_cases = (
["1", 1, 'valid integer'],
["a", 0, 'invalid input'],
[".", 0, 'single dot'],
["1.2e4.2", 0, 'invalid exponent'],
["-1.", 1, 'valid decimal'],
["+1e-8", 1, 'valid scientific notation'],
[".44", 1, 'valid decimal starting with dot'],
);
# loop through test cases and run tests
foreach my $case (@test_cases) {
my $result = is_valid_number($case->[0]);
is($result, $case->[1], $case->[2]);
}
done_testing();
实施
package main
import (
"regexp"
)
// isvalidnumber checks if the given string is a valid number.
func isvalidnumber(str string) bool {
regex := `^[+-]?((\d+(\.\d*)?)|(\.\d+))([ee][+-]?\d+)?$`
matched, _ := regexp.matchstring(regex, str)
return matched
}
go 实现的测试
package main
import (
"testing"
)
func TestIsValidNumber(t *testing.T) {
testCases := []struct {
input string
expected bool
}{
{"1", true},
{"a", false},
{".", false},
{"1.2e4.2", false},
{"-1.", true},
{"+1E-8", true},
{".44", true},
}
for _, tc := range testCases {
result := isValidNumber(tc.input)
if result != tc.expected {
t.Errorf("isValidNumber(%q) = %v; expected %v", tc.input, result, tc.expected)
}
}
}
结论
这些解决方案提供了评估密码强度和验证数字正确性的有效方法。 github 上提供了这两项任务的完整代码。
