北理C语言作业及答案2.docx
《北理C语言作业及答案2.docx》由会员分享，可在线阅读，更多相关《北理C语言作业及答案2.docx（23页珍藏版）》请在冰豆网上搜索。
北理C语言作业及答案2
34北理工的恶龙
成绩:
10/折扣:
背景：
最近，北理工出现了一只恶龙，它长着很多头，而且还会吐火，它将会把北理工烧成废墟，于是，校长下令召集全校所有勇士杀死这只恶龙。
要杀死这只龙，必须把它所有的头都砍掉，每个勇士只能砍一个龙头，龙的每个头大小都不一样，一个勇士只有在身高不小于龙头的直径的情况下才能砍下它。
而且勇士们要求，砍下一个龙头必须得到和自己身高厘米数一样的学分。
校长想花最少的学分数杀死恶龙，于是找到你寻求帮助。
输入：
第一行龙头数n,勇士人数m（1<=n,m<=100）接下来n行，每行包含一个整数，表示龙头的直径接下来m行，每行包含一个整数，表示勇士的身高l
输出：
如果勇士们能完成任务，输出校长需要花的最小费用；否则输出“bitisdoomed!
”
测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例1
1.23↵
2.5↵
3.4↵
4.7↵
5.8↵
6.4↵
1.11↵
1秒
64M
0
测试用例2
1.21↵
2.5↵
3.5↵
4.10↵
1.bitisdoomed!
↵
1秒
64M
0
#include<>
voidmain（）
{
ints=0,t,i,j,m,n,a[100],b[100],c[100];
for（i=0;i<=99;i++）
a[i]=0,b[i]=0,c[i]=0;
scanf（"%d%d",&m,&n）;
for（i=0;i<=m-1;i++）
scanf（"%d",&a[i]）;
for（i=0;i<=n-1;i++）
scanf（"%d",&b[i]）;
if（m>n）
printf（"bitisdoomed!
\n"）;
else
{
for（i=0;i<=m-1;i++）
for（j=i;j<=m-1;j++）
{if（a[i]>a[j]）
{t=a[i],a[i]=a[j],a[j]=t;}}
for（i=0;i<=n-1;i++）
for（j=i;j<=n-1;j++）
{if（b[i]>b[j]）
{t=b[i],b[i]=b[j],b[j]=t;}}
t=0;
for（i=0;i<=m-1;i++）
for（j=0;j<=n-1;j++）
if（a[i]<=b[j]）
{c[t]=b[j];
t++;
b[j]=0;
break;}
if（tprintf（"bitisdoomed!
\n"）;
else
{for（i=0;i<=t;i++）
s=s+c[i];
printf（"%d\n",s）;}
}
}
35杀鸡用牛刀——要用递归啊！
成绩:
5/折扣:
背景：
哈哈！
我们终于学了递归了，现在大家一定感到非常有意思吧，那个典型的“汉诺塔”问题，一个非常短的程序居然可以完成如此复杂的工作，真是神奇啊！
来吧，让我们也动手编写一个递归程序，当然，我们要编写的不可能太复杂。
功能：
求整数n到m区间的累加和，其中n<=m。
输入：
区间的起始点n区间的终止点m
输出：
累加和
要求：
使用递归算法完成。
如此简单的题目当然要有隐含的测试用例啦，就3个，看看谁能猜出来。
测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例1
1.110↵
1.Thesumfrom1to10is55.↵
1秒
64M
0
测试用例2
1.1015↵
1.Thesumfrom10to15is75.↵
1秒
64M
0
#include<>
intsum（intm,intn）
{
inti;
if（n==m）
i=n;
else
i=n+sum（m,n-1）;
return（i）;
}
voidmain（）
{
intm,n;
scanf（"%d%d",&m,&n）;
printf（"Thesumfrom%dto%dis%d.\n",m,n,sum（m,n））;
}
H13：
安全的密码（选做）
成绩:
5/折扣:
随着电子设备的广泛运用，密码也渐渐融入每个人的生活。
保护好密码，不仅关系到个人隐私，更关系到个人的财产和安全。
一个安全的密码，最好由大小写字母、数字或符号组成。
包含越多种类的字符，其安全性就越高。
同时密码还需要有一定的长度，通常至少要由六个以上的字符组成。
并不是每个人都喜欢这样复杂的密码，很多人在设置密码的时候，喜欢使用自己的名字或者生日，但这是很大的安全隐患。
任务
林晓炜正在设计一个网络交易系统，为了保证用户的密码安全，他需要一个程序，判断用户自己设置的密码是否安全，如果不安全，则给出提示。
现在他向你求助，请你帮忙设计一个程序来解决这个问题。
应当按照以下的规则来判断密码是否安全：
1.如果密码长度小于6位，则不安全
2.如果组成密码的字符只有一类，则不安全
3.如果组成密码的字符有两类，则为中度安全
4.如果组成密码的字符有三类或以上，则为安全
通常，可以认为数字、大写字母、小写字母和其它符号为四类不同的字符。
输入
输入的第一行是一个整数N，表明后面有多少组密码。
随后的N行输入包括N个密码，每个密码的长度均小于20个字符。
输出
针对每一个密码判断并输出它是否安全。
对于不安全的密码输出"NotSafe"，对于中度安全的密码输出"MediumSafe"，对于安全的密码输出"Safe"
输入样例
41234abcdefABC1231#c3Gh
输出样例
NotSafeNotSafeMediumSafeSafe
测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例1
1.10↵
2.abcDEF↵
3.ABC↵
4.qw↵
5.`↵
6.ABCDEFGHIJKLMNOPQRST↵
7.4567890↵
8.1aB↵
9.1B↵
10.aX↵
11.qwe123%^&ABC↵
1.MediumSafe↵
2.NotSafe↵
3.NotSafe↵
4.NotSafe↵
5.NotSafe↵
6.NotSafe↵
7.Safe↵
8.NotSafe↵
9.Safe↵
10.Safe↵
1秒
64M
0
#include<>
#include<>
charcheck（chars[]）
{
intstrlength;
strlength=strlen（s）;
intn[4]={0,0,0,0};
intkind=0,i;
if（strlength<6）return'n';.,16，先对前17位数字的权求和Ai:
表示第i位置上的身份证号码数字值Wi:
表示第i位置上的加权因子Wi:
7910584216379105842
（2）计算模
Y=mod（S,11）
（3）通过模得到对应的校验码
Y:
012345678910校验码:
10X98765432
四、举例如下：
北京市朝阳区:
1002X广东省汕头市:
440524
15位的身份证号升级办法：
15位的身份证号：
ddddddyymmddxxp
18位的身份证号：
ddddddyyyymmddxxpy
∙其中dddddd为地址码（省地县三级）
∙yyyymmddyymmdd为出生年月日
∙xx顺号类编码
∙p性别
15位的yy年升为18位后，变成19yy年，但对于百岁以上老人，则为18yy年，此时，他们的最后三位顺序码为996,997,998或999来标记。
输入
输入n组身份证号码，第一行为个数，以后每行为身份证号码。
输出
如果输入的身份证号码为15位，则将其升级为18位后显示输出；否则判断其是否为合法身份证号，并逐行输出。
测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例1
1.4↵
2.350622↵
3.1002X↵
4.02↵
5.96↵
1.Invalid↵
2.Valid↵
3.1002X↵
4.19965↵
1秒
64M
0
#include<>
#include<>
voidshengji（charstr[]）
{
intn=strlen（str）;S+WiS+Wi
1.
1.
1秒
64M
0
测试用例2
1.e-3↵
1.↵
1秒
64M
0
测试用例3
1.e20↵
1.9.↵
1秒
64M
0
测试用例4
1.1E0↵
1.↵
1秒
64M
0
测试用例6
1.E1↵
1.22.↵
1秒
64M
0
#include""
intmain（）
{
intp=-1,n,i=0,j,sign=0,flag=0;charc,s[100];
while（scanf（"%c",&c）&&c!
='e'&&c!
='E'）
if（c=='.'）p=i-1;
elseif（c<='9'&&c>='0'）s[i]=c,i++;
elseif（c=='-'）sign=1;
elseif（p<0）p=i-1;
for（j=i;j<=60;j++）
s[j]='0';
scanf（"%d",&n）;
p+=n;
if（sign）printf（"-"）;
if（p<0）
{
p=-p-1;
printf（"0."）;
for（i=1;i<=p&&i<=8;i++）
printf（"0"）;
for（i=1;i<=8-p;i++）
printf（"%c",s[i-1]）;
}
else
{
i=0;
while（i<=p）
{
if（s[i]=='0'&&!
flag&&ielse{flag=1;printf（"%c",s[i++]）;}
}
printf（"."）;
for（j=1;j<=8;j++）
printf（"%c",s[i++]）;
}
printf（"\n"）;
return0;
}
37大数分解
成绩:
5/折扣:
2007级在“计算机科学导论”的期末考试中有一道试题。
下面请你看看那题目应该如何编写。
从键盘输入的一个大于1的整数，通过算法将该整数分解为若干因子的乘积。
输入：
一个正整数。
输出：
分解后的各个因子。
测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例1
1.24↵
1.2↵
2.2↵
3.2↵
4.3↵
1秒
64M
0
测试用例2
1.17↵
1.17↵
1秒
64M
0
测试用例3
1.15↵
1.3↵
2.5↵
1秒
64M
0
测试用例4
1.3↵
1.3↵
1秒
64M
0
#include<>
voidmain（）
{intn,i;
scanf（"%d",&n）;
for（i=2;n>1;）{
if（n%i==0）{
printf（"%d\n",i）;n/=i;
}
elsei++;
}
}
38回文字符串——递归
成绩:
5/折扣:
有一种特殊形式的字符串，其正反序相同，被称为“回文字符串”。
例如LeveL就是一个回文字符串。
输入：
字符串
输出：
Yes或者No
说明：
如输出Yes，说明输入的字符串是一个回文字符串输出No，说明输入的字符串不是一个回文字符串请使用递归算法实现。
测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例1
1.LeveL↵
1.Yes↵
1秒
64M
0
#include<>
#include<>
intfun（charstr[],inta,intb）
{
if（str[a]!
=str[b]）return0;
else
if（a==b||a+1==b&&str[a+1]==str[b]）return1;
else
if（str[a]==str[b]）return1&&fun（str,a+1,b-1）;
}
voidmain（）
{
charstr[100];
scanf（"%s",str）;
intn;
n=strlen（str）;
switch（fun（str,0,n-1））
{
case1:
printf（"Yes\n"）;break;
case0:
printf（"No\n"）;break;
}
}
39求最大公约数——递归
成绩:
5/折扣:
请使用递归算法计算正整数n和m的最大公约数GCD（n,m）。
=m当m<=n且nmodm=0GCD（N,M）=GCD（m,n）当n输入：
n和m
输出：
n和m的最大公约数
测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例1
1.2448↵
1.24↵
1秒
64M
0
测试用例2
1.1315↵
1.1↵
1秒
64M
0
#include<>
intgcd（intn,intm）
{
if（m<=n&&n%m==0）
returnm;
else
if（nelse
returngcd（m,n%m）;
}
voidmain（）
{
intn,m;
scanf（"%d%d",&n,&m）;
printf（"%d\n",gcd（n,m））;
}
40求序列之和——递归
成绩:
5/折扣:
请使用递归算法求下列序列的前n项之和。
1+1/2-1/3+1/4-1/5......
输入：
n
输出：
序列的前n项和（精确到小数点之后第6位）
测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例1
1.1↵
1.1↵
1秒
64M
0
测试用例2
1.2↵
1.↵
1秒
64M
0
测试用例3
1.3↵
1.↵
1秒
64M
0
#include<>
doublefun（intn）
{
if（n==1）return1;
if（n%2==0）returnfun（n-1）+n;
if（n%2==1）returnfun（n-1）n;
}
voidmain（）
{
intn,m;
scanf（"%d",&n）;
if（n==1）
printf（"1\n"）;
else
printf（"%\n",fun（n））;
}
42子串反向——递归
成绩:
10/折扣:
请编写一个递归函数reverse（charstr[],intstart,intend），该函数的功能是将串str中下标从start开始到end结束的字符颠倒顺序。
假设start和end都在合理的取值范围。
例如：
执行前：
str[]="0123456"；start=1；end=4
执行后：
strr[]="0432156"
要求在该函数中不使用新的数组，没有循环。
注意：
只需要编写递归函数reverse，系统中已经设置好了main函数。
预设代码
前置代码
1./*PRESETCODEBEGIN-NEVERTOUCHCODEBELOW*/
2.
3.#include<>
4.intmain（）
5.{charstr[100];
6.intstart,end;
7.gets（str）;
8.scanf（"%d%d",&start,&end）;
9.reverse（str,start,end）;
10.printf（"%s\n",str）;
11.return0;
12.}
13.
14./*PRESETCODEEND-NEVERTOUCHCODEABOVE*/
测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例1
1.0123456↵
2.14↵
1.0432156↵
1秒
64M
0
测试用例6
1.0123456↵
2.610↵
1.0123456↵
1秒
64M
0
测试用例7
1.0123456↵
2.010↵
1.6543210↵
1秒
64M
0
/*PRESETCODEBEGIN-NEVERTOUCHCODEBELOW*/
#include<>
intmain（）
{charstr[100];
intstart,end;
gets（str）;
scanf（"%d%d",&start,&end）;
reverse（str,start,end）;
printf（"%s\n",str）;
return0;
}
/*PRESETCODEEND-NEVERTOUCHCODEABOVE*/
voidreverse（charstr[],intstart,intend）
{
inti=start,j=end,p=0;
chartemporary;
while（str[p]!
='\0'）
p++;
if（startfor（;i<=j;i++,j--）
{
temporary=str[i];
str[i]=str[j];
str[j]=temporary;
}
elseif（start=p）
{
j=p-1;
for（;i<=j;i++,j--）
{
temporary=str[i];
str[i]=str[j];
str[j]=temporary;
}
}
}
H17：
高精度加减法（选作）
成绩:
10/折扣:
背景：
计算机所能完成的一个基本功能就是完成数据的计算，譬如加法、减法等等。
但是在任何一种计算机上，计算中能够使用的数字都是有一定范围的，超过了范围，就没法得到精确的结果。
你现在接受了一个任务，要编写一个高精度计算器的核心部分。
所谓高精度计算器，就是可以计算很大很大的数据的计算器。
输入：
输入的第一行是一个正整数，表示下面有几组数据需要计算。
之后的每一行是两个十进制的正整数和一个运算符，每个整数可以由最多500个数字组成。
运算符可以是加号或者减号。
输出：
对应着输入的每一行数据，输出计算的结果，每个结果占一行。
测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例1
1.2↵
2.213914+↵
3.-↵
1.↵
2.9381691↵
1秒
64M
0
测试用例2
1.3↵
2.48329+735123↵
3.-6↵
4.9+1↵
1.466354↵
2.↵
3.00↵
1秒
64M
0
测试用例3
1.11↵
2.56789+56789↵
3.45555+44445↵
4.1+12345↵
5.12345+1↵
6.98765-98760↵
7.12345-9876↵
8.↵
9.↵
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↵
1秒
64M
0
#include<>
#include<>
#include<>
#include""
voidmain（）
{
intn=0,i=0,j=0,k=0,b=0;
chara[3][500]={0};
intn1=0,n2=0;
chars[500]={0};
intn3=0;
intc=0,c1=0;
inttemp=0;
charop;
charstr[1001]={0};
char*result;
scanf（"%d",&n）;
result=（char*）malloc（501*n）;//根据输入的n申请内存空间
*result='\0';
/*每次循环都要初始化*/
for（;i{
//gets（str）;
for（j=0;j<500;j++）
{
a[0][j]='\0';a[1][j]='\0';a[2][j]='\0';
s[j]='\0';
str[j]='\0';
str[1000-j]='\0';
}
c=0;c1=0;
k=0;
n1=0;n2=0;n3=0;
/*分离输入的字符串*/
scanf（"%s",&str）;
for（j=0;str[j];j++）
{
if（str[j]!
='+'&&str[j]!
='-'）
a[k][j-n1]=str[j];
else
{
op=str[j];
k=1;
n1=strlen（a[0]）+1;
}
}//forj
n1-=2;
n2=strlen（a[1]）-1;
n3=n1>n2?
n1:
n2;
/*计算加法*/
if（op=='+'）
{
for（;n1>=0&&n2>=0;n1--,n2--,n3--）
{
temp=a[0][n1]+a[1][n2]-96;
temp+=c;
if（temp>=10）
{
s[n3]=t
升级会员 