目录
该文仅用于学习。部分代码思路转载于网络，侵删。
由于题目较多，每个题目被分类整合到其他文章中，便于分类查看和阅读。
该文不再更新，后续题目会直接更新到分类文章中。
螺旋方阵:
//分治
#include <stdio.h>
int a[100][100];
//该函数就是直接打印最外层的一圈数字，很好理解。
//number开始的数字，size代表圈的边长，begin代表位置
void geta(int number, int size, int begin)
{
int i, j, k;
if (size == 0)//注意边界条件
return;
if (size == 1)
{
a[begin][begin] = number;
return;
}
i = begin;
j = begin;
for (k = 0; k < size - 1; k++)//上
{
a[i][j] = number;
number++;
i++;
}
for (k = 0; k < size - 1; k++)//右
{
a[i][j] = number;
number++;
j++;
}
for (k = 0; k < size - 1; k++)下
{
a[i][j] = number;
number++;
i--;
}
for (k = 0; k < size - 1; k++)//左
{
a[i][j] = number;
number++;
j--;
}
geta(number, size - 2, begin + 1);//开始下一层
}
int main()
{
int n;
scanf("%d", &n);
geta(1, n, 0);
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
printf("%d ", a[i][j]);
}
printf("\n");
}
return 0;
}
分解质因数
题目描述：
每个非素数（合数）都可以写成几个素数（也可称为质数）相乘的形式，
这几个素数就都叫做这个合数的质因数。编写程序将一个正整数分解质因数
输入描述：
输入一个正整数n（2<n<1000）
输出描述：
形如a * b * b * c，质因数按照从小到大的顺序排列
输入样例：
90
输出样例：
2 * 3 * 3 * 5
//分解质因数
//每个合数都可以写成几个素数相乘的形式
//因为是从二开始作为元素，且重复利用所以不用担心，有非质数因子
# include <stdio.h>
int main()
{
int n;
int i;
scanf("%d", &n);
for(i = 2; i <= n; i ++)
{
while(n != i)//当n等于i的时候就代表该输出当前的n了
{
if(n % i == 0)
{
printf("%d*", i);
n = n / i;
}
else break;
}
}
printf("%d\n", n);//这是最后除不尽的部分
return 0;
}
寻找最长行
标题
寻找最长的行
类别
字符串
时间限制
1S
内存限制
1000Kb
问题描述
寻找若干行文本中最长的一行
输入说明
输入为多个字符串(每个字符串长度不超过100个字符)，每个字符串占一行，输入的行为“***end***”时表示输入结束
输出说明
输出其中最长的一行长度后换行再输出最长行的内容，如果最长行不止一个，则输出其中的第一行。
输入样例
abce
abdf dlfd
***end***
输出样例
9
abdf dlfd
#include <string.h>
#include <stdio.h>
int main()
{
char s[200],s1[200];
int n,max=0;
while(1)
{
gets(s);
if(strcmp(s,"***end***")==0)
break;
n=strlen(s);
if(n>max)
{
max=n;strcpy(s1,s);//把最长行的长度和最长行保存下来
}
}
printf("%d\n%s\n",max,s1);
return 0;
}
//strcpy(s1,s) 后面的复制到前面
//strcmp(s,"***end***")==0 字符串比较，相等为0 前大于后，则大于0
字符串压缩
问题描述
有一种简单的字符串压缩算法，对于字符串中连续出现的同一个英文字符，用该字符加上连续出现的次数来表示（连续出现次数小于3时不压缩）。
例如，字符串aaaaabbbabaaaaaaaaaaaaabbbb可压缩为a5b3aba13b4。
请设计一个程序，将采用该压缩方法得到的字符串解压缩，还原出原字符串并输出。
输入说明
输入数据为一个字符串（长度不大于50，只包含字母和数字），表示压缩后的字符串
输出说明
在一行上输出解压缩后的英文字符串（长度不超过100），最后换行。
输入样例
a5b3aba13b4
输出样例
aaaaabbbabaaaaaaaaaaaaabbbb
//压缩字符串
//字符加上出现次数来表示压缩方式
//输入一个字符串
//输出解压后的字符串
# include <stdio.h>
int main()
{
int i = 0, sum, count, k;
//i用来全局遍历，sum用来
char s[50], temp;
gets(s);
while(s[i])//对字符串进行遍历
{
printf("%c", s[i]);
temp = s[i];
i ++;sum = 0;count = 0;
//sum用来看数字到底是几
//i++代表看字符串的下一位
while(s[i] >= '0'&&s[i] <= '9')//如果当前项是数字
{
sum = sum * 10 + s[i] - '0';//把字符转化成数字累加，为输出次数
i ++;//i是用来统计位数的
count ++;
}
for(k = 0; k < sum - 1; k ++) printf("%c", temp);
}
return 0;
}
括号匹配
标题
括号匹配
类别
字符串处理
时间限制
2S
内存限制
1000Kb
问题描述
表达式中的合法括号为“(”、“)”、“[”、“]”、“{”、“}”，这三种括号可以按照任意的次序嵌套使用。
请写一个程序，判断给定表达式中的括号是否匹配，既左右括号顺序和数量都匹配。
输入说明
输入为一个表达式字符串，长度不超过50。
输出说明
对输入的表达式，若其中的括号是匹配的，则输出“yes”，否则输出“no”。
输入样例
样例1输入
[(d+f)*{}2]
样例2输入
[(2+3))
输出样例
样例1输出
yes
样例2输出
no
//括号匹配
//()[]{}
//判断给定表达式中 左右括号的顺序和数量是不是都匹配
//输入一个字符串表达式
//输出yes代表匹配，no代表不匹配
#include <stdio.h>
#include <string.h>
int main()
{
int a= 0, b = 0, c = 0, i, flag;
//a,b,c拥戴表示三种括号
//flag表示当有右括号先出现的时候，就不用继续判断了
//i用来遍历字符串
char str[55];
scanf("%s", str);
for(i = 0;i < strlen(str); i ++)
{
if(str[i] == '(') a ++;
else if(str[i] == '[') b ++;
else if(str[i] == '{') c ++;
else if(str[i] == ')')
{
a --;
if(a < 0)
{
flag = 1;
break;
}
}
else if(str[i] == ']')
{
b --;
if(b < 0)
{
flag = 1;
break;
}
}
else if(str[i] == '}')
{
c --;
if(c < 0)
{
flag = 1;
break;
}
}
if(flag == 1) break;
}
if(flag == 1) printf("no");
else if(flag == 0 && a == 0 && b == 0 && c == 0) printf("yes");
else printf("no");
}
表达式求值
标题
表达式求值
类别
字符串处理
时间限制
1S
内存限制
256Kb
问题描述
表达式由两个非负整数x，y和一个运算符op构成，求表达式的值。
这两个整数和运算符的顺序是随机的，可能是”x op y”， “op x y”或者 “x y op”，例如，“25 + 3”表示25加3，“5 30 *” 表示5乘以30，“/ 600 15”表示600除以15。
输入说明
输入为一个表达式，表达式由两个非负整数x，y和一个运算符op构成，x，y和op之间以空格分隔，但顺序不确定。
x和y均不大于10000000，op可以是+，-,*，/，%中的任意一种，分表表示加法，减法，乘法，除法和求余。
除法按整数除法求值，输入数据保证除法和求余运算的y值不为0。
输出说明
输出表达式的值。
输入样例
样例1输入
5 20 *
样例2输入
4 + 8
样例3输入
/ 8 4
输出样例
样例1输出
100
样例2输出
12
样例3输出
2
//表达式求值
//字符串处理
//表达式由两个非负整数x,y,和一个运算符op
//但是三个字符的位置不确定
//op有+,-,*,/,%
//
# include <stdio.h>
int main()
{
char s[20], c;
gets(s);
//注意这里如何遍历字符串
//如果字符元素是数字，注意保存方式
//如果是运算字符，保存运算字符
int i = 0;
int sum1 = 0, sum2 = 0;
int flag = 0;//用来看是存储第一个数字还是第二个数字
while(s[i] != '\0')
{
if(s[i] == '+' || s[i] == '-' ||s[i] == '*' ||s[i] == '/' ||s[i] == '%') c = s[i];
if(s[i] >= '0' && s[i] <= '9')
{
if(flag == 0)
{
sum1 = sum1*10 + (s[i] - '0');
if(s[i + 1] < '0' || s[i + 1] > '9')
{
flag = 1;
}
}
else
{
sum2 = sum2*10 + (s[i] - '0');
}
}
i ++;
}
int res;
if(c == '+') res = sum1 + sum2;
else if(c == '-') res = sum1 - sum2;
else if(c == '*') res = sum1 * sum2;
else if(c == '/') res = sum1 / sum2;
else if(c == '%') res = sum1 % sum2;
printf("%d",res);
return 0;
}
字符串查找
合理使用字符串操作函数
标题
字符串查找
类别
字符串处理
时间限制
2S
内存限制
256Kb
问题描述
给出一个字符串和多行文字，输出在这些文字中出现了指定字符串的行。
程序还需要支持大小写敏感选项：
当选项打开时，表示同一个字母的大写和小写看作不同的字符；
当选项关闭时，表示同一个字母的大写和小写看作相同的字符。
输入说明
输入数据第一行包含一个字符串s，由大小写英文字母组成，长度不超过100。
第二行包含一个数字，表示大小写敏感选项。当数字为0时表示大小写不敏感，当数字为1时表示大小写敏感。
第三行包含一个整数n，表示给出的文字行数。
接下来n行，每行包含一个字符串，字符串由大小写英文字母组成，不含空格和其他字符。每个字符串长度不超过100。
输出说明
输出多行，每行包含一个字符串，按出现的顺序依次给出那些包含了字符串s的行。
输入样例
Hello
1
5
HelloWorld
HiHiHelloHiHi
GrepIsAGreatTool
HELLO
HELLOisNOTHello
输出样例
HelloWorld
HiHiHelloHiHi
HELLOisNOTHello
#include<stdio.h>
#include<string.h>
#define N 100
int main()
{
char key[N+1],s[N+1],lowerkey[N+1],lowers[N+1];
int option,n;
scanf("%s %d %d",key,&option,&n);
strcpy(lowerkey,key);
strlwr(lowerkey);
for(int i=1;i<=n;i++){
scanf("%s",s);
if(option==0){ //大小写不敏感，把匹配和带匹配的字符都转换成小写
strcpy(lowers,s);
strlwr(lowers);
if(strstr(lowers,lowerkey))//查找函数 strstr
printf("%s\n",s);
}
else{
if(strstr(s,key))
printf("%s\n",s);
}
}
return 0;
}
字符串相似度
标题
字符串相似度
类别
字符串处理
时间限制
1S
内存限制
256Kb
问题描述
最长公共子串指给定的两个字符串之间最长的相同子字符串（忽略大小写），最长公共子串长度可用来定义字符串相似度。
现给出两个字符串S1和S2，S1的长度为Len1，S2的长度为Len2，假设S1和S2的最长公共子串长度为LCS，则两个字符串的相似度定义为2*LCS/(Len1+Len2)。
例如：S1=”App”，S2=”apple”，S1长度为3，S2长度为5，它们的最长公共子串为”App”，长度为3，则相似度为2*3/(3+5)=0.75。
现给出两个字符串，请计算它们的相似度结果保留3位小数。
输入说明
输入为两行，分别表示两个字符串S1和S2，每个字符串长度不超过100个字符，所有字符均为可打印字符，包括大小写字母，标点符号和空格。
输出说明
输出两个字符串的相似度，结果四舍五入保留3位小数。
输入样例
App
Apple
输出样例
0.750
#include<stdio.h>
#include<string.h>
#include<math.h>
int main()
{
char s1[101],s2[101],t[101];
int i,j;
float len1,len2,max=0;
int a[100][100]={0};
float similar;
gets(s1);
gets(s2);
len1=strlen(s1);
len2=strlen(s2);
for(i=0;i<len1;i++)
{
for(j=0;j<len2;j++)
{
if(s1[i]==s2[j]||abs(s1[i]-s2[j])==32)
{
if(i!=0&&j!=0)
a[i][j]=a[i-1][j-1]+1;
else a[i][j]=1;
}
}
}
for(i=0;i<len1;i++)
{
for(j=0;j<len2;j++)
{
if(a[i][j]>max) max=a[i][j];
}
}
similar=2.0*max/(len1+len2);
printf("%.3f",similar);
}
ISBN号码
标题
ISBN号码
类别
字符串处理
时间限制
1S
内存限制
256Kb
问题描述
每一本正式出版的图书都有一个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
#include<stdio.h>
int main()
{
char ch[100]={0};
int sum,i;
while(scanf("%s",ch)!=EOF)
{
i=0;
sum=0;
sum=sum+(ch[i]-'0');
for(i=2;i<5;i++)
{
sum=sum+((ch[i]-'0')*i);
}
for(i=6;i<11;i++)
{
sum=sum+((ch[i]-'0')*(i-1));
}
sum=sum%11;
if(sum==10)
{
if(ch[12]=='X')
printf("Right\n");
else{
ch[12]='X';
printf("%s\n",ch) ;
}
}
else if(sum==(ch[12]-'0'))
printf("Right\n");
else
{
ch[12]=(char)(sum+'0');
printf("%s\n",ch);
}
}return 0;
}
字符串相似度
转自 https://blog.csdn.net/qq_39679772/article/details/103584389
标题
字符串相似度
类别
字符串处理
时间限制
1S
内存限制
256Kb
问题描述
最长公共子串指给定的两个字符串之间最长的相同子字符串（忽略大小写），最长公共子串长度可用来定义字符串相似度。
现给出两个字符串S1和S2，S1的长度为Len1，S2的长度为Len2，假设S1和S2的最长公共子串长度为LCS，则两个字符串的相似度定义为2*LCS/(Len1+Len2)。
例如：S1=”App”，S2=”apple”，S1长度为3，S2长度为5，它们的最长公共子串为”App”，长度为3，则相似度为2*3/(3+5)=0.75。
现给出两个字符串，请计算它们的相似度结果保留3位小数。
输入说明
输入为两行，分别表示两个字符串S1和S2，每个字符串长度不超过100个字符，所有字符均为可打印字符，包括大小写字母，标点符号和空格。
输出说明
输出两个字符串的相似度，结果四舍五入保留3位小数。
输入样例
App
Apple
输出样例
0.750
#include<stdio.h>
#include<string.h>
#include<math.h>
int main()
{
char s1[101],s2[101],t[101];
int i,j;
float len1,len2,max=0;
int a[100][100]={0};
float similar;
gets(s1);
gets(s2);
len1=strlen(s1);
len2=strlen(s2);
for(i=0;i<len1;i++)
{
for(j=0;j<len2;j++)
{
if(s1[i]==s2[j]||abs(s1[i]-s2[j])==32)
{
if(i!=0&&j!=0)
a[i][j]=a[i-1][j-1]+1;
else a[i][j]=1;
}
}
}
for(i=0;i<len1;i++)
{
for(j=0;j<len2;j++)
{
if(a[i][j]>max) max=a[i][j];
}
}
similar=2.0*max/(len1+len2);
printf("%.3f",similar);
}
成绩处理
标题
成绩处理
描述
输入5个学生，4门课成绩，二维数组stu[5][4]表示，行标表示学生，列标表示课程成绩，分别编写函数aver()、fals()和well()完成：(1)求第一门课的平均分；(2)统计有2门以上课程不及格的同学人数；(3)平均成绩在90分以上或者全部课程成绩在85分以上的同学视为优秀，统计人数，使用指针完成地址传递，主函数完成数组输入和输出。
时间限制
1
内存限制
10000
类别
1
输入说明
输入二维浮点型数组stu[5][4]
输出说明
输出第一门课程平均分(保留1位小数)、2门以上不及格人数和成绩优秀人数，数据之间空一格。
输入样例
85 73 59 92
93 95 89 88
86 88 88 87
59 51 52 68
78 32 59 91
输出样例
80.2 2 2
提示
注意行列信息。使用指针完成地址传递，主函数完成数组输入和输出。
#include<stdio.h>
double aver(double s);
int fals(double *p,int m);
int well(double *p1,int num);
int main()
{
int i,j,fail,number;
double sum=0,average,stu[5][4];
for(i=0; i<5; i++)
for(j=0; j<4; j++)
scanf("%lf",&stu[i][j]);
for(i=0; i<5; i++)
sum=sum+stu[i][0];
average=aver(sum);
fail=fals(*stu,20);
number=well(*stu,20);
printf("%.1lf %d %d",average,fail,number);
return 0;
}
double aver(double s) {
return (s/5);
}
int fals(double *p,int m) {
int i=0,n=0,c=0,flag=0;
double *p_end;
p_end=p+m;
for(; p<p_end; p++) {
i++;
if((*p)<60)
n++;
if(n>=2 && flag==0) {
flag=1;
c++;
}
if(i%4==0) {
n=0;
flag=0;
}
}
return (c);
}
int well(double *p1,int num) {
double zongfen=0,pingjun;
int i=0,count=0,f=0;
double *p1_end;
p1_end=p1+num;
for(; p1<p1_end; p1++) {
i++;
if(*p1<85) f=1;
zongfen=zongfen+(*p1);
if(i%4==0) {
pingjun=zongfen/4;
if((pingjun>=90)||(f==0))
count++;
f=0;
zongfen=0;
}
}
return (count);
}
字符串长度判断
题目：字符串长度判断
时间限制：1S
内存限制：10000Kb
问题描述：
写一个函数，求一个字符串的长度。在main函数中输入字符串，并输出其长度。
输入说明：
输入一个字符串
输出说明：
输出该字符串中元素的个数。
输入样例：
boy
输出样例：
3
#include<stdio.h>
void func(char q[])
{
int i = 0;
while(q[i] != '\0')
{
i++;
}
printf("%d", i);
}
int main()
{
char q[100];
gets(q);
func(q);
return 0;
}
角谷定理
#include <stdio.h>
int main()
{
int x;
int res = 0;
scanf("%d", &x);
do
{
if(x % 2 == 0) x = x / 2;
else x = x * 3 + 1;
res = res + 1;
} while (x > 1);
/*while( x > 1)
{
if (x % 2 == 0)
x = x / 2;
else
x = x * 3 + 1;
res = res + 1;
}*/
printf("%d", res);
return 0;
}
素数
int x;
int i, flag = 0;
for(int i = 2; i < x; i++)
{
if(x % i == 0) flag = 1;
}
if(flag) printf("x是素数");
else printf("x不是素数")；
哥德巴赫猜想
#include <stdio.h>
int func(int x)
{
int i,flag = 0;
for(int i = 2; i < x; i++)
{
if(x % i == 0) flag = 1;
}
return flag;
}
int main()
{
int x;
scanf("%d", &x);
int i;
for(i = 2; i <= x ; i ++)
{
if(func(i) && func(x - i))
printf("%d %d", i, x - i);
}
return 0;
}
- 最大公约数
1 1 1
0 1 1
0 0 0
-1 -2 1
-4 -4 4
因为负数最大公约数的计算，和正数结果一样，所以我们在运算之前都取绝对值abs();
#include <math.h>
abs(-1) = 1;
方法一：
//注意正负有时候有要求
#include <stdio.h>
#include <math.h>
int main()
{
int a, b, n, i;
scanf("%d %d", &a, &b);
a = abs(a);
b = abs(b);
if (a > b)//找出小的，减少运算
n = b;
else
n = a;
if (a == 0)//有零的情况
printf("%d", b);
else if (b == 0)//有零的情况
printf("%d", a);
else//从小数从大到小遍历
{
for (i = n; i >= 1; i--)
{
if (a % i == 0 && b % i == 0)
{
printf("%d", i);
break;
}
}
}
return 0;
}
方法二：（递归）
#include <stdio.h>
#include <math.h>
int gcd(int a, int b)
{
return b ? gcd(b, a % b) : a;
//如果b大于0，返回b 和 a mod b的最大公约数
//如果b等于0，返回a
}
int main()
{
int a,b;
scanf("%d %d", &a, &b);
printf("%d\n", gcd(abs(a),abs(b)));
return 0;
}
出租车计价
#include <stdio.h>
int main()
{
int min,ans;
double meter,res;
scanf("%lf %d", &meter, &min);
res = 0;
if (meter < 3.0) res = 10.0;
else if(meter > 3.0 && meter <= 10.0) res = 10.0 + (meter - 3.0) * 2.0;
else if(meter > 10) res = 24.0 + (meter - 10.0) * 3.0;
ans = (res + (min / 5) * 2.0) + 0.5;
printf("%d", ans);
return 0;
}
迭代法求根
题目：迭代法求根（1）
时间限制：1S
内存限制：10000Kb
问题描述：
用迭代法求 ，求平方根的迭代公式为
要求前后两次求出的x的差的绝对值小于 。
输入说明：
输入浮点数a。
输出说明：
输出一个浮点数x，小数点后保留5位小数。
输入样例：
3
输出样例：
1.73205
// 迭代法求x等于根号下a的值
#include<stdio.h>
#include<math.h>
int main() {
double x1, x2;
float a;
scanf("%f", &a);
x2 = 1.0;
do{
x1 = x2;
x2 = (x1 + a / x1) / 2.0; // 迭代公式
}while(fabs(x1 - x2) > 1e-5);
printf("%f", x2);
return 0 ;
}
元素平移
题目描述：
已知数组array[10]={1,2,3,4,5,6,7,8,9,10};要求把下标从0到p（p从键盘输入）的数组元素平移到数组的最后，并输出平移后的数组。
输入格式：输入一个整数p；
输出格式：共一行，输出平移后的数组，数字之间用空格分隔
示例：
输入：3
输出：5 6 7 8 9 10 1 2 3 4
#include <stdio.h>
int main()
{
int array[10] = {1,2,3,4,5,6,7,8,9,10};
int n;
scanf("%d", &n);
int q[10], i, j = 0;
for(i = n + 1; i < 10; i ++)
{
q[j] = array[i];
j++;
}
for(i = 0; i <= n; i ++)
{
q[j] = array[i];
j++;
}
for(i = 0; i < 10; i ++)
{
printf("%d ", q[i]);
}
return 0;
}
前项除以后项
题目描述：
数组a包括10个整数，把a中所有的后项除以前项之商取整后存入数组b。
输入格式：共一行，输入数组a中的所有值；
输出格式：共一行，输出数组b中的值，以空格分隔。
示例：
输入：1 2 5 15 60 70 30 90 100 200
输出：2 2 3 4 1 0 3 1 2
#include<stdio.h>
int main()
{
int a[10], b[10], i, j = 0;
for(i = 0; i < 10; i ++)
{
scanf("%d", &a[i]);
if(i > 0)
{
b[j] = a[i] / a[i - 1];
j ++;
}
}
for(i = 0; i < 9; i ++) printf("%d ", b[i]);
return 0;
}
单词统计
\标题
单词统计
描述
输入字符串string[N]（N≤100），各个单词以空格隔开，单词长度小于等于8，输入单词word[M]（M≤8），在
string中查找出相同的单词并统计该单词出现的次数信息，输出单词和出现次数的信息， 数据之间空一格空格。主函数输入字符串和待统计单词，编写函数count()实现统计和信息输出。
时间限制
1
内存限制
10000
类别
1
输入说明
输入一行字符以空格隔开各个单词，输入要统计的单词。
输出说明
格式输出：输出单词及其出现的次数信息，数据之间空一格。
输入样例
dog cat dog dog the abc dog hahe
dog
输出样例
dog 4
提示
采用重循环结构实现计算过程，输出数据之间空一格。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(void) {
char array[100][9];//
char str[1000];
char flag[9];
int i,num,index,count;
gets(str);
gets(flag);
//提取单词
num=index=0;
for(i=0; i<strlen(str); i++) {
if(str[i]!=' ') {
array[num][index]=str[i];
index++;
} else { //碰到空格即为一个单词
array[num][index]='\0';
num++;
index=0;
}
}
array[num][index]='\0';//最后一个单词没有空格
//统计次数
count=0;
for(i=0; i<=num; i++) {
if(strcmp(array[i],flag)==0) {
count++;
}
}
printf("%s %d",flag,count);
return 0;
转自 https://blog.csdn.net/yingmu__/article/details/108040190
}
#include <stdio.h>
#include <string.h>
#define SPACE 0 //空格状态
#define LETTER -1 //字母状态，但是这表示不是要查找的单词的字母的状态
#define WORD 1 //而这种状态是要查找的单词的状态
//当然了，如果状态时大于1的数，说明是要查找的单词的中间部分的状态，上文讲过了
void count(char *str,char *word) //题目要求额外编写函数，其实都一样，OJ只看结果是否正确
{
int state=0,ans=0,i; //state表状态，先假设是空格，因为空格上来就判断是不是三种状态(中的某种状态)
int len=strlen(word);
for(i=0;str[i];++i) //遍历数组，让一个又一个参赛者(单词)接受洗礼
{
switch(state)
{
case(SPACE): //(如果上一个字母是空格)欢迎下一位参赛者入场
if(str[i]==word[0])state=WORD; //(如果这一个字母是所查的单词的第一个字母)恭喜这位参赛者踏过门槛
else if(str[i]==' ')state=SPACE; //(其实这句话可以省略，因为反正都是空格状态，改它是一样的)坐等下一位参赛者入场
else state=LETTER; //(剩下的肯定是其他字母状态了)连门槛都过不了，out
break;
case(LETTER): //(是其他字母状态)这位参赛者已经out了，现在正在求情
if(str[i]==' ')state=SPACE; //求情无效，坐等这位参赛者自行退场
break;
default: //(是要查找的单词状态)已经踏过门槛的参赛者开始接受洗礼或正在接受洗礼
if(state<len) //(还不是最后一个字母)还没有达到最后一关
{
if(str[i]==' ')state=SPACE; //这位参赛者缺乏信心，自行退场了
else if(str[i]==word[state])++state; //(变成下一个字母状态)这位参赛者成功通过这一关，继续闯关
else state=LETTER; //这位参赛者闯关失败，out
}
else if(state==len) //(是最后一个字母)BOSS关
{
if(str[i]==' ') //(如果下一个是空格，找到了！)闯关成功！
{
ans++; //通关的参赛者数加一
state=SPACE; //(状态不要忘记改变)膜拜成功人士的背影，并为下一位参赛者入场做准备
}
else
{
state=LETTER; //可惜，这位参赛者兴奋过头，裁判一怒之下令其退场
}
}
}
}
if(state==len) //最后一位参赛者的评判结果还没出来呢
{
ans++;
}
printf("%s %d",word,ans);
}
int main()
{
char word[9],str[101];
gets(str);
gets(word);
count(str,word);
return 0;
}
转自 https://blog.csdn.net/qq_45836372/article/details/103561950
字符删除
标题
字符删除
描述
主函数中输入一个一维字符数组str[N]（N≤50）和待删除字符ch，调用函数dele()完成内容：1、删除字符数组中的每个待删除字符；2、其它字符依次迁移；3、数组末尾加'\0'结束。
时间限制
1
内存限制
10000
类别
1
输入说明
输入一个一维字符数组和待删除字符。
输出说明
格式输出：输出处理后字符串。
输入样例
There are three men.
e
输出样例
Thr ar thr mn.
提示
字符串输入函数gets()，头文件string.h。
//206 - 210
#include <stdio.h>
void dele(char str[], char c)
{
int j, k;
for (j = k = 0; str[j] != '\0'; j++)
if (str[j] != c)
str[k++] = str[j];
str[k] = '\0';
printf("\n%s", str);
}
int main()
{
char str[100], c;
gets(str);
c = getchar();
dele(str,c);
return 0;
}
单词排序
标题
单词排序
描述
定义一个二维字符数组str[10][20]，行号表示单词序号，列号表示单词最大长度，输入一个正整数N（N≤10），表示单词数，使用函数wd_sort()完成单词的排序，按字母顺序从小到大排列单词，使用指针完成地址传递，主函数完成数组输入和输出。
时间限制
1
内存限制
10000
类别
1
输入说明
输入一个二维字符数组str和一个正整数N，行号表示单词序号，列号表示单词最大长度。
输出说明
格式输出：单词之间空一行。
输入样例
3
word fish egg
输出样例
egg
fish
word
提示
使用指针作形参，实现地址传递。
数组定义后初始化。
使用strcmp()、strcpy()和strlen()函数，头文件string.h。
#include <stdio.h>
#include <string.h>
int main(void)
{
char array[10][20];
char str[21];
int n, i, j, len, num, index;
scanf("%d", &n);
for (i = 0; i < n; i++)
{
scanf("%s", &array[i]);
}
for (i = 1; i < n; i++)
{
for (j = i; j > 0 && (strcmp(array[j], array[j - 1]) < 0); j--)
{
strcpy(str, array[j]);
strcpy(array[j], array[j - 1]);
strcpy(array[j - 1], str);
}
}
for (i = 0; i < n; i++)
{
printf("%s\n", array[i]);
}
return 0;
}
奇偶排序
标题
奇偶排序
描述
定义一个一维整形数组num[20]，输入正整数N（N≤20）代表num的实际元素个数，输入N个任意整数到num中，编写函数sort()实现排序处理，完成前面奇数，后面偶数，分别从小到大排序。使用指针完成地址传递，主函数完成N、数组元素的输入和处理后的数组元素输出。
时间限制
1
内存限制
10000
类别
1
输入说明
输入正整数N（N≤20）和N个任意排列的整形到一维数组num中。
输出说明
格式输出：数据之间空一格，奇数和偶数分界处空三个空格。
输入样例
5
2 3 7 8 4
输出样例
3 7 2 4 8
提示
使用指针作形参，实现地址传递。
前面奇数、后面偶数，分别从小到大排序。
输出数据之间空一格，奇数和偶数分界处空三个空格。
# include <stdio.h>
void sort1(int q1[], int len)
{
int i, j, temp;
for(i = 0 ; i < len - 1; i ++)
for(j = 0; j < len - i - 1; j ++)
{
if(q1[j] > q1[j + 1])
{
temp = q1[j];
q1[j] = q1[j + 1];
q1[j + 1] = temp;
}
}
}
void sort2(int q2[], int len)
{
int i, j, temp;
for(i = 0 ; i < len - 1; i ++)
for(j = 0; j < len - i - 1; j ++)
{
if(q2[j] > q2[j + 1])
{
temp = q2[j];
q2[j] = q2[j + 1];
q2[j + 1] = temp;
}
}
}
int main()
{
int num[20], q1[20], q2[20];
int n, i, j1 = 0, j2 = 0;
scanf("%d", &n);
for(i = 0; i < n; i ++)
{
scanf("%d", &num[i]);
if(num[i] % 2 == 1)
{
q1[j1] = num[i];
j1 ++;
}
else
{
q2[j2] = num[i];
j2 ++;
}
}
sort1(q1, j1);
sort2(q2, j2);
for(i = 0; i < j1; i ++) printf("%d ", q1[i]);
printf(" ");
for(i = 0; i < j2; i ++) printf("%d ", q2[i]);
return 0;
}
字符拷贝
标题
字符拷贝
描述
定义一个一维字符数组str[50]，输入一串字符，输入整数位置信息M(M<50)，调用函数char_cp()把指定位置M之后的内容，拷贝到新字符数组ch[50]中，使用指针完成地址传递，主函数完成数组输入和输出。
时间限制
1
内存限制
10000
类别
1
输入说明
输入一个字符串和整形位置信息，位置M≥0。
输出说明
格式输出：输出处理后字符串ch。
输入样例
There are three men.
6
输出样例
re three men.
提示
使用指针作形参，实现地址传递，位置从0开始。
# include <stdio.h>
# include <string.h>
void char_cp(char str[], char ch[], int M)
{
int i = 0, j = 0, k = 0;
for(j = M + 1; str[j] != '\0'; j ++)
{
ch[k] = str[j];
k ++;
}
}
int main()
{
char str[50], ch[50];
gets(str);
int M, i;
scanf("%d", &M);
char_cp(str, ch, M);
puts(ch);
return 0;
}
最值交换
标题
最值交换
描述
定义一个一维整形数组num[20]，输入整数n(n≤20)和一个整形数列 (n个数)，编写change()函数，查找出数列中的最大值和最小值，并把它们交换位置，主函数完成输入和输出，主函数输出处理后的数列，各元素之间空一个空格。指针进行地址传递，子函数实现查找最值和最值位置交换。
时间限制
1
内存限制
10000
类别
1
输入说明
输入整数n (n≤20)和一个整形数列 (n个数)。
输出说明
格式输出：输出处理后数列。
输入样例
5
2 3 1 5 8
输出样例
2 3 1 8 5
提示
使用指针作形参，实现地址传递。仅对最值进行交换。输出数据之间空一格。
include <stdio.h>
int main()
{
int num[20], n, max, min, x1 = 0, x2 = 0;
scanf("%d", &n);
int i;
scanf("%d", &num[0]);
max = num[0];
min = num[0];
for(i = 1; i < n; i ++)
{
scanf("%d", &num[i]);
if(num[i] >= max)
{
max = num[i];
x1 = i;
}
if(num[i] <= min)
{
min = num[i];
x2 = i;
}
}
int temp;
temp = num[x1];
num[x1] = num[x2];
num[x2] = temp;
for(i = 0; i < n; i ++) printf("%d ", num[i]);
return 1;
}
矩阵相乘
矩阵相乘
输入2×3矩阵A和3×2矩阵B各元素值，计算矩阵A和矩阵B相乘的结果
输入说明：输入整形数组A和数组B,数组元素用空格分隔
输出说明：输出矩阵A*B的结果，矩阵元素之间用空格分隔，数组每行元素用换行分隔
输入样例：
1 2 3
4 5 6
1 2
3 4
5 6
输出样例
22 28
49 64
# include <stdio.h>
int main()
{
int A[2][3], B[3][2], res[2][2];
int i, j, k;
for(i = 0; i < 2; i ++)
for(j = 0; j < 3; j ++)
scanf("%d", &A[i][j]);
for(i = 0; i < 3; i ++)
for(j = 0; j < 2; j ++)
scanf("%d", &B[i][j]);
for(i = 0; i < 2; i ++)
for(j = 0; j < 2; j ++)
res[i][j] = 0;
for(i = 0; i < 2; i ++)
{
for(j = 0; j < 2; j ++)
{
for(k = 0; k < 3; k ++)
res[i][j] = res[i][j] + A[i][k] * B[k][j];
}
}
for(i = 0; i < 2; i ++)
{
for(j = 0; j < 2; j ++)
{
printf("%d ", res[i][j]);
}
printf("\n");
}
return 0;
}
密码强度
标题
密码强度
类别
字符串处理
时间限制
1S
内存限制
256Kb
问题描述
每个人都有很多密码，你知道你的密码强度吗？假定密码由大写字母、小写字母、数字和非字母数字的符号这四类字符构成，密码强度计算规则如下：
1. 基础分：空密码(密码长度为零)0分，非空密码1分
2. 加分项1：密码长度超过8位，+1分
3. 加分项2：密码包含两类不同字符+1分，包含三类不同字符+2分，包含四类不同字符+3分
按照此规则计算的密码强度为0~5。请你设计一个程序计算给出的密码的强度。
输入说明
输入为一个密码字符串，字符串长度不超过50个字符。
输出说明
输出一个整数表示该密码的强度。
输入样例
输入样例1
abcd
输入样例2
ab123
输出样例
样例1输出：
1
样例2输出
2
#include<stdio.h>
#include<string.h>
int main()
{
char a[50];
gets(a);
int len,n1=0,n2=0,n3=0,n4=0,sum=1,i,n;
len=strlen(a);
if(len==0) printf("0\n");
else
{
if(len>8) sum++;
for(i=0;i<=len-1;i++)
{
if(a[i]>='0'&&a[i]<='9'&&n1==0) n1++;
if(a[i]>='a'&&a[i]<='z'&&n2==0) n2++;
if(a[i]>='A'&&a[i]<='Z'&&n3==0) n3++;
if((a[i]<'0'||(a[i]>'9'&&a[i]<'A')||(a[i]>'Z'&&a[i]<'a')||a[i]>'z')&&n4==0) n4++;
}
n=n1+n2+n3+n4;
if(n==2) sum++;
if(n==3) sum=sum+2;
if(n==4) sum=sum+3;
printf("%d\n",sum);
}
return 0;
}
图像旋转
标题
图像旋转
类别
数组
时间限制
1S
内存限制
256Kb
问题描述
旋转是图像处理的基本操作，在这个问题中，你需要将一个图像顺时针旋转90度。
计算机中的图像可以用一个矩阵来表示，为了旋转一个图像，只需要将对应的矩阵旋转即可。例如，下面的矩阵（a）表示原始图像，矩阵（b）表示顺时针旋转90度后的图像。
输入说明
输入的第一行包含两个整数n和m，分别表示图像矩阵的行数和列数。1 ≤ n, m ≤ 100。
接下来n行，每行包含m个非负整数，表示输入的图像，整数之间用空格分隔。
输出说明
输出m行，每行n个整数，表示顺时针旋转90度之后的矩阵，元素之间用空格分隔。
输入样例
2 3
1 5 3
3 2 4
输出样例
3 1
2 5
4 3
#include <stdio.h>
int main()
{
int arr[101][101];//原数组
int tmp[101][101] = {0};//目标数组
int ROW, COL, i, j;//ROW 行 COL 列 i j 用于计数
scanf("%d %d", &ROW, &COL);
for(i = 0; i < ROW; i++)
for(j = 0 ; j < COL ; j++) scanf("%d", &arr[i][j]);
//原数组第一行，左到右 --> 后数组最后一列，从上到下
int dst = ROW - 1;
//原数组第一列变为第一行
for(i = 0; i < ROW; i++,dst--)
for(j = 0 ; j < COL ; j++)
tmp[j][dst] = arr[i][j];
for(i = 0;i < COL; i++)
{
for(j = 0;j < ROW; j++)
printf("%d ",tmp[i][j]);
printf("\n");
}
return 0;
}
画图
标题
画图
类别
数组
时间限制
1S
内存限制
256Kb
问题描述
在一个定义了直角坐标系的纸上，画一个(x1,y1)到(x2,y2)的矩形，指将横坐标范围从x1到x2，纵坐标范围从y1到y2之间的区域涂上颜色。
下图给出了一个画了两个矩形的例子。第一个矩形是(1,1) 到(4, 4)，用绿色和紫色表示。第二个矩形是(2, 3)到(6, 5)，用蓝色和紫色表示。
图中，一共有15个单位的面积被涂上颜色，其中紫色部分被涂了两次，但在计算面积时只计算一次。在实际的涂色过程中，所有的矩形 都涂成统一的颜色，图中显示不同颜色仅为说明方便。给出所有要画的矩形，请问总共有多少个单位的面积被涂上颜色。
输入说明
输入的第一行包含一个整数n，表示要画的矩形的个数，1<=n<=100
接下来n行，每行4个非负整数，分别表示要画的矩形的左下角的横坐标与纵坐标，以及右上角的横坐标与纵坐标。0<=横坐标、纵坐标<=100。
输出说明
输出一个整数，表示有多少个单位的面积被涂上颜色。
输入样例
2
1 1 4 4
2 3 6 5
输出样例
15
- 暴力模拟法：不考虑效率的话，将每一个矩形区域标记，然后最后遍历。
#include<stdio.h>
struct square{
int x1,y1,x2,y2;
};
int main()
{
int n,i,j,k,sum=0,a[101][101]={0};
struct square s[100];
scanf("%d",&n);
for(i=0;i<n;i++) scanf("%d%d%d%d",&s[i].x1,&s[i].y1,&s[i].x2,&s[i].y2);
for(k=0;k<n;k++)
{
for(i=s[k].x2;i>s[k].x1;i--)
{
for(j=s[k].y2;j>s[k].y1;j--)
{
a[i][j]=1;
}
}
}
for(i=0;i<101;i++)
{
for(j=0;j<101;j++)
if(a[i][j]==1) sum++;
}
printf("%d",sum);
}
转自 https://blog.csdn.net/qq_39679772/article/details/103581240
数值求和
标题
数值求和
描述
输入整数N（N≤20），输入二维矩阵A[N] [N]各元素值，计算所有对角线元素的和，每一元素只加一次，输出结算结果。
时间限制
1
内存限制
10000
类别
1
输入说明
输入整形数据N和N×N矩阵各元素值，如2和矩阵元素A={1,2,3,4}。
输出说明
格式输出：输出计算结果。
输入样例
2
1 2
3 4
输出样例
10
提示
采用重循环结构实现计算过程，所有对角线元素只加一次。
#include <stdio.h>
int main()
{
int a[30][30], i, j, sum1 = 0, sum2 = 0;
int N;
scanf("%d", &N);
for (i = 0; i < N; ++i)
{
for (j = 0; j < N; ++j)
{
scanf("%d", &a[i][j]);
}
}
for (i = 0; i < N; ++i)
{
if(i != N - 1 - i) sum1 += a[i][i];
sum2 += a[i][N - 1 - i];
}
printf("%d", sum1 + sum2);
return 0;
}
转换排序
标题
转换排序
描述
输入一维字符数组str[N]（N≤80），查找出其中小写字母并转换成大写字母，按下面方式排序：1、只对大写字母进行排序；2、其他字符原位保持不动；3、转换后的各大写字母由小到大排序。输出排序后的结果。
时间限制
1
内存限制
10000
类别
1
输入说明
输入一行字符数据str[N]（N≤80）。
输出说明
格式输出：输出仅对转换后的大写字母排序结果，其他字符原位不动输出。
输入样例
xA3T7p
输出样例
AP3T7X
提示
注意转换方式和排序要求。
- 遍历一边字符数组，原地小写变大写
- 把需要排序的所有大写字母放入中间数组
- 对中间数组进行排序
- 排序后的中间数组与原数组进行比较整合，替换原数组中的大写字母
#include<stdio.h>
int main()
{
char str[80], temp[80], t;
gets(str);
int i = 0, j = 0, num = 0;
while(str[i] != '\0')
{
if(str[i] >= 'a' && str[i] <= 'z') str[i] -= 32;
if(str[i] >= 'A' && str[i] <= 'Z')
{
temp[num] = str[i];
num ++;
}
i ++;
}
for(i = 0; i < num - 1; i ++)
for(j = 0; j < num - i - 1; j ++)
{
if(temp[j] > temp[j + 1])
{
t = temp[j];
temp[j] = temp[j + 1];
temp[j + 1] = t;
}
}
i = 0;
j = 0;
while(str[i] != '\0')
{
if(str[i] >= 'A' && str[i] <= 'Z')
{
str[i] = temp[j];
j ++;
}
i ++;
}
puts(str);
return 0;
}
最佳位置
标题
最值位置
描述
输入整数N（N≤80），输入一维行向量A[N]各元素值，查找出其中最大值并记录位置信息，输出N、最大值和位置信息， 数据之间空一格空格。
时间限制
1
内存限制
10000
类别
1
输入说明
输入整形数据N和行向量各元素值，如8和行向量元素A={1,2,3,4,5,6,7,8}。
输出说明
格式输出：输出N、最大值和位置信息，数据之间空一格。
输入样例
8
1 2 3 4 5 6 7 8
输出样例
8 8 7
提示
采用重循环结构实现计算过程，输出数据之间空一格。
- 注意最大值的初始设定
#include <stdio.h>
int main()
{
int q[80];
int n, i, max_number, des;
scanf("%d", &n);
scanf("%d", &q[0]);
max_number = q[0];
des = 0;
for(i = 1; i < n; i ++)
{
scanf("%d", &q[i]);
if(q[i] > max_number)
{
max_number = q[i];
des = i;
}
}
printf("%d %d %d", n, max_number, des);
return 0;
}
中间数
标题
中间数
类别
时间限制
1S
内存限制
256Kb
问题描述
在一个整数序列A1, A2, …, An中，如果存在某个数，大于它的整数数量等于小于它的整数数量，则称其为中间数。
在一个序列中，可能存在多个下标不相同的中间数，这些中间数的值是相同的。
给定一个整数序列，请找出这个整数序列的中间数的值。
输入说明
输入的第一行包含了一个整数n，表示整数序列中数的个数，1 ≤ n ≤ 1000。
第二行包含n个正整数，依次表示A1, A2, …,An，1 ≤ Ai ≤ 1000。
输出说明
如果序列的中间数存在，则输出中间数的值，否则输出-1表示不存在中间数。
输入样例
输入样例1
6
2 6 5 6 3 5
输入样例2
4
3 4 6 7
输出样例
输出样例1
5
输出样例2
-1
样例说明
样例1中比5小的数有2个，比5大的数也有2个。因此中间数是5
样例2中4个数都不满足中间数的定义，因此中间数是-1
#include <stdio.h>
int main()
{
int n, i, j;
scanf("%d", &n);
int a[n];
for(i=0; i<n; i++)
scanf("%d", &a[i]);
int high, low, out=-1;
for(i=0; i<n; i++)
{
high=0; low=0;
for(j=0; j<n; j++)
{
if(a[j]<a[i])
low++;
else if(a[j]>a[i])
high++;
}
if(high==low)
{
out=a[i];
break;
}
}
printf("%d", out);
return 0;
}
密码编译
题目：密码编译
时间限制：1S
内存限制：10000Kb
问题描述：
有一行电文，已按照下面的规律译成密码：
A>>Z a>>z
B>>Y b>>y
C>>X c>>x
. .
. .
. .
等等。即第1个字母变成第26个字母，第i个字母变成第（26-i+1）个字母，非字母字符不变，要求编程序将密码译成原文。
输入说明：
输入一串字符（包含7个元素），表示密码。
输出说明：
输出其对应的字符（包含7个元素），表示原文。
输入样例：
ABCDEFG
输出样例：
ZYXWVUT
#include <stdio.h>
int main()
{
char q[10], res[10];
gets(q);
int num = 0, i = 0;
while(q[num] != '\0')
{
if(q[num] >= 'a' && q[num] <= 'z')
{
i = q[num] - 'a' + 1;
q[num] = 'a' + 26 - i;
}else if(q[num] >= 'A' && q[num] <= 'Z')
{
i = q[num] - 'A' + 1;
q[num] = 'A' + 26 - i;
}
num ++;
}
puts(q);
return 0;
}
数组逆序排列
题目：数组逆序排列
时间限制：1S
内存限制：10000Kb
问题描述
将一个包含5个元素的数组逆序排列。
输入说明：
输入一个数组（包含5个元素），元素之间用逗号隔开。
输出说明：
输出一个数组（包含5个元素），元素之间用空格隔开。
输入样例：
8,6,5,4,1
输出样例：
1 4 5 6 8
消除类游戏
问题描述
消除类游戏是深受大众欢迎的一种游戏，游戏在一个包含有n行m列的游戏棋盘上进行，棋盘的每一行每一列的方格上放着一个有颜色的棋子，当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同时被消除。
现在给你一个n行m列的棋盘，棋盘中的每一个方格上有一个棋子，请给出经过一次消除后的棋盘。
请注意：一个棋子可能在某一行和某一列同时被消除。
输入格式
输入的第一行包含两个整数n, m，用空格分隔，分别表示棋盘的行数和列数。
接下来n行，每行m个整数，用空格分隔，分别表示每一个方格中的棋子的颜色。颜色使用1至9编号。
输出格式
输出n行，每行m个整数，相邻的整数之间使用一个空格分隔，表示经过一次消除后的棋盘。如果一个方格中的棋子被消除，则对应的方格输出0，否则输出棋子的颜色编号。
样例输入1
4 5
2 2 3 1 2
3 4 5 1 4
2 3 2 1 3
2 2 2 4 4
样例输出1
2 2 3 0 2
3 4 5 0 4
2 3 2 0 3
0 0 0 4 4
样例说明
棋盘中第4列的1和第4行的2可以被消除，其他的方格中的棋子均保留。
样例输入2
4 5
2 2 3 1 2
3 1 1 1 1
2 3 2 1 3
2 2 3 3 3
样例输出2
2 2 3 0 2
3 0 0 0 0
2 3 2 0 3
2 2 0 0 0
样例说明
棋盘中所有的1以及最后一行的3可以被同时消除，其他的方格中的棋子均保留。
评测用例规模与约定
所有的评测用例满足：1 ≤ n, m ≤ 30。
# include <stdio.h>
int main()
{
int m,n,i,j;
int a[100][100],b[100][100];
scanf("%d %d",&n,&m);
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
scanf("%d",&a[i][j]);
b[i][j]=a[i][j];
}
}
for(i=0;i<n;i++)
{
for(j=1;j<m-1;j++)
{
if(a[i][j]==a[i][j-1]&&a[i][j+1]==a[i][j])
{
b[i][j-1]=0;
b[i][j]=0;
b[i][j+1]=0;
}
}
}
for(j=0;j<m;j++)
{
for(i=1;i<n-1;i++)
{
if(a[i-1][j]==a[i][j]&&a[i+1][j]==a[i][j])
{
b[i-1][j]=0;
b[i][j]=0;
b[i+1][j]=0;
}
}
}
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
printf("%d ",b[i][j]);
printf("\n");
}
}
排序2
标题:
排序2
类别:
数组
时间限制
2S
内存限制
1000Kb
问题描述：
给定N个不同的整数，要求对这N个整数按如下规则排序并输出。
规则一：所有的偶数排在奇数前面。
规则二：在规则一的前提下按照从大到小的顺序排序。
输入说明
数据由两行构成，第一行为整数n（n<=100），表示待排序整数的数量。第二行是n个整数，每个整数的取值区间都为[-32768~32767]，整数之间以空格间隔。
输出说明
在一行输出排好序的整数，整数之间以空格间隔。
输入样例
5
1 2 3 4 5
输出样例
4 2 5 3 1
#include<stdio.h>
void bubble_sort(int arr[], int len) {
int i, j, temp;
for (i = 0; i < len - 1; i++)
for (j = 0; j < len - 1 - i; j++)
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
int main()
{
int n, i, j=0, k=0, b[100], c[100], a[100];
scanf("%d", &n);
for(i = 0; i < n ; i++)
{
scanf("%d",&a[i]);
if(a[i] % 2 == 0)
{
b[j]=a[i];
j++;
}
else
{
c[k]=a[i];
k++;
}
}
bubble_sort(b, j);
bubble_sort(c, k);
for(i = j - 1 ; i >= 0 ; i--)
printf("%d ", b[i]);
for(i = k - 1; i >= 0 ; i--)
printf("%d ", c[i]);
return 0;
}
回文数
标题
回文数
类别
数组
时间限制
2S
内存限制
1000Kb
问题描述
若一个非负整数其各位数字按照正反顺序读完全相同，则称之为回文数，例如12321。
判断输入的整数是否是回文数。若是，则输出该整数各位数字之和，否则输出no。
输入说明
输入为一个整数n，0<=n<1000000000。
输出说明
若该整数为回文数，则输出整数各位数字之和，否则输出no。
输入样例
样例1输入
131
样例2输入
24
输出样例
样例1输出
5
样例2输出
no
#include <stdio.h>
int isPalindrome(int x)//判断是不是回文数
{
if(x<0) return 0;
long long cur=0,num=x;
while(num)
{
cur=cur*10+num%10;
num/=10;
}
if(x==cur) return 1;
else return 0;
};
int func(int x)//求整数各位数字之和
{
int sum = 0;
int index;
while(x > 0)
{
index = x % 10;
x /= 10;
sum += index;
}
return sum;
}
int main()
{
int number;
scanf("%d", &number);
if (isPalindrome(number)) printf("%d", func(number));
else printf("no");
return 0;
}
马鞍点
标题
马鞍点
类别
数组
时间限制
2S
内存限制
1000Kb
问题描述
若一个矩阵中的某元素在其所在行最小而在其所在列最大，则该元素为矩阵的一个马鞍点。
请写一个程序，找出给定矩阵的马鞍点。
输入说明
输入数据第一行只有两个整数m和n（0<m<100,0<n<100），分别表示矩阵的行数和列数；
接下来的m行、每行n个整数表示矩阵元素（矩阵中的元素互不相同），整数之间以空格间隔。
输出说明
在一行上输出马鞍点的行号、列号（行号和列号从0开始计数）及元素的值（用一个空格分隔），之后换行；
若不存在马鞍点，则输出一个字符串“no”后换行。
输入样例
4 3
11 13 121
407 72 88
23 58 1
134 30 62
输出样例
1 1 72
#include <stdio.h>
int main()
{
int a[101][101];
int m,n;
scanf("%d %d", &m, &n);
int i,j;
for(i=0;i<m;i++)
for(j=0;j<n;j++) scanf("%d", &a[i][j]);
int sign=0;
int b[101];
for(i=0;i<m;i++)
{
int min=a[i][0];
for(j=0;j<n;j++)
{
if(a[i][j]<min)
{
min=a[i][j];
}
}
b[i]=min;
}
int c[101];
for(i=0;i<n;i++)
{
int max = a[0][i];
for(j=0;j<m;j++)
{
if(a[j][i]>max)
{
max=a[j][i];
}
}
c[i]=max;
}
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
if(a[i][j]==b[i]&&a[i][j]==c[j])
{
printf("%d %d %d",i,j,a[i][j]);
sign=1;
}
}
if(sign==0) puts("no");
return 0;
}
等差数列
标题
等差数列
类别
数组
时间限制
2S
内存限制
1000Kb
问题描述
请写一个程序，判断给定整数序列能否构成一个等差数列。
输入说明
输入数据由两行构成，第一行只有一个整数n（n<100），表示序列长度（该序列中整数的个数）；
第二行为n个整数，每个整数的取值区间都为[-32768~32767]，整数之间以空格间隔。
输出说明
对输入数据进行判断，不能构成等差数列输出“no”，能构成等差数列输出表示数列公差（相邻两项的差）的绝对值的一个整数。
输入样例
样例1输入
6
23 15 4 18 35 11
样例2输入
5
2 6 8 4 10
输出样例
样例1输出
no
样例2输出
2
# include <stdio.h>
void bubble_sort(int arr[], int len) {
int i, j, temp;
for (i = 0; i < len - 1; i++)
for (j = 0; j < len - 1 - i; j++)
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
int main()
{
int q[101], n, i;
scanf("%d", &n);
for (i = 0; i < n; i ++) scanf("%d", &q[i]);
bubble_sort(q, n);
int flag = 1;
int x1, x2;
for(i = 2; i < n; i ++)
{
x1 = q[i] - q[i - 1];
x2 = q[i - 1] - q[i - 2];
if(x1 != x2)
{
flag = 0;
break;
}
}
if(flag == 1) printf("%d", x1);
else printf("no");
}
查找
标题
查找
类别
数组
时间限制
1S
内存限制
256Kb
问题描述
给定一个包含n个整数的数列A0,A1,A2,…An-1和一个整数k，依次输出 k在序列中出现的位置（从0开始计算）。
输入说明
输入由两行构成，第一行为两个整数n和k，分别表示数列中整数个数和待查找整数k，n和k之间用空格分隔，0<n<100，0<k<10000。
第二行为n个整数，表示数列中的各个整数，整数之间用空格分隔，每个整数均不超过10000。
输出说明
依次输出整数k在数列中出现的位置（从0开始计算），如果k未在数列中出现，则输出-1。
输入样例
样例1输入
5 20
10 20 30 20 5
样例2输入
5 20
10 30 25 34 44
输出样例
样例1输出
1 3
样例2输出
-1
#include<stdio.h>
int main()
{
int i,k,n,a[100],flag1=0;
scanf("%d%d",&n,&k);
for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
if(k==a[i])
{
printf("%d ",i);
flag1=1;
}
}
if(flag1==0) printf("-1");
return 0;
}
0 -1矩阵
标题
0-1矩阵
类别
数组
时间限制
2S
内存限制
1000Kb
问题描述
查找一个只包含0和1的矩阵中每行最长的连续1序列。
输入说明
输入第一行为两个整数m和n(0<=m,n<=100)表示二维数组行数和列数，其后为m行数据，每行n个整数（0或1），输入数据中不会出现同一行有两个最长1序列的情况。
输出说明
找出每一行最长的连续1序列，输出其起始位置(从0开始计算)和结束位置(从0开始计算)，如果这一行没有1则输出两个-1,然后换行。
输入样例
5 6
1 0 0 1 1 0
0 0 0 0 0 0
1 1 1 1 1 1
1 1 1 0 1 1
0 0 1 1 0 0
输出样例
3 4
-1 -1
0 5
0 2
2 3
#include <stdio.h>
int main() {
int i, j, m, n, a[100][100];
scanf("%d %d", &m, &n);
for (i = 0; i < m; i++) //先输入矩阵
{
for (j = 0; j < n; j++)
scanf("%d", &a[i][j]);
}
for (i = 0; i < m; i++)
{
int count = 0, max = 0, location = 0, sign = 0; //注意这些初始化的位置
for (j = 0; j < n; j++) {
if (a[i][j] == 1) {
count++;
sign = 1; //标记变量，有1就是sign = 1
if (j + 1 < n) //现在不是最后一个元素
{
if (a[i][j + 1] == 0 && count > max) //下一个为0，需比较是否为最长
{
max = count;
location = j;
count = 0; //因为1的连续结束了，所以count重赋值为0
}
} else { //现在是最后一个元素
if (count > max) //需比较是否为最长
{
max = count;
location = j;
count = 0; //因为1的连续结束了，所以count重赋值为0
}
}
}
}
if (sign) {
printf("%d %d\n", location - max + 1, location);
} else
puts("-1 -1");
}
return 0;
}
Z字形扫描
标题
Z字形扫描
类别
数组
时间限制
1S
内存限制
256Kb
问题描述
在图像编码的算法中，需要将一个给定的方形矩阵进行Z字形扫描(Zigzag Scan)。给定一个m×n的矩阵，Z字形扫描的过程如下图所示。
对于下面给出的4×4的矩阵:
1 5 3 9
3 7 5 6
9 4 6 4
7 3 1 3
对其进行Z字形扫描后得到长度为16的序列如下所示：
1 5 3 9 7 3 9 5 4 7 3 6 6 4 1 3
请实现一个Z字形扫描的程序，给定一个n×n的矩阵，输出对这个矩阵进行Z字形扫描的结果。
输入说明
数据的第一行为整数n(n<100)，表示矩阵的行和列数；接下来的n行数据，每行分别为n个整数值(每个整数值都不超过1000)，即矩阵的值
输出说明
在一行上输出Z字形扫描得到的整数序列，整数之间用空格分隔
输入样例
4
1 5 3 9
3 7 5 6
9 4 6 4
7 3 1 3
输出样例
1 5 3 9 7 3 9 5 4 7 3 6 6 4 1 3
#include <stdio.h>
int main()
{
int i, j, n, state, count = 0, matrix[500][500];
scanf("%d", &n);
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
scanf("%d", &matrix[i][j]);
i = 0;
j = 0;
state = 1; //1:向右 2:向下 3:向左下 4:向右上
while (count < n * n)
{
switch (state)
{
case 1:
printf("%d ", matrix[i][j++]); //1:向右
if (i == 0)
state = 3;
else if (i == n - 1)
state = 4;
break;
case 2:
printf("%d ", matrix[i++][j]); //2:向下
if (j == 0)
state = 4;
else if (j == n - 1)
state = 3;
break;
case 3:
printf("%d ", matrix[i++][j--]); //3:向左下
if (j == 0)
state = 2;
if (i == n - 1)
state = 1;
break;
case 4:
printf("%d ", matrix[i--][j++]); //4:向右上
if (i == 0)
state = 1;
if (j == n - 1)
state = 2;
}
count++;
}
return 0;
}
相邻区域
标题
相邻区域
类别
数组
时间限制
1S
内存限制
256Kb
问题描述
一个n行m列的矩阵被划分成t个矩形区域，分别用数字1-t来标识，同一个区域内的元素都用同一个数字标识。如下图所示，一个6行8列的矩阵被分成8个矩形区域，分别用编号1-8标识。当两个小区域之间公用一条边时，称这两个区域相邻，例如下图中区域5的相邻区域有6个，分别为1,2,3,6,7,8，但4并不是它的相邻区域。请写一个程序找出区域k的所有相邻区域。
输入说明
输入第一行为四个整数n，m， t，k，整数之间用空格分隔。n表示矩阵行数（n<20），m表示矩阵列数（m<20），t表示矩阵被划分为t个矩形区域（0<t<50），k为其中某个区域的编号（1<=k<=t）。接下来是n行数据，每行m个整数，表示矩阵内各个元素所在的区域，整数之间用空格分隔。
输出说明
输出为一个整数，表示与k相邻的区域个数
输入样例
6 8 8 5
1 1 2 2 2 3 3 4
1 1 2 2 2 3 3 4
1 1 2 2 2 3 3 4
1 1 5 5 5 5 5 6
1 1 5 5 5 5 5 6
7 7 7 7 7 8 8 8
输出样例
6
#include <stdio.h>
int main(void)
{
int array[20][20];
int flag[50] = {0};
int n, m, t, k;
int i, j, count, x1, y1, x2, y2;
scanf("%d%d%d%d", &n, &m, &t, &k);
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
scanf("%d", &array[i][j]);
}
}
x1 = y1 = x2 = y2 = -1;
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
if (array[i][j] == k)
{
if (x1 == -1 && x2 == -1)
{
x1 = i;
x2 = j;
}
if (y1 < i)
{
y1 = i;
}
if (y2 < j)
{
y2 = j;
}
}
}
}
count = 0;
for (i = x1; i <= y1; i++)
{
if (x2 > 0)
{
if (flag[array[i][x2 - 1]] == 0)
{
count++;
flag[array[i][x2 - 1]] = 1;
}
}
if (y2 < m - 1)
{
if (flag[array[i][y2 + 1]] == 0)
{
count++;
flag[array[i][y2 + 1]] = 1;
}
}
}
for (j = x2; j <= y2; j++)
{
if (x1 > 0)
{
if (flag[array[x1 - 1][j]] == 0)
{
count++;
flag[array[x1 - 1][j]] = 1;
}
}
if (y1 < n - 1)
{
if (flag[array[y1 + 1][j]] == 0)
{
count++;
flag[array[y1 + 1][j]] = 1;
}
}
}
printf("%d", count);
return 0;
}
需要知道的基本操作
- 1.数组数据的读入和输出
int q[100], i, n;
scanf("%d", &n)
for(i = 0; i < n; i ++) scanf("%d", &q[i])
- 2.数组作为函数的形式参数
void func(int q[])
{
...
}
int main()
{
int q[100];
func(q);
}
- 3.递归调用：函数直接或者间接调用自己
以求第n个斐波那契数为例
int func(int n)
{
if(n == 1) return 1;//这是一个边界条件，处理了n是1的情况
else if(n == 2) return 1;//这也是一个边界条件，处理了n是2的情况
else return func(n - 1) + func(n - 2);
//递归的主题，处理其他情况，最后都能到达边界情况，然后会一步步回来
- 4.如何对一个浮点数四舍五入
sum是一个浮点数，现保留两位小数
sum = (int)(sum * 100 + 0.5) * 0.01;
printf("%.2lf", sum);
水仙花数
题目：
水仙花数
类别
流程控制
时间限制
2S
内存限制
10000Kb
问题描述
水仙花数是指一个 n 位数 ( n≥3 )，它的每个位上的数字的 n 次幂之和等于它本身。
（例如：1^3 + 5^3 + 3^3 = 153）。
定义一个函数int function(int a, int b)，计算区间[a，b]或区间[b，a]上水仙花数的个数。
输入说明
输入由两个整数a和b构成，a和b之间用空格分隔。0<a,b<10000
输出说明
输出区间[a，b]或区间[b，a]上水仙花数的个数。
输入样例
3 1000
输出样例
4
提示
a,b的位数n可能小于3
#include<stdio.h>
int function(int a,int b);
int main()
{
int m,n,k;
scanf("%d %d", &m, &n);
k = function(m,n);
printf("%d", k);
}
int function (int m,int n)
{
int i,j,temp,k=0;
int sum,a[5]={0};
if(m>n)
{
i=m;
m=n;
n=i;
}
for(;m<n;m++)
{
//进入循环，注意m是循环的条件，所以不能有变动
sum=0;
temp=m;//因此我们引入temp来进行计算
for(i=0;temp/10!=0;i++)
{
//将位数存入数组
a[i]=temp%10;
temp=temp/10;
}
while(temp > 0)
{
a[i] = temp % 10;
temp /= 10;
}
for(j=0;j<=i;j++)
{ /*判断是否为水仙花数，注意题目判定一位数不为水仙花数*/
if(i==2) sum+=a[j]*a[j]*a[j];
if(i==3) sum+=a[j]*a[j]*a[j]*a[j];
}
if(sum==m)k++;
}
return k;
}
斐波那契
标题
斐波纳契数列
类别
函数与递归
时间限制
2S
内存限制
256Kb
问题描述
已知一个斐波纳契数列中的数字依次为1, 1, 2, 3, 5, 8, 13, 21, 34, 55 … 。请判断该数列中第n个数字（n从1开始计数）是不是素数。
输入说明
输入一个整数n（1<n<=40）。
输出说明
判断斐波纳契数列中的第n个数字是不是素数，如果是输出yes，否则输出该数字。
输入样例
样例1输入
6
样例2输入
4
输出样例
样例1输出
8
样例2输出
yes
- 思路：打表法：将可能用到的斐波那契数存放到一个数组，便于操作。
#include <stdio.h>
#include <math.h>
int main()
{
int q[40];
int i;
q[0] = 1;
q[1] = 1;
for(i = 2; i <= 40 ; i ++)
{
q[i] = q[i - 1] + q[i - 2];
}
int n;
scanf("%d", &n);
int j = q[n - 1];
int flag = 0;
for(i = 2; i < sqrt(j); i ++)
{
if (j % i == 0)
{
flag = 1;
}}
if(flag == 0) printf("yes");
else printf("%d", j);
return 0;
}
数列求和
标题
数列求和
类别
函数与递归
时间限制
1S
内存限制
1000Kb
问题描述
有一分数序列：
2/1,3/2,5/3,8/5,13/8,21/13,......An/Bn
A1=2，A2=3，An=An-1+An-2；
B1=1，B2=2，Bn=Bn-1+Bn-2。
求出这个数列的前n(2<=n<=30)项之和。
输入说明
一个整数n
输出说明
输出一个实数表示数列前n项之和，结果保留2位小数（四舍五入）
输入样例
2
输出样例
3.50
#include <stdio.h>
int main()
{
double A[30],B[30];
A[0] = 2.0 ;
A[1] = 3.0;
B[0] = 1.0;
B[1] = 2.0;
int i;
for (i = 2; i < 30; i ++)
{
A[i] = A[i - 1] + A[i - 2];
B[i] = B[i - 1] + B[i - 2];
}
double sum = 0.0;
int n;
scanf("%d", &n);
for (i = 0; i < n ; i ++)
{
sum += A[i]/B[i];
}
sum = (int)(sum * 100 + 0.5) * 0.01;
printf("%.2lf", sum);
}
数字处理
标题
数字处理
类别
函数与递归
时间限制
2S
内存限制
1000Kb
问题描述
编写一个程序，从键盘输入一个非零整数n（0 < n <= 1000000000），对整数n进行如下处理：
将整数的各位数字取出来相加，如果结果是一位数则输出该数，否则重复上述过程，直到得到的结果为一位数，并输出该结果。
例如：n=456，变换过程如下
4+5+6=15
1+5=6
输出结果为6
输入说明
一个非零整数n。
输出说明
输出整数n的处理结果。
输入样例
456
输出样例
6
- 思路：递归，在某一个条件分支调用自己（需要写函数）
#include <stdio.h>
int func(int x)
{
int sum = 0 ;
int index;
while(x > 0)
{
index = x % 10;
x /= 10;
sum += index;
}
if(sum > 9) return func(sum);
else return sum;
}
int main()
{
int n;
scanf("%d", &n);
printf("%d", func(n));
return 0;
}
字符逆序排放
题目：字符逆序排放
时间限制：1S
内存限制：10000Kb
问题描述：
写一个函数，使输入的字符按照反序排放，在主函数中输入和输出字符。
输入说明：
输入一个字符串。
输出说明：
输出上述字符串的逆序排列。
输入样例：
animal
输出样例：
lamina
- 思路：将数组的第1个字符和第n个字符交换位置，第二个和第n-1个交换
#include <stdio.h>
#include <string.h>
void Reverse(char str[]);
int main()
{
char str[100];
gets(str);
Reverse(str);
printf("%s\n", str);
}
void Reverse(char str[])
{
int n = strlen(str);
int i;
char temp;
for (i = 0; i < (n / 2); i++)
{
temp = str[i];
str[i] = str[n - i - 1];
str[n - i - 1] = temp;
}
}
字符串统计
题目：字符串元素统计
时间限制：1S
内存限制：10000Kb
问题描述：
编写一个函数，由实参传来一个字符串，统计字符串中字母，数字的个数，在主函数中输入字符及输出上述结果。
输入说明：
随机输入一个字符串。
输出说明：
依次输出该字符串中字母，数字的个数。
输入样例
abc123
输出样例：
3,3
- 注意数组作为函数的参数的一些常见方式
#include <stdio.h>
#include <string.h>
void func(char *q)
{
int i, x1 = 0, x2 = 0;
while (*q != '\0')
{
if (*q >= 'a' && *q <= 'z' || *q >= 'A' && *q <= 'Z')
x1++;
else if (*q >= '0' && *q <= '9')
x2++;
q++;
}
printf("%d,%d", x1, x2);
}
int main()
{
char q[30];
gets(q);
func(q);
return 0;
}
#include <stdio.h>
#include <string.h>
void func(char q[])
{
int i, x1 = 0, x2 = 0;
int n = strlen(q);
for(i = 0; i < n; i++)
{
if (q[i] >= 'a' && q[i] <= 'z' || q[i] >= 'A' && q[i] <= 'Z')
x1++;
else if (q[i] >= '0' && q[i] <= '9')
x2++;
}
printf("%d,%d", x1, x2);
}
int main()
{
char q[30];
gets(q);
func(q);
return 0;
}
字符串查找
编写一个函数fun，求一个字符串中的英文字母的个数。
主函数中输入字符串，调用函数，输出英文字母个数
输入说明：共一行，输入字符串
输出说明：输出一个整数，为英文字母个数
输入示例：aBc456
输出示例：3
#include <stdio.h>
#include <string.h>
void func(char q[])
{
int i, x1 = 0, x2 = 0;
int n = strlen(q);
for (i = 0; i < n; i++)
{
if (q[i] >= 'a' && q[i] <= 'z' || q[i] >= 'A' && q[i] <= 'Z')
x1++;
}
printf("%d", x1);
}
int main()
{
char q[30];
gets(q);
func(q);
return 0;
}
字符串筛选
编写函数fun，其功能是将字符串s下标为奇数的字符删除，字符串中剩余字符形成的新字符串放在数组t中。
主函数中输入字符串s，调用函数，输出字符数组t。
输入说明：共一行，输入字符串s
输出说明：共一行，输出字符串t
输入示例：abcd1234
输出示例：ac13
- C语言中字符串即为字符数组
#include <stdio.h>
#include <string.h>
void fun(char s[])
{
int n = strlen(s);
int i;
for (i = 0; i < n; i = i + 2)
{
printf("%c", s[i]);
}
}
int main()
{
char s[30];
gets(s);
fun(s);
return 0;
}
字符串连接
编写一个函数fun实现字符串连接功能（不使用strcat函数）。
主函数输入两个字符串，调用函数，输出连接后的字符串
输入说明：共两行，每一行输入一个字符串
输出说明：共一行,输出连接后的字符串
输入示例：abcd
1234
输出示例：abcd1234
#include <stdio.h>
#include <string.h>
void fun(char s[],char t[])
{
int slen=strlen(s);
int k=0;
while(t[k]!='\0'){
s[slen++]=t[k++];
}
s[slen]='\0';
}
int main() {
char s[20];
char t[20];
gets(s);
gets(t);
fun(s,t);
printf("%s",s);
return 0;
}
成绩统计
试题名称 成绩统计
时间限制: 1 秒
内存限制: 256KB
问题描述
有N（0<N<=100）个学生，每个学生有3门课的成绩，输入每个学生数据（包括学号，姓名，三门课成绩），计算每个学生的平均成绩，并按照平均成绩从高到低的顺序输出学生信息，平均成绩相同时，则按照学号从小到大顺序输出。
输入说明
第一行输入学生个数N，然后逐行输入N个学生信息，包括学号，姓名，三门课成绩，学号为正整数，姓名不超过10个字符，各门课程成绩为整数,用空格分隔。
输出说明
按照平均成绩由高到低输出学生信息，平均成绩相同时，则按照学号从小到大顺序输出，输出信息包括学号、姓名、平均成绩（保留1位小数），用空格分隔，每个学生信息占一行。
输入样例
6
18001 LiMing 88 45 90
18003 WangWei 66 60 68
18004 ZhangSan 77 90 83
18110 HanMeiMei 88 77 97
18122 SuSan 66 23 87
18008 YangYang 88 76 95
输出样例
18110 HanMeiMei 87.3
18008 YangYang 86.3
18004 ZhangSan 83.3
18001 LiMing 74.3
18003 WangWei 64.7
18122 SuSan 58.7
# include <stdio.h>
struct student
{
int num;
char name[30];
float score[3];
float res;
}a[50],temp;
int main()
{
int N, i, j;
scanf("%d", &N);
for(i = 0; i < N; i ++)
{
scanf("%d %s %f %f %f", &a[i].num, &a[i].name, &a[i].score[0], &a[i].score[1], &a[i].score[2]);
a[i].res = (a[i].score[0] + a[i].score[1] + a[i].score[2]) / 3;
}
for(i = 0; i < N - 1; i ++)
for(j = 0; j < N - i - 1; j ++)
{
if(a[j].res > a[j + 1].res)
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
for(i = 0; i < N - 1; i ++)
for(j = 0; j < N - i - 1; j ++)
{
if(a[j].res == a[j + 1].res && a[j].num < a[j + 1].num)
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
for(i = N - 1; i >= 0; i --)
printf("%d %s %.1f\n",a[i].num,a[i].name,a[i].res);
return 0;
}
考试排名
试题名称 考试排名
时间限制: 1 秒
内存限制: 256KB
问题描述
某考试有5道题和1道附加题，每题最高得分20分，总分计算为所有题目分数之和。给出一组考生的数据，对其按照总分从高到低进行排名，总分相同时按附加题得分高者优先。
输入说明
第一行为一个整数N，表示考生个数（N小于100），后面N行为考生数据，每行包含考生姓名（长度不超过20个字符）以及6个以空格分隔的整数，分别表示第一题到第五题以及附加题的得分（最后一项）。
输出说明
输出排序结果，每行为一个考生的姓名、总分、附加题得分，以空格分开。
输入样例
3
Jony 18 20 20 20 20 20
Kavin 20 20 20 20 20 18
Kaku 15 15 15 15 15 15
输出样例
Jony 118 20
Kavin 118 18
Kaku 90 15
//考试排名
//考试有5道题，1道附加题，每题最高20分，
//总分为所有题目分数之和
# include <stdio.h>
struct student
{
char name[30];
int score[6];
int res;
}a[50],temp;
int main()
{
int N, i, j;
scanf("%d", &N);
for(i = 0; i < N; i ++)
{
scanf("%s %d %d %d %d %d %d", &a[i].name, &a[i].score[0], &a[i].score[1], &a[i].score[2], &a[i].score[3], &a[i].score[4], &a[i].score[5]);
a[i].res = (a[i].score[0] + a[i].score[1] + a[i].score[2]+ a[i].score[3] + a[i].score[4] + a[i].score[5]);
}
for(i = 0; i < N - 1; i ++)
for(j = 0; j < N - i - 1; j ++)
{
if(a[j].res > a[j + 1].res)
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
for(i = 0; i < N - 1; i ++)
for(j = 0; j < N - i - 1; j ++)
{
if(a[j].res == a[j + 1].res && a[j].score[5] > a[j + 1].score[5])
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
for(i = N - 1; i >= 0; i --)
printf("%s %d %d\n",a[i].name,a[i].res,a[i].score[5]);
return 0;
}
1327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
