HJ36 字符串加密

1. 题目

读题

HJ36 字符串加密

 

 

这道题的意思是让您使用一种加密技巧，把一个字符串转换成另一个字符串。

这种加密技巧的原理是这样的：

• 首先，您需要选择一个单词作为密钥，比如TRAILBLAZERS。
• 然后，您需要把这个单词中重复的字母去掉，只保留第一个出现的字母，比如TRAILBZES。
• 接着，您需要把这个单词放在字母表的下面，然后用剩下的字母按照顺序填充完整，比如：

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
T R A I L B Z E S C D F G H J K M N O P Q U V W X Y

• 最后，您需要把要加密的字符串中的每个字母用上面对应的字母替换，注意保持大小写不变，比如：

Attack AT DAWN -> Tpptad TP ITVH
nihao ni -> le

 

 

考查点

 

2. 解法

思路

 

代码逻辑

 

具体实现

 

import java.util.*;
public class Main{

    // 定义一个函数，根据密钥生成新字母表
    public static char[] createNewKey(String key){
        char[] keys=new char[26];
        int index=0;
        for(char c:key.toCharArray()){
            if(!contains(keys,c)){
                keys[index++]=c;
            }
        }
        for(char c:'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.toCharArray()){
            if(!contains(keys,c)){
                keys[index++]=c;
            }
        }
        return keys;
    }

    // 定义一个函数，根据新字母表加密字符串
    public static String encryptString(String str, char[] keys){
        char[] oldKey="ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
        StringBuilder sb=new StringBuilder();
        for(char c:str.toCharArray()){
            if(Character.isLetter(c)){
                int i=oldKey[c-'A'];
                char newC=keys[i];
                if(Character.isLowerCase(c)){
                    newC=Character.toLowerCase(newC);
                }
                sb.append(newC);
            }else{
                sb.append(c);
            }
        }
        return sb.toString();
    }

    // 定义一个函数，判断一个数组是否包含某个字符
    public static boolean contains(char[] arr,char c){
        for(char a:arr){
            if(a==c){
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            // 输入密钥和需要加密的字符串
            String key=sc.next().toUpperCase();
            String str=sc.next();
            // 调用函数生成新字母表
            char[] keys=createNewKey(key);
            // 调用函数加密字符串
            String res=encryptString(str,keys);
            System.out.println(res);
        }
    }
}

自行实现

public class HJ036 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(encode(sc.nextLine(), sc.nextLine()));
    }


    public static String encode(String key, String info) {
        StringBuffer sb = new StringBuffer();
        for (char c : key.toLowerCase().toCharArray()) {
            if (sb.toString().indexOf(c) == -1) {
                sb.append(c);
            }
        }

        int diff = sb.length();
        char cur = 'a';
        for (int i = 0; i < 26 - diff; i++) {

            while (sb.toString().indexOf(cur) != -1) {
                cur = (char) (cur + 1);
            }
            sb.append(cur);

        }

        String newSeq = sb.toString();
        StringBuffer ans = new StringBuffer();
        boolean flag = false;
        for (char c : info.toCharArray()) {
            if (!Character.isLetter(c)) {
                ans.append(c);
                continue;
            }
            flag = Character.isUpperCase(c);
            c = Character.toLowerCase(c);
            char d = newSeq.charAt(c - 'a');
            if (flag) {
                d = Character.toUpperCase(d);
            }
            ans.append(d);
        }

        return ans.toString();
    }
}

3. 总结