首页 > 试题广场 >

字符串加密

[编程题]字符串加密
  • 热度指数:138093 时间限制: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
import java.util.*;

public class Main {
	
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		while (cin.hasNext()) {
			char[] key = cin.next().toCharArray(),
					s = cin.next().toCharArray();
			
			Set<Character> set = new HashSet<>();
			char[] table = new char[26];
			int k = 0;
			
			
			for (int i = 0; i < key.length; ++i) {
				char c = key[i];
				if (!set.contains(c)) {
					table[k++] = c;
					set.add(Character.toLowerCase(c));
				}
			}
			
			for (; k < 26; ++k) {
				for (int i = 0; i < 26; ++i) {
					char c = (char) ('a' + i);
					if (!set.contains(c)) {
						table[k++] = c;
						set.add(Character.toLowerCase(c));
					}
				}
			}
			
			for (int i = 0; i < s.length; ++i) {
				boolean up = false;
				char c = s[i];
				if (Character.isUpperCase(c)) {
					up = true;
				}
				
				char res = table[c - 'a'];
				if (up) {
					System.out.print(Character.toUpperCase(res));
				}
				System.out.print(res);
			}
			
			System.out.println();
		}
	}
}


发表于 2017-08-22 16:27:50 回复(3)
import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String key = scanner.nextLine();
            String input = scanner.nextLine();
            encryptStr(key, input);
        }
    }
    
    public static void encryptStr (String key, String input) {
        String lowerDict = "abcdefghijklmnopqrstuvwxyz";
        String upperDict = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        String tempDict = "abcdefghijklmnopqrstuvwxyz";
        key = key.toLowerCase();
        String lowerKeyDict = "";
        // build new keyDict;
        for (char c : key.toCharArray()) {
            if (tempDict.indexOf(c) >= 0) {
                lowerKeyDict += c;
                tempDict = tempDict.replaceAll(c+"", "");
            }
        }
        for (char c : lowerDict.toCharArray()) {
            if (lowerKeyDict.indexOf(c) < 0) {
                lowerKeyDict += c;
            }
        }
        String upperKeyDict = lowerKeyDict.toUpperCase();
        String res = "";
        // start encrypt;
        for (char c : input.toCharArray()) {
            // if is lowercase
            if (Character.isLowerCase(c)) {
                res += lowerKeyDict.charAt(lowerDict.indexOf(c));
            }
            // if is uppercase
            else if (Character.isUpperCase(c)) {
                res += upperKeyDict.charAt(upperDict.indexOf(c));
            }
            else {
                res += " ";
            }
            
        }
        System.out.println(res);
    }
}


发表于 2019-08-18 17:55:50 回复(4)
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            String key = sc.next();
            String pwd = sc.next();
            LinkedHashSet<Character> set = new LinkedHashSet<>();
            for(char c : key.toCharArray()) {
                set.add(Character.toUpperCase(c));
            }
            for(char c = 'A'; c <= 'Z'; c++) {
                set.add(c);
            }
            ArrayList<Character> list = new ArrayList<>(set);
            for(char c : pwd.toCharArray()) {
                if(Character.isLowerCase(c)) {//小写
                    System.out.print(Character.toLowerCase(list.get(c - 'a')));
                }else {
                    System.out.print(Character.toUpperCase(list.get(c - 'A')));
                }
            }
            System.out.println();
        }
    }
}

发表于 2021-09-28 19:56:54 回复(0)
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String key = sc.nextLine().toLowerCase();
            String s = sc.nextLine();
            Set<Character> set = new LinkedHashSet<>();
            for (char c : key.toCharArray()) {
                set.add(c);
            }
            for (char c = 'a'; c <= 'z'; c++) {
                if (!set.contains(c)) {
                    set.add(c);
                }
            }
            int k = 0;
            char[] arr = new char[26];
            for (Character c : set) {
                arr[k++] = c;
            }
            
            StringBuffer sb = new StringBuffer();
            for (char c : s.toCharArray()) {
                if (c >= 'a') {
                    sb.append(arr[c - 'a']);
                } else {
                    sb.append(arr[c - 'A' + 'a'] - 'a' + 'A');
                }
            }
            System.out.println(sb);
        }
    }
}

发表于 2021-03-05 13:40:36 回复(1)
import java.util.*;
public class Main{
    public static String alpRef = "abcdefghijklmnopqrstuvwxyz";
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            String keyLower = scanner.next().toLowerCase();
            String rawString = scanner.next();
            Set<String> usefulKeyLower = new LinkedHashSet<>();
            usefulKeyLower.addAll(Arrays.asList(keyLower.split("")));
            for (int i = 0; i < alpRef.length(); i++){
                usefulKeyLower.add(String.valueOf(alpRef.charAt(i)));
            }
            String newRef = String.join("",usefulKeyLower);
            StringBuilder result = new StringBuilder();
            for (int i = 0; i < rawString.length(); i++){
                int index = Character.toLowerCase(rawString.charAt(i)) - 'a';
                if (rawString.charAt(i) - 'a' < 0){
                    result.append(newRef.substring(index,index+1).toUpperCase());
                }else{
                     result.append(newRef.substring(index,index+1));
                }
            }
            System.out.println(result.toString());
        }
    }
}

发表于 2020-12-25 15:12:27 回复(0)
import java.util.*;
public class StringCrypt {
	 public static void main(String[] args){
	        Scanner sc = new Scanner(System.in);
	        while(sc.hasNext()){
	            String str1 = sc.nextLine();//key
	            String str2 = sc.nextLine();
	            System.out.println(Encrypt(str1,str2));
	        }
	    }
	    
	    public static String Encrypt(String str1,String str2){
	        char[] chs = str1.toCharArray();
	        StringBuilder sb = new StringBuilder();//获取key对应的字母表
	        for(int i=0;i<chs.length;i++){
	            if(sb.toString().indexOf(chs[i])==-1){
	                sb.append(chs[i]);
	            }
	        }	        
	        for(int i=0;i<26;i++){
	            if(sb.toString().toUpperCase().indexOf((char)('A'+i))==-1){
	            	sb.append((char)('A'+i));
	            }
	        }
	        //System.out.println(sb.toString());
	        char[] zero = sb.toString().toCharArray();	        
	        char[] chs2 = str2.toCharArray();
	        StringBuilder sb2 = new StringBuilder();//获取加密后的字符串
	        for(int i=0;i<chs2.length;i++){
	        	if(chs2[i]>='A'&&chs2[i]<='Z'){
	        		sb2.append(String.valueOf(zero[chs2[i]-'A']).toUpperCase()) ;
	        	}else if(chs2[i]>='a'&&chs2[i]<='z'){
	        		sb2.append(String.valueOf(zero[chs2[i]-'a']).toLowerCase());
	        	}else{
	        		sb2.append(chs2[i]);
	        	}
	        }
	        
	        return sb2.toString();
	        
	    }
}

发表于 2016-08-14 22:39:32 回复(0)
#include<iostream>
#include<string>
using namespace std;
int main(){
    string key;
    while(cin>>key){
        string str;
        cin>>str;
        string s;
        string ans=str;
        for(int i=0;i<key.length();i++){
        	int flag=0;
            for(int j=0;j<s.length();j++){
            	if(s[j]==key[i]){
            		flag=1;
            		break;
				}
			}
			if(!flag)
				s+=key[i];
        }
        char begin='a',end='z';
        if(key[0]>='A'&&key[0]<='Z'){
        	begin-=32;
        	end-=32;
		}
        for(char ch=begin;ch<=end;ch++){
            if(s.find(ch)==-1)
                s+=ch;
        }
        for(int i=0;i<str.length();i++){
        	 if(key[0]>='A'&&key[0]<='Z')
        		ans[i]=s[str[i]-'A'];
        	else
				ans[i]=s[str[i]-'a'];	
		}
        cout<<ans<<endl;
    }
    return 0;
}

编辑于 2016-08-10 10:26:42 回复(2)
n=input()
m=input()
list1=['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']
res=''
a=1
for i in n[::-1]:
    list1.remove(i)
    list1.insert(0,i)
for i in m:
    a=ord(i)-97
    res+=list1[a]
print(res)
    

发表于 2022-08-11 20:04:17 回复(0)
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;

int main(){
    string s1,s2,tmp1;
    cin>>s1>>s2;
    
    //单词去重
    for(int i=0;i<s1.size();i++){
        if(tmp1.find(s1[i])==tmp1.npos) tmp1+=s1[i];
    }
    
    //字母表
    string tmp2;
    char st='a';
    for(int i=0;i<26;i++){
        tmp2+=st;
        st+=1;
    }
    
    //字母表里去除单词
    for(int i=0;i<tmp1.size();i++){
        tmp2.erase(tmp2.begin()+tmp2.find(tmp1[i]));
    }
    
    //建立新表
    string dic=tmp1+tmp2;

    for(int i=0;i<s2.size();i++){
        cout<<dic[s2[i]-'a'];
    }
}
发表于 2022-08-06 23:24:43 回复(1)
import java.util.*;
public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        char[] ch = new char[26];
        
        char[] key = sc.next().toLowerCase().toCharArray();
        //保证顺序一致的set
        Set<Character> set = new LinkedHashSet<>();
        //先把key中的插入set
        for(int j = 0;j<key.length;j++){
            if(!set.contains(key[j])){
                set.add(key[j]);
            }
        }
        //再把26个字母补全
        for(int i = 0;i<26;i++){
             if(!set.contains((char)(i+'a'))){
                 set.add((char)(i+'a'));   
             }              
        }
        int count = 0;
        //放入数组中,方便用下标直接取值
        for(Character c:set){

            ch[count++] = c;
        }
        char[] in = sc.next().toLowerCase().toCharArray();
        StringBuilder sb = new StringBuilder();
        //计算和‘a’的差值即可直接从数组中取值
        for(int k = 0;k<in.length;k++){
            sb.append(ch[in[k]-'a']);
        }
        System.out.print(sb.toString());
   
    }       
}


发表于 2022-04-08 15:18:11 回复(0)
import java.util.*;
public class Main01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()){
            String key = sc.nextLine().toLowerCase();//后面统一用小写建立键值对
            String str = sc.nextLine();
            //将key中的字母放进容器
            List<Character> list = new ArrayList<>();
            for (Character ch:key.toCharArray()){
                if (!list.contains(ch))
                    list.add(ch);
            }
            //将其他字母补充进容器,并建立键值对
            char c = 'a';
            Map<Character,Character> map = new HashMap<>();
            for (int i = 0;i<26;i++){
                if (!list.contains(c)){
                    list.add(c);
                }
                map.put(c,list.get(i));  //也可以单独建立,如下注释的代码
                c++;
            }

//        //建立键值对
//        char c1 = 'a';
//        Map<Character,Character> map = new HashMap<>();
//        for (int i = 0;i<26;i++){
//            map.put(c1++,list.get(i));
//        }

            for (Character temp:str.toCharArray()){
                if (Character.isLetter(temp)){
                    if (Character.isUpperCase(temp))  //判断是否要输出大写
                        System.out.print(Character.toUpperCase(map.get(Character.toLowerCase(temp))));
                    else
                        System.out.print(map.get(temp));
                }else
                    System.out.print(temp); // 非字母输出原始字符
            }
            System.out.println();
        }
    }
}

发表于 2022-02-17 11:16:33 回复(0)
while True:
    try:
        A=input()
        B=input()
        C="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        A2=''
        res=''
        for i in A:
            if i not in A2:
                A2+=i
        A2=A2.upper()
        for j in C:
            if j not in A2 and j.lower() not in A2:
                A2+=j
        for i in B:
            if i.islower():
                res+=A2[C.index(i.upper())].lower()
            else:
                res+=A2[C.index(i.upper())].upper()
        print(res)


发表于 2022-01-18 11:09:46 回复(0)
while True:
    try:
        key = input()
        value = input()

        l = list(key)
        l1 = l[::-1]
        for index,i in enumerate(l1):
            if l1.count(i) > 1:
                l1[index] = ' '
        for i in range(l1.count(' ')):
            l1.remove(' ')
        l = l1[::-1]

        a_z=[chr(ord('a')+i) for i in range(26)]
        for i in l:
            a_z.remove(i)
        l=l+a_z

        l2=list(value)
        for i in l2:
            if i==" ":
                print(" ",end='')
            else:
                print(l[ord(i)-97],end='')
        print()
    except:
        break

发表于 2021-12-19 22:05:39 回复(0)
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;

/**
 * @author Yuliang.Lee
 * @version 1.0
 * @date 2021/9/15 12:35
 * 字符串加密:
    有一种技巧可以对数据进行加密,它使用一个单词作为它的密匙。下面是它的工作原理:首先,选择一个单词作为密匙,如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。
 * 示例:
    输入:
    nihao
    ni
    输出:
    le
 */
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String key = in.nextLine().toUpperCase();
            String str = in.nextLine();
            Set<Character> set = new LinkedHashSet<>();
            for (int i = 0; i < key.length(); i++) {
                set.add(key.charAt(i));
            }
            for (int ch = 65; ch < 91; ch++) {
                set.add((char) ch);
            }
            // 获得字符加密映射表
            char[] mapper = new char[26];
            int index = 0;
            for (Character e : set) {
                mapper[index] = e;
                index++;
            }
            // 加密输出
            for (int i = 0; i < str.length(); i++) {
                char ch = str.charAt(i);
                if (ch != ' ') {
                    if (ch - 65 > 26) {
                        // 小写
                        ch = (char) (mapper[ch - 97] + 32);
                    } else {
                        // 大写
                        ch = mapper[ch - 65];
                    }
                }
                System.out.print(ch);
            }
            System.out.println();
        }
    }
}

发表于 2021-09-15 18:03:57 回复(0)
#include<bits/stdc++.h>
using namespace std;
int main(){
    string key, s;
    while(cin>>key>>s){
        string tmp;
        for(int i=0;i<key.size();i++){
            if(tmp.find(toupper(key[i]))==-1){
                tmp.push_back(toupper(key[i]));
            }
        }
        for(int i=0;i<26;i++){
            if(tmp.find(i+'A')==-1){
                tmp.push_back(i+'A');
            }
        }
        for(int i=0;i<s.size();i++){
            if(s[i]>='a' && s[i]<='z'){
                s[i]=tolower(tmp[s[i]-'a']);
            }
            else if(s[i]>='A' && s[i]<='Z'){
                s[i]=tmp[s[i]-'A'];
            }
        }
        cout<<s<<endl;
    }
    return 0;
}

发表于 2021-09-01 23:24:12 回复(0)
求问为什么这段程序输出的 len为11????
发表于 2021-09-01 10:37:48 回复(0)
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main() {
	string s, key;
	while(cin >>  key>>s ){
    //密钥映射表的制作
	transform(key.begin(), key.end(), key.begin(), ::toupper);
	int v[26]{0};
	string solve{};
	for (char c : key) {
		v[c - 'A']++;
		if (v[c - 'A'] == 1) {
			solve += c;
		}
	}
	for (int i = 0; i < 26; i++) {
		if (!v[i])
			solve += i + 'A';
	}
	solve += solve;
	transform(solve.begin() + 26, solve.end(), solve.begin() + 26, ::tolower);
	string source = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
	//加密
	for (int i = 0; i < s.size(); i++) {
		s[i]=solve[source.find(s[i])];
	}
	cout << s << endl;
    }
}

发表于 2021-08-16 03:26:40 回复(0)
用string的push_back也太方便了吧!
#include <iostream>
#include <math.h>
#include <string.h>
using namespace std;
int main()
{
	string str, key, secret, result;
	while (cin >> str && cin >> secret)
	{
		//对key的处理
        key="";
		int alpha[26] = { 0 };
		for (int i = 0; i < str.size(); i++)
		{
			if (alpha[str[i] - 'a'] == 0)
			{
				alpha[str[i] - 'a'] = 1;
				key.push_back(str[i]);
			}
		}
		for (int j = 0; j < 26; j++)
		{
			if (alpha[j] == 0)
			{
				key.push_back(j + 'a');
			}
		}
		//对密文的处理
		result ="";
		for (int k = 0; k < secret.size(); k++)
		{
			result.push_back(key[secret[k] - 'a']);
		}
		cout << result<<endl;
	}
}


发表于 2021-07-30 22:52:15 回复(0)
c代码如下
#include<stdio.h>
#include<string.h>
int main(void)
{
    int key[26];
    char word[100];
    char txt[100];
    while(scanf("%s %s",&word,&txt)!=EOF)
    {
        int n=strlen(word);
        for(int i=0;i<n;i++)
        {
            for(int j=i+1;j<n;j++)
            {
                if(word[i]==word[j])
                {
                    word[j]='0';
                }
            }
        }
        int t=0;
        for(int i=0;i<n;i++)
        {
            if(word[i]>='a'&&word[i]<='z')
            {
                key[t]=word[i]-'a';
                t++;
            }
            else if(word[i]>='A'&&word[i]<='Z')
            {
                key[t]=word[i]-'A';
                t++;
            }
        }
        int k;
        int q=0;
        for(int i=0;i<26;i++)
        {
            k=1;
            for(int j=0;j<t;j++)
            {
                if(i==key[j])
                {
                    k=0;
                }
            }
            if(k==1)
            {
                key[t+q]=i;
                q++;
            }
        }
        int len=strlen(txt);
        for(int i=0;i<len;i++)
        {
            if(txt[i]==' ')
            {
                printf(" ");
            }
            else if(txt[i]>='a'&&txt[i]<='z')
            {
                printf("%c",'a'+key[txt[i]-'a']);
            }
            else if(txt[i]>='A'&&txt[i]<='Z')
            {
                printf("%c",'A'+key[txt[i]-'A']);
            }
        }
        printf("\n");
    }
}

发表于 2021-04-13 23:15:08 回复(0)
不难,就是理解起来有点费劲。其实就是对key中的字符进行去重得到newkeynewkey中的字符从字母表中干掉,然后保持字符的相对顺序:newkey中的字符在前,字母表剩余的字符在后,拼接起来得到值列表。原来26个字母的列表对应为其键列表,根据键值对的映射关系来对明文进行翻译。
要想保持原来的大小写,我们可以只建立大写字母的映射关系,在对明文进行逐字符翻译时将明文的字符转换成大写去映射中查找其对应的密文,此时查找到的对应密文是个大写字符,如果明文字符是个小写字符,把这个对应到的密文转换成小写就行了。
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".split()

while True:
    try:
        key, plaintext = input().strip(), input().strip()
        mem = set()       # 用于去重key的字符
        # 构建值列表
        k, v = list(alphabet), []
        for c in key.upper():
            if c not in mem:
                mem.add(c)
                v.append(c)
                k.remove(c)
        v.extend(k)
        # 构建映射关系
        mp = dict(zip(alphabet, v))
        # 加密
        ciphertext = []
        for c in plaintext:
            if ord(c) >= 97 and ord(c) <= 122:
                # 由于mp中的key为大写字母,所有明文中字符为小写字母时转换为大写字母来进行翻译
                ciphertext.append(mp[c.upper()].lower())
            else:
                ciphertext.append(mp[c])
        print(''.join(ciphertext))
    except:
        break


编辑于 2021-03-23 15:25:46 回复(0)