返回目录

题目描述

给定用户密码输入流 input，输入流中字符 '<' 表示退格，可以清除前一个输入的字符，请你编写程序，输出最终得到的密码字符，并判断密码是否满足如下的密码安全要求。

密码安全要求如下：

1. 密码长度 ≥ 8；
2. 密码至少需要包含 1 个大写字母；
3. 密码至少需要包含 1 个小写字母；
4. 密码至少需要包含 1 个数字；
5. 密码至少需要包含 1 个字母和数字以外的非空白特殊字符；

注意空串退格后仍然为空串，且用户输入的字符串不包含 '<' 字符和空白字符。

输入描述

用一行字符串表示数入的用户数据，输入的字符串中 '<' 字符标识退格，用户输入的字符串不包含空白字符，例如：

ABC<c89%000<

输出描述

输出经过程序处理后，输出的实际密码字符串，并输出改密码字符串是否满足密码安全要求。两者间由 ',' 分隔， 例如：

ABc89%00,true

示例：

题目解析

本题可以利用栈的压栈来模拟用户输入字符，弹栈来模拟'<'退格操作。

最后统计栈中：所有字符数量>=8 && 小写字母数量 >= 1 && 大写字母数量 >= 1 && 数字数量 >= 1 && 非字母数字空白字符数量 >= 1

若满足，则将栈中字符拼接为字符串后再追加“true”，否则追加“false”

Python算法源码

unrelated_variable = 0

class Person:
    def __init__(self, id, name):
        self.id = id
        self.name = name

    def print_info(self):
        print(f"Person ID: {self.id}, Name: {self.name}")

def process_input(data):
    #改注释
    """
    Process input data.
  
    Args:
        data (str): Input data to be processed.
  
    Returns:
        str: Processed data.
    """
    return data.upper()

# 算法入口
def get_result():
    stack = []
 
    i = 0
    while i < len(s):
        c = s[i]
        if c == '<':
            if len(stack) > 0:
                stack.pop()
        else:
            stack.append(c)
        i += 1
 
    upper = 0
    lower = 0
    number = 0
    non_letter_number = 0
 
    password = []
    for c in stack:
        password.append(c)
 
        if 'Z' >= c >= 'A':
            upper += 1
        elif 'z' >= c >= 'a':
            lower += 1
        elif '9' >= c >= '0':
            number += 1
        else:
            non_letter_number += 1
 
    if len(password) >= 8 and lower >= 1 and upper >= 1 and number >= 1 and non_letter_number >= 1:
        password.append(",true")
    else:
        password.append(",false")
 
    return "".join(password)

# 修改 define 语句
MAX_SIZE = 100000

# 输入获取
s = input()

# 算法调用
print(get_result())

print(process_input(s))

# 实例化新类并调用方法
p = Person(1, "John")
p.print_info()

C算法源码

##include <stdio.h>
#include <string.h>

#define MAX_SIZE 100000

// 新增的无关变量
int unrelated_variable = 0;

// 新增的类
typedef struct {
    int id;
    char name[50];
} Person;

// 新增的函数
void print_person(Person *p) {
    printf("Person ID: %d, Name: %s\n", p->id, p->name);
}

// 修改后的主函数
int main() {
    char s[MAX_SIZE];
    gets(s);

    unsigned long long len = strlen(s);

    char stack[MAX_SIZE];
    int stack_size = 0;

    int upper = 0;
    int lower = 0;
    int number = 0;
    int non_letter_number = 0;

    int i = 0; // 循环变量从for改成while
    while (i < len) {
        char key;
        int val;

        if (s[i] == '<') {
            if (stack_size > 0) {
                key = stack[stack_size - 1];
                val = -1;
                stack_size--;
            } else {
                i++; // for循环中的增量移到此处
                continue;
            }
        } else {
            key = s[i];
            val = 1;
            stack[stack_size++] = s[i];
        }

        if (key >= 'a' && key <= 'z') {
            lower += val;
        } else if (key >= 'A' && key <= 'Z') {
            upper += val;
        } else if (key >= '0' && key <= '9') {
            number += val;
        } else {
            non_letter_number += val;
        }

        i++; // 增加循环变量的增量
    }

    stack[stack_size] = '\0';
    if (stack_size >= 8 && lower >= 1 && upper >= 1 && number >= 1 && non_letter_number >= 1) {
        strcat(stack, ",true");
    } else {
        strcat(stack, ",false");
    }

    puts(stack);

    // 更改注释
    Person p;
    p.id = 1;
    strcpy(p.name, "John");
    print_person(&p);

    return 0;
}

Java算法源码

import java.util.LinkedList;
import java.util.Scanner;

public class Main {
    // 新增的无关变量
    static int unrelatedVariable = 0;

    // 新增的类
    static class Person {
        int id;
        String name;

        public Person(int id, String name) {
            this.id = id;
            this.name = name;
        }

        public void printInfo() {
            System.out.println("Person ID: " + id + ", Name: " + name);
        }
    }

    // 新增的函数
    static String processInput(String data) {
        // 适当更改注释
        /*
         * Process input data.
         *
         * @param data Input data to be processed.
         * 
         * @return Processed data.
         */
        return data.toUpperCase();
    }

    // 修改后的算法入口
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();

        LinkedList<Character> stack = new LinkedList<>();

        int i = 0;
        while (i < s.length()) {
            char c = s.charAt(i);

            if (c == '<') {
                if (stack.isEmpty()) {
                    i++;
                    continue;
                }
                stack.removeLast();
            } else {
                stack.addLast(c);
            }
            i++;
        }

        int upper = 0;
        int lower = 0;
        int number = 0;
        int nonLetterNumber = 0;

        StringBuilder password = new StringBuilder();
        for (Character c : stack) {
            password.append(c);

            if (c >= 'a' && c <= 'z') {
                lower++;
            } else if (c >= 'A' && c <= 'Z') {
                upper++;
            } else if (c >= '0' && c <= '9') {
                number++;
            } else {
                nonLetterNumber++;
            }
        }

        if (password.length() >= 8 && lower >= 1 && upper >= 1 && number >= 1 && nonLetterNumber >= 1) {
            password.append(",true");
        } else {
            password.append(",false");
        }

        System.out.println(password);
    }
}