母亲节手抄报内容-申东旭

1.
Hello world.

让我们用C语言向世界问好。
最早的程序基本是这个样子的：
程序一：
#include
void main()
{
printf(Hello world.n);
}
程序二：
#include
int main()
{
printf(Hello world.n);
return0;
}
#include
void main()
{
printf(
}


2. Welcome to Beijing.
让我们来练习如何显示多行文字。
#include
void main()
{
printf(
printf(
printf(
}


3. 求A+B
输入两个整数，求它们的和.

#include
void main()
{
int a,b;
int sum;

scanf(
sum=a+b;
printf(
}


4.
求 x 的 3次方

输入：一个整数。
输出：该整数的 3 次方值。

#include
void main()
{
int x;
int s;
scanf(
s=x*x*x;
printf(
}


5.
学习打印你的第一个图形

背景：
我们已经学习了printf函数，这里 给出了一个小程序，它运行的结果是输出一个由星号（*）
组成的4*4的正方形。
程序如下：
#include
void main()
{
printf(
printf(
printf(
printf(
}
要求：
按照上面的程序范例，编写一个小程序，要求输出的是 4 行由*号组成的等腰三角形。
#include
void main()
{
printf( *n
printf( ***n
printf(
printf(

}


6.
一年级的算术题

背景：
小明上小学一年级了，老师已经教会了他们进行整数的 +、-、*、、% 计算，下面老师
开始出题，给出一个简单的算术表达式，请小明给出计算结果。
输入：
接受两个整数，每个整数之间使用空格分隔。例如输入格式为：123 444
输出：
分别输出按照整型数据进行 +、-、*、、* 之后的运行结果。
#include
void main()
{
int a,b,c,d,e,f,g;
scanf(
c=a+b;
d=a-b;
e=a*b;
f=ab;
g=a%b;
printf(
printf(
printf(
printf(
printf(
system(
}


7.
求两个变量的最小值

输入：两个整型数
输出：两个整型值中的最小值
#include
void main()
{
int a,b,min;
scanf(
min=a>b?b:a;
printf(
system(
}

8. 判断三角形的形状
要求：
输入三角型的三条边，判断三角形的形状。假设输入的三边边长均>0。
输入：
三角型的3条边的长度（int型）。
输出：
等边三角形：equilateral triangle
等腰三角形：isoceles triangle
不构成三角形：non-triangle
一般三角形：triangle
#include
void main()
{
int a,b,c;
scanf(
if (a+b>c&&a+c>b&&b+c>a)
if (a==b&&b==c)
printf(
else if (a==b||a==c||b==c)
printf(
else
printf(
else
printf(
system(
}


9. 计算圆柱的侧面积及体积
如果已知圆柱的底面半径 r ，以及高 h ，则可计算出圆柱的侧面积 s=2πrh ，体积 v=π
r
2
h 。其中 π=3.1415926
输入
第一行输入圆柱的底面半径 r
第二行输入圆柱的高 h
输出
s=< 圆柱的侧面积 >,v=< 圆柱的体积 >
要求
1. 所有变量都定义为双精度类型
2. 结果精确到小数点后两位
#include

#define p 3.1415926
void main()
{
int r,h;
double s,v;
scanf(
s=p*2*r*h;
v=p*r*r*h;

printf(
system(
}


10. 计算时钟的夹角
背景：
钟面上的时针和分针之间的夹角总是在 0 ～180之间 ( 包括 0 和180 ) 。举例来说，
十二点的时候两针之间的夹角为 0 ，而在六点的时候夹角为180 ，在三点的时候为90 。
本题要解决的是计算 12:00 到 11:59 之间任意一个时间的夹角。
输入：
每组测试数据包含两个数字：第一个数字代表小时 ( 大于 0 小于等于 12) ，第二个数
字代表分 ( 在区间 [0, 59] 上 ) 。
输出：
对应每组测试数据，用常用格式显示时间以及这个时候时针和分针间的最小夹角，精确 到
小数点后一位。
#include
void main()
{
double s,f,j1,j2,j;
scanf(
j1=6*f;
j2=30*s+f*3060;
j=j1-j2;
j=j>=0?j:-j;
j=j>180?360-j:j;
printf(
printf(
system(
}


11. 找出最大素数

素数是指一个只能被1和它本身整除的数，在数论中占 有重要的研究地位，在当代密码学
中也被广泛应用。
输入：
取值范围
输出：
该范围内的最大素数
#include
#include
int main()
{
int i,m,n;
scanf(
for(i=1;i<=n;i++)
{
if(ss(i)==1)
m=i;
}
printf(
system(
return 0;
}

int ss(int a)
{
int i;
for(i=2;i<=a2;i++)
{
if(a%i==0)
{
return 0;
}
}
return 1;
}


12. 求最后3位数值
中学时我们就会求一个数的 n 次方了，但计算机不会，请你来编 写一个程序吧。由于计算
机比较“笨”，所以我们编写程序的功能不用太强，只要能算出 a 的 n 次方的最后 3 位数
就可以了。
输入：
a 和 n 的值。假设 a<=150 。
输出：

求 a 的 n 次方的最后 3 位数。
#include
#include
int main()
{
int n,i,j,a,k,m[300],q[300],p[3],g,s,b,f=3;
scanf(
b=a100;
s=(a%100)10;
g=a%10;
for(i=0;i<300;i++)
{
m[i]=0;
q[i]=0;
}
m[0]=g;m[1]=s;m[2]=b;p[0]=g;p[1]=s;p[2]=b;
for(i=1;i {
for(j=0;j<=2;j++)
{
for(k=0;k {
q[k+j]=q[k+j]+p[j]*m[k];
if(q[k+j]>=10)
{

q[k+j+1]=q[k+j+1]+q[k+j]10;

q[k+j]=q[k+j]%10;
}
}
}
f=f+2;
for(k=0;k {
m[k]=q[k];
q[k]=0;
}
}
if(n==0)
printf(
else
printf(
system(

return 0;
}


13.
贪吃的猴子

有一只猴子，第一天摘了若干个桃子 ，当即吃了一半，但还觉得不过瘾 ，就又多吃了一
个。第2天早上又将剩下的桃子吃掉一半，还是觉得不过瘾，就又多吃了两个。以后每
天早上都吃了前一天剩下的一半加天数个（例如，第5天吃了前一天剩下的一般加5个）。
到第 n天早上再想吃的时候，就只剩下一个桃子了。
输入：
天数n
输出：
第一天的桃子个数
#include
#include
int main()
{
int i,n,m,s;
scanf(
s=1;
for(i=n-1;i>0;i--)
{
s=(s+i)*2;
}
if(s==1)
printf(
else
printf(
system(
return 0;
}


14.
黑色星期五

在西方，星期五和数字13都代表着坏运气 ，两个不幸的个体最后结合成超级不幸的一天。
所以，不管哪个月的十三日又恰逢星期五就叫“黑色星期 五”。
输入：
年份
输出：
判断该年是否包含黑色星期五，如包含，给出具体日期
#include
int main(){

int a,b,i,j,k=0;
int moth[13]={0,13,44,72,103, 133,164,194,225,256,286,317,347};
int c[13];
for (i=1;i <= 12;i++)
c[i]=0;
scanf(
j=0;
if (a%4==0)
for (i=3;i<=12;i++)
moth[i]++;
if (a>=2006){
for (i=2006;i if (i%4==0)
j=j+ 366;
else
j=j+365;
for (i=1;i<=12;i++)
if ((j+moth[i]-13)%7==0){
c[i]=1;
k++;
}
}
else{
for (i=2006;i>a;i--)
if ((i-1)%4==0)
j=j+ 366;
else
j=j+365;
for (i=1;i<=12;i++)
if ((j-moth[i]+13)%7==0){
c[i]=1;
k++;
}
}
if (k!=1){
printf(
printf(
for (i=1;i<=12;i++)
if (c[i]==1)
printf(
}
else{
printf(
printf(

for (i=1;i<=12;i++)
if (c[i]==1)
printf(
}
}


15.
你会输出一行星号?

我们才开始上机，现在需要我们用最简单得办法，在一行中输出n个星号。
输入：
n值
输出：
一行中n个星号。
#include
#include
int main()
{
int i,n;
scanf(
for(i=0;i {
printf(
}
printf(
system(
return 0;
}


16. 计算SUM的值
已知公式：SUM = 1 + 12 + 13 + 14 + ... + 1n
输入：
n
输出：
达式 sum 的值。结果保留 6 位小数。
#include
int main()
{
int n;
double i,s=0;
scanf(
for(i=1;i<=n;i++)

{
s=s+1i;
}
printf(
#include
int cf(int m,int n)
{
int i,s=m;
for(i=1;i {
s=m*s;
}
if(n==0)
s=1;
return s;
}

int main()
{
int j,i,n,q,p,s,f=0,m;
scanf(
for(j=cf(10,n-1);j {















if(f==0)
printf(
system(
return 0;
}
system(
s=0;q=j;
for(i=n-1;i>=1;i--)
{
m=cf(10,i);
p=qm;
s=s+cf(p,n);
q=q%m;
}
s=s+cf(q,n);
if(s==j)
{
f=1;
printf(
}
}

return 0;
}


17.
寻找特殊整数

请编写一个程序寻找一种特殊整数：一个 n 位的正整数等于其各位数字的n次方之和。
例如：407=4×4×4+0×0×0+7×7×7。所以407就是一个特殊数。
输入：
正整数的位数n（n<=6）。
输出：
所有此n位特殊数。每个数占一行。若不存在符合条件的特殊数，则输出提示：“No output.”；
若存在，则从小到大进行输出。
说明：
假设输入为4，在4位 整数中，有3个4位的特殊数，则输出格式为（输出中的1111、2222和
9999并不是4位特殊 数，只是格式样例）：
1111
2222
9999

#include
#include
int cf(int m,int n)
{
int i,s=m;
for(i=1;i {
s=m*s;
}
if(n==0)
s=1;
return s;
}

int main()
{
int j,i,n,q,p,s,f=0,m;
scanf(
for(j=cf(10,n-1);j {
s=0;q=j;
for(i=n-1;i>=1;i--)

{
m=cf(10,i);
p=qm;
s=s+cf(p,n);
q=q%m;
}
s=s+cf(q,n);
if(s==j)
{
f=1;
printf(
}
}
if(f==0)
printf(
system(
return 0;
}


18. 空心的倒三角型
背景：
请根据要求打印可空心倒三角形。

输入：
输入三角形的高度（h >= 0）。

输出：
打印相应的空心倒三角形。图样参见测试用例。
#include
int main()
{
int i,j,n,f;
scanf(
for(i=1;i<=(2*n-1);i++)
{
printf(
}
printf(
j=1;
while(j!=n)
{

for(i=1;i<=j;i++)
{
printf(
}
printf(
f=2*n-3-2*j;
for(i=1;i<=f;i++)
{
printf(
}
if(j!=n-1)
{
printf(
}
else
printf(

j=j+1;
}
system(
return 0;
}


19. 空心字符菱形
输入：

菱型起始字母和菱形的高度。

输出：

参看测试用例，打印空心的由字符组成的菱形。

#include
int main()
{
char a;
int f,i,j,n;
scanf(
getchar();
scanf(
f=2*n-1;

if(n==1)
{
printf(
return 0;
}
for(i=1;i<=n-1;i++)
{
printf(
}
printf(
for(i=1;i<=n-2;i++)
{














a=a+1;
printf(
for(i=1;i<=f-2;i++)
{


printf(
for(i=1;i<=n-2;i++)
{









a=a+1;
for(j=1;j<=n-i-1;j++)
{
printf(
}
printf(
for(j=1;j<=2*i-1;j++)
{
printf(
}

printf(
}
printf(
}
a=a-1;
for(j=1;j<=i;j++)
{
printf(
}
printf(
for(j=1;j<=2*(n-i-1)-1;j++)
{

printf(
}

printf(
}
a=a-1;
for(i=1;i<=n-1;i++)
{
printf(
}
printf(
system(
return 0;
}


20. 空心梯形

输入行数 n 和首数字字符，在屏幕上输出由数字围起的高和下底宽度均 n 的空心梯形。
要求：输出的数字是循环的，即输出数字 9 后再输出的数字是 0。

输入：
行数n 和首字符

输出：
空心梯形

#include
int cc(int k)
{
if(k<=47)k=k+10;
else if(k>=58)k=k-10;
return k;
}

int main()
{
int q=1,i,n,f=0,j,m,k,p,c;
char a[70][70];
scanf(
m=2*n-1+4*(n-1);
k=c+48;
for(i=1;i<=n;i++)

{
for(j=1;j<=f;j++)
{
a[i][j]=32;
}
if(i==1)
{
for(j=f+1;j<=m2;j=j+2)
{
a[1][j]=k;
a[1][j+1]=32;
k=k+1;
k=cc(k);
}
if(n%2==0)
{
for(j;j<=m;j=j+2)
{
a[1][j]=a[1][j-2*q];
a[1][j+1]=32;
q=q+2;
}
}
else
{
a[1][m2+1]=cc(k);
for(j=m2+2;j<=m;j=j+2)
{
a[1][j+1]=a[1][j+1-4*q];
a[1][j]=32;
q=q+1;
}
}
}
else if(i!=n)
{
a[i][f+1]=cc(a[1][1]+i-1);
p=m-2*(f+1);
for(j=f+2;j<=p+f+1;j++)
{
a[i][j]=32;
}
a[i][m-f]=a[i][f+1];
}

else
{
for(j=f+1;j<=f+2*n-1;j=j+1)
{
a[i][j]=a[1][j];
}
}
f=f+2;
}
f=0;
for(i=1;i<=n;i++)
{
for(j=1;j<=m-f;j++)
{
printf(
}
printf(
f=f+2;
}
system(
return 0;
}


H1：计算通用产品代码(UPC)的校验位（选作）
背景
许多年来，货物生产商 都会把超市售卖的每件商品上放置一个条码。这种被称为通用产品代
码（Universal Product Code，缩写UPC）的条码可以识别生产商和产品。超市可以通过扫
描产品上的条 码来确定支付此项商品的费用。每一个条码由十二位数字构成，通常这些数字
会显示在条码下面。例如， 包装为26盎司的Morton牌碘化盐所用条码下的数字是：
0 24600 01003 0 < br>第一个数字表示商品的种类（0表示大部分的食品杂货，2表示需要称量的货品，3表示药
品或和 健康相关的商品，而5表示优惠券）。接下来的一组五位数字用来识别生产商。而
第二组五位数字则用来 区分产品类型（其中包括包装尺寸）。最后一位数字是“校验位”，它
可以帮助鉴别先前数字中的错误。 如果条码扫描出现错误，那么前十一位数字和最后一位数
字可能会不一致，而超市扫描机也会拒绝整个条 码。
下面是一种计算校验位的方法：首先把第一位、第三位、第五位、第七位、第九位和第十一
位数字相加。然后把第二位、第四位、第六位、第八位和第十位数字相加。接着把第一次加

法结果乘以3后再加上第二次加法的结果。随后，再把上述结果减去1。减法后的结果除以
10取余 数。最后，用9减去上一步骤中得到的余数。现在以Morton碘盐为例，第一组数字
的加法是0+4 +0+0+0+3=7，而第二组数字的加法是2+6+0+1+0=9。把第一组加法值乘以3
后再加 上第二组加法值得到的结果是30。再减去1，结果变为29。再把这个值除以10取
余数为9。9在减 去余数结果9，最终值为0。
输入
每次输入三行数据，第一行是UPC的第一位数字，第二 行是UPC的第一组五位数字，第
三行是UPC的第二组五位数字。
输出
UPC的校验位
提示
本题有隐藏测试用例。如果想多找不同的实例验证你的算法， 可以拿身边书或食品背后的条
码测试一下。
#include
int main()
{
int a[2],b[10],c[10],s1,s2,s,i;
char x[10],y[10];
scanf(
for(i=1;i<=5;i++)
{
scanf(
b[i]=x[i]-48;
}
getchar();
for(i=1;i<=5;i++)
{
scanf(
c[i]=y[i]-48;
}
s1=a[1]+b[2]+b[4]+c[1]+c[3]+c[5];
s2=b[1]+b[3]+b[5]+c[2]+c[4];
s=s1*3+s2-1;
s=9-s%10;
printf(
system(
return 0;
}

H2：数制转换（选作）

我们通常使用的都是十进制的数字，但其实在生活中也经常会使用其它进制。
这个题目会给 你两个不同的数字，它们不属于同一进制，要求你计算出当它们分别处于何种
进制之中时，两个数字相等 。譬如 12 和 5 ，在十进制下它们是不等的，但若 12 使用 3
进制而 5 使用六进制或十进制时，它们的值就是相等的。因此只要选择合适的进制， 12 和
5 就可以是相等的。
程序的输入是两个数字 M 和 N( 其十进制的值不超过 1000000000) ，它们的进制在
2~36 之间。对于十以下的数字，用 0~9 表示，而十以上的数字，则使用大写的 A~Z 表
示。
求出分别在 2~36 哪种进制下 M 和 N 相等。若相等则输出相应的进制，若不等则输出错
误信息。当然了，对于多种 可能成立的情况，找出符合要求的进制最小的一组就行了。信息
的格式见测试用例。
#include
#include

int c[50][50];
char b[50][50];
int lo[50];
int dev(int a,int b){
int i,j,k;
long long m,n;
k=1;
m=0;
n=0;
for (i=lo[1];i>=1;i--){
m+=k*c[i][1];
k*=a;
}
k=1;
for (i=lo[2];i>=1;i--){
n=n+k*c[i][2];
k*=b;
}
if (m==n)
return 1;
else
return 0;
}

int main(){
int i,j,k,ma[40],l,t=0;
char one;
one='a';
j=1;
i=1;
lo[1]=0;
lo[2]=0;
ma[2]=2;
ma[1]=2;
while (one!='n')
{
scanf(
if ((one >='0')&& (one<='9'))
{
b[i][j]=one;
c[i][j]=one-'0';
lo[j]++;
}
else
if ((one >='A')&& (one<='Z'))
{
b[i][j]=one;
c[i][j]=one -'A'+10;
lo[j]++;
}
else
if (t==0)
{
t=1;
j++;
i=1;
}
if (c[i][j]>=ma[j])
ma[j]=c[i][j]+1;
if (one != ' ')
i++;
}

for (i=ma[1];i<=36;i++)
for (j=ma[2];j<=36;j++)
if(dev(i,j))
{

for(l=1;l<=lo[1];l++)
printf(
printf(
for(l=1;l<=lo[2];l++)
printf(
printf(
system (
return 0;
}
for(l=1;l<=lo[1];l++)
printf(
printf(
for(l=1;l<=lo[2];l++)
printf(
printf(
system (
return 0;
}


21. 零钱换整钱
小明手中有一堆硬币，小红手中有若干张10元的整钱。已知 1 角的硬币厚度为 1.8mm，
5 角的硬币厚 1.5mm， 1 元的硬币为 2.0mm 。小明和小红一起玩游戏，小红拿出若干
张10元的纸币，小明要将 1 角的硬币放成一摞，将 5 角的硬币硬币放成一摞，将 1 元
的硬币放成一摞，如果 3 摞硬币一样高，并且金额能够正好小红要求的面值，则双方可以
进行交换，否则没有办法交换。
输入：
小红希望交换几张10元的纸币
输出：
1 角的数量,5 角的数量,1元的数量
#include
int main()
{
float i,j,k,n,m=0,f,s,x[5];
scanf(
for(i=0;i<=n*10;i++)
{

for(j=0;j<=n*10;j++)
{
x[1]=i*2.0;
x[2]=j*1.5;
if(x[1]==x[2])
{

for(k=0;k<=n*10;k++)
{

s=1.0*i+0.5*j+0.1*k;

x[3]=k*1.8;

if((s==n*10)&&(x[2]==x[3]))

{

printf(

m=1;

}
}
}
}
}
if(m==0)
printf(
system(
return 0;
}


22. 买东西

某商品有A、B、C三种品牌，各品牌的价格各不相同，其中A品牌的价格为每个5元， B
品牌为每个3元，而C品牌为每3个1元。如果要用 M 元钱买 N 个该商品，要求每个商
品至少买一个，编程求各种品牌各能买多少个。
输入：
先后输入M（钱数）及N（商品个数）的实际数值

输出：
所有可能 情况下可以购买的3种商品的个数，按A、B、C品牌的顺序输出，用逗号分隔。
例如：2,30,68 ；表示A品牌商品2个、B品牌商品30个、C品牌商品68个。
要求：因为有多个结果，结果的排序按照A品牌的个数从少到多的顺序输出。
#include
#include
int main()
{
int a,b,c,n,m,s;
scanf(
for(a=1;a<=n5;a++)
{
for(b=1;b<=m-a;b++)
{
c=m-a-b;
if(c%3==0)
{
s=a*5+b*3+c3;
if(s==n)
printf(
}
}
}
system(
return 0;
}


23 谁能出线
背景：

电视台举办“超级学生”才艺大赛，由于报名人数狂多，所以要先进行分组预赛。按规定，
每1 0名学生为一个预赛小组，评委打出分数（0~100分），各小组第一名可以进入下一轮；
如果有多名 学生得分相同都是第一名，则可同时进入下一轮。

输入：
按顺序给出一个小组10个人的最后得分（int）。

输出：
能够出线的学生序号（0~9）。
#include
#include

int main()
{
int i,j,a[10],m=0;
for(i=0;i<=9;i++)
{
scanf(
if(m<=a[i])m=a[i];
}
for(i=0;i<=9;i++)
{
if(m==a[i])
printf(
}
system(
return 0;
}


24. 寻找特殊偶数
背景
有一种特殊偶数，它每一位上的数字都两两不相同。我 们现在需要找出四位数中某一区间
内的这类偶数。

输入
所要寻找的四位 偶数的范围。每组输入有两个数字：第一个数字是最小范围；第二个数字
是最大范围。如果输入遇到0， 输入结束。

输出
列出此范围内的所有特殊偶数，并且列出此范围内特殊偶数的个数。

#include
#include
int main()
{
int n,m,i,j,f,k,a[5];
while(~scanf(
{

f=0;
for(i=n;i<=m;i++)
{
a[1]=i1000;
a[2]=(i%1000)100;

a[3]=(i%100)10;
a[4]=i%10;

if((a[1]!=a[2])&&(a[1]!=a[3])&&(a[1]!=a[4])&&( a[2]!=a[3])&&(a[2]!=a[4])&&(a[3]!=a[4])&&(
i%2= =0))
{

printf(

f=f+1;

}
}
if(f==0)printf(
else printf(
}
system(
return 0;
}


25.输出字母围起的正方形

输入N*N图形正方形的边长N，图形左上角的字母， 输出由字母围成的空心正方形。输出
的字母是顺时针连续的，且是循环的，即输出字母'Z'后输出字母 。注意在两个字母之
间有一个空格。
例如输入：
6 M
输出如下图形：
M N O P Q R
F S
E T
D U
C V
B A Z Y X W
#include
#include
int main()
{
char m,a[1000];
int l,n,i,j;
scanf(

scanf(
if(n==1)printf(
else
{
l=4*(n-1);a[1]=m;
for(i=2;i<=l;i++)
{
if((a[i-1]!=122)&&(a[i-1]!=90))a[i]=a[i-1]+1;
else if(a[i-1]==122)a[i]=97;
else a[i]=65;
}
printf(
for(i=2;i<=n;i++)
{
printf(
}
printf(
for(i=0;i<=n-3;i++)
{
printf(
for(j=1;j<=2*n-3;j++)
{
printf(
}
printf(
}
printf(
for(j=l-i-1;j>=n+i+1;j--)
{
printf(
}
printf(
}
system(
return 0;
}


H3：猜数字（选作）
有如下一组数字，其中每个数字都在 1 ~ 63 之间，

1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61

63
2 3 6 7 10 11 14 15 18 19 22 23 26 27 30 31 34 35 38 39 42 43 46 47 50 51 54 55 58 59 62
63
4 5 6 7 12 13 14 15 20 21 22 23 28 29 30 31 36 37 38 39 44 45 46 47 52 53 54 55 60 61 62
63
8 9 10 11 12 13 14 15 24 25 26 27 28 29 30 31 40 41 42 43 44 45 46 47 56 57 58 59 60 61 62
63
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
63
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
63
现在需要编写一个程序，当从键盘输入某数字在且仅在哪几 行出现了，该程序可以“猜”
出这个数字是几。

输入：
程序的输入是一串以空白符分开的数字，当输入 0 时表示输入结束。

输出：
输出猜到的数字。

#include
int main()
{
int
a[6][32]={1,3,5,7,9,1 1,13,15,17,19,21,23,25,27,29,31,33,35,37,39,41,43, 45,47,49,51,53,55,57,59,
61,63,

2,3,6,7,10,11,14,15,18,19,22,23,26,27,30,31,34 ,35,38,39,42,43,46,47,50,51,54,55,58,59,62,63,

4,5,6,7,12,13,14,15,20,2 1,22,23,28,29,30,31,36,37,38,39,44,45,46,47,52,53, 54,55,60,61,62,63,

8,9,1 0,11,12,13,14,15,24,25,26,27,28,29,30,31,40,41,42, 43,44,45,46,47,56,57,58,59,60,61,62,63,

16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,3 1,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,

32,33,34,35,36,37,3 8,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54, 55,56,57,58,59,60,61,62,6
3};
int i,f=0,n,b[32],k,j,c[6],l,m,p;
while(~scanf(
{
c[f]=n-1;
if(f==0)
{

for(i=0;i<32;i++)
{
b[i]=a[n-1][i];
}
}
else
{
for(i=0;i<32;i++)
{




if(b[i]==a[n-1][j])k=1;






for(i=0;i<6;i++)
{












if(b[l]==a[i][m])


b[l]=0;

}




k=0;
for(j=0;j<32;j++)
{

}
if(k==0)b[i]=0;
}
}
f=f+1;
}
p=0;
for(j=0;j{
if(i==c[j])p=1;
}
if(p==0)
{
for(l=0;l<32;l++)
{
for(m=0;m<32;m++)
{

{


}
}
}
}

for(i=0;i<32;i++)
{
if(b[i]!=0)
printf(
}
system(
return 0;
}


H4：小蜜蜂（选作）


一只小蜜蜂在 如下图所示的蜂窝上爬行。它爬行时，只能从一个格爬到相邻的大号格子中。
例如，从 1 号格子可以爬到 2 号或者 3 号格子，从 2 号则可以爬到 3 号或者 4 号格子。

请问从一个格子 a 爬到一个格子 b 一共有多少种可行的路线。
输入：
分别是起始点 a 和终止点 b 的编号。（ a 和 b 在 1~100 之间，且 a输出：

#include
int main()
{
int a[100][100],l[100],n,m,i,j,p;
scanf(
a[0][0]=1;a[1][0]=1;l[0]=1;l[1]=1;
for(i=2;i<100;i++)
{
for(j=0;j<100;j++)
{
a[i][j]=0;
}
}
for(i=1;i {
l[i+1]=l[i];

for(j=0;j {
if((a[i+1][j]+a[i-1][j]+a[i][j])<10)
{

a[i+1][j]=a[i+1][j]+a[i][j]+a[i-1][j];
}
else
{

a[i+1][j]=(a[i+1][j]+a[i-1][j]+a[i][j])-10;
a[i+1][j+1]=a[i+1][j+1]+1;
}
}
p=l[i];
if(a[i+1][p]==1)l[i+1]=l[i+1]+1;
}
for(j=l[m-n];j>0;j--)
{
printf(
}
printf(
system(
return 0;
}


H5 铺地板（选作）
背景：
你是一名室内装潢工程队的配料员。你的 伙伴们喜欢采用“之”字型的方式铺大理石地砖，图
案如下：
1
3
4
10
11
2
5
9
12
19
6
8
13
18
20
7
14
17
21
24
15
16
22
23
25
学了 C 语言以后，你决定编写一个程序，帮助你的同伴生成这样的图形。
输入：
方阵N的大小。
输出
方阵。

#include

int main()
{
int n,i,j,a[100][100],p;
scanf(
a[0][0]=1;a[0][1]=2;
for(i=2;i {
a[0][i]=a[0][i-1]+i*2;
a[0][i+1]=a[0][i]+1;
}
for(i=0;i {
if(a[0][i]<10)printf(
else printf(
}
if(a[0][n-1]>=10)printf(
else printf(
for(i=1;i {
for(j=0;j {
if(p==0)
{
a[i][j]=a[i-1][j+1]+1;
p=1;
}
else if(p==1)
{
a[i][j]=a[i-1][j+1]-1;
p=0;
}
if(a[i][j]<10)printf(
else printf(
}
if(n%2==1&&i%2==1)
{
a[i][n-1]=a[i-1][n-1]+1;
}
else if(n%2==1&&i%2==0)
{
a[i][n-1]=a[i-1][n-1]+2*(n-i);
}
else if(n%2==0&&i%2==0)
{

a[i][n-1]=a[i-1][n-1]+1;
}
else if(n%2==0&&i%2==1)
{
a[i][n-1]=a[i-1][n-1]+2*(n-i);
}
if(a[i][n-1]<10)printf(
else printf(
if(n%2==1)
{
if(p==1)p=0;
else p=1;
}
}
system(
return 0;
}
H6 晕（选作）
成绩: 5 折扣: 0.8
看着这样的“回”形图案你晕吗？
让我们不用数组，来做出它。
输入：
n。正方形的边长
输出：
边长为 n 的数字回形方阵。
#include
#include
void main()
{
char s[1000],t[1000],u[1000];
int i=0,j=0,n=0,m,x,y;
gets(s);
gets(t);
x=strlen(s);y=strlen(t);
while(n {
if(i==x)
{

for(;j u[n]=t[j];

}




break;
}
if(j==y)
{

for(;i u[n]=s[i];
break;
}
if(s[i]>t[j])
{
u[n]=t[j];
j++;
n++;
}
else
{
u[n]=s[i];
i++;
n++;
}

}
for(i=0;i printf(
printf(
H7 子数整除（选作）
成绩: 5 折扣: 0.8
对于一个五位数a1a2a3a4a5，可将其拆分为三个子数：



sub1=a1a2a3
sub2=a2a3a4
sub3=a3a4a5
例如，五位数20207可以拆分成：



sub1=202
sub2=020（=20）
sub3=207

现在给定一个正整数K，要求你编程求出10000到3 0000之间所有满足下述条件的五位数，
条件是这些五位数的三个子数sub1、sub2、sub3 都可被K整除。
输出时请按照由小到大的顺序排列（每行输出一个数）。

#include
void main()
{
char s[1000],t[1000],u[1000];
int i,j,k=0,n=0;
gets(s);
gets(t);
for(i=0;s[i]!='0';i++)
{
k=0;
for(j=0;t[j]!='0';j++)
{
if(s[i]==t[j])
{k=1;break;}
}
if(k==0)
{
u[n]=s[i];
n++;
}
}
for(j=0;j printf(
printf(
}
H8 邮票组合（选作）
成绩: 5 折扣: 0.9
背景：

我们寄信都要贴邮票，在邮局有一些小面 值的邮票，通过这些小面值邮票中的一张或
几张的组合，可以满足不同邮件的不同的邮资。
现在，邮局有4种不同面值的邮票。在每个信封上最多能贴5张邮票，面值可相同，
可不同。
输入：

四种邮票的面值。
输出：

用这四种面值组成的邮资最大的从1开始的一个连续的区间。

说明：

如结果为10，则表明使用4张邮票可组合出1、2、3、4、5、6、7、8、9、10这些
邮资。
名词解释：
邮资：就是你寄东西需要花多少钱。
邮票面额：是由国家发行的具有固定价格的花纸片，被称为邮票。
如果你寄东西，邮局称了重量，告诉 你要240分。这样你就要贴邮票了。如果现在邮局的
邮票有面值为80分、50分、20分和10分的 四种，你就可以采用不同的组合得到240的
邮资，例如：采用3张80分的可以凑出240分；或者2 4张10分的凑起来240分也可以。
显然不同邮票的组合都可以得到同样一种邮资。
#include
#include
void main()
{
char s[5][100],t[100];
int i,j,k,a;
for(i=0;i<5;i++)
gets(s[i]);
for(i=0;i<4;i++)
{
for(j=i+1;j<5;j++)
{
a=strcmp(s[i],s[j]);
if(a<0)
{
strcpy(t,s[i]);
strcpy(s[i],s[j]);
strcpy(s[j],t);
}
}
}
for(i=0;i<5;i++)
printf(
}


H9 撞球(选做)
成绩: 5 折扣: 0.8
一天，丁俊晖编一整天的程序 ，突然觉得累了，于是便决定在房间内四处走走。他的房间是
矩形的，他从电脑开始随便选了一个角度开 始行走。由于职业习 惯，丁俊晖走路始终是直
线，而且碰到墙以后会反弹，入射角度与出射角度完全相 同。丁俊晖会一直行走，直到灵感

再次迸发。假设他的行走速度是匀速的，现在， 丁俊晖的母亲想知道他一共休息了多长时
间以便提醒他继续工作。
丁俊晖想考考他的母亲， 于是他记录了自己碰到墙壁的序列并且告诉了她，你有没有办法能
够帮助她计算出小丁所走的路程？
输入

输入包括多个测试用例，每个测试用例如下：
第一行包含两个数字 w, l(0第二行包括两个数字 x0, y0，代表电脑的位置坐标 (x0, y0)；
第三行包含两个数字 x1, y1，代表丁俊晖的位置坐标 (x1, y1)；
最后一行是一个包含'F', 'B', 'L', 'R'四种字符的字符串，分别代表墙在前面、后面、左边或是
右边，字符串的长度小于等于 1000；
我们约定，左上角的坐标为0,0，所有的坐标都是浮点型数字。

输出

一个浮点型数字，代表总路程，结果精确到小数点后 4 位。
#include
void main()
{
int n,m,a[100],b[100],i,j,s=0,k=1,t;
scanf(
for(i=0;i scanf(
for(i=0;i scanf(

}


for(i=0;i{
for(j=i+1;j {
if(a[i]>a[j])
{t=a[i];a[i]=a[j];a[j]=t;}
}
}
for(i=0;i{
for(j=i+1;j {
if(b[i]>b[j])
{t=b[i];b[i]=b[j];b[j]=t;}
}
}
if(b[m-1] printf(
else
{
for(i=j=0;i {
if(b[j]>=a[i])
s=s+b[j],i++;
}
printf(
}

H10. 整数问题(选做)
成绩: 5 折扣: 0.8
请求输出满足以下条件的n位正整数的个数：
要求该n位整数的从高位开始前1位可 以被1整除，该n位整数前2位可以被2*2整除，
该整数前3位可以被3*3整除，该整数前4位可以 被4*4整除……。即该整数前k位都可
被k平方整除。
例如：n=1，则符合条件的1位正 整数为1～9，输出答案9。n=2，符合条件的正整数为：
12, 16, 20, 24, 28, 32, 36, 40, 44, 48， 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96，则
输出答案22。当n=4时，2432就是一个符合题意的 整数。第一位2可以被1整除；前2
为24可以被4整除；前3位243可以被9整除；整个4位243 2可以被16整除。
输入：
n(0<=n<9)

输出：
符合该条件的n位正整数的数量
（本题目为软件学院2007年保研学生初试上机试题。本题可以不用数组）
#include
int sum(int n,int m)
{
int r;
if(n==m) r=m;
else
r=n+sum(n+1,m);
return(r);
}
void main()
{
int n,m,s;
scanf(
s=sum(n,m);
printf(
}

26 二年级小学生的题目
成绩: 10 折扣: 0.8
两个二年级 小朋友在一起玩游戏，小明给出一堆不超过两位的正整数和运算要求（+、-、
*、、%），小丽要找出 这些整数中的最大值和最小值，然后按照小明的要求算出最大数与
最小数进行算术运算的结果。
输入：
用逗号分隔的不超过两位的正整数序列，及其运算符和等号
输出：
最大数 op 最小数=结果
#include
#include
#include
void main()
{
char s[100],t[100],ch;
int n,i,y=0,k;
scanf(
for(i=0;i<100;i++)
t[i]='0';
k=strlen(s);
if(n>=0)
{

}



t[0]=s[0];
t[n+1]='.';
for(i=2;i {
if(i<=n+1)
t[i-1]=s[i];
if(i>=n+2)
t[i]=s[i];
}
}
else
{
y=n;t[1]='.';t[1-n]=s[0];
for(i=2;i t[i-n]=s[i];
}
for(i=0;i<=abs(n)+9+y;i++)
printf(
printf(
27 等值数列段
成绩: 10 折扣: 0.8
如果一个数列中的某一段（至少有两个元素）的各元素值均相同，则称之为等值数列段。等
值数 列段中元素的个数叫做等值数列段的长度。
输入：
由N个元素组成的整数数列A（其中N<=50)
输出：
A中长度最大的所有等值数列段的始末位置，如果没有等值数列段，则输出No equal
number list.
说明：
始末位置是指数组下标，即0表示第一个元素。
如果有多个同等长度的等值数列，只输出第一个等值数列的起始位置。
当在一个LIST中出现两个等长的连续串的时候，我们的答案应该是第一个等长串。
#include
void func(int n)
{
int k=0,i;
for(i=2;i<=n-1;i++)
{
if(n%i==0)

{
printf(
k=1;
break;
}
}
if(k==0)
printf(
else
func(ni);
}
void main()
{
int n;
scanf(
func(n);
}

28 大家一起做游戏
成绩: 15 折扣: 0.8
幼儿园的小朋友们刚学习了如何数数，阿姨在下课时组织大家一起玩游戏。规则如下：所有的小朋友绕成一圈，顺序排号，从第一个小朋友开始报数，凡是报到固定数字（例如5）的，
都退出 该游戏，直到只剩下一位小朋友游戏才中止。
每个小朋友都希望自己能有更多的练习数数的机会，所以都希望成为最终被留下的那位。
现在 ，请大家帮小朋友们计算一下，在第一次排号的时候排到第几位才能成为最终被留下的
小朋友。
输入：
小朋友的个数（<=50）要被练习的数字
输出：
最终被留下的小朋友的序号
说明：
如“要被练习的数字”是5，则每次数到5的同学要退出该游戏
时间限制内存限制额外进程

64M

0


测试用例
2
测试输入
1. 4 3↵
期待的输出
1. The left child is NO 1.↵
1秒
#include
#define N 60

void main()
{
inti , x , number , circle , count , a[N]
scanf(
for( count = 0 count < number count++ )
a[count] = 1
for( count = i = x = 0 x < number-1 i++ )
{
if ( i>= number )
i = 0
if ( a[i] == 1 )
count++
else continue;
if ( count % circle == 0 )
{
a[i] = 0
x++
}
}
for(i = 0 a[i] == 0 i++ )

printf(
}

29 组成最大数
成绩: 10 折扣: 0.8
任意输入一个自然数，输出该自然数的各位数字组成的最大数。例如，输入 1593 ，则输
出为 9531 。
输入：自然数 n
输出：各位数字组成的最大数

测试用例 1
测试输入
1. 1593↵
期待的输出
1. 9531↵
时间限制
1秒
内存限制
64M
额外进程
0

#include
#include
#define N 10000
void main()

{



















}


char a[N];
inti,j,p,t,lenth;
scanf(
lenth=strlen(a);
for(i=0;i{
p=i;
for(j=i+1;j if(a[p]>a[j]) p=j;
if(p!=i)
{
t=a[p];
a[p]=a[i];
a[i]=t;
}
}
for(i=lenth-1;i>=0;i--)
printf(
printf(
30 删除重复字符
成绩: 5 折扣: 0.8
背景：
输入一个长度不超过 100 的字符串，删除串中的重复字符。
输入：

输入要检查的字符串，长度不超过100个字符。例如：abacaeedabcdcd。
输出：

删除重复字符后的字符串。例如：abced。
时间内存额外
限制限制进程

测试输入 期待的输出

测试
用例
1
测试
用例
2
测试
用例
3
1. abacaeedabcdcd↵ 1. abced↵

1秒
64M 0
1. 4455577yuyuyu↵ 1. 123457yu↵
1秒
64M 0
1. 111↵ 1. 1↵
1秒
64M 0
#include
#include
#define N 100
void main()
{
char a[N];
inti,j,lenth;
scanf(
lenth=strlen(a);
for(i=1;i {
for(j=0;j if(a[i]==a[j]) a[i]='0';
}
for(i=0;i if(a[i]!='0') printf(
printf(
}

H11：五年级小学生的题目（选做）
成绩: 5 折扣: 0.8
那两个小朋 友在不断进步，他们已经学会了负数和多位数，于是他们又开始进行游戏了。小
明给出一堆整数和运算要 求（+、-、*、、%），小丽要找出这些整数中的最大值和最小值，
然后按照小明的要求算出最大数与 最小数进行算术运算的结果。
输入：
用逗号分隔的整数序列，及其运算符和等号
输出：
最大数 op 最小数=结果

说明：本题目应该可以不使用数组就可以完成，关键是如何处理负数和减法。
时间限内存限额外进

测试用
例 1
测试用
例 2
测试用
例 3
测试输入 期待的输出
制 制
64M
64M
程
0
0

1. 1,10,100,+,=↵ 1. 100 + 1 = 101↵
1秒
1. 100 + (-100) =
1秒
0↵
1. 20 * (-20) =
-400↵
1秒
1. -100,-1,1,100,+,=↵
1. -20,-10,0,10,20,*,=↵
64M 0


#include
#define N 100
void main()
{
char a[N],b[N];
int i,j,k,p,t,e,flag1,flag2,num[N];
for(i=0,flag2=1; flag2 i++ )
{
for( e=1,num[i]=0,flag1=1; flag1; )
{
scanf(
if(a[i] == '=') {flag1=0;flag2=0;}
else if(a[i] == '-') {e=-1,b[i]=a[i];}
else if(a[i] == ',') {num[i]*=e;flag1=0;}
else {num[i]=num[i]*10+a[i]-'0',b[i]=a[i];}
}
}
for(j=0;j {
p=j;
for(k=j+1;k if(num[p] if(p!=j)
{
t=num[p];
num[p]=num[j];
num[j]=t;
}
}

switch (b[i-2])
{
case '+': t=num[0]+num[i-3];break;
case '-': t=num[0]-num[i-3];break;
case '*': t=num[0]*num[i-3];break;
case '': t=num[0]num[i-3];break;
case '%': t=num[0]%num[i-3];break;
}
if( num[i-3]>=0 ) printf(
else if ( num[i-3]<0 &&num[0]>=0 ) printf(%c (%d)
num[0],b[i-2],num[i-3],t);
elseprintf(
}



= %dn
H12：扫雷（选做）
成绩: 5 折扣: 0.8
背景
你玩 儿过扫雷游戏吧？有个操作系统中带了这个小游戏，那个系统叫什么来着？在游戏
中要想过关，就必须要 在一个NxM的区域上找出所有的地雷。游戏过程中，计算机会在地
图上显示一些数字从而帮助你确定哪 里有地雷。例如，在下面这个有两颗地雷的 4x4 的地
图（*表示地雷）：
*...
....
.*..
....
根据上面的地图，可以计算出应该提供给游戏者的数字如下所示：
*100
2210
1*10
1110
每个数字表示了该方格周围到底有几个地雷，当然，一个方格周围最多的时候只会有八个。
输入

输入中将包括一系列的地图，每个地图的第一行有两个整数 n 和 m（0 它们表示了地图的行数和列数。下面的 n 行每行都有 m 个字符，其中 表示安全而
表示地雷。如果地图的 n 和 m 都为 0，则表示输入结束。
输出
针对每一个地图，首先输出一行：
Field #x:
其中 x 是当前地图的编号（从 1 开始）。下面的 n 行则将地图中的 以数字表示，该
数字表示该方格周围有多少颗地雷。
来源
http:

测试输入
1. 4 4↵
2. *...↵
3. ....↵
4. .*..↵
5. ....↵
6. 3 5↵
7. **...↵
8. .....↵
9. .*...↵
10. 0 0↵
1.
2.
3.
4.
5.
6.
7.
8.
9.
3 3↵
...↵
...↵
...↵
3 3↵
***↵
***↵
***↵
0 0↵
期待的输出 时间限制
1秒
内存限制
64M
额外进程
0

测试用例 1
1. Field #1:↵
2. *100↵
3. 2210↵
4. 1*10↵
5. 1110↵
6. ↵
7. Field #2:↵
8. **100↵
9. 33200↵
10. 1*100↵
1.
2.
3.
4.
5.
6.
7.
8.
9.
Field #1:↵
000↵
000↵
000↵
↵
Field #2:↵
***↵
***↵
***↵
1秒
64M 0
测试用例 2
#include
#define N 110
void main()
{
char a[N][N];
intn,m,t,i,j,k=1;
staticint b[N][N];

for(n=m=1; n!=0 && m!=0; )
{
for(i=0;i {
for(j=0;j b[i][j]=0;
}
scanf(
for(t=n;t>0;t--)
scanf(
for(i=0;i {
for(j=0;j {
if(a[i][j]=='*')
{

b[i][j]++;b[i+1][j]++;b[i+2][j]++;b[i][j+1]++ ;b[i+2][j+1]++;b[i][j+2]++;b[i+1][j+2]++;b[i+2
][j+2]++;
}
}
}
if(n!=0&&k>1) {printf(
else if(n!=0) {printf(
for(i=0;i {
for(j=0;j {
if(a[i][j]=='*') printf(
else printf(
}
}
}
}
31 合并字符串
成绩: 10 折扣: 0.8
输入两个已经按 从小到大顺序排列好的字符串，编写一个合并两个字符串的函数，使合并后
的字符串，仍然是从小到大排 列。

输入：

两个已经排好顺序（升序）的两个字符串
输出：

一个合并在一起的有序（升序）的字符串
要求：
设计一个效率尽量高的算法，对每个字符串只扫描一遍就可以了。
如果采用先进行串连接，然后再进行排序的算法，则效率太低了。
时间限制内存限制额外进程

1秒
64M

0


测试用例
1
测试用例
2
测试用例
3
测试用例
4
测试用例
5
测试用例
6
测试输入 期待的输出
1. abcdef↵
2. bcefghi↵
1. 123456↵
2. 789↵
1. 789↵
2. 12345↵
1. 123456↵
2. 123456↵
1. 123456↵
2. ↵
1. ↵
2. 123456↵
1. abbccdeeffghi↵
1. 123456789↵
1秒
64M 0
1. 12345789↵
1秒
64M 0
1. 6↵
1秒
64M 0
1. 123456↵
1秒
64M 0
1. 123456↵
1秒
64M 0
#include
#include
main()
{
inti,j,m,len;
char a[100]={'0'};
char b[100]={'0'};
gets(a);
gets(b);

strcat(a,b);

len=strlen(a);
for(i=1;i {
for(j=0;j {
if(a[j]>a[j+1])
{
m=a[j];
a[j]=a[j+1];
a[j+1]=m;
}
}
}
puts(a);
system(
}


32 串的减法
成绩: 10 折扣: 0.8
输入字符串s和t（串长不超过80个字符）， 将在字符串s中出现，但未在字符串t中出现
的字符组成一个新的字符串放在u中，u中字符按原字符串 中字符顺序排列，不去掉重复字
符，输出u。
例如：当s=，t=时，u=。
输入：
第一行为串s
第二行为串t
输出：
串u

测试输入 期待的输出
1. 1135↵
时间限制
1秒
内存限制
64M
额外进程
0

测试用例 1
1. 112345↵
2. 2467↵


#include
#define N 100

void main()
{
char s[N],t[N],u[N];
inti,j,k=0,flag;
gets(s);
gets(t);
for(i=0,flag=1 s[i]!='0' i++ )
{
for( j=0,flag=1 t[j]!='0' && flag j++ )
if( s[i]==t[j] ) flag=0;
if( flag )
{
u[k]=s[i];
k++;
}
}
for(i=0;i printf(
printf(
}

33 单词排序
成绩: 10 折扣: 0.8
输入 5 个单词，将它们按从大到小的顺序排列后输出。
输入：

5个单词
输出：

排序后的顺序

测试输入 期待的输出
以文本方式显示
1.
2.
3.
4.
Pascal↵
Fortran↵
C++↵
C↵
时间限制
1秒
内存限制
64M
额外进程
0

以文本方式显示
1.
2.
3.
4.
BASIC↵
C++↵
Pascal↵
C↵
测试用例 1

5. Fortran↵ 5. BASIC↵

#include
#include
main()
{
char w[5][20],a[20];
int i,j;
for(i=0;i<5;i++)
gets(w[i]); *用一维数组读串的方式生成二维数组*
for(i=0;i<4;i++)
for(j=i;j<5;j++)
if(strcmp(w[i],w[j])<0) *用字符串比较函数判断*
{ *冒泡法排序：直接交换*
strcpy(a,w[j]);
strcpy(w[j],w[i]);
strcpy(w[i],a);
}
for(i=0;i<5;i++)
puts(w[i]); *用一维数组写串的方式输出二维数组*
}


34 北理工的恶龙
成绩: 10 折扣: 0.8
背景：
最近，北理工出现了一只恶龙，它长着很多头，而且还会吐火，它将会把北理工烧成废墟，
于 是，校长下令召集全校所有勇士杀死这只恶龙。要杀死这只龙，必须把它所有的头都砍掉，
每个勇士只能 砍一个龙头，龙的每个头大小都不一样，一个勇士只有在身高不小于龙头的直
径的情况下才能砍下它。而 且勇士们要求，砍下一个龙头必须得到和自己身高厘米数一样的
学分。校长想花 最少的学分数杀死恶龙，于是找到你寻求帮助。
输入：
第一行 龙头数 n , 勇士人数 m （ 1<=n, m<=100 ） 接下来 n 行，每行包含一个整数，
表示龙头的直径 接下来 m 行，每行包含一个整数，表示勇士的身高 l
输出：
如果勇士们能完成任务，输出校长需要花的最小费用；否则输 出 “ bit is doomed! ”
时间限制

1秒
64M
内存限制

0
额外进程


测试输入 期待的输出
测试用例 以文本方式显示 以文本方式显示

1
1.
2.
3.
4.
5.
6.
2 3↵
5↵
4↵
7↵
8↵
4↵
1. 11↵
以文本方式显示
1.
2.
3.
4.
2 1↵
5↵
5↵
10↵
以文本方式显示
1. bit is doomed!↵
1秒
64M 0
测试用例
2

#include
#define M 100
void sort(int a[],int n)
{
int i,j,p;
for(i=0;i for(j=0;j {
if(a[j]>a[j+1])
{
p=a[j];
a[j]=a[j+1];
a[j+1]=p;
}
}
}
void main ( )
{
int n, m, i, j, k;
int cavalier[M],dragon[M];
long result=0;
scanf(
for(k=0;k scanf(
for(k=0;k scanf(
sort(dragon,n);
sort(cavalier,m);

for(i=j=0;i {
if(cavalier[i]>=dragon[j])
{
result+=cavalier[i];
i++;
j++;
}
else i++;
}
if (j==n)
printf(
else printf(
}



35 杀鸡用牛刀——要用递归啊！
成绩: 5 折扣: 0.8
背景：
哈哈！我们终于学了递归了，现在大家一定感到非常有意思吧，那个典型的“ 汉诺塔”问题，
一个非常短的程序居然可以完成如此复杂的工作，真是神奇啊！来吧，让我们也动手编写 一
个递归程序，当然，我们要编写的不可能太复杂。
功能：

求整数 n 到 m 区间的累加和，其中n<=m。
输入：

区间的起始点n 区间的终止点m
输出：

累加和
要求：

使用递归算法完成。如此简单的题目当然要有隐含的测试用例啦，就3个，看看谁能猜出
来。
时间限制内存限制额外进程


测试输入 期待的输出

以文本方式显示
测试用
例 1
1. 1 10↵
以文本方式显示
1. The sum from 1 to 10 is
55.↵
以文本方式显示
1. The sum from 10 to 15 is
75.↵
1秒
64M 0
以文本方式显示
测试用
例 2 1. 10 15↵
1秒
64M 0

#include
int sum(int n,int m)
{
return n==m?n:sum(n,m-1)+m;
}
int main()
{ int n,m;
scanf(
printf(
return 0;
}




【未按时提交，找的别的程序】H13：安全的密码（选做）
成绩: 5 折扣: 0.8
随着电子设备的广泛运用，密码也渐渐融入每个人的生活。保护好密码，不仅关系到个人隐私，更关系到个人的财产和安全。一个安全的密码，最好由大小写字母、数字或符号组成。包含越多种类的字
符，其安全性就越高。同时密码还需要有一定的长度，通常至少要由六个以上的字符组成。
并不是每个 人都喜欢这样复杂的密码，很多人在设置密码的时候，喜欢使用自己的名字或者生日，但
这是很大的安全 隐患。
任务
林晓炜正在设计一个网络交易系统，为了保证用户的密码安全，他需要一个程序 ，判断用户自己设置
的密码是否安全，如果不安全，则给出提示。现在他向你求助，请你帮忙设计一个程 序来解决这个问
题。
应当按照以下的规则来判断密码是否安全：
1. 如果密码长度小于 6 位，则不安全

2. 如果组成密码的字符只有一类，则不安全
3. 如果组成密码的字符有两类，则为中度安全
4. 如果组成密码的字符有三类或以上，则为安全
通常，可以认为数字、大写字母、小写字母和其它符号为四类不同的字符。
输入
输入的第一行是一个整数 N，表明后面有多少组密码。随后的 N 行输入包括 N 个密码，每个密码
的长度均小于 20 个字符。
输出
针对每一个密码判断并输出它是否安全。对于不安全的密码输出 ，对于中度安全的密码输
出 ，对于安全的密码输出
输入样例
4
1234
abcdef
ABC123
1#c3Gh
输出样例
Not Safe
Not Safe
Medium
Safe Safe
时间限内存限额外进

测试输入 期待的输出
制 制 程
以文本方式显示

1. 10↵
2. abcDEF↵
测试
用例
1
3. ABC↵
4. qw↵
5. `↵
6. ABCDEFGHIJKLMNOPQRST↵
7. 123456789↵
8. 1aB↵
9. 1 B↵
10. a X ↵
以文本方式显示

1. Medium Safe↵
2. Not Safe↵
3. Not Safe↵
4. Not Safe↵
5. Not Safe↵
6. Not Safe↵
7. Safe↵
8. Not Safe↵
9. Safe↵
1秒 64M 0

11. qwe123%^&ABC↵ 10. Safe↵


#include
#include
int main()
{
int time;
char s[ 100 ];
char * p;
int shu,dazimu,xiaozimu,qita;
scanf(
for(;time>0;time--){
gets(s);
p = s;
if(strlen(s)<6)printf(
else {
shu=dazimu=xiaozimu=qita=0;
while(*p){
if(*p>='0'&&*p<='9')shu=1;
else if(*p>='A'&&*p<='Z')dazimu=1;
else if(*p>='a'&&*p<='z')xiaozimu=1;
else qita=1;
p++;
}
switch(shu+dazimu+xiaozimu+qita){
case 1:printf(只有一种字符
case 2:printf(有两种字符
default:printf(种字符及以上
}
}
}
return 0;
}




【未按时提交，找的别的程序】H14：身份证的奥秘（选做）
成绩: 5 折扣: 0.8
背景

18位身份证标准 在国家质量技术监督局于1999年7月1日实施的GB11643-1999《公民身份号码》
中做了 明确的规定。 GB11643-1999《公民身份号码》为GB11643-1989《社会保障号码》的修 订
版，其中指出将原标准名称社会保障号码更名为公民身份号码，另外GB11643-1999《公民 身份
号码》从实施之日起代替GB11643-1989。GB11643-1999《公民身份号码》 主要内容如下：
一、范围
该标准规定了公民身份号码的编码对象、号码的结构和表现形 式，使每个编码对象获得一个唯一的、
不变的法定号码。
二、编码对象
公民身份号码的编码对象是具有中华人民共和国国籍的公民。
三、号码的结构和表示形式
1、号码的结构
公民身份号码是特征组合码，由十七位数字本体码和一位校验码组成。排列 顺序从左至右依次为：六
位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。
2、地址码
表示编码对象常住户口所在县(市、旗、区)的行政区划代码，按GBT2260的规定执行。
3、出生日期码
表示编码对象出生的年、月、日，按GBT7408的规定执行，年、月、日代码之间不用分隔符。
4、顺序码
表示在同一地址码所标识的区域范围内，对同年、同月、同日出生的人编定的顺 序号，顺序码的奇数
分配给男性，偶数分配给女性。
5、校验码
（1）十七位数字本体码加权求和公式
S = Sum(Ai * Wi), i = 0, ... , 16 ，先对前17位数字的权求和
Ai: 表示第i位置上的身份证号码数字值
Wi: 表示第i位置上的加权因子
Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2

（2）计算模
Y = mod(S, 11)
（3）通过模得到对应的校验码
Y: 0 1 2 3 4 5 6 7 8 9 10
校验码: 1 0 X 9 8 7 6 5 4 3 2
四、举例如下：
北京市朝阳区: 11002X
广东省汕头市: 440014
15位的身份证号升级办法：
15位的身份证号：dddddd yymmdd xx p
18位的身份证号：dddddd yyyymmdd xx p y




其中dddddd为地址码（省地县三级）
yyyymmdd yymmdd 为出生年月日
xx顺号类编码
p性别
15 位的 yy 年升为 18 位后，变成 19yy年，但对于百岁以上老人， 则为 18yy 年，此时，他们的
最后三位顺序码为996, 997, 998 或 999 来标记。
输入

输入n组身份证号码，第一行为个数，以后每行为身份证号码。
输出

如果输入的身份证号码为15位，则将其升级为18位后显示输出；否则判断 其是否为合法身份证号，
并逐行输出。
时间内存额外

测试输入
以文本方式显示
测试
用例
1
1. 4↵
2. 350331↵
3. 11002X↵
4. 112↵
期待的输出
限制限制进程

以文本方式显示
1. Invalid↵
2. Valid↵
3. 11002X↵

1秒 64M 0

5. 116↵ 4. 119965↵


#include
#include
char y[11]={'1','0','X','9','8','7','6','5','4 ','3','2'};
int flag=0,w[17]={7,9,10,5,8,4, 2,1,6,3,7,9,10,5,8,4,2};

char jiaoyan(char s[]) 放回校验位
{
int sum=0,j=0,i=0;
for(i=0;j<17;i++,j++)
{
if(s[15]=='0'&&i==6)j+=2;
sum+=(s[i]-48)*w[j];
}
if(s[15]=='0')
{
if(flag)return y[(sum+10)%11];
else return y[(sum+11)%11];
}
else return y[sum%11];
}
int main()
{
int a,i;
scanf(
for(;a>0;a--)
{
char s[25];
flag=0;
gets(s);
if(strlen(s)!=15&&strlen(s)!=18)
{ printf(
if(s[15]=='0') 15位身份证升级
{
if(s[12]=='9'&&s[13]=='9'&&s[14]>='6'&&s[14]<='9')
flag=1;
for(i=0;i<15;i++)
{
if(i==6)printf(
printf(
}

printf(
}
else 18位身份证升级
{
if(s[17]==jiaoyan(s))printf(
else printf(
}
}
return 0;
}



36 科学记数法
成绩: 10 折扣: 0.8
对于非常大或者非常小的数据，我们通常用科学记数法来表 示。例如在科技文献和电脑中经
常遇到的 2.3×10
6
（计算机中的科学记数法表示为：2.3E6），或者 9.18×10
-5
（科学记
树法表示：9.18E-5）这种类型的数据。
输入：
用科学记数法表示的数据。即为符合C语言表示的科学记数法表示。
输出：
该数据的双精度表示
说明：
输入数据的精度不高于小数点后50位。
输入数据时，在实数和幂之间有空格进行分隔，空格个数不定。
结果保留到小数点后8位，如不足8位用0补足，超过8位则截断，不进行四舍五入的处
理。
时额
内
间外
存
限进
限
制程
制

以文本方式显示
测试用例 1
1. 1.2345 E 3↵
以文本方式显示
1. 1234.50000000↵



测试输入 期待的输出
1640
秒
M

以文本方式显示
测试用例 2
1. 1.2345 e-3↵
以文本方式显示
1. 2.234567891234
5678912345678
9 e 20↵
以文本方式显示
测试用例 4
1. 1 E 0↵
以文本方式显示
测试用例 6 1. 2.234567890123
4567890 E 1↵
以文本方式显示
1. 0.00123450↵
1640
秒
M


以文本方式显示
1. 2234567893.4567
8900↵
1640
秒
M


测试用例 3
以文本方式显示
1. 1.00000000↵
1640
秒
M


以文本方式显示
1. 22.34567890↵
1640
秒
M



#include
int main()
{
int p=-1,n,i=0,j,sign=0,flag=0;char c,s[100];
while(scanf(
if(c=='.')p=i-1;
else if(c<='9'&&c>='0')s[i]=c,i++;
else if(c=='-')sign=1;
else if(p<0)p=i-1;
for(j=i;j<=60;j++)
s[j]='0';
scanf(
p+=n;
if(sign)printf(
if(p<0)
{
p=-p-1;
printf(
for(i=1;i<=p&&i<=8;i++)
printf(
for(i=1;i<=8-p;i++)
printf(
}
else
{

i=0;
while(i<=p)
{
if(s[i]=='0'&&!flag&&i else{flag=1;printf(
}
printf(
for(j=1;j<=8;j++)
printf(
}
printf(
return 0;
}





37 大数分解
成绩: 5 折扣: 0.8
2007级在“计算机科学导论”的期末考试中有一道试题。下面请你看看那题目应该如何编写。
从键盘输入的一个大于 1 的整数，通过算法将该整数分解为若干因子的乘积。
输入：

一个正整数。
输出：

分解后的各个因子。
时间限制


测试输入 期待的输出 内存限制
64M
额外进程
0

以文本方式显示 1秒
以文本方式显示
测试用例 1
1. 24↵
1.
2.
3.
4.
2↵
2↵
2↵
3↵

以文本方式显示 以文本方式显示 1秒
测试用例 2
1. 17↵ 1. 17↵
64M 0
以文本方式显示 1秒
以文本方式显示
测试用例 3
1. 15↵
1. 3↵
2. 5↵
64M 0
以文本方式显示 以文本方式显示 1秒
测试用例 4
1. 3↵ 1. 3↵
64M 0

#include
void main()
{ int n,i;
scanf(
for(i=2;n>1;) {
if(n%i==0) {
printf(
}
else i++;
}
}


38 回文字符串——递归
成绩: 5 折扣: 0.8
有一种特殊形式的字符串，其 正反序相同，被称为“回文字符串”。例如LeveL就是一个
回文字符串。
输入：
字符串
输出：
Yes或者No
说明：
如输出Yes，说明输入的字符串是一个回文字符串
输出No，说明输入的字符串不是一个回文字符串
请使用递归算法实现。

测试输入 期待的输出 时间限制 内存限制
64M
额外进程
0

以文本方式显示 以文本方式显示 1秒
测试用例 1
1. LeveL 1. Yes

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

#include
#include
int f(char a[],int i,int j)
{
if(a[i]!=a[j]) return 0;
else if(a[i]==a[j]&&(i==j||i+1==j)) return 1;
else if(a[i]==a[j]) {return 1&&f(a,i+1,j-1);}
}
int main()
{
static char s[100];
int n,a;
gets(s);
n=strlen(s);
a=f(s,0,n-1);
if(a==0) printf();
if(a==1) printf();
}
#include
#include
int f(char a[],int i,int j)
{
if(a[i]!=a[j]) return 0;
else if(a[i]==a[j]&&(i==j||i+1==j)) return 1;
else if(a[i]==a[j]) {return 1&&f(a,i+1,j-1);}
}
int main()
{
static char s[100];
int n,a;
gets(s);
n=strlen(s);
a=f(s,0,n-1);
if(a==0) printf(
if(a==1) printf(
}


39 求最大公约数——递归
成绩: 5 折扣: 0.8

请使用递归算法计算正整数n和m的最大公约数GCD(n,m)。
= m 当 m<=n 且 n mod m =0
GCD(N,M) = GCD(m,n) 当n = GCD(m, n mod m) 其他
输入：
n和m
输出：
n和m的最大公约数

测试输入 期待的输出 时间限制 内存限制
64M
额外进程
0

以文本方式显示 以文本方式显示 1 秒
测试用例 1
1. 24 48 1. 24
以文本方式显示 以文本方式显示 1 秒
测试用例 2
1. 13 15 1. 1
64M 0
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
#include
int f(int x,int y)
{
int a;
if(x%y==0) a=y;
else a=f(y,x%y);
return a;
}
int main()
{
int x,y;
scanf(,&x,&y);
if(x else printf(,f(y,x));
return 0;
}
40 求序列之和——递归
成绩: 5 折扣: 0.8
请使用递归算法求下列序列的前n项之和。
1 + 12 - 13 + 14 -15 ......

输入：
n
输出：
序列的前n项和（精确到小数点之后第6位）

测试输入 期待的输出 时间限制
1秒
内存限制
64M
额外进程
0

以文本方式显示 以文本方式显示
测试用例 1
1. 1 1. 1
以文本方式显示 以文本方式显示
测试用例 2
1. 2 1. 1.500000
1秒
64M 0
以文本方式显示 以文本方式显示
测试用例 3
1. 3 1. 1.166667
1秒
64M 0
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
#include
#include
double f(int n)
{
double x;
if(n==1) x=1;
else if(n%2==1) x=-1.0n+f(n-1);
else if(n%2==0) x=1.0n+f(n-1);
return x;

}
int main()
{
int n;
scanf(,&n);
if(n==1) printf();
else printf(,f(n));
}
H15：编码问题（选作）
成绩: 5 折扣: 0.8
设有一个整形数组 A[0..N-1]；存放的元素为 0～N-1 (1（i≠j）。例如，当N=6时，有：A=（ 4，3，0，5，1，2）。此时，数组A的编码定义如
下：

A[0]编码为0；
A[i]编码为：在A[0]，A[1]，…，A[i-1]中比A[i]的值小的个数 （i=1，2，…，N-1）
例如上面数组 A的编码为：B=（0，0，0，3，1，2）
若给出数组A，则可求出其编码。同理，若给出数组A的编码，可求出A中的原数据。
输入：
推导方向（取值为1或2，如为1，则表示根据数组求数组编码；如为2，则表示根据编
码反求数组）
数组个数
数组或数组编码元素
输出：
数组编码、或数组本身（元素之间以空格分隔）
时间限内存限额外进
制
1秒
以文本方式显示
测试用
例 1
1. 1
2. 6
3. 4 3 0 5 1 2
以文本方式显示
以文本方式显示
测试用
例 2
1. 1
2. 8
3. 1 0 3 2 5 6 7 4
以文本方式显示
以文本方式显示
测试用
例 4
1. 2
2. 6
3. 0 0 2 3 1 3
1. 2 0 4 5 1 3
1. 0 0 2 2 4 5 6 4
1. 0 0 0 3 1 2
制
64M
程
0


测试输入
以文本方式显示
期待的输出
1秒
64M 0
1秒
64M 0
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
#include
int n;
static int b[100];
void f1(int a[])
{
int i,j,k;
b[0]=0;
for(i=1;i<=n-1;i++)
{
k=0;
for(j=0;j

12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
{
if(a[i]>a[j]) k++;
}
b[i]=k;
}
}
int f(int a[],int q)
{
int i=0,k=0;
if(q==0)
{
for(i=0;;i++)
{
if(a[i]==0){return i;}
}
}
else
{
for(;;)
{
if(a[i]==0) {i++;k++;}
else {i++;}
if(k==q+1) return (i-1);
}
}
}
int main()
{
int i,j;
static int a[100],c[100];
scanf(,&j);
scanf(,&n);
for(i=0;i<=n-1;i++) scanf(,&a[i]);
if(j==1) f1(a);
if(j==2)
{
for(i=n-1;i>=0;i--)
{
b[i]=f(c,a[i]);
c[b[i]]=1;
}
}
for(i=0;i<=n-2;i++) printf(,b[i]);
printf(,b[n-1]);

56.
57.
return 0;
}
#include
int n;
static int b[100];
void f1(int a[])
{
int i,j,k;
b[0]=0;
for(i=1;i<=n -1;i++)
{
k=0;
for(j=0;j{
i f(a[i]>a[j]) k++;
}
b[i]=k;
}
}
int f(int a[],int q)
{
int i=0,k=0;
if(q==0)
{
for(i=0;;i++)
{

H16：洗牌（选作）
成绩: 5 折扣: 0.8
假设我们有 2n 张牌，它们以 1, 2, ..., n, n+1, ..., 2n 编号并在开始时保持着这种顺序。
一次洗牌就是将牌原来的次序变为 n+1, 1, n+2, 2, ..., 2n, n，也就是将原来的前 n 张牌放
到位置 2, 4, ..., 2n，并且将余下的 n 张牌按照他们原来的次序放到奇数位置 1, 3, ...,
2n-1。已经证明对于任何一个自然数 n，这 2n 张牌经过一定次数的洗牌就回到原来的次
序。但我们不知道对于一个特定的 n，需要几次洗牌才能将牌洗回原来的次序。
输入：
牌张数的一半n，即初始情况下一共有2n张牌，n为int型整数
输出：
将牌洗回原来的次序所需要的洗牌次数

测试输入 期待的输出 时间限制 内存限制
64M
额外进程
0

以文本方式显示 以文本方式显示 1 秒
测试用例 1
1. 10 1. 6
以文本方式显示 以文本方式显示 1 秒
测试用例 2
1. 20 1. 20
64M 0
1.
2.
3.
#include
int n;
void f1(int a[])

4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
{
int t[20001];
int i;
for(i=1;i<=n;i++) t[2*i]=a[i];
for(i=1;i<=n;i++) t[2*i-1]=a[i+n];
for(i=1;i<=2*n;i++) a[i]=t[i];
}
int main()
{
int i,k=1;
int a[20001];
scanf(,&n);
for(i=1;i<=2*n;i++)
{
a[i]=i;
}
f1(a);
for(;;)
{
if(a[2*n]!=2*n) {f1(a);k++;}
else break;
}
printf(,k);
}
#include
int n;
void f1(int a[])
{
int t[20001];
int i;
for(i=1;i<=n;i++) t[2*i]=a[i];
for(i=1 ;i<=n;i++)t[2*i-1]=a[i+n];
for(i=1;i<=2*n;i++) a[i]=t[i];
}
int main()
{
int i,k=1;
int a[20001];
scanf(
for(i=1;i<=2* n;i++)
{
a[i]=i;
}
f1(a);
for(;;){
if(a[2*n]!=2*n) {f1(a);k++;}
else break;

41.输出字符回形阵
成绩: 10 折扣: 0.8
输入图形行数N和中心字符，输出如图所示回形方阵。
例如，输入：5 Z

输出如下图形：
X X X X X
X Y Y Y X
X Y Z Y X
X Y Y Y X
X X X X X
注：N<24，且N是奇数。

测试输入 期待的输出
以文本方式显示
以文本方式显示
测试用例 1
1. 5 Z
1.
2.
3.
4.
5.
X X X X X
X Y Y Y X
X Y Z Y X
X Y Y Y X
X X X X X
无限制
64M 0
时间限制
无限制
内存限制
64M
额外进程
0

以文本方式显示
以文本方式显示
1. z z z
测试用例 2
1. 3 a 2. z a z
3. z z z
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
#include
int n;
int min(int x,int y)
{
if(x>y) x=y;
return x;
}
char t(char x)
{
if(x<'A'||(x>'Z'&&x<'a')) x=x+26;
return x;
}
void p(int i,int j,char x)
{
int a;
i=min(i,n-i+1);
j=min(j,n-j+1);
a=min(i,j);
printf(,t(x-n2-1+a));
}

21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
int main()
{
char x;
int i,j;
scanf(,&n,&x);
if(n%2==1)
{
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
if(j==n) p(i,j,x);
else {p(i,j,x);printf();}
}
printf();
}
}
else printf(,n);
return 0;
}
#include
int n;
int min(int x,int y)
{
if(x>y) x=y;
return x;
}
char t(char x)
{
if(x<'A'||(x>'Z'&&x<'a')) x=x+26;
return x;
}
void p(int i,int j,char x)
{
int a;
i=min(i,n-i+1);
j=m in(j,n-j+1);
a=min(i,j);
printf(
}
int main()
{
char x;
int i,j;

42 子串反向——递归
成绩: 10 折扣: 0.8
请编写一个递归函数 reverse(char str[], int start, int end ) ，该函数的功能是将串 str 中下
标从 start 开始到 end 结束的字符颠倒顺序。假设 start 和 end 都在合理的取值范围。
例如：
执行前：str[]=；start=1 ；end=4

执行后：strr[]=
要求在该函数中不使用新的数组，没有循环。
注意：只需要编写递归函数 reverse，系统中已经设置好了main函数。
预设代码
前置代码
view plaincopy to clipboardprint?
1. * PRESET CODE BEGIN - NEVER TOUCH CODE BELOW *
2.
3. #include
4. int main( )
5. { char str[100];
6. int start, end;
7. gets(str);
8. scanf(, &start, &end);
9. reverse( str, start, end );
10. printf(, str);
11. return 0;
12. }
13.
14. * PRESET CODE END - NEVER TOUCH CODE ABOVE *
* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW *
#include
int main( )
{char str[100];
int start, end;
gets(str);
scanf(
reverse( str, start, end );
printf(
return 0;
}
* PRESET CODE END - NEVER TOUCH CODE ABOVE *

测试输入 期待的输出
以文本方式显示


时间限制

1秒
内存限制额外进程

64M 0

测试用例
1
以文本方式显示
1. 0123456
1. 0432156

2. 1 4
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW *

#include
int main( )
{ char str[100];
int start, end;
gets(str);
scanf(, &start, &end);
reverse( str, start, end );
printf(, str);
return 0;
}

* PRESET CODE END - NEVER TOUCH CODE ABOVE *

#include
void reverse(char s[],int a,int b)
{
char t;
int n;
n=strlen(s);
if(a>n-1) a=n-1;
if(b>n-1) b=n-1;
if(a==b||a+1==b) {t=s[a];s[a]=s[b];s[b]=t;}
else {t=s[a];s[a]=s[b];s[b]=t;reverse(s,a+1,b-1);}
}
* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW *
#include
int main( )
{char str[100];
int start, end;
gets(str);
scanf(
reverse( str, start, end );
printf(
return 0;
}
* PRESET CODE END - NEVER TOUCH CODE ABOVE *
#include
void reverse(char s[],int a,int b)
{
char t;
int n;
n=strlen(s);
if(a>n-1) a=n-1;
if(b>n-1) b=n-1;
if(a==b||a+1==b) {t=s[a];s[a]=s[b];s[b]=t;}

H17：高精度加减法（选作）
成绩: 10 折扣: 0.8
背景：
计算机所能完成的一个基本功能就是完成数据的计算，譬如加法、减法等等。但是在任 何一
种计算机上，计算中能够使用的数字都是有一定范围的，超过了范围，就没法得到精确的结
果。
你现在接受了一个任务，要编写一个高精度计算器的核心部分。所谓高精度计算器，就是可
以计算很大很大的数据的计算器。
输入：
输入的第一行是一个正整数，表示下面有几组数 据需要计算。之后的每一行是两个十进制的
正整数和一个运算符，每个整数可以由最多 500 个数字组成。运算符可以是加号或者减号。
输出：
对应着输入的每一行数据，输出计算的结果，每个结果占一行。
时额
内
间外
存
限进
限
制程
制

测
以文本方式显示
试
1. 2
用
2. 213914+23466123
例
3. 32862934-23481243

1
以文本方式显示
测
试
用
例

2
1. 3
2. 4832931+1
2735123
3. 3287562378-2893568726
4871236
4. 999999999+1
以文本方式显示
1. 23680037
2. 9381691



测试输入 期待的输出
1640
秒
M
以文本方式显示
1. 0546635
4
2. 123191
142
3. 1000000000
1640
秒
M
测以文本方式显示 以文本方式显示
1640

试
用
例

3
秒
M
1. 11
2. 56789+56789
3. 45555+44445
4. 1+12345
5. 12345+1
6. 98765-98760
7. 12345-9876
8. 12345-12345
9. 12345-12346
10. 1-54321
11. 0-0
12. 0+0
1. 113578
2. 90000
3. 12346
4. 12346
5. 5
6. 2469
7. 0
8. -1
9. -54320
10. 0
11. 0

#include
#include

int main(void)
{
int k,i,j,n,m,x,y,x1,y1,flag;
int a[600],b[600],c[600];
charstr[1500],g;
scanf(
for (i=1;i<=n;i++)
{
scanf(
m=strlen(str);
k=0;x=1;y=1;
while (str[k]!='+'&&str[k]!='-') {a[x]=str[k]-48;k++;x++;}
for (j=1;j<=(x-1)2;j++) {x1=a[j];a[j]=a[x-j];a[x-j]=x1;}
g=str[k];k=k+1;
while (kfor (j=1;j<=(y-1)2;j++) {x1=b[j];b[j]=b[y-j];b[y-j]=x1;}
if (x>y) {for (j=y;j<=x;j++) b[j]=0;a[x]=0;}
else {for (j=x;j<=y;j++) a[j]=0;b[y]=0;}
if (g=='+')
{
if (xfor (j=1;j<=x;j++)
{
a[j]=a[j]+b[j];
a[j+1]=a[j+1]+a[j]10;
a[j]=a[j]%10;

}
if (a[x]==0) x--;
for (j=x;j>=1;j--) printf(
printf(
}
else
{
if (x>y) flag=1; else flag=0;
if (x==y)
{
x1=x-1;y1=y-1;
while (a[x1]==b[y1]&&x1>1&&y1>1) {x1--;y1--;}
if (x1==1&&y1==1&&a[x1]==b[y1]) {printf(
if (a[x1]>b[y1]) flag=1; else flag=0;
}
if (flag==0) {x=y;for (j=1;jfor (j=1;j<=x;j++)
{
if (a[j]>=b[j]) a[j]=a[j]-b[j];
else {a[j]=a[j]+10-b[j];a[j+1]=a[j+1]-1;}
}
if (flag==0) printf(
while (a[x]==0) x--;
for (j=x;j>=1;j--) printf(
printf(
}
}
return 0;
}
43. 缩写展开
成绩: 10 折扣: 0.8
在保存字符串时，对出现在连 续位置的若干个字符，如这些字符在ASCII表中也是连续出
现，则可以将这些字符使用缩写形式进行 保存，以节省保存空间。例如用A- Z表示
ABCD...XYZ，1-5表示12345，c-f表示cdef。
输入：
包含缩写形式的字符串
输出：
将缩写形式进行还原后的字符串

说明：
只分别对大写字母、小写字母和数字进行压缩，对于形如9-A，a-C这样的缩写不进行处理。
时额
间内存外
限限制进
制

程

164M 0
秒

测试输入 期待的输出
测
以文本方式显示
试
用
1. 0-9
例
1
测
以文本方式显示
试
用
1. G-I
例
2
测
以文本方式显示
试
用
1. ABDG-K035-9abd-h
例
3
测
以文本方式显示
试
用
1. abcdefghijklmn
例
4
测
以文本方式显示
试
用
1. 1-1
例
5

#include
#include
main()
{
char a[100],j;
inti,k;
gets(a);
k=strlen (a);
for (i=0;i以文本方式显示
1. 
以文本方式显示
1. GHI
164M 0
秒
以文本方式显示
1. ABDGHIJK0356789abdefgh
164M 0
秒
以文本方式显示
1. abcdefghijklmn
164M 0
秒
以文本方式显示
1. 1-1
164M 0
秒

{

if (a[i]=='-')
{

if(('a'<=a[i-1]&&a[i-1]=a[i-1]&&a[i-1] {
for (j=a[i-1]+1;j {
printf(
}
}
elseprintf(
}
elseprintf(
}
printf(
}

44. 函数递归
成绩: 10 折扣: 0.8
编写一个函数，使用递归算法求满足下述定义的整数序列的第n项。

f( n ) =


1
f(n-1) + f(n-3)
f(n-2) + f(n-4)
-1
当 n >= 0 且 n <= 4 时
当 n > 4 且n为偶数时
当 n > 4 且n为奇数时
其他

函数原型如下：

intfindf(int n);

参数说明：n 项数；返回值是第n项值。
例如输入：10，输出：8
预设代码
前置代码
view plainprint?

1. * PRESET CODE BEGIN - NEVER TOUCH CODE BELOW *
2.
3. #include
4.
5. int main()
6. { int n,s, findf( int );
7. scanf(, &n);
8. s = findf(n);
9. printf(, s);
10. return 0;
11. }
12.
13. * PRESET CODE END - NEVER TOUCH CODE ABOVE *

测试用例 1
测试输入 期待的输出 时间限制
无限制
内存限制
64M
额外进程
0

以文本方式显示

以文本方式显示

1.

10
↵
1.

8
↵


intfindf(int n)
{
if (n>=0&&n<=4) return 1;
if (n>4&&n%2==0) return (findf(n-1)+findf(n-3));
if (n>4&&n%2==1) return (findf(n-2)+findf(n-4));
return -1;
}

45. 大家再来做游戏
成绩: 10 折扣: 0.8
还是那个大家做游戏的问题：
幼儿园的小朋友们刚学习了如何数数，阿姨在下课时组织大家一 起玩游戏。规则如下：所有
的小朋友绕成一圈，顺序排号，给出开始报数的小孩的编号后，从这个小朋友 开始报数，凡
是报到固定数字（例如5）的，都退出该游戏，接着从下一个小朋友在从1开始报数，直到
只剩下一位小朋友游戏才中止。
输入： 小朋友的个数（<=50）开始报数的小孩的编号 要被练习的数字
输出： 最终被留下的小朋友的序号
例如输入：4 1 3
输出：The left child is NO 1.

说明：这次，以函数的方式 实现上述问题。主函数已经给出，仅需提交自己编写的函数。你
可以尝试用递归方法来解决呦！
这个问题是著名的约瑟夫问题，基于著名犹太历史学家 Josephus讲述的一个，所以函数的
名字是josephus。
函数原型：
intjosephus( int * boy, int n, int m, int r)
参数说明：
int * boy：保存参加游戏的小孩编号的整型数组的首地址。小孩的编号从1开始。
int n：开始参加游戏的小孩总数。
int m：开始时第一次报数的小孩的编号。
int r：要被练习的数字。
预设代码
josephus.c
view plainprint?

1. * PRESET CODE BEGIN - NEVER TOUCH CODE BELOW *
2.
3. #include
4. int josephus( int *boy, int n, int m, int r );
5.
6. int main( )
7. { int i, boy[50]={0}, n, m, r;
8. scanf(,&n,&m,&r);
9. if( n<=0 || n>50 || m<=0 || m>50 || r<=0 )
10. printf( );
11. else
12. {
13. for( i=0; i14. boy[i] = i + 1;
15. printf( , josephus( boy, n, m,
r ) );
16. }
17. return 0;
18. }
19.
20. * PRESET CODE END - NEVER TOUCH CODE ABOVE *
时间内存限额外
限制进程
制

无限
64M 0

测试输入 期待的输出
以文本方式显示

测试以文本方式显示

用例
1
1.

4 1 3
↵
1.

The left child is NO 1.
↵

制
测试
以文本方式显示
用例
1.

7 2 3
↵

2
以文本方式显示
1.

The left child is NO 5.
↵

无限
64M
制
0

intjosephus( int *boy, int n, int m, int r )
{
intx,k,flag,i;
flag=0;
for (x=0;x {
if (boy[x]>0) {flag=flag+1;i=boy[x];}
if (flag>1) break;
}
if (flag==1) return i;
k=1;
x=m-1;
if (x==-1) x=n-1;
while (k<=r)
{
if (boy[x]>0) k++;
if (x==n-1) x=0; else x++;
}
if (x==0) x=n-1;else x=x-1;
boy[x]=-1;
x=x+1;
returnjosephus( boy, n, x,r);
}

H18：拱猪计分（选作）
成绩: 5 折扣: 0.8
背景：
拱猪是一种很有趣的扑克牌游戏。即使你不知道它的玩法，你也可以由它的计分方式来
了解它的趣味性。 假设在此我们仅考虑四个人的拱猪牌局，本题要求你根据下面的计分规则，
在牌局结束时计算四位玩家所 得分数。
1. 我们分别以S、H、D及C来代表黑桃，红心，方块及梅花，并以数字1至 13来
代表A、2、…、Q、K等牌点，例如：H1为红心A，S13为黑桃K。

2. 牌局结束时，由各玩家持有的有关计分的牌(计分牌)仅有S12(猪)，所有红 心牌，
D11(羊)及C10(加倍)等16张牌。其它牌均弃置不计。若未持有这16张牌之任一张< br>则以得零分计算。
3. 若持有C10的玩家只有该张牌而没有任何其它牌则得+50分，若除了C10 还有其
它计分牌，则将其它计分牌所得分数加倍计算。
4. 若红心牌不在同一家，则H1至H13等13张牌均以负分计，其数值为-50， -2，-3，
-4， -5，-6，-7，-8，-9，-10，-20，-30，-40。而且S12与D11分别以-100及+1 00
分计算。
5. 若红心牌H1至H13均在同一家，有下列情形：
o
所有红心牌以+200分计算。
o
若S12、D11皆在吃下所有红心牌之一家，则此玩家得+500分。
o
而C10还是以前面所述原则计算之。
例一：若各玩家持有计分牌如下： ( 每列代表一玩家所持有之牌 )
S12 H3 H5 H13
D11 H8 H9
C10 H1 H2 H4 H6 H7
H10 H11 H12
则各家之得分依序为： -148 、 +83 、 -138 及 -60 。
例二：若各玩家持有计分牌如下：(第四家未持有任何计分牌)
H1 H2 H3 H4 H5 H6 H7 H8 H9 H10 H11 H12 H13
S12 C10
D11
则各家之得分依序为： +200 、 -200 、 +100 及 0 。
例三：若有一玩家持有所有 16 张计分牌，则得 +1000 分。其余三家均得零分。
输入：
每个输入文件由多组测试数据构成，每组测试数据有四行，每一行第一个数为 该玩家所
持有计分牌总数，而后列出其所持有之所有计分牌，牌数与各计分牌均以一个以上的空格分开。相邻两组测试数据之间不会有空白行，读到四家持牌数都为 0 表示文件结束。
输出：
每一行输出一组测试数据对应的结果，依次输出各家所得分数，共四个整数 ( 含正负号，
0 除外)，相邻两个整数之间以一个空格分开，符号和数字间不可以有空格。每组输出间不
需要有空白行。
时内额
间存外
限限进

测试输入 期待的输出

制制程


以文本方式显示


测
试
用
例

1
1.

2.

3.

4.

5.

4 S12 H3 H5 H13
↵

3 D11 H8 H9
↵

6 C10 H1 H2 H4 H6 H7
↵

3 H10 H11 H12
↵

13 H1 H2 H3 H4 H5 H6 H7 H8 H9
以文本方式显示

H10 H11 H12 H13
↵
1.

-148 +83 -138 -60
164
0
6.

2 S12 C10
↵

↵

秒
M
7.

1 D11
↵
2.

+200 -200 +100 0
↵

8.

0
↵

9.

0
↵

10.

0
↵

11.

0
↵

12.

0
↵


#include
#include
typedefstruct person
{
int n;牌数
charpai[52][4];
int score;
}person;

int haveS12(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}

int haveD11(person * Preson)
{
int i;
for(i=0;in;i++)
{

if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}

int haveH1(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH2(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH3(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH4(person * Preson)
{
int i;
for(i=0;in;i++)

{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH5(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH6(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH7(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH8(person * Preson)
{
int i;
for(i=0;in;i++)

{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH9(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH10(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH11(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH12(person * Preson)
{
int i;
for(i=0;in;i++)

{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveH13(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}
int haveC10(person * Preson)
{
int i;
for(i=0;in;i++)
{
if(strcmp(Preson->pai[i],
break;
}
if(i!=Preson->n) return 1;
else return 0;
}

voidScoreCalcuate(person * Preson)
{
inti,j,k;
intscoretemp=0;
k=0;表示红心牌数量
if(haveC10(Preson))有C10
{
if(Preson->n==1&&haveC10(Preson))
{
scoretemp=25;
}
else
{
for(i=0;in;i++)计算红心牌数量

{
if(Preson->pai[i][0]=='H')
k++;
}
if(k==13)所有红心牌都在此人手上
{
if(haveS12(Preson)&&haveD11(Preson))
scoretemp=500;
else
{
scoretemp=200;
if(haveS12(Preson))
scoretemp=scoretemp-100;
if(haveD11(Preson))
scoretemp=scoretemp+100;

}
}
else
{
if(haveH1(Preson))scoretemp=scoretemp-50;
if(haveH2(Preson))scoretemp=scoretemp-2;
if(haveH3(Preson))scoretemp=scoretemp-3;
if(haveH4(Preson))scoretemp=scoretemp-4;
if(haveH5(Preson))scoretemp=scoretemp-5;
if(haveH6(Preson))scoretemp=scoretemp-6;
if(haveH7(Preson))scoretemp=scoretemp-7;
if(haveH8(Preson))scoretemp=scoretemp-8;
if(haveH9(Preson))scoretemp=scoretemp-9;
if(haveH10(Preson))scoretemp=scoretemp-10;
if(haveH11(Preson))scoretemp=scoretemp-20;
if(haveH12(Preson))scoretemp=scoretemp-30;
if(haveH13(Preson))scoretemp=scoretemp-40;
if(haveS12(Preson))
scoretemp=scoretemp-100;
if(haveD11(Preson))
scoretemp=scoretemp+100;

}
}
Preson->score=2*scoretemp;
}
else 无C10
{

if(Preson->n==1&&haveC10(Preson))
{
scoretemp=50;
}
else
{
for(i=0;in;i++)计算红心牌数量
{
if(Preson->pai[i][0]=='H')
k++;
}
if(k==13)所有红心牌都在此人手上
{
if(haveS12(Preson)&&haveD11(Preson))
scoretemp=500;
else
{
scoretemp=200;
if(haveS12(Preson))
scoretemp=scoretemp-100;
if(haveD11(Preson))
scoretemp=scoretemp+100;

}
}
else
{
if(haveH1(Preson))scoretemp=scoretemp-50;
if(haveH2(Preson))scoretemp=scoretemp-2;
if(haveH3(Preson))scoretemp=scoretemp-3;
if(haveH4(Preson))scoretemp=scoretemp-4;
if(haveH5(Preson))scoretemp=scoretemp-5;
if(haveH6(Preson))scoretemp=scoretemp-6;
if(haveH7(Preson))scoretemp=scoretemp-7;
if(haveH8(Preson))scoretemp=scoretemp-8;
if(haveH9(Preson))scoretemp=scoretemp-9;
if(haveH10(Preson))scoretemp=scoretemp-10;
if(haveH11(Preson))scoretemp=scoretemp-20;
if(haveH12(Preson))scoretemp=scoretemp-30;
if(haveH13(Preson))scoretemp=scoretemp-40;
if(haveS12(Preson))
scoretemp=scoretemp-100;
if(haveD11(Preson))
scoretemp=scoretemp+100;

}
}
Preson->score=scoretemp;
}
}
main(void)
{
intn,i,j=-1;j保存人数
int x;
person Person[100];最多有100人
do
{
scanf(输入此人的牌数
Person[++j].n=n;
for(i=0;i {
scanf(
}
scanf(输入此人的牌数
Person[++j].n=n;
for(i=0;i {
scanf(
}
scanf(输入此人的牌数
Person[++j].n=n;
for(i=0;i {
scanf(
}
scanf(输入此人的牌数
Person[++j].n=n;
for(i=0;i {
scanf(
}

x=Person[j].n+Person[j-1].n+Person[ j-2].n+Person[j-3].n;
}while(x!=0);
输入完成，开始计算j个人的分数
int mount=j+1;人数

for(i=0;i {
ScoreCalcuate(&Person[i]);
}
for(i=1;i<=mount-4;i++)
{
if(Person[i-1].score>0)
{
printf(
if(i%4!=0) printf(
}
else
{printf(
if(i%4!=0) printf(
}
if(i%4==0) printf(
}
}

46 求表示方法
成绩: 10 折扣: 0.8
设 m、n 均为自然数，m 可表示为一些不超过 n 的自然数之和，f(m,n) 为这种表示方式
的数目。
例如，f(5,3)=5，有5种表示方法：3+2，3+1+1，2+2+1，2+1+1+1，1+ 1+1+1+1。
请编写程序，计算f(m,n)的值。
输入：
m n
输出：
f(m,n)的值

测试用例 1
测试用例 2
测试输入 期待的输出 时间限制 内存限制
64M
64M
额外进程
0
0

以文本方式显示 以文本方式显示
1秒
1.

5 3
↵
1.

5
↵

以文本方式显示 以文本方式显示
1秒
1.

6 4
↵
1.

9
↵

#include
int f(intm,int n)
{
if (n==1||m==1) return 1;
if (mif (n==m) return (1+f(n,n-1));
return(f(m,n-1)+f(m-n,n));
}

int main(void)
{
intm,n;
scanf(
printf(
return 0;
}

47.查找子字符串
成绩: 10 折扣: 0.8
编写一个函数， 该函数的功能是在给定的字符串中查找可能的子字符串，该子字符串是由给
定的同一字符组成的最长的字 符串。
例如：给定字符串是“ asddrrddddds ”，给定的字符是„ d ‟ , 获得的子字符串是“ ddddd ”。
函数原型： char * search(char *str, char ch) 。
参数说明：str保存给定的字符串的首地址（字符串长度不大于100），ch保存给定的字符。 < br>函数返回值：找到的符合要求的子字符串的首地址。如果没有符合要求的子字符串，返回一
个空指 针。
预设代码
search_46.c
view plainprint?

1. * PRESET CODE BEGIN - NEVER TOUCH CODE BELOW *
2.
3. #include

4.
5. char *search( char *str, char ch );
6.
7. main()
8. {
9. char s[100] = {0}, ch, *p;
10. gets(s);
11. ch = getchar();
12. p = search( s, ch );
13. if( p == NULL )
14. printf();
15. else
16. while( *p == ch )
17. putchar( *p++ );
18. printf();
19. }
20.
21. * PRESET CODE END - NEVER TOUCH CODE ABOVE *
额
时
外
间内存
进
限限制
程
制




测试输入 期待的输出
测
试
以文本方式显示
用
1.

asddrrddddds
↵

例
2.

d
↵


1
测
试
以文本方式显示
用
1.

abcde
↵

例
2.

1
↵


2
测
试
以文本方式显示
用
1.

↵

例
2.

↵


3
以文本方式显示
1.

ddddd
↵

无
64
限
M
制
0
以文本方式显示
1.

There is not the sub-string.
↵

无
64
限
M
制
0
以文本方式显示
1.

There is not the sub-string.
↵

无
64
限
M
制
0

char *search(char *str, char ch)
{
inti,m,h,t;
intans[4];
m=strlen(str);
h=0;t=0;ans[1]=-1;ans[2]=0;
for (i=0;i {
if (str[i]==ch)
{
h=i;
while (str[i]==ch) i++;
if (i-h>ans[2]) {ans[1]=h;ans[2]=i-h;}
}
}
if (ans[1]!=-1) return &str[ans[1]];
else return 0;
}
元素值之和
成绩: 5 折扣: 0.8
编写函数，计算给定的整型数组的奇数元素值之和、偶数元素值之和。
例如数组元素的值依次为： 1 ， 8 ， 2 ， 3 ， 11 ， 6 ；则奇数值之和 15 、偶数值
之和 16 。
函数原型： void findsum( int *pa , int n, int *podd, int *peven ) 。
参数说明： pa 是整型数组的首地址， n 是数组元素个数(元素个数不大于100)，指针
podd 、 peven 保存奇数之和、偶数之和的整型变量的地址。
返回值：无返回值。
预设代码
findsum_48.c
view plaincopy to clipboardprint?

1. * PRESET CODE BEGIN - NEVER TOUCH CODE BELOW *
2.
3. #include

4.
5. void findsum( int *pa, int n, int *podd, int *peven );
6.
7. main( )
8. {
9. int i, n, a[100], odd, even;
10. scanf( ,&n );
11. for( i=0; i12. scanf(,&a[i] );
13. findsum( a, n, &odd, &even );
14. printf(, odd, even );
15. }
16.
17. * PRESET CODE END - NEVER TOUCH CODE ABOVE *
* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW *
#include
void findsum( int *pa, int n, int *podd, int *peven );
main( )
{
int i, n, a[100], odd, even;
scanf(
for( i=0; iscanf(
findsum( a, n, &odd, &even );
printf(
}
* PRESET CODE END - NEVER TOUCH CODE ABOVE *

时间限内存限额外进

测试输入
以文本方式显示
测试用
例 1
1. 6
2. 1 8 2 3 11 6
以文本方式显示
测试用
例 2
1. 1
2. 0
期待的输出
制 制 程
0

以文本方式显示
1. odd=15,even=16
无限制 64M

以文本方式显示
1. odd=0,even=0
无限制 64M
0
答案：
1. void findsum( int *pa, int n, int *podd, int *peven )
2. {

3. int i;
4. *(podd)=0,*(peven)=0;
5. for(i=0;i6. {
7. if(*(pa+i)%2==0) *(peven)=*(peven)+*(pa+i);
8. else *(podd)=*(podd)+*(pa+i);
9. }
10. }
67：
逆波兰算术表达式（选作）
成绩: 5 折扣: 0.8
传统的算术表 达式是由操作数(又叫运算对象或运算量)和运算符以及改变运算次序的圆
括号连接而成的式子。 其运算规则如下：

(1) 先计算括号内，后计算括号外；
(2) 在无括号或同层括号内，先进行乘除运算，后进行加减运算，即乘除运算的优先级
高于加减运算 的优先级；
(3) 同一优先级运算，从左向右依次进行。

在这种表达式的计算过程中，既要考虑括号的作用，又要考虑运算符的优先级，还要考
虑运算符出现的先 后次序。
波兰科学家卢卡谢维奇(Lukasiewicz)提出了算术表达式的另一种表示 ，即后缀表示，又
称逆波兰式，其定义是把运算符放在两个运算对象的后面。在后缀表达式中，不存在括 号，
也不存在优先级的差别，计算过程完全按照运算符出现的先后次序进行，整个计算过程仅需
一遍扫描便可完成。
例如：
35+6的逆波兰表达式为3 5 6 +
2*(3+4)的逆波兰表达式为2 3 4 + *
输入：
一个只包含加、减、乘、除和数字的逆波兰表达式
输出：
该表达式的值

测试输入 期待的输出 时间限制 内存限制 额外进程

以文本方式显示
测试用例 2
1. 2 3 + 5 *
以文本方式显示 1 秒
1. 25
64M 0
答案：
1. #include
2. #include
3. #include
4. #define MAX 100
5. int run(char input[])
6. {int length=strlen(input);
7. int i;
8. int k;
9. int m;
10. int mn;
11. int temp;
12. int num[MAX],j=0;
13. int w[10],iw=0;
14. for(i=0;i15. for(i=0;i16. {if(input[i]=='*')
17. {temp=num[j-2]*num[j-1];
18. j=j-2;
19. for(k=j+1;k20. num[j]=temp;}
21. else if(input[i]=='')
22. {temp=num[j-2]num[j-1];
23. j=j-2;
24. for(k=j+1;k25. num[j]=temp;}
26. else if(input[i]=='+')
27. {temp=num[j-2]+num[j-1];
28. j=j-2;
29. for(k=j+1;k30. num[j]=temp;}
31. else if(input[i]=='-')
32. {temp=num[j-2]-num[j-1];
33. j=j-2;
34. for(k=j+1;k35. num[j]=temp;}
36. else if(input[i]==' ')
37. {mn=0;
38. for(m=iw-1;m>=0;m--)
39. {num[j]=num[j]+w[mn]*pow(10,m);

40. mn++;}
41. j++;iw=0;}
42. else
43. {w[iw]=(int)input[i]-48;
44. iw++;}
45. }return num[0];}
46. void main()
47. {char input[MAX];
48. gets(input);
49. int result;
50. result=run(input);
51. printf(,result);
52. }
68：
计算子字符串个数
成绩: 5 折扣: 0.8
字符串匹配问题：输入一个字符串，计算其中包含的连续给定的子字符串的个数。
例如输入字符串“ EFABCABCABCDABCDD ” , 给定子字符串“ ABC” ，输出是 3 。
函数原型： int countsub( char *str, char *subs ) 。
参数说明： str 保存输入的字符串的首地址， subs 保存需要统计的子字符串的首地址。
返回值：包含的连续子字符串的个数。
预设代码
countsub_H20.c
view plaincopy to clipboardprint?

1.
2.
3.
4.
5.
6.
7.
8.
* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW *

#include

int countsub( char *str, char *ss );

main( )
{