题解 | #密码验证合格程序#

以下是使用Go语言实现的代码示例来验证密码是否符合要求：

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func isPasswordValid(password string) bool {
	if len(password) < 8 {
		return false
	}

	// 计算密码中包含的字符种类数量
	characterTypes := 0
	if containsLowerCase(password) {
		characterTypes++
	}
	if containsUpperCase(password) {
		characterTypes++
	}
	if containsDigit(password) {
		characterTypes++
	}
	if containsSpecialSymbol(password) {
		characterTypes++
	}

	if characterTypes < 3 {
		return false
	}

	// 检查密码中是否有长度大于2的包含公共元素的子串重复
	for i := 0; i < len(password)-2; i++ {
		substr := password[i : i+3]
		if strings.Count(password, substr) > 1 {
			return false
		}
	}

	return true
}

func containsLowerCase(s string) bool {
	for _, c := range s {
		if unicode.IsLower(c) {
			return true
		}
	}
	return false
}

func containsUpperCase(s string) bool {
	for _, c := range s {
		if unicode.IsUpper(c) {
			return true
		}
	}
	return false
}

func containsDigit(s string) bool {
	for _, c := range s {
		if unicode.IsDigit(c) {
			return true
		}
	}
	return false
}

func containsSpecialSymbol(s string) bool {
	for _, c := range s {
		if !(unicode.IsLetter(c) || unicode.IsDigit(c)) {
			return true
		}
	}
	return false
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		text := scanner.Text()
		if isPasswordValid(text) {
			fmt.Println("OK")
		} else {
			fmt.Println("NG")
		}
	}
}

在上面的代码中，我们定义了一个 isPasswordValid 函数来检查密码是否符合要求。它首先检查密码长度是否超过8位，然后计算密码中包含的字符种类数量，如果少于3种，则返回 false。接下来，它会遍历密码中的每个三个字符的子串，并检查是否有重复出现的子串，如果有则返回 false。最后，如果所有的条件都满足，则返回 true。

在 main 函数中，我们读取用户输入的密码，并调用 isPasswordValid 函数进行验证。根据验证结果输出 "OK" 或 "NG"。

package main

import (
	"bufio"
	"fmt"
	"os"
)

func valid(str string) bool {
	// 判断长度
	if len(str) <= 8 {
		return false
	}
	// 包括大小写字母，数字，其他符号，以上四种至少三种
	mapSet := map[int]bool{}
	for i := 0; i < len(str); i++ {
		if str[i] >= '0' && str[i] <= '9' {
			mapSet[0] = true
		} else if str[i] >= 'A' && str[i] <= 'Z' {
			mapSet[1] = true
		} else if str[i] >= 'a' && str[i] <= 'z' {
			mapSet[2] = true
		} else {
			mapSet[3] = true
		}
	}
	count := 0

	for _, v := range mapSet {
		if v {
			count++
		}
	}
	if count < 3 {
		return false
	}
	// 不能有长度大于2的不含公共元素的子串重复（注：其他符号不含空格或换行）
	m := make(map[string]bool)
	for i := 0; i < len(str)-2; i++ {
		if m[str[i:i+3]] {
			return false
		} else {
			m[str[i:i+3]] = true
		}
	}
	return true
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		text := scanner.Text()
		if valid(text) {
			fmt.Println("OK")
		} else {
			fmt.Println("NG")
		}
	}
}

错误示例：

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"unicode"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		password := scanner.Text()
		if isValidPassword(password) {
			fmt.Println("OK")
		} else {
			fmt.Println("NG")
		}
	}

}

func isValidPassword(password string) bool {
	// 检查长度是否超过8位
	if len(password) <= 8 {
		return false
	}

	// 检查是否包括大小写字母、数字、其他符号
	var hasLower, hasUpper, hasDigit, hasSymbol bool
	for _, char := range password {
		switch {
		case unicode.IsLower(char):
			hasLower = true
		case unicode.IsUpper(char):
			hasUpper = true
		case unicode.IsDigit(char):
			hasDigit = true
		case !unicode.IsSpace(char) && !unicode.IsControl(char):
			hasSymbol = true
		}
	}
	if !(hasLower && hasUpper && hasDigit && hasSymbol) {
		return false
	}

	// 检查是否有长度大于2的包含公共元素的子串重复
	for i := 0; i < len(password)-3; i++ {
		substr := password[i : i+3]
		if strings.Contains(password[i+3:], substr) {
			return false
		}
	}

	return true
}

这段代码首先读取输入的字符串数量，然后使用循环读取每个密码字符串。对于每个密码字符串，调用isValidPassword函数来判断是否符合密码要求。isValidPassword函数首先检查密码长度是否超过8位。然后使用循环遍历每个字符，检查是否包括大小写字母、数字和其他符号。最后，使用循环检查是否有长度大于2的包含公共元素的子串重复。如果所有条件都满足，则返回true，否则返回false。 最后，根据isValidPassword函数的返回值，打印输出"OK"或"NG"。