NOI 1.7编程基础之字符串(35题)

01:统计数字字符个数

总时间限制: 
1000ms

内存限制: 
65536kB
描述

输入一行字符，统计出其中数字字符的个数。

输入
一行字符串，总长度不超过255。
输出
输出为1行，输出字符串里面数字字符的个数。
样例输入
Peking University is set up at 1898.
样例输出
4
来源
习题(7-1) 医学部 2010 期末试题 樊波

 1 #include<cstdio>
 2 #include<cstring>
 3 char a[1000];
 4 int main()
 5 {
 6
 7   unsigned int i,count=0;
 8   gets(a);
 9   for(i=0;i<=strlen(a)-1;i++)
10   if(a[i]>=‘0‘&&a[i]<=‘9‘)
11   count++;
12   printf("%d",count);
13   return 0;
14 }

02:找第一个只出现一次的字符

总时间限制: 
1000ms

内存限制: 
65536kB
描述

给定一个只包含小写字母的字符串，请你找到第一个仅出现一次的字符。如果没有，输出no。

输入
一个字符串，长度小于100000。
输出
输出第一个仅出现一次的字符，若没有则输出no。
样例输入
abcabd
样例输出
c
 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstring>
 4 #include<algorithm>
 5 using namespace std;
 6 char s[103000];
 7 int zj=0,flag=0,t;
 8 struct node
 9 {
10     int x;//字符出现次数
11     int y;//标号
12     int c;//字符码
13 };node a[101],f[101];
14 int cmp(const node &p,const node &q)
15 {
16     return p.y<q.y;
17 }
18 int main()
19 {
20     scanf("%s",s+1);
21     int len=strlen(s+1);
22     for(int i=1;i<=30;i++)
23       a[t].x=0,a[t].y=99;
24     for(int i=1;i<=len;i++)
25       {
26           t=s[i]-96;a[t].x++;
27         if(a[t].x==1) a[t].y=i;
28       }
29     for(int i=1;i<=30;i++)
30       if(a[i].x==1) f[++zj].x=a[i].x,f[zj].y=a[i].y,f[zj].c=i,flag=1;
31     if(flag==1)
32     {
33       sort(f+1,f+zj+1,cmp);
34       putchar(f[1].c+96);
35     }
36     else printf("no");
37     return 0;
38 }

03:基因相关性

总时间限制: 
1000ms

内存限制: 
65536kB
描述

为了获知基因序列在功能和结构上的相似性，经常需要将几条不同序列的DNA进行比对，以判断该比对的DNA是否具有相关性。

现比对两条长度相同的DNA序列。首先定义两条DNA序列相同位置的碱基为一个碱基对，如果一个碱基对中的两个碱基相同的话，则称为相同碱基对。接着计算相同碱基对占总碱基对数量的比例，如果该比例大于等于给定阈值时则判定该两条DNA序列是相关的，否则不相关。

输入
有三行，第一行是用来判定出两条DNA序列是否相关的阈值，随后2行是两条DNA序列（长度不大于500）。
输出
若两条DNA序列相关，则输出“yes”，否则输出“no”。
样例输入
0.85
ATCGCCGTAAGTAACGGTTTTAAATAGGCC
ATCGCCGGAAGTAACGGTCTTAAATAGGCC
样例输出
yes
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 char a[501],b[501];
 6 double p,ans=0;
 7 int main(){
 8     cin>>p;
 9     scanf("%s%s",a,b);
10     int len=strlen(a),i=0;
11     while(i<len){
12         if(a[i]==b[i]) ans++;
13         i++;
14     }
15     double l=len;
16     printf("%s\n",ans/l>p?"yes":"no");
17     return 0;
18 }

04:石头剪子布

总时间限制: 
1000ms

内存限制: 
65536kB
描述

石头剪子布，是一种猜拳游戏。起源于中国，然后传到日本、朝鲜等地，随着亚欧贸易的不断发展它传到了欧洲，到了近现代逐渐风靡世界。简单明了的规则，使得石头剪子布没有任何规则漏洞可钻，单次玩法比拼运气，多回合玩法比拼心理博弈，使得石头剪子布这个古老的游戏同时用于“意外”与“技术”两种特性，深受世界人民喜爱。

游戏规则：石头打剪刀，布包石头，剪刀剪布。

现在，需要你写一个程序来判断石头剪子布游戏的结果。

输入
输入包括N+1行：
第一行是一个整数N，表示一共进行了N次游戏。1 <= N <= 100。
接下来N行的每一行包括两个字符串，表示游戏参与者Player1，Player2的选择（石头、剪子或者是布）：
S1 S2
字符串之间以空格隔开S1,S2只可能取值在{"Rock", "Scissors", "Paper"}（大小写敏感）中。
输出
输出包括N行，每一行对应一个胜利者（Player1或者Player2），或者游戏出现平局，则输出Tie。
样例输入
3
Rock Scissors
Paper Paper
Rock Paper
样例输出
Player1
Tie
Player2
提示
Rock是石头，Scissors是剪刀，Paper是布。

 1 #include<cstdio>
 2 #include<cstring>
 3 using namespace std;
 4 int a[10];
 5 char s1[100],s2[100];
 6 int main()
 7 {
 8     int n,i;
 9     scanf("%d",&n);
10     for(i=1;i<=n;++i)
11     {
12         scanf("%s",s1);
13         scanf("%s",s2);
14         if (s1[0]==‘R‘)
15           {
16               if(s2[0]==‘R‘) a[i]=0;
17               if(s2[0]==‘S‘) a[i]=1;
18               if(s2[0]==‘P‘) a[i]=2;
19           }
20           if (s1[0]==‘P‘)
21           {
22               if(s2[0]==‘R‘) a[i]=1;
23               if(s2[0]==‘S‘) a[i]=2;
24               if(s2[0]==‘P‘) a[i]=0;
25           }
26           if (s1[0]==‘S‘)
27           {
28               if(s2[0]==‘R‘) a[i]=2;
29               if(s2[0]==‘S‘) a[i]=0;
30               if(s2[0]==‘P‘) a[i]=1;
31           }
32           if(a[i]==1) printf("Player1\n");
33           if(a[i]==2) printf("Player2\n");
34           if(a[i]==0) printf("Tie\n");
35     }
36
37     return 0;
38 }

05:输出亲朋字符串

总时间限制: 
1000ms

内存限制: 
65536kB
描述

编写程序，求给定字符串s的亲朋字符串s1。

亲朋字符串s1定义如下：给定字符串s的第一个字符的ASCII值加第二个字符的ASCII值，得到第一个亲朋字符； 给定字符串s的第二个字符的ASCII值加第三个字符的ASCII值，得到第二个亲朋字符；依此类推，直到给定字符串s的倒数第二个字符。亲朋字符串的最 后一个字符由给定字符串s的最后一个字符ASCII值加s的第一个字符的ASCII值。

输入
输入一行，一个长度大于等于2，小于等于100的字符串。字符串中每个字符的ASCII值不大于63。
输出
输出一行，为变换后的亲朋字符串。输入保证变换后的字符串只有一行。
样例输入
1234
样例输出
cege
 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 #include<algorithm>
 5 using namespace std;
 6 #define N 521
 7 char a[N],c[N];
 8 int main(){
 9     //freopen("sh.txt","r",stdin);
10     gets(a);
11     int len=strlen(a);
12     for(int i=0;i<len-1;i++)
13       c[i]=a[i]+a[i+1];
14     c[len-1]=a[0]+a[len-1];
15     puts(c);
16     return 0;
17 }

06:合法 C 标识符

总时间限制: 
1000ms

内存限制: 
65536kB
描述

给定一个不包含空白符的字符串，请判断是否是C语言合法的标识符号（注：题目保证这些字符串一定不是C语言的保留字）。

C语言标识符要求：

1. 非保留字；

2. 只包含字母、数字及下划线（“_”）。

3. 不以数字开头。

输入
一行，包含一个字符串，字符串中不包含任何空白字符，且长度不大于20。
输出
一行，如果它是C语言的合法标识符，则输出yes，否则输出no。
样例输入
RKPEGX9R;TWyYcp
样例输出
no
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 char s[501];
 6 double p,ans=0;
 7 int main(){
 8     scanf("%s",s);
 9     int len=strlen(s);
10     if(s[0]>=‘0‘&&s[0]<=‘9‘) {printf("%s\n","no");return 0;}
11     for(int i=0;i<len;i++)
12         if((s[i]>=‘0‘&&s[i]<=‘9‘)||(s[i]>=‘a‘&&s[i]<=‘z‘)||(s[i]>=‘A‘&&s[i]<=‘Z‘)||s[i]==‘_‘);
13         else {printf("%s\n","no");return 0;}
14     printf("%s\n","yes");
15     return 0;
16 }

07:配对碱基链

总时间限制: 
1000ms

内存限制: 
65536kB
描述

脱氧核糖核酸（DNA）由两条互补的碱基链以双螺旋的方式结合而成。而构成DNA的碱基共有4种，分别为腺瞟呤（A）、鸟嘌呤（G）、胸腺嘧啶（T）和胞嘧啶（C）。我们知道，在两条互补碱基链的对应位置上，腺瞟呤总是和胸腺嘧啶配对，鸟嘌呤总是和胞嘧啶配对。你的任务就是根据一条单链上的碱基序列，给出对应的互补链上的碱基序列。

输入
一个字符串，表示一条碱基链。这个字符串只含有大写字母A、T、G、C，分别表示腺瞟呤、胸腺嘧啶、鸟嘌呤和胞嘧啶。字符串长度不超过255。
输出
一个只含有大写字母A、T、G、C的字符串，为与输入的碱基链互补的碱基链。
样例输入
ATATGGATGGTGTTTGGCTCTG
样例输出
TATACCTACCACAAACCGAGAC
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 char s[501],c[501];
 6 int main(){
 7     scanf("%s",s);
 8     int len=strlen(s);
 9     for(int i=0;i<len;i++)
10         switch(s[i]){
11                case ‘T‘:c[i]=‘A‘;break;
12                case ‘A‘:c[i]=‘T‘;break;
13              case ‘G‘:c[i]=‘C‘;break;
14                case ‘C‘:c[i]=‘G‘;break;
15         }
16     puts(c);
17     return 0;
18 }

08:字符替换

总时间限制: 
1000ms

内存限制: 
65536kB
描述

把一个字符串中特定的字符全部用给定的字符替换，得到一个新的字符串。

输入
只有一行，由一个字符串和两个字符组成，中间用单个空格隔开。字符串是待替换的字符串，字符串长度小于等于30个字符，且不含空格等空白符；
接下来一个字符为需要被替换的特定字符；
接下来一个字符为用于替换的给定字符。
输出
一行，即替换后的字符串。
样例输入
hello-how-are-you o O
样例输出
hellO-hOw-are-yOu
 1 #include<cstring>
 2 #include<iostream>
 3 using namespace std;
 4 char c[30],a,b;
 5 int main(){
 6      cin>>c>>a>>b;
 7      int i;
 8      for(i=0;i<strlen(c);i++){
 9          if(c[i]==a)c[i]=b;
10     }
11      for(i=0;i<strlen(c);i++)cout<<c[i];
12      return 0;
13 }

09:密码翻译

总时间限制: 
1000ms

内存限制: 
65536kB
描述

在情报传递过程中，为了防止情报被截获，往往需要对情报用一定的方式加密，简单的加密算法虽然不足以完全避免情报被破译，但仍然能防止情报被轻易的识别。我们给出一种最简的的加密方法，对给定的一个字符串，把其中从a-y，A-Y的字母用其后继字母替代，把z和Z用a和A替代，其他非字母字符不变，则可得到一个简单的加密字符串。

输入
输入一行，包含一个字符串，长度小于80个字符。
输出
输出每行字符串的加密字符串。
样例输入
Hello! How are you!
样例输出
Ifmmp! Ipx bsf zpv!
来源
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 char s[501];
 6 int main(){
 7     gets(s);
 8     int len=strlen(s);
 9     for(int i=0;i<len;i++){
10         if((s[i]>=‘a‘&&s[i]<=‘y‘)||(s[i]>=‘A‘&&s[i]<=‘Y‘)) {s[i]++;continue;}
11         if(s[i]==‘z‘) {s[i]=‘a‘;continue;}
12         if(s[i]==‘Z‘) {s[i]=‘A‘;continue;}
13     }
14     puts(s);
15     return 0;
16 }

10:简单密码

总时间限制: 
1000ms

内存限制: 
65536kB
描述

Julius Caesar曾经使用过一种很简单的密码。对于明文中的每个字符，将它用它字母表中后5位对应的字符来代替，这样就得到了密文。比如字符A用F来代替。如下是密文和明文中字符的对应关系。

密文
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

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

你的任务是对给定的密文进行解密得到明文。

你需要注意的是，密文中出现的字母都是大写字母。密文中也包括非字母的字符，对这些字符不用进行解码。

输入
一行，给出密文，密文不为空，而且其中的字符数不超过200。
输出
输出一行，即密文对应的明文。
样例输入
NS BFW, JAJSYX TK NRUTWYFSHJ FWJ YMJ WJXZQY TK YWNANFQ HFZXJX
样例输出
IN WAR, EVENTS OF IMPORTANCE ARE THE RESULT OF TRIVIAL CAUSES
来源
 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 using namespace std;
 5 char c[261];
 6 int main(){
 7     ios::sync_with_stdio(false);
 8     gets(c);
 9     int len=strlen(c);
10     for(int i=0;i<len;i++)
11       if(c[i]>=‘A‘&c[i]<=‘Z‘)
12         if(c[i]-5<‘A‘) c[i]=‘Z‘-(5-(c[i]-‘A‘))+1;
13         else c[i]-=5;
14     for(int i=0;i<len;i++)
15       cout<<c[i];
16     return 0;
17 }

11:潜伏者

总时间限制: 
1000ms

内存限制: 
65536kB
描述

R国和S国正陷入战火之中，双方都互派间谍，潜入对方内部，伺机行动。

历经艰险后，潜伏于S国的R国间谍小C终于摸清了S国军用密码的编码规则：

1、    S国军方内部欲发送的原信息经过加密后在网络上发送，原信息的内容与加密后所的内容均由大写字母‘A’—‘Z’构成（无空格等其他字母）。

2、    S国对于每个字母规定了对应的“密字”。加密的过程就是将原信息中的所有字母替换为其对应的“密字”。

3、    每个字母只对应一个唯一的“密字”，不同的字母对应不同的“密字”。“密字”可以和原字母相同。

例如，若规定‘A’的密字为‘A’，‘B’的密字为‘C’（其他字母及密字略），则原信息“ABA”被加密为“ACA”。

现在，小C通过内线掌握了S国网络上发送的一条加密信息及其对应的原信息。小C希望能通过这条信息，破译S国的军用密码。小C的破译过程是这样的：扫描原信息，对于原信息中的字母x（代表任一大写字母），找到其在加密信息中的对应大写字母y，并认为在密码里y是x的密字。如此进行下去直到停止于如下的某个状态：

1、    所有信息扫描完毕，‘A’—‘Z’所有26个字母在原信息中均出现过并获得了相应的“密字”。

2、    所有信息扫描完毕，但发现存在某个（或某些）字母在原信息中没有出现。

3、    扫描中发现掌握的信息里有明显的自相矛盾或错误（违反S过密码的编码规则）。例如某条信息“XYZ”被翻译为“ABA”就违反了“不同字母对应不同密字”的规则。

在小C忙得头昏脑胀之际，R国司令部又发来电报，要求他翻译另外一条从S国刚刚截取到的加密信息。现在请你帮助小C：通过内线掌握的信息，尝试破译密码。然后利用破译的密码，翻译电报中的加密信息。

输入
共3行，每行为一个长度在1到100之间的字符串。
第1行为小C掌握的一条加密信息。
第2行为第1行的加密信息所对应的原信息。
第3行为R国司令部要求小C翻译的加密信息。
输入数据保证所有字符串仅由大写字母‘A’—‘Z’构成，且第1行长度与第2行相等。
输出
共1行。
若破译密码停止时出现2，3两种情况，请你输出“Failed”（不含引号，注意首字母大写，其它小写）。
否则请输出利用密码翻译电报中加密信息后得到的原信息。
样例输入
样例 #1：
AA
AB
EOWIE

样例 #2：
QWERTYUIOPLKJHGFDSAZXCVBN
ABCDEFGHIJKLMNOPQRSTUVWXY
DSLIEWO

样例 #3：
MSRTZCJKPFLQYVAWBINXUEDGHOOILSMIJFRCOPPQCEUNYDUMPP
YIZSDWAHLNOVFUCERKJXQMGTBPPKOIYKANZWPLLVWMQJFGQYLL
FLSO
样例输出
样例 #1：
Failed

样例#2：
Failed

样例#3：
NOIP
提示
输入输出样例1说明：原信息中的字母‘A’和‘B’对应相同的密字，输出“Failed”。

输入输出样例2说明：字母‘Z’在原信息中没有出现，输出“Failed”。

来源
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 char mi[501],ming[501],p[501],f[501];
 6 int a[101]={0};//对应ascll码
 7 int main(){
 8     scanf("%s%s%s",mi,ming,p);
 9     int len=strlen(mi);
10     for(int i=0;i<len;i++){
11         if(a[int(mi[i])]){//有重复
12             if(f[int(mi[i])]!=ming[i]){printf("Failed\n");return 0;}
13         }else{
14             a[int(mi[i])]++;
15             f[int(mi[i])]=ming[i];
16         }
17     }
18     for(int i=65;i<=90;i++)
19       for(int j=65;j<=90;j++)
20         if(f[i]==f[j]&&i!=j){printf("Failed\n");return 0;}
21     for(int i=65;i<=90;i++)//不全
22         if(!a[i]){printf("Failed\n");return 0;}
23     int zp=strlen(p);
24     for(int i=0;i<zp;i++)
25       p[i]=f[int(p[i])];
26     puts(p);
27     return 0;
28 }

12:加密的病历单

总时间限制: 
1000ms

内存限制: 
65536kB
描述

小英是药学专业大三的学生，暑假期间获得了去医院药房实习的机会。 
在药房实习期间，小英扎实的专业基础获得了医生的一致好评，得知小英在计算概论中取得过好成绩后，主任又额外交给她一项任务，解密抗战时期被加密过的一些伤员的名单。 
经过研究，小英发现了如下加密规律（括号中是一个“原文 -> 密文”的例子） 
1.  原文中所有的字符都在字母表中被循环左移了三个位置（dec  -> abz） 
2.  逆序存储（abcd -> dcba ） 
3.  大小写反转（abXY -> ABxy）

输入
一个加密的字符串。（长度小于50且只包含大小写字母）
输出
输出解密后的字符串。
样例输入
GSOOWFASOq
样例输出
Trvdizrrvj
来源
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 char mi[1001];
 6 int main(){
 7     cin>>mi;
 8     int len=strlen(mi);
 9     for(int i=0;i<len;i++) mi[i]+=3;
10     for(int i=0;i<len;i++){
11         if(mi[i]>90&&mi[i]<97) mi[i]-=26;
12         if(mi[i]>122) mi[i]-=26;
13         if(mi[i]>=65&&mi[i]<=90) mi[i]+=32;
14         else mi[i]-=32;
15     }
16     for(int i=len-1;i>=0;i--) cout<<mi[i];
17     cout<<endl;
18     return 0;
19 }

13:将字符串中的小写字母转换成大写字母

总时间限制: 
1000ms

内存限制: 
65536kB
描述

给定一个字符串，将其中所有的小写字母转换成大写字母。

输入
输入一行，包含一个字符串（长度不超过100，可能包含空格）。
输出
输出转换后的字符串。
样例输入
helloworld123Ha
样例输出
HELLOWORLD123HA
 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 #include<algorithm>
 5 using namespace std;
 6 #define N 521
 7 char a[N],c[N];
 8 int main(){
 9     //freopen("sh.txt","r",stdin);
10     gets(a);
11     int l=strlen(a);
12     for(int i=0;i<l;i++)
13       if(a[i]>=‘a‘&&a[i]<=‘z‘) a[i]-=32;
14     puts(a);
15     return 0;
16 }

14:大小写字母互换

总时间限制: 
1000ms

内存限制: 
65536kB
描述

把一个字符串中所有出现的大写字母都替换成小写字母，同时把小写字母替换成大写字母。

输入
输入一行：待互换的字符串。
输出
输出一行：完成互换的字符串（字符串长度小于80）。
样例输入
If so, you already have a Google Account. You can sign in on the right.
样例输出
iF SO, YOU ALREADY HAVE A gOOGLE aCCOUNT. yOU CAN SIGN IN ON THE RIGHT.
来源
 1 #include<cstdio>
 2 #include<cstring>
 3 using namespace std;
 4 char s[9999];
 5 int main()
 6 {
 7    gets(s);
 8    int len=strlen(s);
 9    for(int i=0;i<len;i++){
10         if(s[i]>=65&&s[i]<=90) s[i]+=32;
11         else if(s[i]>=97&&s[i]<=122)s[i]-=32;
12    }
13    puts(s);
14    return 0;
15 }

15:整理药名

总时间限制: 
1000ms

内存限制: 
65536kB
描述

医生在书写药品名的时候经常不注意大小写，格式比较混乱。现要求你写一个程序将医生书写混乱的药品名整理成统一规范的格式，即药品名的第一个字符如果是字母要大写，其他字母小写。如将ASPIRIN、aspirin整理成Aspirin。

输入
第一行一个数字n，表示有n个药品名要整理，n不超过100。
接下来n行，每行一个单词，长度不超过20，表示医生手书的药品名。药品名由字母、数字和-组成。
输出
n行，每行一个单词，对应输入的药品名的规范写法。
样例输入
4
AspiRin
cisapride
2-PENICILLIN
Cefradine-6
样例输出
Aspirin
Cisapride
2-penicillin
Cefradine-6
来源
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 char s[25];int n;
 6 int main(){
 7     scanf("%d",&n);
 8     while(n--){
 9         memset(s,NULL,sizeof(s));
10         scanf("%s",s);
11         if(s[0]>=‘a‘&&s[0]<=‘z‘) s[0]-=32;
12         for(int i=1;i<strlen(s);i++)
13             if(s[i]>=‘A‘&&s[i]<=‘Z‘) s[i]+=32;
14         printf("%s\n",s);
15     }
16     return 0;
17 }

16:忽略大小写的字符串比较

总时间限制: 
1000ms

内存限制: 
65536kB
描述

一般我们用strcmp可比较两个字符串的大小，比较方法为对两个字符串从前往后逐个字符相比较（按ASCII码值大小比较），直到出现不同的字符或遇到‘\0‘为止。如果全部字符都相同，则认为相同；如果出现不相同的字符，则以第一个不相同的字符的比较结果为准（注意：如果某个字符串遇到‘\0‘而另一个字符串还未遇到‘\0‘，则前者小于后者）。但在有些时候，我们比较字符串的大小时，希望忽略字母的大小，例如"Hello"和"hello"在忽略字母大小写时是相等的。请写一个程序，实现对两个字符串进行忽略字母大小写的大小比较。

输入
输入为两行，每行一个字符串，共两个字符串。（每个字符串长度都小于80）
输出
如果第一个字符串比第二个字符串小，输出一个字符"<"；
如果第一个字符串比第二个字符串大，输出一个字符">"；
如果两个字符串相等，输出一个字符"="。
样例输入
Hello, how are you?
hello, How are you?
样例输出
=
来源
 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 #include<algorithm>
 5 #include<cstdlib>
 6 using namespace std;
 7 #define N 510
 8 char s1[N],s2[N];
 9 int main(){
10     gets(s1);
11     gets(s2);
12     int l1=strlen(s1);
13     int l2=strlen(s2);
14     for(int i=0;i<l1;i++)
15       if(s1[i]>=‘A‘&&s1[i]<=‘Z‘) s1[i]+=32;
16     for(int i=0;i<l2;i++)
17       if(s2[i]>=‘A‘&&s2[i]<=‘Z‘) s2[i]+=32;
18     if(!strcmp(s1,s2)) cout<<‘=‘<<endl;
19     else if(strcmp(s1,s2)>0) cout<<‘>‘<<endl;
20     else if(strcmp(s1,s2)<0) cout<<‘<‘<<endl;
21     return 0;
22 }

17:字符串判等

总时间限制: 
1000ms

内存限制: 
65536kB
描述

判断两个由大小写字母和空格组成的字符串在忽略大小写，且忽略空格后是否相等。

输入
两行，每行包含一个字符串。
输出
若两个字符串相等，输出YES，否则输出NO。
样例输入
a A bb BB ccc CCC
Aa BBbb CCCccc
样例输出
YES
 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstring>
 4 #include<cstdlib>
 5 using namespace std;
 6 char s1[9999],s2[9999];
 7 int z1=0,z2=0;
 8 int main()
 9 {
10    //freopen("sh.in","r",stdin);
11    char ch=getchar();
12    while(ch!=10) {if(ch!=32) s1[z1++]=ch;ch=getchar();}
13    do
14    {if(ch!=32&&ch!=10) s2[z2++]=ch;ch=getchar();}
15    while(ch!=10);
16    int f=1;
17    if(z1!=z2) {printf("NO\n");return 0;}
18    else for(int i=1;i<=z1;i++){
19             if(abs(s1[i]-s2[i])==0||abs(s1[i]-s2[i])==32);
20             else {f=0;break;}
21    }
22    printf("%s\n",f?"YES":"NO");
23    return 0;
24 }

18:验证子串

总时间限制: 
1000ms

内存限制: 
65536kB
描述

输入两个字符串，验证其中一个串是否为另一个串的子串。

输入
输入两个字符串， 每个字符串占一行，长度不超过200且不含空格。
输出
若第一个串s1是第二个串s2的子串，则输出(s1) is substring of (s2) 
否则，若第二个串s2是第一个串s1的子串，输出(s2) is substring of (s1) 
否则，输出 No substring。
样例输入
abc
dddncabca
样例输出
abc is substring of dddncabca
来源
 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 using namespace std;
 5 string s1,s2;
 6 int main(){
 7     //freopen("sh.txt","r",stdin);
 8     ios::sync_with_stdio(false);
 9     cin>>s1>>s2;
10     int l1=s2.find(s1);
11     int l2=s1.find(s2);
12     if(l1>=0||s1==s2){cout<<s1<<" is substring of "<<s2;return 0;}
13     else if(l2>=0){cout<<s2<<" is substring of "<<s1;return 0;}
14     else cout<<"No substring";
15     return 0;
16 }

19:字符串移位包含问题

总时间限制: 
1000ms

内存限制: 
65536kB
描述

对于一个字符串来说，定义一次循环移位操作为：将字符串的第一个字符移动到末尾形成新的字符串。

给定两个字符串s1和s2，要求判定其中一个字符串是否是另一字符串通过若干次循环移位后的新字符串的子串。例如CDAA是由AABCD两次移位后产生的新串BCDAA的子串，而ABCD与ACBD则不能通过多次移位来得到其中一个字符串是新串的子串。

输入
一行，包含两个字符串，中间由单个空格隔开。字符串只包含字母和数字，长度不超过30。
输出
如果一个字符串是另一字符串通过若干次循环移位产生的新串的子串，则输出true，否则输出false。
样例输入
AABCD CDAA
样例输出
true
 1 #include<cstdio>
 2 #include<cstring>
 3 using namespace std;
 4 char s1[1001],s2[1001],n[1001];
 5 int prime(char *s1,char *s2)
 6 {
 7     int len=strlen(s1);
 8     for(int i=0;i<len;i++){
 9         char tmp=s1[0];
10         for(int j=0;j<len-1;j++)
11             s1[j]=s1[j+1];
12         s1[len-1]=tmp;
13         if(strstr(s1,s2)!=NULL)
14             return 1;
15     }
16     return 0;
17 }
18 void jh(){
19     strcpy(n,s1);
20     strcpy(s1,s2);
21     strcpy(s2,n);
22 }
23 int main()
24 {
25     scanf("%s%s",s1,s2);
26     int len1=strlen(s1),len2=strlen(s2);
27     if(len1<len2)jh();
28     if(prime(s1,s2))
29         printf("true\n");
30     else
31         printf("false\n");
32     return 0;
33 }

20:删除单词后缀

总时间限制: 
1000ms

内存限制: 
65536kB
描述

给定一个单词，如果该单词以er、ly或者ing后缀结尾， 则删除该后缀（题目保证删除后缀后的单词长度不为0）， 否则不进行任何操作。

输入
输入一行，包含一个单词（单词中间没有空格，每个单词最大长度为32）。
输出
输出按照题目要求处理后的单词。
样例输入
referer
样例输出
refer
 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 using namespace std;
 5 char s[261];
 6 int main(){
 7     ios::sync_with_stdio(false);
 8     gets(s+1);
 9     int len=strlen(s+1);
10     if((s[len-1]==‘e‘&&s[len]==‘r‘)||(s[len-1]==‘l‘&&s[len]==‘y‘)) len=len-2;
11     else if(s[len-2]==‘i‘&&s[len-1]==‘n‘&&s[len]==‘g‘) len-=3;
12     for(int i=1;i<=len;i++)
13       cout<<s[i];
14     return 0;
15 }

21:单词替换

总时间限制: 
1000ms

内存限制: 
65536kB
描述

输入一个字符串，以回车结束（字符串长度<=100）。该字符串由若干个单词组成，单词之间用一个空格隔开，所有单词区分大小写。现需要将其中的某个单词替换成另一个单词，并输出替换之后的字符串。

输入
输入包括3行，
第1行是包含多个单词的字符串 s;
第2行是待替换的单词a(长度 <= 100);
第3行是a将被替换的单词b(长度 <= 100).

s, a, b 最前面和最后面都没有空格.

输出
输出只有 1 行，将s中所有单词a替换成b之后的字符串。
样例输入
You want someone to help you
You
I
样例输出
I want someone to help you
 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstring>
 4 using namespace std;
 5 string s,a,b;
 6 int main()
 7 {
 8     while(getline(cin,s)){
 9         getline(cin,a);
10         getline(cin,b);
11         for(int i=0;i<s.length();i++)
12         if(s.length()-i>=a.length()){
13           if(s.substr(i,a.length())==a&&(i==0||s[i-1]==‘ ‘)&&(i==s.length()-a.length()||s[i+a.length()]==‘ ‘))
14             s.replace(i,a.length(),b);
15         }else break;
16     cout<<s<<endl;
17     }
18     return 0;
19  }

22:紧急措施

总时间限制: 
1000ms

内存限制: 
65536kB
描述

近日，一些热门网站遭受黑客入侵，这些网站的账号、密码及email的数据惨遭泄露。你在这些网站上注册若干账号（使用的用户名不一定相同），但是注册时使用了相同的email。你此时拿到了那份泄露的数据，希望尽快将自己的密码更改。策略如下：根据email找到你的用户名和密码，然后更改密码。更改的规则为：小写和大写交换，非字母字符保持不变。

输入
第一行为你的email地址，长度不超过50个字符且只包含字母、数字和‘@’符号。
第二行为账号数N，N(0 < N < 10000)。
接下来N行，每行表示一个账号，格式为：
用户名 密码 email
它们之间用单个空格分开。用户名、密码、email均不含空格，且长度不超过50个字符。
输出
有若干行，每行为你的一个账号，包括：你的账号，修改后的密码（之间用单个空格分隔）。
如果没有你的账号，则输出empty。
样例输入
样例输入1：
[email protected]
5
helloKitty iLoveCats [email protected]
2012 maya2012 [email protected]
KittyCat 5iKitty [email protected]
program password [email protected]
whoAmi Feb.29$ [email protected]

样例输入2：
[email protected]
1
2012 maya2012 [email protected]
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 string yh,mm,yx;
 6 string s1;
 7 int n,flag=0;
 8 int main()
 9 {
10     ios::sync_with_stdio(false);
11     cin>>s1>>n;
12     for(int i=0;i<n;i++){
13         cin>>yh>>mm>>yx;
14         if(s1==yx){
15             int len=mm.length();
16             for(int i=0;i<len;i++){
17                if(mm[i]>=‘A‘&&mm[i]<=‘Z‘) {mm[i]+=32;continue;}
18                if(mm[i]>=‘a‘&&mm[i]<=‘z‘)  mm[i]-=32;
19              }
20             cout<<yh<<‘ ‘;
21             cout<<mm<<endl;
22             flag=1;
23         }
24     }
25     if(!flag) cout<<"empty\n";
26     return 0;
27 }

23:过滤多余的空格

总时间限制: 
1000ms

内存限制: 
65536kB
描述

一个句子中也许有多个连续空格，过滤掉多余的空格，只留下一个空格。

输入
一行，一个字符串（长度不超过200），句子的头和尾都没有空格。
输出
过滤之后的句子。
样例输入
Hello      world.This is    c language.
样例输出
Hello world.This is c language.
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define N 521
char a[N][N],ct[N];
int main(){
    //freopen("sh.txt","r",stdin);
    int x=0;
    while(~scanf("%s",ct)){
        int len=strlen(ct);
        for(int i=0;i<len;i++)
          a[x][i]=ct[i];
        x++;
    }
    for(int j=0;j<x;j++)
      cout<<a[j]<<‘ ‘;
      return 0;
}

24:单词的长度

总时间限制: 
1000ms

内存限制: 
65536kB
描述

输入一行单词序列，相邻单词之间由1个或多个空格间隔，请对应地计算各个单词的长度。

注意，如果有标点符号（如连字符，逗号），标点符号算作与之相连的词的一部分。没有被空格间开的符号串，都算作单词。

输入
一行单词序列，最少1个单词，最多300个单词，单词之间用至少1个空格间隔。单词序列总长度不超过1000。
输出
依次输出对应单词的长度，之间以逗号间隔。
样例输入
She was born in 1990-01-02  and  from Beijing city.
样例输出
3,3,4,2,10,3,4,7,5
 1 #include<stdio.h>
 2 char a[10010];
 3 int main()
 4 {
 5     int i,sum=0;
 6     gets(a);
 7     for(i = 0;i <= 10010;i++){
 8        if(a[i]!=‘ ‘&&a[i]!=‘\0‘){
 9          sum=sum++;}
10        else    {
11        if(a[i]==‘\0‘){
12        printf("%d",sum);
13      return 0;}
14      else
15        if(sum!=0){
16         printf("%d,",sum);
17          sum=0;
18     }
19    }
20   }
21     return 0;
22 }

25:最长最短单词

总时间限制: 
1000ms

内存限制: 
65536kB
描述

输入1行句子（不多于200个单词，每个单词长度不超过100），只包含字母、空格和逗号。单词由至少一个连续的字母构成，空格和逗号都是单词间的间隔。

试输出第1个最长的单词和第1个最短单词。

输入
一行句子。
输出
两行输出：
第1行，第一个最长的单词。
第2行，第一个最短的单词。
样例输入
I am studying Programming language C in Peking University
样例输出
Programming
I
提示
 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 using namespace std;
 5 #define N 510
 6 char c[N][51];
 7 char ct[N];
 8 int z[N],x=0;
 9 int mi=0x7f,ma,miz,maz;
10 int main(){
11     //freopen("sh.txt","r",stdin);
12     while(~scanf("%s",ct)){
13         int len=strlen(ct);z[x]=len;
14         for(int i=0;i<len;i++)
15           c[x][i]=ct[i];
16         x++;
17     }
18     for(int q=0;q<x;q++){
19       if(z[q]<mi){
20           mi=z[q];
21           miz=q;
22       }
23       if(z[q]>ma){
24           ma=z[q];
25           maz=q;
26       }
27 }    cout<<c[maz]<<endl;
28      cout<<c[miz]<<endl;
29     return 0;
30 }

26:字符串最大跨距

总时间限制: 
1000ms

内存限制: 
65536kB
描述

有三个字符串S,S1,S2，其中，S长度不超过300，S1和S2的长度不超过10。想检测S1和S2是否同时在S中出现，且S1位于S2的左边，并在S中互不交叉（即，S1的右边界点在S2的左边界点的左侧）。计算满足上述条件的最大跨距（即，最大间隔距离：最右边的S2的起始点与最左边的S1的终止点之间的字符数目）。如果没有满足条件的S1，S2存在，则输出-1。

例如，S = "abcd123ab888efghij45ef67kl", S1="ab", S2="ef"，其中，S1在S中出现了2次，S2也在S中出现了2次，最大跨距为：18。

输入
三个串：S1, S2, S3，其间以逗号间隔（注意，S1, S2, S3中均不含逗号和空格）；
输出
S1和S2在S最大跨距；若在S中没有满足条件的S1和S2，则输出-1。
样例输入
abcd123ab888efghij45ef67kl,ab,ef
样例输出
18
 1 #include<cstring>
 2 #include<cstdio>
 3 #include<iostream>
 4 using namespace std;
 5 #define N 1010
 6 char a[N],s[N],s1[N],s2[N],*l,*r;
 7 int lenn,L,R;
 8 void read(){
 9     int zj=0,f1,f2;
10     for(int i=0;i<lenn;i++){
11         if(a[i]!=‘,‘) s[zj++]=a[i];
12         else {f1=i+1;zj=0;break;}
13     }
14     for(int i=f1;i<lenn;i++){
15         if(a[i]!=‘,‘) s1[zj++]=a[i];
16         else {f2=i+1;zj=0;break;}
17     }
18     for(int i=f2;i<lenn;i++)
19        s2[zj++]=a[i];
20 }
21 void fz(char *a,int len){
22     int i,j=len-1;
23     len/=2;
24     for(i=0;i<len;i++,j--){
25         char t=a[i];
26         a[i]=a[j];
27         a[j]=t;
28     }
29 }
30 int main(){
31     scanf("%s",a);
32     lenn=strlen(a);
33     read();//分割
34     int len=strlen(s);
35     int len1=strlen(s1);
36     int len2=strlen(s2);
37     l=strstr(s,s1);
38     L=l-s+len1-1;
39     fz(s,len);//翻转
40     fz(s2,len2);
41     r=strstr(s,s2);
42     R=r-s+len2-1;
43     R=len-R-1;//还原
44     if(L>R) printf("-1\n");
45     else printf("%d\n",R-L-1);
46     return 0;
47 }

28:单词倒排

总时间限制: 
1000ms

内存限制: 
65536kB
描述

编写程序，读入一行英文(只包含字母和空格，单词间以单个空格分隔)，将所有单词的顺序倒排并输出，依然以单个空格分隔。

输入
输入为一个字符串（字符串长度至多为100）。
输出
输出为按要求排序后的字符串。
样例输入
I am a student
样例输出
student a am I
 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 using namespace std;
 5 char c[101][101];
 6 char ct[101];
 7 int x=0;
 8 int main(){
 9     //freopen("sh.txt","r",stdin);
10     while(~scanf("%s",ct)){
11         int len=strlen(ct);
12         for(int i=0;i<len;i++)
13           c[x][i]=ct[i];
14         x++;
15     }
16     for(int q=x-1;q>=0;q--){
17         for(int p=0;c[q][p]!=‘\0‘;p++)
18           cout<<c[q][p];
19           cout<<‘ ‘;
20     }
21     return 0;
22 }

29:ISBN号码

总时间限制: 
1000ms

内存限制: 
65536kB
描述

每一本正式出版的图书都有一个ISBN号码与之对应，ISBN码包括9位数字、1位识别码和3位分隔符，其规定格式如“x-xxx-xxxxx-x”，其中符号“-”是分隔符（键盘上的减号），最后一位是识别码，例如0-670-82162-4就是一个标准的ISBN码。ISBN码的首位数字表示书籍的出版语言，例如0代表英语；第一个分隔符“-”之后的三位数字代表出版社，例如670代表维京出版社；第二个分隔之后的五位数字代表该书在出版社的编号；最后一位为识别码。

识别码的计算方法如下：

首位数字乘以1加上次位数字乘以2……以此类推，用所得的结果mod 11，所得的余数即为识别码，如果余数为10，则识别码为大写字母X。例如ISBN号码0-670-82162-4中的识别码4是这样得到的：对067082162这9个数字，从左至右，分别乘以1，2，…，9，再求和，即0×1+6×2+„„+2×9=158，然后取158 mod 11的结果4作为识别码。

你的任务是编写程序判断输入的ISBN号码中识别码是否正确，如果正确，则仅输出“Right”；如果错误，则输出你认为是正确的ISBN号码。

输入
只有一行，是一个字符序列，表示一本书的ISBN号码（保证输入符合ISBN号码的格式要求）。
输出
共一行，假如输入的ISBN号码的识别码正确，那么输出“Right”，否则，按照规定的格式，输出正确的ISBN号码（包括分隔符“-”）。
样例输入
样例 #1：
0-670-82162-4

样例 #2：
0-670-82162-0
样例输出
样例 #1：
Right

样例 #2：
0-670-82162-4
来源
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 char s[31];
 6 int a[31],ans=0;
 7 int main()
 8 {
 9     memset(a,-1,sizeof(a));
10     scanf("%s",s);
11     for(int i=0;i<13;i++){
12         if(s[i]==‘X‘) a[i]=10;
13         else if(s[i]>=‘0‘&&s[i]<=‘9‘) a[i]=s[i]-‘0‘;
14     }
15     int zj=1;
16     for(int i=0;i<12;i++)
17       if(a[i]!=-1) ans+=a[i]*zj,zj++;
18     int w=ans%11;
19     if(a[12]==w) {printf("Right\n");return 0;}
20     for(int i=0;i<12;i++) cout<<s[i];
21     if(w==10) cout<<‘X‘<<endl;
22     else cout<<w<<endl;
23     return 0;
24 }

30:字符环

总时间限制: 
1000ms

内存限制: 
65536kB
描述

有两个由字符构成的环。请写一个程序，计算这两个字符环上最长连续公共字符串的长度。例如，字符串“ABCEFAGADEGKABUVKLM”的首尾连在一起，构成一个环；字符串“MADJKLUVKL”的首尾连在一起，构成一个另一个环；“UVKLMA”是这两个环的一个连续公共字符串。

输入
一行，包含两个字符串，分别对应一个字符环。这两个字符串之间用单个空格分开。字符串长度不超过255，且不包含空格等空白符。
输出
输出一个整数，表示这两个字符环上最长公共字符串的长度。
样例输入
ABCEFAGADEGKABUVKLM MADJKLUVKL
样例输出
6
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 string a,b;
 6 int ans=0,tmp=0,x;
 7 int main()
 8 {
 9      cin>>a>>b;
10      int lena=a.length();
11      int lenb=b.length();
12      a+=a;//环
13      b+=b;
14      x=min(lena,lenb);
15      for(int i=0;i<lena;i++)
16          for(int j=0;j<lenb;j++){
17              while(a[i+tmp]==b[j+tmp]&&tmp<=x)
18                  tmp++;
19             ans=max(ans,tmp);
20             tmp=0;
21         }
22     ans=min(ans,lena);
23     ans=min(ans,lenb);
24     printf("%d\n",ans);
25     return 0;
26 }

31:字符串p型编码

总时间限制: 
1000ms

内存限制: 
65536kB
描述

给定一个完全由数字字符（‘0‘,‘1‘,‘2‘,…,‘9‘）构成的字符串str，请写出str的p型编码串。例如：字符串122344111可被描述为"1个1、2个2、1个3、2个4、3个1"，因此我们说122344111的p型编码串为1122132431；类似的道理，编码串101可以用来描述1111111111；00000000000可描述为"11个0"，因此它的p型编码串即为110；100200300可描述为"1个1、2个 0、1个2、2个0、1个3、2个0"，因此它的p型编码串为112012201320。

输入
输入仅一行，包含字符串str。每一行字符串最多包含1000个数字字符。
输出
输出该字符串对应的p型编码串。
样例输入
122344111
样例输出
1122132431
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 char a[10010];
 6 int main()
 7 {
 8      scanf("%s",a);
 9      int lena=strlen(a);
10      char ch=a[0];
11      int x=1;
12      for(int i=1;i<=lena;i++){
13          if(ch!=a[i]){
14              cout<<x<<ch;
15              ch=a[i];
16              x=1;
17          }
18          else
19              x++;
20      } cout<<endl;
21     return 0;
22 }

32:行程长度编码

总时间限制: 
1000ms

内存限制: 
65536kB
描述

在数据压缩中，一个常用的途径是行程长度压缩。对于一个待压缩的字符串而言，我们可以依次记录每个字符及重复的次数。这种压缩，对于相邻数据重复较多的情况比较有效。 例如，如果待压缩串为"AAABBBBCBB"，则压缩的结果是(A,3)(B,4)(C,1)(B,2)。当然，如果相邻字符重复情况较少，则压缩效率就较低。

现要求根据输入的字符串，得到大小写不敏感压缩后的结果（即所有小写字母均视为相应的大写字母）。

输入
一个字符串，长度大于0，且不超过1000，全部由大写或小写字母组成。
输出
输出为一行，表示压缩结果，形式为：
(A,3)(B,4)(C,1)(B,2)
即每对括号内部分别为字符（都为大写）及重复出现的次数，不含任何空格。
样例输入
aAABBbBCCCaaaaa
样例输出
(A,3)(B,4)(C,3)(A,5)
来源
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 char a[10010];
 6 int main()
 7 {
 8      scanf("%s",a);
 9      int lena=strlen(a);
10      for(int i=0;i<lena;i++)
11         if(a[i]>=‘a‘&&a[i]<=‘z‘) a[i]-=32;
12      char ch=a[0];
13      int x=1;
14      for(int i=1;i<=lena;i++){
15          if(ch!=a[i]){
16              printf("(%c,%d)",ch,x);
17              ch=a[i];
18              x=1;
19          }
20          else
21              x++;
22      }
23     return 0;
24 }

33:判断字符串是否为回文

总时间限制: 
1000ms

内存限制: 
65536kB
描述

输入一个字符串，输出该字符串是否回文。回文是指顺读和倒读都一样的字符串。

输入
输入为一行字符串（字符串中没有空白字符，字符串长度不超过100）。
输出
如果字符串是回文，输出yes；否则，输出no。
样例输入
abcdedcba
样例输出
yes
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 using namespace std;
 5 char a[1010],b[1010];
 6 int main()
 7 {
 8      scanf("%s",a);
 9      int len=strlen(a);
10      for(int i=0;i<len;i++)
11         b[i]=a[len-1-i];
12      printf("%s\n",strcmp(a,b)==0?"yes":"no");
13      return 0;
14 }

34:回文子串

总时间限制: 
1000ms

内存限制: 
65536kB
描述

给定一个字符串，输出所有长度至少为2的回文子串。

回文子串即从左往右输出和从右往左输出结果是一样的字符串，比如：abba，cccdeedccc都是回文字符串。

输入
一个字符串，由字母或数字组成。长度500以内。
输出
输出所有的回文子串，每个子串一行。
子串长度小的优先输出，若长度相等，则出现位置靠左的优先输出。
样例输入
123321125775165561
样例输出
33
11
77
55
2332
2112
5775
6556
123321
165561
来源
 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 #include<algorithm>
 5 using namespace std;
 6 #define N 521
 7 char a[N],c[N];int l,m;
 8 bool prime(char *a){
 9     int l=strlen(a);
10     int j=l-1,i=0;
11     while(j>=l/2){
12         if(a[i]!=a[j]) return 0;
13         i++;j--;
14     }
15     return 1;
16 }
17 int main(){
18     //freopen("sh.txt","r",stdin);
19     gets(a);
20     l=strlen(a);
21     for(int i=2;i<=l;i++)
22       for(int j=0;j<l;j++){
23           if(i+j>l) break;
24           m=-1;
25           memset(c,NULL,sizeof(c));
26           for(int k=j;k-j<i;k++)
27             c[++m]=a[k];
28           if(prime(c)) puts(c);
29       }
30     return 0;
31 }

时间： 2024-10-24 23:27:59

NOI 1.7编程基础之字符串(35题)的相关文章

c#编程基础之字符串函数

c#常用的字符串函数 例一: 获取字符串的大小写函数 ToLower():得到字符串的小写形式 ToUpper():得到字符串的大写形式 注意: 字符串时不可变的,所以这些函数都不会直接改变字符串的内容,而是把修改后的字符串通过函数返回值的形式返回. 源码如下: using System; using System.Collections.Generic; using System.Text; namespace 字符串函数学习 { class Program { static void Mai

c#编程基础之字符串基础

1.C#中单个的字符串用单引号包含就是char类型,('a'),单引号中放且只能放一个字符 2.单个字符也可以表示为字符串,还可以有长度为0的字符串. 3.使用s.Length属性来获得字符串中的字符个数. 4.string 可以看做是char类型的只读数组.char c=s[1];例子:遍历输出string中的每个元素. 5.c#中字符串有一个重要的特性:不可变性.字符串一旦声明,就不再可以改变. 所以只能通过索引来读取指定位置的char,不能对指定位置的char进行修改. 6.如果要对cha

noi题库（noi.openjudge.cn） 1.7编程基础之字符串T21——T30

T21:单词替换 描述 输入一个字符串,以回车结束(字符串长度<=100).该字符串由若干个单词组成,单词之间用一个空格隔开,所有单词区分大小写.现需要将其中的某个单词替换成另一个单词,并输出替换之后的字符串. 输入 输入包括3行,第1行是包含多个单词的字符串 s;第2行是待替换的单词a(长度 <= 100);第3行是a将被替换的单词b(长度 <= 100). s, a, b 最前面和最后面都没有空格. 输出 输出只有 1 行,将s中所有单词a替换成b之后的字符串. 样例输入 You w

1.7编程基础之字符串

个人QQ:757394026团队QQ:466373640个人博客:www.doubleq.winc++/noi/信息学奥数博客:http://www.cnblogs.com/zwfymqz 1 #include <cstdio> 2 #include <iostream> 3 #include <cstring> 4 using namespace std; 5 char a[10001]; 6 int now; 7 char b[1001][1001]; 8 int

1.7编程基础之字符串-11 潜伏者

描述 R国和S国正陷入战火之中,双方都互派间谍,潜入对方内部,伺机行动. 历经艰险后,潜伏于S国的R国间谍小C终于摸清了S国军用密码的编码规则: 1.    S国军方内部欲发送的原信息经过加密后在网络上发送,原信息的内容与加密后所的内容均由大写字母'A'-'Z'构成(无空格等其他字母). 2.    S国对于每个字母规定了对应的"密字".加密的过程就是将原信息中的所有字母替换为其对应的"密字". 3.    每个字母只对应一个唯一的"密字",不同

编程基础之字符串——02找第一个只出现一次的字符

描述 给定一个只包含小写字母的字符串,请你找到第一个仅出现一次的字符.如果没有,输出no. 输入一个字符串,长度小于100000.输出输出第一个仅出现一次的字符,若没有则输出no.样例输入 abcabd 样例输出 c自己做不出,但得到了两个别人的答案: 1 #include<iostream> 2 #include<cstdio> 3 #include<cstring> 4 using namespace std; 5 char a[100100]; 6 int mai

NOI 1.5编程基础之循环控制 44:第n小的质数

描述 输入一个正整数n,求第n小的质数. 输入 一个不超过10000的正整数n. 输出 第n小的质数. 样例输入 10 样例输出 29

第二周：神经网络的编程基础-----------10个测验题（Neural Network Basics）

--------------------------------------------------中文翻译----------------------------------------------------------------------------------------- 1.神经元的计算是什么?(B) A. 在将输出应用到激活函数之前, 神经元计算所有特征的平均值 B. 神经元计算一个线性函数 (z = Wx + b), 然后是一个激活函数 C. 神经元计算一个激活函数, 后跟一

noi寒假刷题之旅_ 1.8编程基础之多维数组(25题)

»1.8编程基础之多维数组(25题) 上次编辑的时候忘记保存了,前面几题就算了趴懒得 08:矩阵加法 #include<iostream> #define MAX 105 using namespace std; int table[MAX][MAX]; int main() { int n,m; cin>>n>>m; for(int i=0;i<n;++i)for(int j=0;j<m;++j)cin>>table[i][j]; int t;