题解 | 字符串加密

import java.util.Scanner;
import java.util.Set;
import java.util.HashSet;
import java.util.ArrayList;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 2. 读取第一个输入：种子字符串s（用于生成新字母表）
        String s = in.nextLine();
        // 将种子字符串转换为字符数组，方便后续遍历处理
        char[] chars = s.toCharArray();

        // 3. 调用工具方法，生成26位完整的新字母表
        StringBuilder newAlphabet = getStringBuilder(chars);
        // 将新字母表转换为字符串（便于后续按索引取值）
        String newStr = newAlphabet.toString();

        // 4. 读取第二个输入：需要加密的明文t
        String t = in.nextLine();
        // 创建StringBuilder存储加密后的密文（高效拼接字符串）
        StringBuilder res = new StringBuilder();

        // 5. 遍历明文字符，逐个替换为新字母表的对应字符
        for (char c : t.toCharArray()) {
            // 计算当前字符在标准字母表(a-z)中的索引（a=0, b=1...z=25）
            int index = c - 'a';
            // 按索引取新字母表的对应字符，追加到密文结果中
            res.append(newStr.charAt(index));
        }

        // 6. 输出最终加密后的密文
        System.out.println(res.toString());
        // 关闭Scanner，释放资源
        in.close();
    }

    /**
     * 核心工具方法：根据种子字符数组生成26位新字母表
     * @param chars 种子字符串转换后的字符数组
     * @return 26位新字母表的StringBuilder对象
     */
    private static StringBuilder getStringBuilder(char[] chars) {
        // 1. 去重逻辑：Set用于快速判断字符是否已存在（保证唯一性）
        Set<Character> set = new HashSet<>();
        // 2. 保序逻辑：List用于按首次出现顺序存储去重后的字符
        ArrayList<Character> list = new ArrayList<>();

        // 遍历种子字符数组，完成去重并保留首次出现顺序
        for (char c : chars) {
            if (set.contains(c)) {
                // 字符已存在，跳过（去重）
                continue;
            } else {
                // 字符首次出现：标记到Set，同时加入List保序
                set.add(c);
                list.add(c);
            }
        }

        // 3. 将去重保序后的List转换为基础字符串（新字母表的前半部分）
        StringBuilder sb = new StringBuilder();
        for (Character c : list) {
            sb.append(c);
        }
        // 基础串：去重后的种子字符串（长度<26）
        String baseStr = sb.toString();

        // 4. 补全基础串为26位新字母表：先拼接基础串，再补充缺失字符
        StringBuilder newAlphabet = new StringBuilder(baseStr);
        // 遍历a-z所有字符，补充基础串中没有的字符
        for (char c = 'a'; c <= 'z'; c++) {
            String charStr = String.valueOf(c);
            // 字符未出现在基础串中，追加到新字母表末尾
            if (!baseStr.contains(charStr)) {
                newAlphabet.append(c);
            }
        }

        // 返回完整的26位新字母表
        return newAlphabet;
    }
}