首页 > 试题广场 >

字符串加密

[编程题]字符串加密

热度指数：156800 时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32M，其他语言64M
算法知识视频讲解

$\hspace{15pt}$ 对于给定的字符串 $s$ ，我们可以利用其进行加密。
$\hspace{15pt}$ 具体地，首先先将 $s$ 进行去重，即如果 $s$ 中存在重复的字母，则只保留第一次出现的字母。随后，从 $\texttt{$ 开始依次在字符串末尾补充 $s$ 中未出现的字母，使得 $s$ 成为一个完整的字母表。
$\hspace{15pt}$ 最后，对于给定的明文 $t$ ，我们利用上述字母表进行加密，即对于 $t$ 中的每个字母，替换为 $s$ 构建得到的新字母表中相同位置的字母。

输入描述:

第一行输入一个长度为  ，仅由小写字母构成的字符串  ，代表待构建的新字母表底串。
第二行输入一个长度为  ，仅由小写字母构成的字符串  ，代表需要加密的明文。

输出描述:

在一行上输出一个字符串，代表加密后的密文。

示例1

输入

trailblazers
attackatdawn

输出

tpptadtpitvh

说明

在这个样例中，加密的操作如下：
 对  进行去重  ，得到  ；
 随后从  开始依次在字符串末尾补充  中未出现的字母，得到  ；
 最后，对于  中的每个字母，替换为  构建得到的新字母表中相同位置的字母。我们可以列出对照表：

 最后，对于  中的每个字母，替换为  构建得到的新字母表中相同位置的字母，得到  。

示例2

输入

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)

Java

牛客176747785号

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)

Java

少年乖

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)

tigg_ZZ

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)

Java

PGCharles

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)

Python 3

牛客226747070号

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)

牛客336427968号

#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)

Java

heyren

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)

Java

镜花水月_

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)

Python 3

每天都要变强

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)

Python 3

撒旦法说

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)

Java

LSur

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)

C++

算法小屁孩

#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)

C++

牛客568909235号

#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)

C++

在刷题的马来熊很豁达

用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)

pein531

不难，就是理解起来有点费劲。其实就是对key中的字符进行去重得到newkey，newkey中的字符从字母表中干掉，然后保持字符的相对顺序：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)

KratosW

我的思路比较麻烦，希望大神指正

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 source = sc.next();
			StringBuilder sb = new StringBuilder();
			String abc = "";
			Map<Character,Character> letterMap = new HashMap();
			if(97<=Integer.valueOf(key.charAt(0)) && Integer.valueOf(key.charAt(0))<=122){
                abc = "abcdefghijklmnopqrstuvwxyz";
			}else{
				abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
			}
                //先把key去重
				for (int i = 0; i < key.length(); i++) {
					char c = key.charAt(i);
					if(!sb.toString().contains(String.valueOf(c))){
						sb.append(c);
					}
				}
                //key和26个字母中的其他字母组成下行字符串
				for(int i = 0;i<abc.length();i++){
					char c = abc.charAt(i);
					if(!sb.toString().contains(String.valueOf(c))){
						sb.append(c);
					}
				}
                //将上行字符串和下行字符串一一对应放入map中
				for(int i = 0;i<abc.length();i++){
					char c1 = abc.charAt(i);
					char c2 = sb.charAt(i);
					letterMap.put(c1, c2);
				}
                //根据source来取值
				for(int i = 0;i<source.length();i++){
					char c = source.charAt(i);
					System.out.print(letterMap.get(c));
				}
			System.out.println("");
		}
    }
}

发表于 2021-03-03 11:55:43 回复(0)

国际精神病研究院王医生

//去重->维护一套密码机制
import java.util.*;

public class Main {
    public static void main(String[] args) {
        String oldKey = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
        LinkedHashSet<Character> set = new LinkedHashSet<>();
        HashMap<Character,Character> map = new HashMap();
            String key = in.nextLine();
            String value = in.nextLine();
            for(int i =0; i<key.length(); i++){
                if(key.charAt(i)>'Z'){
                    set.add((char)(key.charAt(i)-32));
                }else{
                    set.add(key.charAt(i));
                }

            }
            for(int i =0; i<oldKey.length(); i++){
                set.add(oldKey.charAt(i));
            }
            int index = 0;
            for(char s : set){
                map.put(oldKey.charAt(index),s);
//                 map.put(oldKey.charAt(index)+"",((char)(s+32))+"");
                index++;
            }
            //AscII大小写差值为26+6=32
            for(int i = 0; i<value.length(); i++){
                if(value.charAt(i)>'Z'){
                    char k = map.get((char)(value.charAt(i)-32));
                    System.out.print((char)(k+32));
            } else {
                System.out.print((char)map.get(value.charAt(i)));
            }
// 三元编译不过 ？？System.out.print(value.charAt(i)>'Z'?(char)(map.get((char)(value.charAt(i)-32))+32):map.get(value.charAt(i)));
            }
                System.out.println("");
        }
    }
}

发表于 2021-03-01 23:11:15 回复(0)

一般市民Young

为什么本地IDE用例通的过，在这不通过？求解

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

#define MAXSIZE 100
#define ALNUMS 26

typedef struct{
    char num;
    char exist;
}Dic;

int main(){
    char key[ALNUMS] = {'\0'};
    while(gets(key)){
        char str[MAXSIZE] = {'\0'};
        gets(str);
        int i, j, len_key = strlen(key);
        Dic *dic = (Dic*)calloc(ALNUMS, sizeof(Dic));
        int len_str = strlen(str);
        for(i=0, j= 0; i<len_key; i++){
            int temp = toupper(key[i]) - 'A';
            if(dic[temp].exist == 0){
                dic[temp].exist = 1;
                dic[j].num = temp + 'A';
                j++;
            }
        }
        for(i=0; i<ALNUMS; i++){
            if(dic[i].exist == 0){
                dic[j++].num = i + 'A';
                dic[i].exist = 1;
            }
        }

        for(i=0; i<len_str; i++){
            if(isupper(str[i])){
                printf("%c", dic[str[i]-'A'].num);
            }
            else if(islower(str[i]))
                printf("%c", tolower(dic[str[i]-'a'].num));
            else
                printf("%c", str[i]);
        }
        printf("\n");
        free(dic);
    }
    
    return 0;
}

发表于 2020-12-15 15:00:10 回复(0)

提交观点

问题信息

字符串

难度：

793条回答 1339收藏 45509浏览

通过挑战的用户

查看代码

牛客80860...

2023-02-20 13:57:14
牛客92073...

2022-09-19 09:45:01
不言语

2022-09-17 22:24:45
诗韵0115

2022-09-16 17:16:25
菠萝菠萝、

2022-09-16 15:05:53

字符串加密

输入描述:

输出描述:

输入

输出

说明

输入

输出

问题信息

热门推荐

通过挑战的用户

相关试题