题解 | #密码强度检查#

题目链接

密码强度检查

题目描述

评估密码字符串 $S$ 的强度，规则如下：

如果密码长度小于 8，则强度为 Weak。
否则，检查密码中包含的字符类型（小写字母、大写字母、数字、特殊字符）：
- 包含所有四种类型，强度为 Strong。
- 包含正好三种类型，强度为 Medium。
- 其他情况（一或两种），强度为 Weak。

输入:

第一行一个整数 $T$ ，表示数据组数。
接下来 $T$ 行，每行一个密码字符串 $S$ 。

输出:

对每个密码，输出其强度级别。

解题思路

本题要求我们根据一系列规则判断密码的强度。我们可以直接按照题目描述的规则进行模拟。

检查长度：首先判断密码字符串 $S$ 的长度。如果长度小于 8，直接判定为 Weak。
统计字符类型：如果长度大于等于 8，我们需要统计密码中出现的字符种类。我们可以使用四个布尔变量来标记是否出现了小写字母、大写字母、数字和特殊字符。
- has_lower: 标记是否出现小写字母。
- has_upper: 标记是否出现大写字母。
- has_digit: 标记是否出现数字。
- has_special: 标记是否出现特殊字符。
遍历字符串：遍历密码字符串 $S$ 中的每一个字符：
- 如果字符是小写字母，将 has_lower 设为 true。
- 如果字符是大写字母，将 has_upper 设为 true。
- 如果字符是数字，将 has_digit 设为 true。
- 如果以上都不是，则为特殊字符，将 has_special 设为 true。
计算类型数量：遍历结束后，统计四个布尔变量中为 true 的数量，记为 $C$ 。
判断强度：根据 $C$ 的值输出最终结果：
- 如果 $C = 4$ ，强度为 Strong。
- 如果 $C = 3$ ，强度为 Medium。
- 如果 $C < 3$ (即 1 或 2)，强度为 Weak。

由于有多组测试数据，需要将上述逻辑放在一个循环中执行 $T$ 次。

代码

c++
java
python

#include <iostream>
#include <string>
#include <cctype>

using namespace std;

// 解决单次查询的函数
void solve() {
    string s;
    cin >> s;

    // 规则1：检查长度
    if (s.length() < 8) {
        cout << "Weak\n";
        return;
    }

    // 规则2：统计字符类型
    bool has_lower = false;
    bool has_upper = false;
    bool has_digit = false;
    bool has_special = false;

    for (char c : s) {
        if (islower(c)) {
            has_lower = true;
        } else if (isupper(c)) {
            has_upper = true;
        } else if (isdigit(c)) {
            has_digit = true;
        } else {
            has_special = true; // 其他可见字符均为特殊字符
        }
    }

    // C++中布尔值可以直接相加，true为1，false为0
    int types = has_lower + has_upper + has_digit + has_special; 

    if (types == 4) {
        cout << "Strong\n";
    } else if (types == 3) {
        cout << "Medium\n";
    } else {
        cout << "Weak\n";
    }
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while (t-- > 0) {
            String s = sc.next();
            
            // 规则1：检查长度
            if (s.length() < 8) {
                System.out.println("Weak");
                continue;
            }
            
            // 规则2：统计字符类型
            boolean hasLower = false;
            boolean hasUpper = false;
            boolean hasDigit = false;
            boolean hasSpecial = false;
            
            for (char c : s.toCharArray()) {
                if (Character.isLowerCase(c)) {
                    hasLower = true;
                } else if (Character.isUpperCase(c)) {
                    hasUpper = true;
                } else if (Character.isDigit(c)) {
                    hasDigit = true;
                } else {
                    hasSpecial = true; // 其他可见字符均为特殊字符
                }
            }
            
            int types = 0;
            if (hasLower) types++;
            if (hasUpper) types++;
            if (hasDigit) types++;
            if (hasSpecial) types++;
            
            if (types == 4) {
                System.out.println("Strong");
            } else if (types == 3) {
                System.out.println("Medium");
            } else {
                System.out.println("Weak");
            }
        }
    }
}

# 解决单次查询的函数
def solve():
    s = input()
    
    # 规则1：检查长度
    if len(s) < 8:
        print("Weak")
        return
        
    # 规则2：统计字符类型
    has_lower = False
    has_upper = False
    has_digit = False
    has_special = False
    
    for c in s:
        if c.islower():
            has_lower = True
        elif c.isupper():
            has_upper = True
        elif c.isdigit():
            has_digit = True
        else:
            has_special = True # 其他可见字符均为特殊字符
            
    # Python中布尔值可以直接相加，True为1，False为0
    types = has_lower + has_upper + has_digit + has_special
    
    if types == 4:
        print("Strong")
    elif types == 3:
        print("Medium")
    else:
        print("Weak")

# 读取测试数据组数 T
t = int(input())
for _ in range(t):
    solve()

算法及复杂度

算法：模拟。我们遍历字符串一次来统计字符类型，然后根据规则判断。
时间复杂度：对于每组测试数据，我们需要遍历一次密码字符串。设密码字符串的长度为 $L$ 。因此，单次处理的时间复杂度为 $\mathcal{O}(L)$ 。总共有 $T$ 组测试数据，所以总时间复杂度为 $\mathcal{O}(T \cdot L)$ 。
空间复杂度：我们只使用了几个布尔变量来存储状态，这是常数级别的额外空间。输入字符串本身需要 $\mathcal{O}(L)$ 的空间来存储。因此，总空间复杂度为 $\mathcal{O}(L)$ 。