时间限制: 1000 ms 内存限制: 65536 KB
输出一个整数序列中与指定数字相同的数的个数。
输入包含三行:
第一行为 N ( N ≤ 100 ) N(N≤100) N(N≤100),表示整数序列的长度;
第二行为 N N N个整数,整数之间以一个空格分开;
第三行包含一个整数,为指定的数字 m m m。
输出为 N N N个数中与 m m m相同的数的个数。
3
2 3 2
2
2
#include
int n,num[101],m;
int main(void){
register int i,sum=0;
scanf("%d",&n);
for(i=1;i<=n;++i)
scanf("%d",&num[i]);
scanf("%d",&m);
for(i=1;i<=n;++i)
if(num[i]==m)
++sum;
printf("%d\n",sum);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
陶陶家的院子里有一棵苹果树,每到秋天树上就会结出 10 10 10个苹果。苹果成熟的时候,陶陶就会跑去摘苹果。陶陶有个 30 30 30厘米高的板凳,当她不能直接用手摘到苹果的时候,就会踩到板凳上再试试。
现在已知 10 10 10个苹果到地面的高度,以及陶陶把手伸直的时候能够达到的最大高度,请帮陶陶算一下她能够摘到的苹果的数目。假设她碰到苹果,苹果就会掉下来。
包括两行数据。第一行包含 10 10 10个 100 100 100到 200 200 200之间(包括 100 100 100和 200 200 200)的整数(单位:厘米)分别表示 10 10 10个苹果到地面的高度,两个相邻的整数之间用一个空格隔开。第二行只包括一个 100 100 100到 120 120 120之间(包括 100 100 100和 120 120 120)的整数(单位:厘米),表示陶陶把手伸直的时候能够达到的最大高度。
包括一行,这一行只包含一个整数,表示陶陶能够摘到的苹果的数目。
100 200 150 140 129 134 167 198 200 111
110
5
#include
int n,tall[11];
int main(void){
register int i,sum=0;
for(i=1;i<=10;++i)
scanf("%d",&tall[i]);
scanf("%d",&n);
for(i=1;i<=10;++i)
if(tall[i]<=n+30)
++sum;
printf("%d\n",sum);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
下面是一个图书的单价表:
计算概论 28.9 28.9 28.9元/本
数据结构与算法 32.7 32.7 32.7元/本
数字逻辑 45.6 45.6 45.6元/本
C++
程序设计教程 78 78 78元/本
人工智能 35 35 35元/本
计算机体系结构 86.2 86.2 86.2元/本
编译原理 27.8 27.8 27.8元/本
操作系统 43 43 43元/本
计算机网络 56 56 56元/本
JAVA
程序设计 65 65 65元/本
给定每种图书购买的数量,编程计算应付的总费用。
输入一行,包含 10 10 10个整数,分别表示购买的《计算概论》、《数据结构与算法》、《数字逻辑》、《C++程序设计教程》、《人工智能》、《计算机体系结构》、《编译原理》、《操作系统》、《计算机网络》、《JAVA程序设计》
的数量(以本为单位)。每两个整数用一个空格分开。
输出一行,包含一个浮点数 f f f,表示应付的总费用。精确到小数点后一位。
1 5 8 10 5 1 1 2 3 4
2140.2
#include
int b[10];
int main(void){
register int i;
for(i=0;i<10;++i)
scanf("%d",&b[i]);
float s=(b[0]*28.9)+(b[1]*32.7)+(b[2]*45.6)+(b[3]*78)+(b[4]*35)+(b[5]*86.2)+(b[6]*27.8)+(b[7]*43)+(b[8]*56)+(b[9]*65);
printf("%.1f\n",s);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
将一个数组中的值按逆序重新存放。例如,原来的顺序为 8 , 6 , 5 , 4 , 1 8,6,5,4,1 8,6,5,4,1。要求改为 1 , 4 , 5 , 6 , 8 1,4,5,6,8 1,4,5,6,8。
输入为两行:第一行数组中元素的个数 n ( 1 < n < 100 ) n(1<n<100) n(1<n<100),第二行是 n n n个整数,每两个整数之间用空格分隔。
输出为一行:输出逆序后数组的整数,每两个整数之间用空格分隔。
5
8 6 5 4 1
1 4 5 6 8
#include
#include
int n,num[101];
int main(void){
register int i;
scanf("%d",&n);
for(i=1;i<=n;++i)
scanf("%d",&num[i]);
for(i=n;i>=1;--i)
printf("%d ",num[i]);
putchar('\n');
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
某医院想统计一下某项疾病的获得与否与年龄是否有关,需要对以前的诊断记录进行整理,按照 0 − 18 , 19 − 35 , 36 − 60 , 61 0-18,19-35,36-60,61 0−18,19−35,36−60,61以上(含 61 61 61)四个年龄段统计的患病人数占总患病人数的比例。
共 2 2 2行,第一行为过往病人的数目 n ( 0 < n ≤ 100 ) n(0<n≤100) n(0<n≤100),第二行为每个病人患病时的年龄。
按照 0 − 18 , 19 − 35 , 36 − 60 , 61 0-18,19-35,36-60,61 0−18,19−35,36−60,61以上(含 61 61 61)四个年龄段输出该段患病人数占总患病人数的比例,以百分比的形式输出,精确到小数点后两位。每个年龄段占一行,共四行。
10
1 11 21 31 41 51 61 71 81 91
20.00%
20.00%
20.00%
40.00%
#include
#include
int n,sum[4],temp;
int main(void){
register int i;
scanf("%d",&n);
for(i=1;i<=n;++i){
scanf("%d",&temp);
if(temp<=18)
++sum[0];
else if(temp<=35)
++sum[1];
else if(temp<=60)
++sum[2];
else
++sum[3];
}
printf("%.2f%%\n%.2f%%\n%.2f%%\n%.2f%%\n",sum[0]*100.0/n,sum[1]*100.0/n,sum[2]*100.0/n,sum[3]*100.0/n);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
某校大门外长度为 L L L的马路上有一排树,每两棵相邻的树之间的间隔都是 1 1 1米。我们可以把马路看成一个数轴,马路的一端在数轴 0 0 0的位置,另一端在 L L L的位置;数轴上的每个整数点,即 0 , 1 , 2 , . . . , L 0,1,2,...,L 0,1,2,...,L都种有一棵树。
由于马路上有一些区域要用来建地铁。这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数,区域之间可能有重合的部分。现在要把这些区域中的树(包括区域端点处的两棵树)移走。你的任务是计算将这些树都移走后,马路上还有多少棵树。
第一行有两个整数 L ( 1 ≤ L ≤ 10000 ) , M ( 1 ≤ M ≤ 100 ) L(1≤L≤10000),M(1≤M≤100) L(1≤L≤10000),M(1≤M≤100), L L L代表马路的长度, M M M代表区域的数目, L L L和 M M M之间用一个空格隔开。接下来的 M M M行每行包含两个不同的整数,用一个空格隔开,表示一个区域的起始点和终止点的坐标。
对于 20 % 20\% 20%的数据,区域之间没有重合的部分;对于其它的数据,区域之间有重合的情况。
包括一行,这一行只包含一个整数,表示马路上剩余的树的数目。
500 3
150 300
100 200
470 471
298
#include
#include
bool tr[10001];
int l,m,t1,t2;
int main(void){
register int i,j,sum=0;
scanf("%d%d",&l,&m);
for(i=1;i<=m;++i){
scanf("%d%d",&t1,&t2);
for(j=t1;j<=t2;++j)
tr[j]=true;
}
for(i=0;i<=l;++i)
if(!tr[i])
++sum;
printf("%d\n",sum);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
在线性代数、计算几何中,向量点积是一种十分重要的运算。给定两个 n n n维向量 a = ( a 1 , a 2 , . . . , a n ) , b = ( b 1 , b 2 , . . . , b n ) a=(a_1,a_2,...,a_n),b=(b_1,b_2,...,b_n) a=(a1,a2,...,an),b=(b1,b2,...,bn),求点积 a ? b = a 1 b 1 + a 2 b 2 + . . . + a n b n a?b=a_1b_1+a_2b_2+...+a_nb_n a?b=a1b1+a2b2+...+anbn。
第一行是一个整数 n ( 1 ≤ n ≤ 1000 ) n(1≤n≤1000) n(1≤n≤1000);
第二行包含 n n n个整数 a 1 , a 2 , . . . , a n a_1,a_2,...,a_n a1,a2,...,an;
第三行包含 n n n个整数 b 1 , b 2 , . . . , b n b_1,b_2,...,b_n b1,b2,...,bn;
相邻整数之间用单个空格隔开。每个整数的绝对值都不超过 1000 1000 1000。
一个整数,即两个向量的点积结果。
3
1 4 6
2 1 5
36
#include
#include
int n,a[1001],b[1001];
int main(void){
register int i,sum=0;
scanf("%d",&n);
for(i=1;i<=n;++i)
scanf("%d",&a[i]);
for(i=1;i<=n;++i)
scanf("%d",&b[i]);
for(i=1;i<=n;++i)
sum+=a[i]*b[i];
printf("%d\n",sum);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
假设有 N ( N ≤ 5000 ) N(N≤5000) N(N≤5000)盏灯,从 1 1 1到 N N N按顺序依次编号,初始时全部处于开启状态;有 M M M个人( M M M为不大于 N N N的正整数)也从 1 1 1到 M M M依次编号。
第一个人将灯全部关闭,第二个人将编号为 2 2 2的倍数的灯打开,第三个人将编号为 3 3 3的倍数的灯做相反处理(即将打开的灯关闭,将关闭的灯打开)。依照编号递增顺序,以后的人都和 3 3 3号一样,将凡是自己编号倍数的灯做相反处理。
请问:当第 M M M个人操作之后,哪几盏灯是关闭的,按从小到大输出其编号,其间用逗号间隔。
输入正整数 N N N和 M M M,以单个空格隔开。
顺次输出关闭的灯的编号,其间用逗号间隔。
10 10
1,4,9
#include
#include
bool l[5001]
int n,m;
int main(void){
register bool flag=true;
register int i;
memset(l,true,sizeof(l));
scanf("%d%d",&n,&m);
for(i=1;i<=m;++i)
for(j=1;j<=n;++j)
if(j%i==0)
l[j]=!l[j];
for(i=1;i<=n;++i)
if(flag&&!l[i])
printf("%d",i),flag=false;
else if(!l[i])
printf(",%d",i);
putchar('\n');
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
在一个序列(下标从 1 1 1开始)中查找一个给定的值,输出第一次出现的位置。
第一行包含一个正整数 n ( 1 ≤ n ≤ 10000 ) n(1≤n≤10000) n(1≤n≤10000),表示序列中元素个数。
第二行包含 n n n个整数,依次给出序列的每个元素,相邻两个整数之间用单个空格隔开。元素的绝对值不超过 10000 10000 10000。
第三行包含一个整数 x x x,为需要查找的特定值。 x x x的绝对值不超过 10000 10000 10000。
若序列中存在 x x x,输出 x x x第一次出现的下标;否则输出 − 1 -1 −1。
5
2 3 6 7 3
3
2
#include
int n,num[10001],x;
int main(void){
register int i;
scanf("%d",&n);
for(i=1;i<=n;++i)
scanf("%d",&num[i]);
scanf("%d",&x);
for(i=1;i<=n;++i)
if(num[i]==x)
return printf("%d\n",i+1),0;
puts("-1");
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
津津上初中了。妈妈认为津津应该更加用功学习,所以津津除了上学之外,还要参加妈妈为她报名的各科复习班。另外每周妈妈还会送她去学习朗诵、舞蹈和钢琴。但是津津如果一天上课超过八个小时就会不高兴,而且上得越久就会越不高兴。假设津津不会因为其它事不高兴,并且她的不高兴不会持续到第二天。请你帮忙检查一下津津下周的日程安排,看看下周她会不会不高兴;如果会的话,哪天最不高兴。
包括七行数据,分别表示周一到周日的日程安排。每行包括两个小于 10 10 10的非负整数,用空格隔开,分别表示津津在学校上课的时间和妈妈安排她上课的时间。
包括一行,这一行只包含一个数字。如果不会不高兴则输出 0 0 0,如果会则输出最不高兴的是周几(用 1 , 2 , 3 , 4 , 5 , 6 , 7 1,2,3,4,5,6,7 1,2,3,4,5,6,7分别表示周一,周二,周三,周四,周五,周六,周日)。如果有两天或两天以上不高兴的程度相当,则输出时间最靠前的一天。
5 3
6 2
7 2
5 3
5 4
0 4
0 6
3
#include
int num[7][2],s[7];
int main(void){
register int i,MAX=0;
for(i=0;i<7;++i){
scanf("%d%d",&num[i][0],&num[i][1]);
s[i]=num[i][0]+num[i][1];
}
for(i=0;i<7;++i)
if(s[i]>s[MAX])
MAX=i;
printf("%d\n",MAX+1);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输出一个整数序列中最大的数和最小的数的差。
第一行为 M M M,表示整数个数,整数个数不会大于 10000 10000 10000;
第二行为 M M M个整数,以空格隔开,每个整数的绝对值不会大于 10000 10000 10000。
输出 M M M个数中最大值和最小值的差。
5
2 5 7 4 2
5
#include
using namespace std;
int main(){
int m,a[10001];
int max=0,min=99999;
int difference;
int i;
cin>>m;
for(i=1;i<=m;i++){
cin>>a[i];
if(a[i]>max)
max=a[i];
if(a[i]<min)
min=a[i];
}
difference=max-min;
cout<<difference<<endl;
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输出一个整数数列中不与最大数相同的数字之和。
输入分为两行:
第一行为 N N N( N N N为接下来数的个数, N ≤ 100 N≤100 N≤100);
第二行 N N N个整数,数与数之间以一个空格分开,每个整数的范围是 − 1000 , 000 -1000,000 −1000,000到 1000 , 000 1000,000 1000,000。
输出为 N N N个数中除去最大数其余数字之和。
3
1 2 3
3
#include
using namespace std;
int a[10001];
int main(){
int n;
cin>>n;
int max=-1;
long long int tot=0;
for(int i=1;i<=n;i++){
cin>>a[i];
if(a[i]>max)
max=a[i];
}
for(int i=1;i<=n;i++)
if(a[i]!=max)
tot=tot+a[i];
cout<<tot;
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
医院采样了某临床病例治疗期间的白细胞数量样本 n n n份,用于分析某种新抗生素对该病例的治疗效果。为了降低分析误差,要先从这 n n n份样本中去除一个数值最大的样本和一个数值最小的样本,然后将剩余 n − 2 n-2 n−2个有效样本的平均值作为分析指标。同时,为了观察该抗生素的疗效是否稳定,还要给出该平均值的误差,即所有有效样本(即不包括已扣除的两个样本)与该平均值之差的绝对值的最大值。
现在请你编写程序,根据提供的 n n n个样本值,计算出该病例的平均白细胞数量和对应的误差。
输入的第一行是一个正整数 n ( 2 < n ≤ 300 ) n(2<n≤300) n(2<n≤300),表明共有 n n n个样本。
以下共有 n n n行,每行为一个浮点数,为对应的白细胞数量,其单位为 1 0 9 / L 10^{9}/L 109/L。数与数之间以一个空格分开。
输出为两个浮点数,中间以一个空格分开。分别为平均白细胞数量和对应的误差,单位也是 1 0 9 / L 10^{9}/L 109/L。计算结果需保留到小数点后 2 2 2位。
5
12.0
13.0
11.0
9.0
10.0
11.00 1.00
#include
#include
using namespace std;
int main(void){
double n;
int flag_max,flag_min;
int i;
double max=-99999,min=99999;
double a[3001],b[3001],sum=0;
double average,ave_max=-99999;
cin>>n;
for(i=1;i<=n;i++){
cin>>a[i];
if(a[i]>max){
max=a[i];
flag_max=i;
}
if(a[i]<min){
min=a[i];
flag_min=i;
}
sum+=a[i];
}
average=1.0*(sum-max-min)/(n-2);
for(i=1;i<=n;i++){
if(i!=flag_max&&i!=flag_min){
b[i]=a[i]-average;
if(b[i]<0)
b[i]=-b[i];
}
else
b[i]=-99999;
}
for(i=1;i<=n;i++)
if(b[i]>ave_max)
ave_max=b[i];
printf("%.2lf %.2lf\n",average,ave_max);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给定一个非负整数数组,统计里面每一个数的出现次数。我们只统计到数组里最大的数。
假设 F m a x ( F m a x < 10000 ) F_{max}(F_{max}<10000) Fmax(Fmax<10000)是数组里最大的数,那么我们只统计 { 0 , 1 , 2 , . . . , F m a x } \{0,1,2,...,F_{max}\} {0,1,2,...,Fmax}里每个数出现的次数。
第一行 n ( 1 ≤ n ≤ 10000 ) n(1≤n≤10000) n(1≤n≤10000)是数组的大小。
紧接着一行是数组的 n n n个元素。
按顺序输出每个数的出现次数,一行一个数。如果没有出现过,则输出 0 0 0。
5
1 1 2 3 1
0
3
1
1
#include
#include
int main(void){
int n;
scanf("%d",&n);
int num[n];
for(int i=0;i<n;i++)
scanf("%d",num+i);
std::sort(num,num+n);
for(int i=0;i<=num[n-1];i++){
int sum=0;
for(int j=0;j<n;j++)
if(num[j]==i)
sum+=1;
printf("%d\n",sum);
}
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
已知一个已经从小到大排序的数组,这个数组的一个平台( P l a t e a u Plateau Plateau)就是连续的一串值相同的元素,并且这一串元素不能再延伸。
第一行有一个整数 n n n,为数组元素的个数。第二行有 n n n个整数,整数之间以一个空格分开。
输出最长平台的长度。
10
1 2 2 3 3 3 4 5 5 6
3
#include
int main(void){
int n;
scanf("%d",&n);
int num[n];
for(int i=0;i<n;i++)
scanf("%d",&num[i]);
int MAX=1;
if(n==0)
MAX=0;
int sum=1;
for(int i=0;i<n-1;i++){
if(num[i]==num[i+1])
sum++;
else
sum=1;
if(sum>MAX)
MAX=sum;
}
printf("%d",MAX);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给定含有 n n n个整数的序列,要求对这个序列进行去重操作。所谓去重,是指对这个序列中每个重复出现的数,只保留该数第一次出现的位置,删除其余位置。
输入包含两行:
第一行包含一个正整数 n ( 1 ≤ n ≤ 20000 ) n(1≤n≤20000) n(1≤n≤20000),表示第二行序列中数字的个数;
第二行包含 n n n个整数,整数之间以一个空格分开。每个整数大于等于 10 10 10、小于等于 5000 5000 5000。
输出只有一行,按照输入的顺序输出其中不重复的数字,整数之间用一个空格分开。
5
10 12 93 12 75
10 12 93 75
#include
int main(void){
int n;
scanf("%d",&n);
int num[n];
for(int i=0;i<n;i++){
scanf("%d",&num[i]);
for(int j=0;j<i;j++)
if(num[j]==num[i]){
i--;
n--;
}
}
for(int i=0;i<n;i++)
printf("%d ",num[i]);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
为了准备一个独特的颁奖典礼,组织者在会场的一片矩形区域(可看做是平面直角坐标系的第一象限)铺上一些矩形地毯。一共有 n n n张地毯,编号从 1 1 1到 n n n。现在将这些地毯按照编号从小到大的顺序平行于坐标轴先后铺设,后铺的地毯覆盖在前面已经铺好的地毯之上。地毯铺设完成后,组织者想知道覆盖地面某个点的最上面的那张地毯的编号。注意:在矩形地毯边界和四个顶点上的点也算被地毯覆盖。
第一行,一个整数 n n n,表示总共有 n n n张地毯。
接下来的 n n n行中,第 i + 1 i+1 i+1行表示编号 i i i的地毯的信息,包含四个正整数 a , b , g , k a,b,g,k a,b,g,k,每两个整数之间用一个空格隔开,分别表示铺设地毯的左下角的坐标 ( a , b ) (a,b) (a,b)以及地毯在 x x x轴和 y y y轴方向的长度。
第 n + 2 n+2 n+2行包含两个正整数 x x x和 y y y,表示所求的地面的点的坐标 ( x , y ) (x,y) (x,y)。
输出共 1 1 1行,一个整数,表示所求的地毯的编号;若此处没有被地毯覆盖则输出 − 1 -1 −1。
3
1 0 2 3
0 2 3 3
2 1 3 3
2 2
3
#include
int main(void){
int n;
scanf("%d",&n);
int a[n],b[n],g[n],k[n];
for(int i=0;i<n;i++)
scanf("%d%d%d%d",&a[i],&b[i],&g[i],&k[i]);
int x,y;
scanf("%d%d",&x,&y);
for(int i=n-1;i>=0;i--)
if(a[i]<=x&&x<=a[i]+g[i]&&b[i]<=y&&y<=b[i]+k[i]){
printf("%d",i+1);
return 0;
}
printf("-1");
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给定一个 5 × 5 5×5 5×5的矩阵(数学上,一个 r × c r×c r×c的矩阵是一个由 r r r行 c c c元素排列成的矩形阵列),将第 n n n行和第 m m m行交换,输出交换后的结果。
输入共 6 6 6行,前 5 5 5行为矩阵的每一行元素,元素与元素之间以一个空格分开。
第 6 6 6行包含两个整数 m , n ( 1 ≤ m , n ≤ 5 ) m,n(1≤m,n≤5) m,n(1≤m,n≤5),以一个空格分开。
输出交换之后的矩阵,矩阵的每一行元素占一行,元素之间以一个空格分开。
1 2 2 1 2
5 6 7 8 3
9 3 0 5 3
7 2 1 4 6
3 0 8 2 4
1 5
3 0 8 2 4
5 6 7 8 3
9 3 0 5 3
7 2 1 4 6
1 2 2 1 2
#include
int main(void){
int a[5][5];
for(int i=0;i<5;i++)
for(int j=0;j<5;j++)
scanf("%d",&a[i][j]);
int m,n;
scanf("%d%d",&m,&n);
m--;
n--;
for(int i=0;i<5;i++){
int temp=a[m][i];
a[m][i]=a[n][i];
a[n][i]=temp;
}
for(int i=0;i<5;i++){
for(int j=0;j<5;j++)
printf("%d ",a[i][j]);
printf("\n");
}
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入三个自然数 N , i , j ( 1 ≤ i ≤ n , 1 ≤ j ≤ n ) N,i,j(1≤i≤n,1≤j≤n) N,i,j(1≤i≤n,1≤j≤n),输出在一个 N × N N×N N×N格的棋盘中(行列均从 1 1 1开始编号),与格子 ( i , j ) (i,j) (i,j)同行、同列、同一对角线的所有格子的位置。
一行,三个自然数 N ( 1 ≤ N ≤ 10 ) , i , j N(1≤N≤10),i,j N(1≤N≤10),i,j,相邻两个数之间用单个空格隔开。
第一行:从左到右输出同一行格子位置;
第二行:从上到下输出同一列格子位置;
第三行:从左上到右下输出同一对角线格子位置;
第四行:从左下到右上输出同一对角线格子位置。
其中每个格子位置用如下格式输出: ( x , y ) (x,y) (x,y), x x x为行号, y y y为列号,采用英文标点,中间无空格。相邻两个格子位置之间用单个空格隔开。
4 2 3
(2,1) (2,2) (2,3) (2,4)
(1,3) (2,3) (3,3) (4,3)
(1,2) (2,3) (3,4)
(4,1) (3,2) (2,3) (1,4)
#include
int main(void){
int n,i,j;
scanf("%d%d%d",&n,&i,&j);
for(int k=1;k<=n;k++)
printf("(%d,%d) ",i,k);
putchar('\n');
for(int k=1;k<=n;k++)
printf("(%d,%d) ",k,j);
putchar('\n');
for(int k=1;k<=n;k++)
if(k+j-i>0&&k+j-i<=n)
printf("(%d,%d) ",k,k+j-i);
putchar('\n');
for(int k=n;k>=1;k--)
if(i+j-k>0&&i+j-k<=n)
printf("(%d,%d) ",k,i+j-k);
putchar('\n');
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入一个整数矩阵,计算位于矩阵边缘的元素之和。所谓矩阵边缘的元素,就是第一行和最后一行的元素以及第一列和最后一列的元素。
第一行分别为矩阵的行数 m m m和列数 n ( m < 100 , n < 100 ) n(m<100,n<100) n(m<100,n<100),两者之间以一个空格分开。
接下来输入的 m m m行数据中,每行包含 n n n个整数,整数之间以一个空格分开。
输出对应矩阵的边缘元素和。
3 3
3 4 1
3 7 1
2 0 1
15
#include
int main(void){
int m,n,sum=0;
scanf("%d%d",&m,&n);
int a[m][n];
for(int i=0;i<m;i++)
for(int j=0;j<n;j++)
scanf("%d",&a[i][j]);
for(int i=0;i<n;i++)
sum=sum+a[0][i]+a[m-1][i];
for(int j=1;j<m-1;j++)
sum=sum+a[j][0]+a[j][n-1];
printf("%d",sum);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给定一个 5 × 5 5×5 5×5的矩阵,每行只有一个最大值,每列只有一个最小值,寻找这个矩阵的鞍点。鞍点指的是矩阵中的一个元素,它是所在行的最大值,并且是所在列的最小值。
输入包含一个 5 5 5行 5 5 5列的矩阵。
如果存在鞍点,输出鞍点所在的行、列及其值,如果不存在,输出not found
。
11 3 5 6 9
12 4 7 8 10
10 5 6 9 11
8 6 4 7 2
15 10 11 20 25
4 1 8
#include
#define N 5
int a[N][N];
int main(void){
bool flag=false;
int Max,Min,Ni,Nj;
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
scanf("%d",&a[i][j]);
for(int i=0;i<N;i++){
Max=a[i][0];
for(int j=0;j<N;j++)
if(a[i][j]>=Max)
Ni=i,
Nj=j,
Max=a[i][j];
Min=Max;
for(int k=0;k<N;k++)
if(a[k][Nj]<Min)
Min=a[k][Nj];
if(Max==Min){
flag=true;
printf("%d %d %d",Ni+1,Nj+1,Max);
break;
}
}
if(!flag)
printf("not found");
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给出两幅相同大小的黑白图像(用 01 01 01矩阵表示),求它们的相似度。说明:若两幅图像在相同位置上的像素点颜色相同,则称它们在该位置具有相同的像素点。两幅图像的相似度定义为相同像素点数占总像素点数的百分比。
第一行包含两个整数 m m m和 n n n,表示图像的行数和列数,中间用单个空格隔开。 1 ≤ m ≤ 100 , 1 ≤ n ≤ 100 1≤m≤100,1≤n≤100 1≤m≤100,1≤n≤100。
之后 m m m行,每行 n n n个整数 0 0 0或 1 1 1,表示第一幅黑白图像上各像素点的颜色。相邻两个数之间用单个空格隔开。
之后 m m m行,每行 n n n个整数 0 0 0或 1 1 1,表示第二幅黑白图像上各像素点的颜色。相邻两个数之间用单个空格隔开。
一个实数,表示相似度(以百分比的形式给出),精确到小数点后两位。
3 3
1 0 1
0 0 1
1 1 0
1 1 0
0 0 1
0 0 1
44.44
#include
#include
int main(void){
int m,n;
scanf("%d%d",&m,&n);
short a[m][n],b[m][n];
for(int i=0;i<m;i++)
for(int j=0;j<n;j++)
scanf("%d",&a[i][j]);
for(int i=0;i<m;i++)
for(int j=0;j<n;j++)
scanf("%d",&b[i][j]);
int sum=0;
for(int i=0;i<m;i++)
for(int j=0;j<n;j++)
if(a[i][j]==b[i][j])
sum+=1;
printf("%.2f",(double)sum/m/n*100);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入两个 n n n行 m m m列的矩阵 A A A和 B B B,输出它们的和 A + B A+B A+B。
第一行包含两个整数 n n n和 m m m,表示矩阵的行数和列数 ( 1 ≤ n ≤ 100 , 1 ≤ m ≤ 100 ) (1≤n≤100,1≤m≤100) (1≤n≤100,1≤m≤100)。
接下来 n n n行,每行 m m m个整数,表示矩阵 A A A的元素。
接下来 n n n行,每行 m m m个整数,表示矩阵 B B B的元素。
相邻两个整数之间用单个空格隔开,每个元素均在 1 − 1000 1-1000 1−1000之间。
n n n行,每行 m m m个整数,表示矩阵加法的结果。相邻两个整数之间用单个空格隔开。
3 3
1 2 3
1 2 3
1 2 3
1 2 3
4 5 6
7 8 9
2 4 6
5 7 9
8 10 12
#include
int main(void){
int n,m;
scanf("%d%d",&n,&m);
int a[n][m];
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
scanf("%d",&a[i][j]);
for(int i=0;i<n;i++)
for(int j=0;j<m;j++){
int temp;
scanf("%d",&temp);
a[i][j]+=temp;
}
for(int i=0;i<n;i++){
for(int j=0;j<m;j++)
printf("%d ",a[i][j]);
printf("\n");
}
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
计算两个矩阵的乘法。 n × m n×m n×m阶的矩阵 A A A乘以 m × k m×k m×k阶的矩阵 B B B得到的矩阵 C C C是 n × k n×k n×k阶的,且
C [ i ] [ j ] = ∑ k = 1 m A [ i ] [ k ] × B [ k ] [ j ] C[i][j]=\sum^{m}_{k=1}A[i][k]×B[k][j] C[i][j]=k=1∑mA[i][k]×B[k][j]
C [ i ] [ j ] C[i][j] C[i][j]表示矩阵 C C C中第 i i i行第 j j j列元素。
第一行为 n , m , k n,m,k n,m,k,表示矩阵 A A A是 n n n行 m m m列,矩阵 B B B是 m m m行 k k k列, n , m , k n,m,k n,m,k均小于 100 100 100。
然后先后输入 A A A和 B B B两个矩阵,矩阵 A A A是 n n n行 m m m列,矩阵 B B B是 m m m行 k k k列,矩阵中每个元素的绝对值不会大于 1000 1000 1000。
输出矩阵 C C C,一共 n n n行,每行 k k k个整数,整数之间以一个空格分开。
3 2 3
1 1
1 1
1 1
1 1 1
1 1 1
2 2 2
2 2 2
2 2 2
#include
int main(void){
int n,m,k;
scanf("%d%d%d",&n,&m,&k);
int A[n][m],B[m][k];
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
scanf("%d",&A[i][j]);
for(int i=0;i<m;i++)
for(int j=0;j<k;j++)
scanf("%d",&B[i][j]);
for(int i=0;i<n;i++,putchar('\n'))
for(int j=0;j<k;j++){
int sum=0;
for(int l=0;l<m;l++)
sum+=A[i][l]*B[l][j];
printf("%d ",sum);
}
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入一个 n n n行 m m m列的矩阵 A A A,输出它的转置 A T A^T AT。
第一行包含两个整数 n n n和 m m m,表示矩阵 A A A的行数和列数 ( 1 ≤ n ≤ 100 , 1 ≤ m ≤ 100 ) (1≤n≤100,1≤m≤100) (1≤n≤100,1≤m≤100)。
接下来 n n n行,每行 m m m个整数,表示矩阵 A A A的元素。相邻两个整数之间用单个空格隔开,每个元素均在 1 − 1000 1-1000 1−1000之间。
m m m行,每行 n n n个整数,为矩阵 A A A的转置。相邻两个整数之间用单个空格隔开。
3 3
1 2 3
4 5 6
7 8 9
1 4 7
2 5 8
3 6 9
#include
int main(void){
int n,m;
scanf("%d%d",&n,&m);
int a[m][n];
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
scanf("%d",&a[j][i]);
for(int i=0;i<m;i++){
for(int j=0;j<n;j++)
printf("%d ",a[i][j]);
printf("\n");
}
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入一个 n n n行 m m m列的黑白图像,将它顺时针旋转 90 90 90度后输出。
第一行包含两个整数 n n n和 m m m,表示图像包含像素点的行数和列数。 ( 1 ≤ n ≤ 100 , 1 ≤ m ≤ 100 ) (1≤n≤100,1≤m≤100) (1≤n≤100,1≤m≤100)。
接下来 n n n行,每行 m m m个整数,表示图像的每个像素点灰度。相邻两个整数之间用单个空格隔开,每个元素均在 0 − 255 0-255 0−255之间。
m m m行,每行 n n n个整数,为顺时针旋转 90 90 90度后的图像。相邻两个整数之间用单个空格隔开。
3 3
1 2 3
4 5 6
7 8 9
7 4 1
8 5 2
9 6 3
#include
int main(void){
int n,m;
scanf("%d%d",&n,&m);
int a[m][n];
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
scanf("%d",&a[j][i]);
for(int i=0;i<m;i++){
for(int j=n-1;j>=0;j--)
printf("%d ",a[i][j]);
printf("\n");
}
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给定 n n n行 m m m列的图像各像素点的灰度值,要求用如下方法对其进行模糊化处理:
四周最外侧的像素点灰度值不变;
中间各像素点新灰度值为该像素点及其上下左右相邻四个像素点原灰度值的平均(舍入到最接近的整数)。
第一行包含两个整数 n n n和 m m m,表示图像包含像素点的行数和列数。 ( 1 ≤ n ≤ 100 , 1 ≤ m ≤ 100 ) (1≤n≤100,1≤m≤100) (1≤n≤100,1≤m≤100)。
接下来 n n n行,每行 m m m个整数,表示图像的每个像素点灰度。相邻两个整数之间用单个空格隔开,每个元素均在 0 − 255 0-255 0−255之间。
m m m行,每行 n n n个整数,为模糊处理后的图像。相邻两个整数之间用单个空格隔开。
4 5
100 0 100 0 50
50 100 200 0 0
50 50 100 100 200
100 100 50 50 100
100 0 100 0 50
50 80 100 60 0
50 80 100 90 200
100 100 50 50 100
#include
#include
int main(void){
int n,m;
scanf("%d%d",&n,&m);
int num[n][m],ans[n][m];
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
scanf("%d",&num[i][j]),ans[i][j]=num[i][j];
for(int i=1;i<n-1;i++)
for(int j=1;j<m-1;j++)
ans[i][j]=round((num[i][j]+num[i-1][j]+num[i][j-1]+num[i+1][j]+num[i][j+1])/5.0);
for(int i=0;i<n;i++,putchar('\n'))
for(int j=0;j<m;j++)
printf("%d ",ans[i][j]);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入一行字符,统计出其中数字字符的个数。
一行字符串,总长度不超过 255 255 255。
输出为 1 1 1行,输出字符串里面数字字符的个数。
Peking University is set up at 1898.
4
#include
#include
int main(void){
char str[256];
gets(str);
int sum=0;
for(int i=0;i<strlen(str);i++)
if('0'<=str[i]&&str[i]<='9')
sum+=1;
printf("%d",sum);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给定一个只包含小写字母的字符串,请你找到第一个仅出现一次的字符。如果没有,输出no
。
一个字符串,长度小于 100000 100000 100000。
输出第一个仅出现一次的字符,若没有则输出no
。
abcabd
c
#include
int main(void){
char a[100000];
int b;
for(b=0;b<100000;b++){
scanf("%c",&a[b]);
if(a[b]==10){
break;
}
}
int flag=0,c,d;
for(c=0;c<b;c+=1){
flag=0;
for(d=0;d<b;d++){
if(a[c]==a[d]&&c!=d){
flag=1;
break;
}
}
if(flag==0){
printf("%c",a[c]);
return 0;
}
}
printf("no");
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
为了获知基因序列在功能和结构上的相似性,经常需要将几条不同序列的 D N A DNA DNA进行比对,以判断该比对的 D N A DNA DNA是否具有相关性。
现比对两条长度相同的 D N A DNA DNA序列。定义两条 D N A DNA DNA序列相同位置的碱基为一个碱基对,如果一个碱基对中的两个碱基相同的话,则称为相同碱基对。接着计算相同碱基对占总碱基对数量的比例,如果该比例大于等于给定阈值时则判定该两条 D N A DNA DNA序列是相关的,否则不相关。
有三行,第一行是用来判定出两条 D N A DNA DNA序列是否相关的阈值,随后 2 2 2行是两条 D N A DNA DNA序列(长度不大于 500 500 500)。
若两条 D N A DNA DNA序列相关,则输出yes
,否则输出no
。
0.85
ATCGCCGTAAGTAACGGTTTTAAATAGGCC
ATCGCCGGAAGTAACGGTCTTAAATAGGCC
yes
#include
#include
int main(void){
double f;
char dna1[512],dna2[512];
scanf("%lf",&f);
scanf("%s",dna1);
scanf("%s",dna2);
int sum=0;
for(int i=0;i<strlen(dna1);i++)
if(dna1[i]==dna2[i])
sum+=1;
if((double)sum/strlen(dna1)>=f)
printf("yes");
else
printf("no");
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
石头剪子布,是一种猜拳游戏。起源于中国,然后传到日本、朝鲜等地,随着亚欧贸易的不断发展它传到了欧洲,到了近现代逐渐风靡世界。简单明了的规则,使得石头剪子布没有任何规则漏洞可钻,单次玩法比拼运气,多回合玩法比拼心理博弈,使得石头剪子布这个古老的游戏同时用于“意外”与“技术”两种特性,深受世界人民喜爱。
游戏规则:石头打剪刀,布包石头,剪刀剪布。
现在,需要你写一个程序来判断石头剪子布游戏的结果。
第一行是一个整数 N N N,表示一共进行了 N N N次游戏 ( 1 ≤ N ≤ 100 ) (1≤N≤100) (1≤N≤100)。
接下来 N N N行的每一行包括两个字符串,表示游戏参与者Player1
,Player2
的选择(石头、剪子或者是布)。
字符串之间以空格隔开。
输出包括 N N N行,每一行对应一个胜利者(Player1
或者Player2
),或者游戏出现平局,则输出Tie
。
3
Rock Scissors
Paper Paper
Rock Paper
Player1
Tie
Player2
#include
int main(void){
int n;
char word_1[16],word_2[16];
scanf("%d",&n);
while(n--){
scanf("%s%s",word_1,word_2);
if(word_1[0]=='R')
if(word_2[0]=='R')
printf("Tie\n");
else if(word_2[0]=='P')
printf("Player2\n");
else
printf("Player1\n");
else if(word_1[0]=='S')
if(word_2[0]=='S')
printf("Tie\n");
else if(word_2[0]=='R')
printf("Player2\n");
else
printf("Player1\n");
else
if(word_2[0]=='P')
printf("Tie\n");
else if(word_2[0]=='S')
printf("Player2\n");
else
printf("Player1\n");
}
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
编写程序,求给定字符串 s s s的亲朋字符串 s 1 s_1 s1。
亲朋字符串 s 1 s_1 s1定义如下:给定字符串 s s s的第一个字符的ASCII
值加第二个字符的ASCII
值,得到第一个亲朋字符; 给定字符串 s s s的第二个字符的ASCII
值加第三个字符的ASCII
值,得到第二个亲朋字符;依此类推,直到给定字符串 s s s的倒数第二个字符。亲朋字符串的最后一个字符由给定字符串 s s s的最后一个字符ASCII
值加 s s s的第一个字符的ASCII
值。
输入一行,一个长度大于等于 2 2 2,小于等于 100 100 100的字符串。字符串中每个字符的ASCII
值不大于 63 63 63。
输出一行,为变换后的亲朋字符串。输入保证变换后的字符串只有一行。
1234
cege
#include
#include
int main(void){
char str[101];
gets(str);
char ch=str[0];
for(int i=0;i<strlen(str)-1;i++)
str[i]+=str[i+1];
str[strlen(str)-1]+=ch;
printf("%s",str);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给定一个不包含空白符的字符串,请判断是否是C语言
合法的标识符号(注:题目保证这些字符串一定不是C语言
的保留字)。
C语言
标识符要求:
非保留字;
只包含字母、数字及下划线(_
);
不以数字开头。
一行,包含一个字符串,字符串中不包含任何空白字符,且长度不大于 20 20 20。
一行,如果它是C语言
的合法标识符,则输出yes
,否则输出no
。
RKPEGX9R;TWyYcp
no
#include
#include
int main(void){
char str[256];
gets(str);
for(int i=0;i<strlen(str);i++)
if(('0'<=str[i]&&str[i]<='9'&&i!=0)||('A'<=str[i]&&str[i]<='Z')||('a'<=str[i]&&str[i]<='z')||str[i]=='_');
else{
printf("no");
return 0;
}
printf("yes");
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
脱氧核糖核酸由两条互补的碱基链以双螺旋的方式结合而成。而构成 D N A DNA DNA的碱基共有 4 4 4种,分别为腺瞟呤、鸟嘌呤、胸腺嘧啶和胞嘧啶。我们知道,在两条互补碱基链的对应位置上,腺瞟呤总是和胸腺嘧啶配对,鸟嘌呤总是和胞嘧啶配对。你的任务就是根据一条单链上的碱基序列,给出对应的互补链上的碱基序列。
一个字符串,表示一条碱基链。这个字符串只含有大写字母 A , T , G , C A,T,G,C A,T,G,C,分别表示腺瞟呤、胸腺嘧啶、鸟嘌呤和胞嘧啶。字符串长度不超过 255 255 255。
一个只含有大写字母 A , T , G , C A,T,G,C A,T,G,C的字符串,为与输入的碱基链互补的碱基链。
ATATGGATGGTGTTTGGCTCTG
TATACCTACCACAAACCGAGAC
#include
#include
int main(void){
char str[256];
scanf("%s",str);
for(int i=0;i<strlen(str);i++)
switch(str[i]){
case 'A': str[i]='T';break;
case 'T': str[i]='A';break;
case 'C': str[i]='G';break;
case 'G': str[i]='C';break;
}
printf("%s",str);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
在情报传递过程中,为了防止情报被截获,往往需要对情报用一定的方式加密,简单的加密算法虽然不足以完全避免情报被破译,但仍然能防止情报被轻易的识别。我们给出一种最简的的加密方法,对给定的一个字符串,把其中从 a − y , A − Y a-y,A-Y a−y,A−Y的字母用其后继字母替代,把 z , Z z,Z z,Z用 a , A a,A a,A替代,其他非字母字符不变,则可得到一个简单的加密字符串。
输入一行,包含一个字符串,长度小于 80 80 80个字符。
输出每行字符串的加密字符串。
Hello! How are you!
Ifmmp! Ipx bsf zpv!
#include
#include
int main(void){
char str[80];
gets(str);
for(int i=0;i<strlen(str);i++)
if('a'<=str[i]&&str[i]<='y'||'A'<=str[i]&&str[i]<='Y')
str[i]+=1;
else if(str[i]=='z'||str[i]=='Z')
str[i]-=25;
printf("%s",str);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
小英是药学专业大三的学生,暑假期间获得了去医院药房实习的机会。
在药房实习期间,小英扎实的专业基础获得了医生的一致好评,得知小英在计算概论中取得过好成绩后,主任又额外交给她一项任务,解密抗战时期被加密过的一些伤员的名单。
经过研究,小英发现了如下加密规律(括号中是一个“原文 → \to →密文”的例子)
原文中所有的字符都在字母表中被循环左移了三个位置( d e c → a b z {dec}\to{abz} dec→abz);
逆序存储( a b c d → d c b a {abcd}\to{dcba} abcd→dcba );
大小写反转( a b X Y → A B x y {abXY}\to{ABxy} abXY→ABxy)。
一个加密的字符串(长度小于 50 50 50且只包含大小写字母)。
输出解密后的字符串。
GSOOWFASOq
Trvdizrrvj
#include
#include
int main(void){
char a[100001];
char ans[1001];
gets(a);
for(int i=0;i<strlen(a);i++){
if(a[i]>='A'&&a[i]<='Z')
a[i]=a[i]+32;
else
a[i]=a[i]-32;
}
for(int i=strlen(a)-1,now=0;i>=0;i--){
ans[now]=a[i];
now++;
}
for(int i=0;i<strlen(a);i++){
if((ans[i]>=65&&ans[i]<=87)||(ans[i]>=97&&ans[i]<=119))
ans[i]=ans[i]+3;
else{
ans[i]=ans[i]-23;
}
}
puts(ans);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给定一个字符串,将其中所有的小写字母转换成大写字母。
输入一行,包含一个字符串(长度不超过 100 100 100,可能包含空格)。
输出转换后的字符串。
helloworld123Ha
HELLOWORLD123HA
#include
#include
int main(void){
char str[101];
gets(str);
for(int i=0;i<strlen(str);i++)
if('a'<=str[i]&&str[i]<='z')
str[i]-=32;
printf("%s",str);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
医生在书写药品名的时候经常不注意大小写,格式比较混乱。现要求你写一个程序将医生书写混乱的药品名整理成统一规范的格式,即药品名的第一个字符如果是字母要大写,其他字母小写。如将ASPIRIN
、aspirin
整理成Aspirin
。
第一行一个数字 n n n,表示有 n n n个药品名要整理, n n n不超过 100 100 100。
接下来 n n n行,每行一个单词,长度不超过 20 20 20,表示医生手书的药品名。药品名由字母、数字和-
组成。
n n n行,每行一个单词,对应输入的药品名的规范写法。
4
AspiRin
cisapride
2-PENICILLIN
Cefradine-6
Aspirin
Cisapride
2-penicillin
Cefradine-6
#include
#include
void strlwr_(char *str){
for(int i=0;i<strlen(str);i++)
if('A'<=str[i]&&str[i]<='Z')
str[i]+=32;
return;
}
int main(void){
int n;
scanf("%d",&n);
for(int i=0;i<n;i++){
char str[21];
scanf("%s",str);
strlwr_(str);
if('a'<=str[0]&&str[0]<='z')
str[0]-=32;
printf("%s\n",str);
}
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入两个字符串,验证其中一个串是否为另一个串的子串。
输入两个字符串, 每个字符串占一行,长度不超过 200 200 200且不含空格。
若第一个串 s 1 s_1 s1是第二个串 s 2 s_2 s2的子串,则输出(s1) is substring of (s2)
;
否则,若第二个串 s 2 s_2 s2是第一个串 s 1 s_1 s1的子串,输出(s2) is substring of (s1)
;
否则,输出No substring
。
abc
dddncabca
abc is substring of dddncabca
#include
#include
int main(void){
char s1[201],s2[201];
scanf("%s%s",s1,s2);
if(strstr(s2,s1)!=NULL)
printf("%s is substring of %s",s1,s2);
else if(strstr(s1,s2)!=NULL)
printf("%s is substring of %s",s2,s1);
else
printf("No substring");
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给定一个单词,如果该单词以er
、ly
或者ing
后缀结尾, 则删除该后缀(题目保证删除后缀后的单词长度不为 0 0 0), 否则不进行任何操作。
输入一行,包含一个单词(单词中间没有空格,每个单词最大长度为 32 32 32)。
输出按照题目要求处理后的单词。
referer
refer
#include
#include
int main(void){
char a[32];
char *p;
gets(a);
p=a;
if(strlen(a)<4)
printf("%s",a);
else{
if(strcmp(p+strlen(a)-3,"ing")==0)
a[strlen(a)-3]='\0';
p=a;
if(strcmp(p+strlen(a)-2,"er")==0)
a[strlen(a)-2]='\0';
p=a;
if(strcmp(p+strlen(a)-2,"ly")==0)
a[strlen(a)-2]='\0';
printf("%s",a);
}
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入一行单词序列,相邻单词之间由 1 1 1个或多个空格间隔,请对应地计算各个单词的长度。
注意:如果有标点符号(如连字符,逗号),标点符号算作与之相连的词的一部分。没有被空格间开的符号串,都算作单词。
一行单词序列,最少 1 1 1个单词,最多 300 300 300个单词,单词之间用至少 1 1 1个空格间隔。单词序列总长度不超过 1000 1000 1000。
依次输出对应单词的长度,之间以逗号间隔。
She was born in 1990-01-02 and from Beijing city.
3,3,4,2,10,3,4,7,5
#include
#include
int main(void){
char str[128];
bool flag=true;
while(std::cin>>str){
if(flag)
std::cout<<strlen(str),flag=false;
else
std::cout<<','<<strlen(str);
}
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入 1 1 1行句子(不多于 200 200 200个单词,每个单词长度不超过 100 100 100),只包含字母、空格和逗号。单词由至少一个连续的字母构成,空格和逗号都是单词间的间隔。
试输出第 1 1 1个最长的单词和第 1 1 1个最短单词。
一行句子。
第 1 1 1行,第一个最长的单词。
第 2 2 2行,第一个最短的单词。
I am studying Programming language C in Peking University
Programming
I
#include "iostream"
#include
#include
#include
#include "cstring"
using namespace std;
int main() {
char s[10000];
cin.getline(s, 10000);
int len = 0;
int Max = 0;
char s1[201];
char result[201];
char ans[201];
int Min = 1 << 30;
for (int i = 0; s[i]; i++) {
if ((s[i] != ' ') && (s[i] != ',')) {
int k = i;
int j = 0;
len = 0;
for (; ((s[k] != ' ') && (s[k] != ',') && s[k]); k++, j++) {
s1[j] = s[k];
len++;
i = k;
}
if (len > Max) {
s1[j] = '\0';
strcpy(result, s1);
Max = len;
}
if (len < Min) {
s1[j] = '\0';
strcpy(ans, s1);
Min = len;
}
}
}
cout << result << endl;
cout << ans << endl;
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入一个句子(一行),将句子中的每一个单词翻转后输出。
只有一行,为一个字符串,不超过 500 500 500个字符。单词之间以空格隔开。
翻转每一个单词后的字符串,单词之间的空格需与原文一致。
hello world
olleh dlrow
#include
#include
#include
using namespace std;
int main()
{
char s[1000];
int len,position;
int sum=0;
int i,j;
gets(s);//获取字符串s
len=strlen(s);//求字符串长度
s[len]=' ';//末尾加一空格方便计算
for(i=0;i<=len;i++)
{
if(s[i]!=' ') sum++;//计算单词长度
else
{
position=i;//记录单词末位置
for(j=1;j<=sum;j++)//倒序输出
cout<<s[--position];
sum=0;//计数器归零
if(i!=len)//若不是自己加上的空格就输出空格
cout<<" ";
}
}
cout<<endl;
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给定一个完全由数字字符( 0 , 1 , . . . , 9 0,1,...,9 0,1,...,9)构成的字符串 s t r str str,请写出 s t r str str的 p p p型编码串。例如:字符串122344111
可被描述为1个1、2个2、1个3、2个4、3个1
,因此我们说122344111
的 p p p型编码串为1122132431
。
输入仅一行,包含字符串 s t r str str。每一行字符串最多包含 1000 1000 1000个数字字符。
输出该字符串对应的 p p p型编码串。
122344111
1122132431
#include
#include
int main(void){
char str[1001];
scanf("%s",str);
int len=1;
for (int i=0;i<strlen(str)-1;i++)
if (str[i]==str[i+1])
len+=1;
else{
printf("%d%c",len,str[i]);
len=1;
}
printf("%d%c",len,str[strlen(str)-1]);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入一个字符串,输出该字符串是否回文。回文是指顺读和倒读都一样的字符串。
输入为一行字符串(字符串中没有空白字符,字符串长度不超过 100 100 100)。
如果字符串是回文,输出yes
;否则,输出no
。
abcdedcba
yes
#include
#include
char str[256];
int main(void){
gets(str);
for(int i=0,j=strlen(str)-1;i<=j;i++,j--)
if(str[i]!=str[j])
return puts("no"),0;
puts("yes");
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
输入学生的人数,然后再输入每位学生的分数和姓名,求获得最高分数的学生的姓名。
第一行输入一个正整数 N ( N ≤ 100 ) N(N≤100) N(N≤100),表示学生人数。接着输入 N N N行,每行格式如下:
分数 姓名
分数是一个非负整数,且小于等于 100 100 100;
姓名为一个连续的字符串,中间没有空格,长度不超过 20 20 20。
数据保证最高分只有一位同学。
获得最高分数同学的姓名。
5
87 lilei
99 hanmeimei
97 lily
96 lucy
77 jim
hanmeimei
#include
#include
struct stu{
int fs;
char name[21];
};
bool cmp(stu a,stu b){
return a.fs<b.fs;
}
int main(void){
int n;
scanf("%d",&n);
stu st[n];
for(int i=0;i<n;i++){
scanf("%d",&st[i].fs);
scanf("%s",st[i].name);
}
std::sort(st,st+n,cmp);
printf("%s",st[n-1].name);
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
给定一个字符串,在字符串中找到第一个连续出现至少 k k k次的字符。
第一行包含一个正整数 k ( 1 ≤ k ≤ 1000 ) k(1≤k≤1000) k(1≤k≤1000),表示至少需要连续出现的次数。
第二行包含需要查找的字符串。字符串长度在 1 1 1到 2500 2500 2500之间,且不包含任何空白符。
若存在连续出现至少 k k k次的字符,输出该字符;否则输出No
。
3
abcccaaab
c
#include
#include
#include
int main(void){
int k;
scanf("%d",&k);
char str[2501];
std::cin>>str;
if(k==1&&strlen(str)!=0){
printf("%c",str[0]);
return 0;
}
for(int i=1,sum=1;i<strlen(str);i++){
if(str[i-1]==str[i])
sum+=1;
else
sum=1;
if(sum>=k){
printf("%c",str[i]);
return 0;
}
}
printf("No");
return 0;
}
时间限制: 1000 ms 内存限制: 65536 KB
一个以.
结尾的简单英文句子,单词之间用空格分隔,没有缩写形式和其它特殊形式。
一个以.
结尾的简单英文句子(长度不超过 500 500 500),单词之间用空格分隔,没有缩写形式和其它特殊形式。
该句子中最长的单词。如果多于一个,则输出第一个。
I am a student of Peking University.
University
#include
#include
#define N 500
char s[N],maxword[N];
int main(void){
int len,maxlen=0;
while(~scanf("%s",s)){
len=strlen(s);
if(s[len-1]=='.')
s[--len]='\0';
if(len>maxlen)
maxlen=len,
strcpy(maxword,s);
}
printf("%s",maxword);
return 0;
}