首页 > 试题广场 >

字符串加密

[编程题]字符串加密
  • 热度指数：149229 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M
  • 算法知识视频讲解
有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，如TRAILBLAZERS。如果单词中包含有重复的字母，只保留第1个，将所得结果作为新字母表开头，并将新建立的字母表中未出现的字母按照正常字母表顺序加入新字母表。如下所示：

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。

请实现下述接口，通过指定的密匙和明文得到密文。

数据范围： ，保证输入的字符串中仅包含小写字母


输入描述:
先输入key和要加密的字符串


输出描述:
返回加密后的字符串
示例1

输入

nihao
ni

输出

le
算法知识视频讲解
添加回答
Java
许愿面试顺利的鲸鱼很豁达头像 许愿面试顺利的鲸鱼很豁达

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String key = sc.nextLine();
        String password = sc.nextLine();

        // 26个字母
        int i = 0;
        Map<String, Integer> map = new LinkedHashMap<>();
        for (char c = 'a'; c <= 'z'; c++) {
            map.put(String.valueOf(c), i);
            i++;
        }

        // key 去重字母
        List<String> newList = new ArrayList<>();
        for (char c : key.toCharArray()) {
            String temp = String.valueOf(c);
            if (!newList.contains(temp)) {
                newList.add(temp);
            }
        }
        Set<String> set = map.keySet();
        for (String s : set) {
            if (!newList.contains(s)) {
                newList.add(s);
            }
        }
        for (char c : password.toCharArray()) {
            String temp = String.valueOf(c);
            Integer index = map.get(temp);
            String sec = newList.get(index);
            if (Character.isUpperCase(c)) {
                sec = sec.toUpperCase();
            }
            System.out.print(sec);
        }
        sc.close();
    }
}
发表于 2024-11-01 01:01:09 回复(0)
Java
认真的芝士在敲键盘头像 认真的芝士在敲键盘
// 参考题解
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            // 密钥
            String key = in.nextLine();
            // 明文
            String pwd = in.nextLine();
            // 有序去重
            Set<Character> set = new LinkedHashSet<>();
            for (int i = 0; i < key.length(); i++) {
                set.add(key.charAt(i));
            }
            // 补全字母
            for (int i = 0; i < 26; i++) {
                set.add((char)('a' + i));
            }
            // 集合转列表
            List<Character> list = new ArrayList<>(set);

            // 加密
            StringBuilder s = new StringBuilder();
            for (int i = 0; i < pwd.length(); i++) {
                if (pwd.charAt(i) == ' ') {
                    s.append(pwd.charAt(i));
                } else {
                    int index = Integer.valueOf(pwd.charAt(i) - 'a');
                    s.append(list.get(index));
                }
            }
            System.out.println(s);
        }
    }
}
发表于 2024-09-12 11:53:12 回复(0)
Java
JavaKD头像 JavaKD
import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String key = in.nextLine().toUpperCase();
        char[] keyCharArray = key.toCharArray();
        char[] wolds = in.nextLine().toCharArray();
        StringBuilder bd = new StringBuilder();
        boolean[] flag = new boolean[26];
        // 密文去重，放置首位
        for (int i = 0; i < keyCharArray.length; i++) {
            if (!flag[keyCharArray[i] - 'A']) {
                flag[keyCharArray[i] - 'A'] = true;
                bd.append(keyCharArray[i]);
            }
        }
        // 补充其余密文中不存在的字母
        for (char c = 'A'; c <= 'Z'; c++) {
            if (!flag[c - 'A']) {
                flag[c - 'A'] = true;
                bd.append(c);
            }
        }
        // 明文转密文
        StringBuilder builder = new StringBuilder();
        char[] c = bd.toString().toCharArray();
        for (int i = 0; i < wolds.length; i++) {
            char wold = wolds[i];
            // 如果是小写
            if (wold > 'Z') {
                builder.append((char) (c[wolds[i] - 'a'] + 32));
            } else if (wold == ' ') {
                // 空格
                builder.append(wold);
            } else {
                // 大写
                builder.append((c[wolds[i] - 'A']));
            }
        }
        System.out.println(builder);
    }
}
发表于 2024-09-07 22:17:59 回复(0)
Java
CH_NG头像 CH_NG 
import java.io.BufferedReader;
import java.io.InputStreamReader;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        // 注意 hasNext 和 hasNextLine 的区别
        String s;
        while ((s=in.readLine())!=null) { // 注意 while 处理多个 case
            char[] arr = getArray(s);
            s = in.readLine();
            char[] res = new char[s.length()];
            for (int i = 0;i < s.length();i++) {
                res[i] = arr[s.charAt(i)];
            }
            System.out.println(String.valueOf(res));
        }
    }

    private static char[] getArray(String s) {
        char[] arr = new char[128];
        StringBuilder sb = new StringBuilder(s);
        for (int i = 0;i < sb.length();i++) {
            while (sb.indexOf(String.valueOf(sb.charAt(i))) != sb.lastIndexOf(String.valueOf(sb.charAt(i)))) {
                sb.deleteCharAt(sb.lastIndexOf(String.valueOf(sb.charAt(i))));
            }
        }
        s = sb.toString();
        sb = new StringBuilder();
        int j = 0;
        for (char i = 'a';i <= 'z';i++) {
            sb.append(i);
            if (arr[i] == 0) {
                if (j < s.length())
                    arr[i] = s.charAt(j);
            }
            j++;
        }
        for (int i = 0;i < s.length();i++) {
            while (sb.indexOf(String.valueOf(s.charAt(i))) > -1) {
                sb.deleteCharAt(sb.indexOf(String.valueOf(s.charAt(i))));
            }
        }
        j = 0;
        for (char i = (char)('a'+s.length());i <= 'z';i++) {
            if (arr[i] == 0) {
                if (j < sb.length())
                    arr[i] = sb.charAt(j);
            }
            j++;
        }
        return arr;
    }
}

发表于 2024-07-16 16:52:11 回复(0)
Java
牛客317900105号头像 牛客317900105号
屎山如下： 
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String key = in.nextLine();
            String str = in.nextLine();

            //定义大写字母表
            String upperAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
            //定义小写字母表
            String lowerAlphabet = "abcdefghijklmnopqrstuvwxyz";
            //使用linkedHashSet去重
            LinkedHashSet<Character> upperSet = new LinkedHashSet<>();
            LinkedHashSet<Character> lowerSet = new LinkedHashSet<>();
            for (int i = 0; i < key.length(); i++) {
                upperSet.add(Character.toUpperCase(key.charAt(i)));
                lowerSet.add(Character.toLowerCase(key.charAt(i)));
            }
            for (char c = 'A'; c <= 'Z'; c++) {
                upperSet.add(c);
            }
            for (char c = 'a'; c <= 'z'; c++) {
                lowerSet.add(c);
            }
            List<Character> lowerList = new ArrayList<>(lowerSet);
            List<Character> upperList = new ArrayList<>(upperSet);
            //对字符串进行加密
            for (int i = 0; i < str.length(); i++) {
                int index = -1;
                char c = str.charAt(i);
                if (c >= 'a' && c <= 'z') {
                    for (int j = 0; j < lowerAlphabet.length(); j++) {
                        if (c == lowerAlphabet.charAt(j)) {
                            index = j;
                            break;
                        }
                    }
                    if (index != -1) {
                        System.out.print(lowerList.get(index));
                    }
                } else {
                    for (int j = 0; j < upperAlphabet.length(); j++) {
                        if (c == upperAlphabet.charAt(j)) {
                            index = j;
                            break;
                        }
                    }
                    if (index != -1) {
                        System.out.print(upperList.get(index));
                    }
                }
            }
        }
    }
}

发表于 2024-07-05 23:32:37 回复(0)
Java
老师我太想进步溜头像 老师我太想进步溜 
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        char[] key = in.nextLine().toCharArray();
        char[] wolds = in.nextLine().toCharArray();
        Set<Character> set = new LinkedHashSet<>();
        for (char c : key) {
            set.add(c);
        }
        int k = 0;
        while (set.size() < 26) {
            char c = (char)('a' + k);
            set.add(c);
            k++;
        }
        Object[] arr = set.toArray();
        StringBuilder builder = new StringBuilder();
        for (char c : wolds) {
            int n = c - 'a';
            builder.append(arr[n]);
        }
        System.out.println(builder.toString());
    }
}

发表于 2024-03-09 19:19:55 回复(0)
Java
整顿职场的小飞象很安静头像 整顿职场的小飞象很安静
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        String key = in.nextLine();
        String mima = in.nextLine();
        //对key去重
        //LinkedHashSet保证顺序不打乱；
        Set<Character> keySet = new LinkedHashSet<>();
        for (int i = 0; i < key.length(); i++) {
            keySet.add(key.charAt(i));
        }

        StringBuilder sbKey = new StringBuilder();

        //创建一个字母表
        String ZhiMuBiao1 = "abcdefghijklmnopqrstuvwxyz";
        String ZhiMuBiao = "abcdefghijklmnopqrstuvwxyz";
        for (Character c : keySet) {
            ZhiMuBiao = ZhiMuBiao.replace(c + "", "");
            sbKey.append(c);
        }
        String newKeyBiao = sbKey.append(ZhiMuBiao).toString();

        char[] newBiao = newKeyBiao.toCharArray();

        char[] MiMaChar = mima.toCharArray();
        Map<Character, Character> maps = new HashMap<>();
        for (int i = 0; i < ZhiMuBiao1.length(); i++) {
            maps.put(ZhiMuBiao1.charAt(i), newBiao[i]);
        }
        for (int i = 0; i < MiMaChar.length; i++) {
            for (Character c : maps.keySet()) {
                if (MiMaChar[i] == c) {
                    System.out.print(maps.get(c));
                    break;
                }
            }
        }
        //abcdefghijklmnopqrstuvwxyz 相当于key
        //nihaobcdefgjklmpqrstuvwxyz    相当于value
    }
}
发表于 2024-03-06 13:50:09 回复(0)
Java
已注销头像 已注销 
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;


public class Main {
    private static final int LOWER_CASE_SIZE = 26;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String key = null;

        while ((key = br.readLine()) != null) {
            char[] kChs = key.toLowerCase().toCharArray();
            char[] dict = new char[LOWER_CASE_SIZE];
            boolean[] seen = new boolean[LOWER_CASE_SIZE];
            int idx = 0;

            for (char ch : kChs) {
                if (seen[ch - 'a']) {
                    continue;
                }
                dict[idx++] = ch;
                seen[ch - 'a'] = true;
            }
            for (int i = 0; i < LOWER_CASE_SIZE; i++) {
                if (seen[i]) {
                    continue;
                }
                dict[idx++] = (char) (i + 'a');
            }
            
            char[] pChs = br.readLine().toLowerCase().toCharArray();
            StringBuilder sb = new StringBuilder();
            for (char ch : pChs) {
                sb.append(dict[ch - 'a']);
            }

            System.out.println(sb);
        }
    }
}

发表于 2024-03-05 10:34:30 回复(0)
Java
今生能进大厂吗头像 今生能进大厂吗 
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String s1 =  in.nextLine();
            String s2 =  in.nextLine();
            Set<Character> tree = new LinkedHashSet();
            for (int i = 0; i < s1.length(); i++) {
                tree.add(s1.charAt(i));
            }
            //构建字母表
            String letter = "abcdefghijklmnopqrstuvwxyz";
            StringBuilder stringBuilder = new StringBuilder();
            for (Character c : tree) {
                letter = letter.replace(c+"","");
                stringBuilder.append(c);
            }
            stringBuilder.append(letter);
            //注意:字母字符的大小写状态应该保留
            StringBuilder res = new StringBuilder();
            for (char c : s2.toCharArray()) {
                if (Character.isUpperCase(c)){
                    res.append(Character.toUpperCase(stringBuilder.charAt(c - 'A')));
                }else if (Character.isLowerCase(c)){
                    res.append(stringBuilder.charAt(c - 'a'));
                }else {
                    res.append(c);
                }
            }
            System.out.println(res);
        }
    }
}

编辑于 2024-01-04 15:32:11 回复(0)
Java
Kili_66头像 Kili_66 
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String key = in.nextLine() + "abcdefghijklmnopqrstuvwxyz";
        String word = in.nextLine();
        List<Character> list = new ArrayList();
        for(int i = 0; i < key.length(); i++){
            if(!list.contains(key.charAt(i)))
                list.add(key.charAt(i));
        }
        for(int i = 0; i < word.length(); i++){
            System.out.print(list.get(word.charAt(i) - 'a'));
        }
    }
}

发表于 2023-11-23 22:33:50 回复(0)
Java
豌豆悠悠头像 豌豆悠悠 
import java.util.*;
import java.util.stream.Collectors;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String key = in.nextLine();
        String word = in.nextLine();

        String result = key + "abcdefghijklmnopqrstuvwxyz";
        List<Character> allList = new ArrayList<>();
        for(char c:result.toCharArray()){
            allList.add(c);
        }
        List<Character> list = allList.stream().distinct().collect(Collectors.toList());
        StringBuilder sb = new StringBuilder();
        for(char a:word.toCharArray()){
            sb.append(list.get(a-'a'));
        }
        System.out.println(sb.toString());
    }
}

发表于 2023-10-29 21:12:46 回复(1)
Java
哈吉马阿拉菇头像 哈吉马阿拉菇 
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String key = in.nextLine();
        String input = in.nextLine();
        System.out.print(new Main().encrypt(key, input));
    }

    public String encrypt(String key, String input) {
        char[] chars = key.toCharArray();
        LinkedHashSet<Character> set = new LinkedHashSet<>();
        for (char ch : chars) {
            set.add(ch);
        }
        LinkedHashSet<Character> set1 = new LinkedHashSet<>();
        for (int i = 97; i <= 122; i++) {
            set1.add((char)i);
        }
        LinkedHashSet<Character> set2 = new LinkedHashSet<>();
        set2.addAll(set1);
        set1.removeAll(set);
        set.addAll(set1);

        HashMap<Character, Character> map = new HashMap<>();
        Iterator<Character> iterator2 = set2.iterator();
        Iterator<Character> iterator = set.iterator();

        for (int i = 0; i < set.size(); i++) {
            map.put(iterator2.next(), iterator.next());
        }

        char[] chs = input.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            if (Character.isLetter(chs[i])) {
                chs[i] = map.get(chs[i]);
            }
        }
        return new String(chs);
    }
}

发表于 2023-09-19 22:45:49 回复(0)
Java
牛客106397800号头像 牛客106397800号 
import java.util.Scanner;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedHashSet;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String key = br.readLine();
        String line = br.readLine();

        // 业务场景为存取有序，且不重复，所以用linkedHashSet数据结构
        LinkedHashSet<Character> set = new LinkedHashSet<>();
        for (int i = 0; i < key.length(); i++) {
            char c = key.charAt(i);
            // 统一转换为大写
            set.add(Character.toUpperCase(c));
        }


        // 添加其他的字母到密钥中
        for (char i = 'A'; i <= 'Z'; i++) {
            set.add(i);
        }

        // 转换为list，方便后续使用索引找到对应加密后的字符
        ArrayList<Character> list = new ArrayList<>();
        for (Character character : set) {
            list.add(character);
        }

        // 打印密钥
        // System.out.println(list);

        // 正常顺序的字符，保存大写，与密钥大小写一致
        ArrayList<Character> list2 = new ArrayList<>();
        for (char i = 'A'; i <= 'Z'; i++) {
            list2.add(i);
        }
        //System.out.println(list2);

        StringBuilder result = new StringBuilder();
        // 遍历要加密的字符串
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            // 获取在正常字符顺序中的索引值
            int index = list2.indexOf(Character.toUpperCase(c));
            // 获取加密后的字符
            Character character = list.get(index);
            // 大小写保持一致
            if (Character.isLowerCase(c)){
                result.append(Character.toLowerCase(character));
            }else if (Character.isUpperCase(c)){
                result.append(Character.toUpperCase(character));
            }
        }

        System.out.println(result);

    }
}

发表于 2023-08-09 09:54:47 回复(0)
Java
转身劈杀头像 转身劈杀 
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        String str = in.nextLine();
        String password = in.nextLine();
        Set<Character> set = new TreeSet<>();
        List<Character> list = new ArrayList<>();
        for(int i = 0 ; i < str.length(); i ++){
            if(set.add(str.charAt(i))){
                list.add(str.charAt(i));
            }
        }
        
        for(int a = 97; a <= 122 ; a ++){ // a-z 97 -122
            if(list.contains((char)(a))){
                continue;
            }else{
                list.add((char)(a));
            }
        }

        for(int i = 0 ; i < password.length() ; i++){
            System.out.print(list.get((int)(password.charAt(i)) - 97)); // a-z 97 -122
        }
    
    }
}

发表于 2023-06-09 15:15:03 回复(0)
Java
SUMMERENT头像 SUMMERENT 
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        //密匙key
        String key = in.nextLine();
        //要加密的字符串
        String str = in.nextLine();
        char[] keys = key.toCharArray();
        //keys 去重
        Set<Character> set = new LinkedHashSet<>();
        for (char c : keys) {
            set.add(c);
        }
        //set转String类型，去掉[]空格和逗号
        String keySet = set.toString().replaceAll("[\\[\\]\\s,]", "");
        //定义小写字母
        String alphabet = "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";
        String[] st = alphabet.split(" ");
        Map<String, String> map = new HashMap<>();
        //循环keySet，保存到map中，其中map的key为 alphabet中的前 keySet.length() 个单词 ，value为keySet的每个单词
        for (int i = 0; i < keySet.length(); i++) {
            map.put(st[i], String.valueOf(keySet.charAt(i)));
        }
        //循环alphabet ，定义res = keySet.length()
        for (int i = 0, res = keySet.length(); i < st.length; i++) {
            //如果 map中不包含value为 st[i]，则需要把当前st[i] 作为value存入map中，把st[res++]作为map的key，
            if (!map.containsValue(st[i])) {
                map.put(st[res++], st[i]);
            }
        }
        //加密后的字符串
        String result = "";
        //遍历要加密的字符串，是否在map的key中，如果在，则输出对应的value
        for (int j = 0; j < str.length(); j++) {
            String c = String.valueOf(str.charAt(j));
            if (map.containsKey(c)) {
                result += map.get(c);
            }
        }
        System.out.println(result);
    }
}

发表于 2023-05-30 15:02:36 回复(0)
Java
牛客781396821号头像 牛客781396821号
看着麻烦，实际还好，也没有坑 
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 构建字典顺序26个字母的字母表
        List<Character> old = new ArrayList<Character>();
        for (int i = 0 ; i < 26 ; i++) {
            old.add((char)('a' + i));
        }
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String a = in.nextLine();
            String b = in.nextLine();
            List<Character> newList = new ArrayList<Character>();
            // 构建新的字母表，先放入key字符串
            for (int i = 0 ; i < a.length() ; i++) {
                char c = a.charAt(i);
                if (!newList.contains(c)) {
                    newList.add(c);
                }
            }
            // 构建新的字母表，顺序放入其他字符串
            for (int i = 0 ; i < 26 ; i++) {
                char c = old.get(i);
                if (!newList.contains(c)) {
                    newList.add(c);
                }
            }
            // 输出加密后的字符串
            for (int i = 0 ; i < b.length() ; i++) {
                char c = b.charAt(i);
                int index = c - 'a';
                System.out.printf(String.valueOf(newList.get(index)));
            }
            System.out.printf("\n");
        }
    }
}


发表于 2023-05-26 16:57:03 回复(0)
Java
joyvvvv头像 joyvvvv 
public class Test01 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String key = in.nextLine();
            String str = in.nextLine();
            //根据秘钥初始化字母表
            Character[] chars = init(key);
            
            StringBuffer sb = new StringBuffer();
            //遍历字符串，根据字母表得到密文
            for (int i = 0; i < str.length(); i++) {
                sb.append(chars[str.charAt(i)-'a']);
            }
            System.out.println(sb.toString());
        }
    }
    public static Character[] init(String key){
        Character[] table = {'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'};
        ArrayList<Character> list = new ArrayList<>();
        //遍历key，添加到list集合中
        for (int i = 0; i < key.length(); i++) {
            char c = key.charAt(i);
            if(key.indexOf(c)==i){
                //使用过的字母标记为‘0’
                table[c-'a']='0';
                list.add(c);
            }
        }
        //将剩余字母添加到集合中
        for (int i = 0; i < table.length; i++) {
            if(table[i]!='0'){
                list.add(table[i]);
            }
        }
        return list.toArray(new Character[list.size()]);
    }
}

发表于 2023-05-16 16:59:05 回复(0)
Java
简单点201811271018392头像 简单点201811271018392 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        List<Character> dic = new ArrayList<>();
        char start = 'a';

        for (int i = 0; i < 26; i++) {
            dic.add(start);
            start++;
        }

        String st ;
        while ((st = bf.readLine()) != null) {
            List<Character> list = new ArrayList<>();
            for (String s : Arrays.stream(st.split("")).distinct().collect(
                        Collectors.toList())) {
                list.add(s.charAt(0));
            }

            for (Character s : list) {
                dic.remove(s);
            }
            dic.addAll(0, list);
//加密字典构造好，后用再次得到字符依次获取字典中对应索引位置的字符
            //即使用传入字符-'a'活得索引值
            //依次获取
            char[] res = bf.readLine().toCharArray();
            for (int i = 0; i < res.length; i++) {
                res[i] = dic.get(res[i] - 'a');
            }
            System.out.println(res);

        }
    }
}

发表于 2023-05-12 14:39:15 回复(0)
Java
成哥丿头像 成哥丿
通过全部用例    运行时间43ms    占用内存10920KB

import java.util.Scanner;

import java.util.HashMap;
import java.util.Map;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    private static final String ZMB = "abcdefghijklmnopqrstuvwxyz";
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String mima = in.nextLine();
        String mingwen = in.nextLine();
        in.close();
       
        StringBuilder stringBuilder = new StringBuilder();
        Map<Character, String> map = new HashMap<>();
        char[] array = mima.toCharArray();
        for (char ch : array) {
            if(!map.containsKey(ch)){
                map.put(ch, null);
                stringBuilder.append(ch);
            }
        }
       
        char[] zmbArray = ZMB.toCharArray();
        for (char ch : zmbArray) {
            if(!map.containsKey(ch)){
                map.put(ch, null);
                stringBuilder.append(ch);
            }
        }
       
        String newZMB = stringBuilder.toString();
        StringBuilder stringBuilder2 = new StringBuilder();
        char[] mingwenArray = mingwen.toCharArray();
        for (char ch : mingwenArray) {
            int index = ZMB.indexOf(ch);
            stringBuilder2.append(newZMB.charAt(index));
        }
       
        System.out.println(stringBuilder2.toString());
    }
}
发表于 2023-05-05 17:21:42 回复(0)
提交观点

问题信息

字符串
难度：
98条回答 41337浏览

热门推荐

通过挑战的用户

查看代码

相关试题

字符串加密

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号