AnyviewC编程作业系统——支持程序可视化运行、调试和测评
AnyviewC编程作业系统——支持程序可视化运行、调试和测评
AnyviewC题库：C程序设计 例题62--习题239（2012-4-27）
1.025 编写一个C程序，用函数printf(char *s)输出以下3行信息：第1章 程序设计和C语言(例题0--习题0/2)
********************
* Very Good! *
********************
注意：（1）要求精确到每个字符、空格、字母及其大小写。
（2）可多次调用printf(char *s)，每次仅一个字符串参数。
1.055 编写一个程序，输入a、b、c三个值，输出其中最大值。要求不改变下列给定的程序框架内容，填入合适语句，使其成为满足题目要求的正确程序。
void main()
{ int a,b,c,max;
scanf("%d,%d,%d",&a,&b,&c); /*请输入三个数*/
printf("最大数为："%d",max);
}
第2章 算法——程序的灵魂
第3章 最简单的程序设计——顺序结构程序设计(例题49--习题0/61)
（含：数据类型、运算和表达式）
【例题3.010e】显示字符串
编写程序，显示字符串"Let's study C."并换行。
【程序】
void main()
{ printf("Let's study C.\n"); //'\n'为换行符，可出现在字符串中
}
【习题3.012】用printf语句显示一行字符编写程序，显示字符串"I am a student."后换行。
【程序】
void main()
{
printf( );
}
【习题3.013】显示一行
编写程序，显示字符串"C Language Program"后换行。
【例题3.020e】用printf语句显示多个字符串
编写程序，用printf语句将3个字符串"Let's"，"study"和"programming"用空格分隔显示在同一行。
【程序】
void main()
{ printf("Let's "); //末尾加一个空格，但不换行
printf("study "); //末尾加一个空格，但不换行
printf("programming\n"); //显示后换行
}
【习题3.023】用printf语句在一行上显示多个字符串编写程序，用printf语句将3个字符串"I"，"love"和"China"用空格分隔显示在同一行。
【程序】
void main()
{ printf( );
printf( );
printf( ); //注意：最后要换行
}
【例题3.030e】换行显示
编写程序，在显示字符串"C Language"后，换行显示字符串"C++ Language"。
【程序】
void main()
{ printf("C Language\n"); //显示后换行
printf("C++ Language\n"); //显示后换行
}
【习题3.032】换行显示
编写程序，显示字符串"Apple is red."后，换行显示"Banana is yellow."。
【程序】
void main()
{ printf( );
printf( ); //最后一行显示后，通常也换行
}
【习题3.033】显示多行
编写程序，将字符串"Apple iPad"，"Apple iPhone"和"Apple iPod"分三行显示。注意：最后一行显示后，也应换行。
【例题3.040e】隔行显示
编写程序，在显示字符串"C Language"后，隔1行再显示字符串"C++ Language"。
【程序】
void main()
{ printf("C Language\n"); //显示后换行
printf("\n"); //只换行，即隔1行再显示
printf("C++ Language\n"); //显示后换行
}
【习题3.042】隔行显示
编写程序，在显示字符串"Apple is red."后，隔1行再显示"Banana is yellow."。
【程序】
void main()
{ printf( );
printf( ); //只换行，实现“隔1行”
printf( ); //最后一行显示后，通常也换行
}
【例题3.050e】注释
编写程序，显示字符串"C Language Exercise"，要求在主函数之前加上内容为C Language Exercise的注释。
【程序】
/*C Language Exercise*/ //符合题意的注释
void main()
{ printf("C Language Exercise\n");//显示
}
【习题3.053】注释
编写程序，显示字符串"C Program"，并要求在第一行加注释"Printf Test"。
【例题3.060e】整型变量，赋值，四则运算
编写程序，分别给变量ａ赋值15和变量ｂ赋值3，然后依次求并显示两者的和、差、积、商。
【程序】
void main()
{ int a,b,sum,min,tim,sep; //整形变量说明
a=15; //赋值
b=3; //赋值
sum=a+b; //加
min=a-b; //减
tim=a*b; //乘
sep=a/b; //除
printf("%d+%d=%d\n",a,b,sum);
printf("%d-%d=%d\n",a,b,min);
printf("%d*%d=%d\n",a,b,tim);
printf("%d/%d=%d\n",a,b,sep);
}
【习题3.063】整型变量，赋值，加减四则运算
编写程序，分别给变量ａ赋值7和变量ｂ赋值5，求a加b赋给c，a减去b赋给d，并显示。
【程序】
void main()
{ int a,b,c,d;
a= ;
b= ;
c= ; //加
d= ; //减
printf("%d+%d=%d\n",a,b,c);
printf("%d-%d=%d\n",a,b,d);
}
【例题3.070e】余数
编写程序，将215÷9的商和余数分别赋给c和d。
【程序】
void main()
{ int a,b,c,d; //整形变量说明
a=215; //赋值
b=9; //赋值
c=a/b; //将商赋给ｃ
d=a%b; //将余数赋给ｄ
printf("%d/%d=%d...%d\n",a,b,c,d); //显示
}
【习题3.073】整型变量，求商和余数
在以下程序空缺处填写合适内容，使得程序能够分别给变量ａ赋值215，变量ｂ赋值19，c赋值75，然后依次求a除以b，a除以c的商和余数并显示结果。
void main()
{ int a,b,c,d,e,f,g;
a=215;
b=19;
c=75;
d= /*a除以b的商*/
e= /*a除以b的余数*/
f= /*a除以c的商*/
g= /*a除以c的余数*/
printf("%d/%d=%d...%d\n",a,b,d,e);
printf("%d/%d=%d...%d\n",a,c,f,g);
}
【习题3.076】整型变量，赋值，乘除余四则运算
编写程序，分别给变量ａ赋值17和变量ｂ赋值5，求a乘b赋给c，a÷b的商赋给d，余赋给e，并显示。
【程序】
void main()
{ int a,b,c,d,e;
a=
b=
c=
d=
e=
printf("%d*%d=%d\n",a,b,c); /* 显示a乘b的积c */
printf("%d/%d=%d...%d\n",a,b,d); /* 显示a除以b的商d */
printf("%d%%%d=%d...%d\n",a,b,e); /* 显示a除以b的余数e */
}
【例题3.080e】算术表达式
编写程序，不使用变量，显示35*25的值。
【程序】
void main()
{ printf("%d*%d=%d\n",35,25,35*25);//显示结果
}
【习题3.083】算术表达式
编写程序，不使用变量，显示11+2*3的值。
【程序】
void main()
{ printf("%d+%d*%d=%d\n", );
}
【例题3.090e】算术表达式
编写程序，先对整型变量a赋值15，b赋值10，然后将a+b与a-b的商赋给c，并显示c的值。
【程序】
void main()
{ int a,b,c;
a=15;
b=10;
c=(a+b)/(a-b);
printf("(%d+%d)/(%d-%d)=%d\n",a,b,a,b,c);//显示结果
}
【习题3.092】算术表达式
编写程序，先对整型变量a赋值11，b赋值2，然后将a/b与b-a%10的乘积赋给c，并显示c的值。
【程序】
void main()
{ int a,b,c;
a= ;
b= ;
c= ;
printf( );
}
【习题3.093】算术表达式
在以下程序空缺处填写合适内容，使得程序能够分别给变量ａ赋值511，变量ｂ赋值246，c赋值257，d赋值495，然后求(a+b)与(b-c)*(a-d)的商并赋给e和显示结果。
void main()
{ int a,b,c,d,e;
printf("(%d+%d)/((%d-%d)*(%d-%d))=%d\n",a,b,b,c,a,d,e);
}
【例题3.100e】逗号运算符（也称为顺序运算符）
编写程序，求a*b与c*d之和，其中用顺序运算符对变量a，b，c和d依次赋值为8，7，5和6。
【程序】
void main()
{ int a,b,c,d,timsum;
a=8,b=7,c=5,d=6; //使用逗号分隔，4个赋值构成一个语句
timsum=a*b+c*d;
printf("%d*%d+%d*%d=%d\n",a,b,c,d,timsum);
}
【习题3.103】
在空缺处填写合适内容，使得程序能够在一个语句中，用逗号运算符依次对变量a，b和c赋值为27，36和7，求a+b与c的商并赋给d和显示结果。
void main()
{ int a,b,c,d;
printf("(%d+%d)/%d=%d\n",a,b,c,d);
}
【习题3.106】逗号运算符（也称为顺序运算符）
在以下程序空缺处填写合适内容，使得程序能够在一个语句中利用逗号运算符依次将-25赋给a，5赋给b，a/b赋给c，最后显示c的值。
【程序】
void main()
{ int a,b,c;
c=
printf("c=%d\n",c);
}
【例题3.110e】重复赋值
编写程序，对变量a和b均赋值为5，变量c赋值为8，分行显示a，b和c的平方值。
【程序】
void main()
{ int a,b,c;
a=b=5,c=8; //对a和b重复赋值
printf("%d*%d=%d\n",a,a,a*a);
printf("%d*%d=%d\n",b,b,b*b);
printf("%d*%d=%d\n",c,c,c*c);
}
【习题3.113】重复赋值，表达式，显示
在以下程序空缺处填写合适内容，使得程序能够将变量ａ和b均赋值为20，c赋值为58，d赋值为表达式c-a/5除以c-2*b的商，并显示该表达式和变量d的值的等式。
【程序】
void main()
{ int a,b,c,d;
a=b=
d=
printf("(%d-%d/5)/(%d-2*%d)=%d\n",c,a,c,b,d);
}
【例题3.120e】变量初始化
编写程序，变量a和b分别赋值为123和20，求a和b的乘积。要求在进行变量说明的同时给变量赋值。
【程序】
void main()
{ int a=123,b=20; //在说明变量a和b的同时对其赋值(初始化)
int c;
c=a*b;
printf("%d*%d=%d\n",a,b,c);
}
【习题3.123】整型变量初始化，表达式，显示
在以下程序空缺处填写合适内容，使得程序能够分别对变量ａ赋值12，b赋值34，c赋值56，d赋值表达式a*b*c的值，并显示该表达式和变量d的值的等式。
【程序】
void main()
{
printf("%d*%d*%d=%d\n",a,b,c,d);
}
【例题3.130e】浮点数（实数）
编写程序，将789.456123赋给变量a，28.2468赋给变量b，求a和b的和、差、积、商。
【程序】
void main()
{ float a,b,sum,min,tim,sep; //实数型变量说明
a=789.456123;
b=28.2468;
sum=a+b;
min=a-b;
tim=a*b;
sep=a/b;
printf("%f+%f=%f\n",a,b,sum);
printf("%f-%f=%f\n",a,b,min);
printf("%f*%f=%f\n",a,b,tim);
printf("%f/%f=%f\n",a,b,sep);
}
【习题3.132】浮点数，赋值，加减四则运算
编写程序，将1.234赋给变量a，23.456赋给变量b，求a加b赋给c，a减去b赋给d，并显示。
【程序】
void main()
{ float a,b,c,d;
a= ;
b= ;
c= ; //加
d= ; //减
printf("%f+%f=%f\n",a,b,c);
printf("%f-%f=%f\n",a,b,d);
}
【习题3.133】浮点型变量，赋值，表达式，显示
在以下程序空缺处填写合适内容，使得程序能够分别对变量f赋值12.345，g赋值67.89，h赋值表达式f*g的值，并显示该表达式和变量h的值的等式。
【程序】
void main()
{
f= ,g=
h=
printf("%.3f*%.2f=%f\n",f,g,h);
}
【习题3.135】浮点数，赋值，乘除四则运算
编写程序，将111.234赋给变量a，23.456赋给变量b，求a乘b赋给c，a÷b赋给d，并显示。
【程序】
void main()
{ float a,b,c,d;
printf("%.3f*%.3f=%f\n",a,b,c);
printf("%.3f/%.3f=%f\n",a,b,d);
}
【例题3.140e】浮点数计算
编写程序，将圆周率3.14159赋给变量a，半径7.24赋给变量b，求其圆面积和圆周长。
【程序】
void main()
{ float a,b,c,d;
a=3.14159;
b=7.24;
c=b*b*a;
d=2*a*b;
printf("area=%.3f\n",c); //按3位小数的格式显示结果
printf("circ=%.4f\n",d); //按4位小数的格式显示结果
}
【习题3.142】浮点数计算
编写程序，给三角形的三边长分别赋值：3.45赋给a，4.56赋给b，5.67赋给c，求其三边长之和。
【程序】
void main()
{ float a,b,c;
printf("%.2f+%.2f+%.2f=%.2f\n",a,b,c,a+b+c);
}
【习题3.143】浮点型变量，赋值，表达式，显示
在以下程序空缺处填写合适内容，使得程序能够分别对变量f赋值2.345，g赋值6.789，h赋值f与g的平方和，并显示h的值。
【程序】
void main()
{
printf("%f\n",h);
}
【习题3.145】浮点型变量，赋值，表达式，显示在以下程序空缺处填写合适内容， 使得程序能够分别对变量f赋值-2.345，g赋值6.789，h赋值f与g的3次方和，并显示h的值。
【程序】
void main()
{
printf("%f\n",h);
}
【例题3.150e】将整数转换为浮点数
编写程序，对变量a赋值为321，b赋值为123.4567，求其浮点数的和。
【程序】
void main()
{ int a;
float b,c;
a=321,b=123.4567;
c=(float)a+b;
printf("%f\n",c);
}
【习题3.153】赋值，表达式，类型转换，显示
在以下程序空缺处填写合适内容，使得程序能够分别对变量a赋值12，b赋值345.678，将a实数化后求a*b赋给a。
【程序】
void main()
{ int a;
float b,c;
a= ,b=
c=
printf("%f\n",c);
}
【例题3.160e】浮点数转换为整数
编写程序，令变量b取值35.425，c取值52.954，先将b+c的结果转换为整数后赋给变量a1，然后将b和c的值分别转换为整数后求和赋给变量a2。
【程序】
void main()
{ int a1,a2;
float b,c;
b=35.425,c=52.954;
a1=(int)(b+c);
a2=(int)b+(int)c;
printf("%d\n",a1);
printf("%d\n",a2);
}
【习题3.162】强制类型转换运算符
编写程序，对变量a赋值为1.63，b赋值为4.46，将a+b的和取整后赋给c，并显示c。
【程序】
void main()
{ float a,b;
int c;
a= ;
b= ;
c= ;
printf("c=%d\n",c);
}
【习题3.163】浮点型变量，赋值，表达式，类型转换，显示
在以下程序空缺处填写合适内容，使得程序能够分别对变量b赋值34.567，c赋值56.789，将b*c的值整数化后赋给a1，再将b与c分别整数化后求积赋给a2。
【程序】
void main()
{ int a1,a2;
printf("a1=%d\n",a1);
printf("a2=%d\n",a2);
}
【习题3.166】浮点变量，赋值，表达式，类型转换，显示
在以下程序空缺处填写合适内容，使得程序能够分别对变量b赋值2.34567，c赋值56.789，将b与c分别整数化后求和赋给a。
【程序】
void main()
{ int a;
printf("a=%d\n",a);
}
【习题3.168】浮点变量，赋值，表达式，类型转换，显示
在以下程序空缺处填写合适内容，使得程序能够先后对浮点型变量y赋值1/3和1.0/3.0。请观察程序运行输出的结果。
【程序】
void main()
{
float y;
y=
printf("y=%f\n",y); /*输出*/
y=
printf("y=%f\n",y); /*再次输出*/
}
【例题3.170e】组合运算符
编写程序，首先令变量a值为2，b值为5，c值为6，d值为10，然后依次将a加b的值赋予a，b减c的值赋予b，c乘以d的值赋予c，d除以a的值赋予d，a除以c的余数赋予a。
【程序】
void main()
{ int a=2,b=5,c=6,d=10;
a+=b;
b-=c;
c*=d;
d/=a;
a%=c;
printf("%d %d %d %d %d\n",a,b,c,d,a);
//用空格分隔，在同一行显示各运算结果
}
【习题3.173】自反运算赋值，显示
在以下程序空缺处填写合适内容，使得程序能够分别对变量a赋值34，b赋值56，用自反运算赋值将a+b的值赋给a，b*a的值赋给b，并显示a和b的值。
【程序】
void main()
{
a+=
b*=
printf("a=%d b=%d\n",a,b);
}
【习题3.175】自反运算赋值，显示
在以下程序空缺处填写合适内容，使得程序能够分别对变量a赋值567，b赋值18，c赋值5，用自反运算赋值将a÷b的商赋给a，b÷c的余数赋给b，并显示a和b的值。
【程序】
void main()
{
a/=
b%=
printf("%d %d %d\n",a,b,c);
}
【例题3.180e】增1运算：++
编写程序，先对整型变量a赋值为80，然后依次分行显示++a，a++和a的值。
【程序】
void main()
{ int a=80;
printf("%d\n",++a); //前++
printf("%d\n",a++); //后++
printf("%d\n",a);
}
【习题3.183】增1运算：++
编写程序，先对整型变量a赋值600，然后依次分行显示a++，++a的值。
【程序】
void main()
{ int a=600;
printf("%d\n", );
printf("%d\n", );
}
【习题3.184】增1运算：++
编写程序，先对整型变量a赋值为10，然后依次分行显示a++，a，++a，和a的值。
【程序】
void main()
{ int a=10;
printf("%d\n", );
printf("%d\n", );
printf("%d\n", );
printf("%d\n", );
}
【习题3.185】增1运算：++
编写程序，先对整型变量a赋值1；接着将++a+10赋给b，显示b的值；然后将10-a++赋给c，显示c的值；最后再次显示a的值。
【程序】
void main()
{ int a=1,b,c;
b= ；
printf("b=%d ",b);
c= ；
printf("c=%d ",c);
printf("a=%d\n",a);
}
【习题3.186】增1运算：++
编写程序，先对整型变量a赋值10，显示a的值；接着将++a+5赋给b，显示b的值；然后将7+a++赋给c，显示c的值；最后再次显示a的值。
【程序】
void main()
{ int a=10,b,c;
printf("a=%d ",a);
b=
printf("b=%d ",b);
c=
printf("c=%d ",c);
printf("a=%d\n",a);
}
【例题3.190e】减1运算：--
编写程序，先令整型变量a的值为80，然后依次分行显示--a，a--和a的值。
【程序】
void main()
{ int a=80;
printf("%d\n",--a);
printf("%d\n",a--);
printf("%d\n",a);
}
【习题3.193】减1运算：--
编写程序，先对整型变量a赋值600，然后依次分行显示a--，--a的值。
【程序】
void main()
{ int a=600;
printf("%d\n", );
printf("%d\n", );
}
【习题3.194】减1运算：--
编写程序，先对整型变量a赋值为10，然后依次分行显示a--，a，--a，和a的值。
【程序】
void main()
{ int a=10;
printf("%d\n", );
printf("%d\n", );
printf("%d\n", );
printf("%d\n", );
}
【习题3.196】减1运算：--
编写程序，先对整型变量a赋值10，显示a的值；接着将--a+5赋给b，显示b的值；然后将7+a--赋给c，显示c的值；最后再次显示a的值。
【程序】
void main()
{ int a=10,b,c;
printf("a=%d ",a);
b=
printf("b=%d ",b);
c=
printf("c=%d ",c);
printf("a=%d\n",a);
}
【习题3.197】减1运算：--
编写程序，先对整型变量a赋值100；接着将--a-10赋给b，显示b的值；然后将10+a--赋给c，显示c的值；最后再次显示a的值。
【程序】
void main()
{ int a=100,b,c;
b= ;
printf("b=%d ",b);
c= ;
printf("c=%d ",c);
printf("a=%d\n",a);
}
【例题3.210e】移位运算：左移 <<，右移 >>
编写程序，先令整型变量a值为7，b值为11，依次将a的值右移1位赋给c，将b的值左移3位赋给d，最后显示c和d的值。
【程序】
void main()
{ int a=7,b=11;
int c,d;
c=a>>1; //c赋值为a的值右移1个二进位的结果
d=b<<3; //d赋值为b的值左移3个二进位的结果
printf("%d %d\n",c,d);
}
【习题3.213】移位运算：左移 <<，右移 >>
编写程序，先令整型变量a值为9，b值为11，依次将a的值右移2位赋给c，将b的值左移2位赋给d，最后显示c和d的值。
【程序】
void main()
{ int a=9,b=11;
int c,d;
c=
d=
printf("c=%d d=%d\n",c,d);
}
【例题3.220e】按位运算符
编写程序，先令整型变量a取值7，b取值11，依次求出并显示a和b的AND、OR、XOR的结果。
【程序】
void main()
{ int a=7,b=11;
int c,d,e;
c=a&b;
d=a|b;
e=a^b;
printf("%d&%d=%d\n",a,b,c);
printf("%d|%d=%d\n",a,b,d);
printf("%d^%d=%d\n",a,b,e);
}
【习题3.223】16进制数，按位与运算：&
编写程序，先令整型变量a值为16进制数0x123a，b值为0x1100，将a和b按位与的值赋给c之后，显示a，b和c的值。
【程序】
void main()
{
c=
printf("%x & %x = %x\n",a,b,c);
}
【例题3.230e】运算符&，|和^的组合运用
编写程序，先令变量a取值5，b取值12，c取值4，求a|b和a^c的结果的&。
【程序】
void main()
{ int a=5,b=12,c=4;
int er,ok;
er=a&b|a^c; //不符合题意
ok=(a|b)&(a^c); //注意运算的优先级和括号的使用
printf("%d|%d&%d^%d=%d error\n",a,b,a,c,er);
printf("(%d|%d)&(%d^%d)=%d ok\n",a,b,a,c,ok);
}
【例题3.240e】按位取反运算：~
编写程序，先令整型变量a取值9，然后对a的值按位取反后赋给b，显示b的值。
【程序】
void main()
{ int a=9;
int b;
b=~a;
printf("%d\n",b);
}
【习题3.243】长整型，16进制数，按位取反运算：~
编写程序，先令整型变量a值为16进制数0x12ac，显示a的值；然后将a的值按位求反后赋给b，显示b的值。
【程序】
void main()
{ long a=
long b;
printf("a=%x\n",a);
b=
printf("b=%x\n",b);
}
【例题3.270e】字符型变量
编写程序，先将字符'C'赋予变量a、'H'赋予b，字符'N'赋予c，然后在同一行用空格分隔显示a、b、c的值。
【程序】
void main_ans()
{ char a,b,c;
a='C';
b='H';
c='N';
printf("%c %c %c\n",a,b,c);
}
【例题3.280e】字符显示
编写程序，先将字符'A'、'n'、'y'、'v'、'i'、'e'、'w'分别赋给变量a、b、c、d、e、f、g，然后在同一行依次显示各变量的值。
【程序】
void main()
{ char a,b,c,d,e,f,g;
a='A',b='n',c='y',d='v';
e='i',f='e',g='w';
printf("%c%c%c%c%c%c%c\n",a,b,c,d,e,f,g);
}
【例题3.290e】字符和ASCII码
编写程序，先将字符'C'、'H'、'N'分别赋给变量a，b，c，然后显示变量a、b、c的字符值和ASCII码。
【程序】
void main()
{ char a,b,c;
a='C',b='H',c='N';
printf("%c:%d %c:%d %c:%d\n",a,a,b,b,c,c);
}
【习题3.293】字符的ASCII码
在以下程序空缺处填写合适内容，使得程序能够对字符变量ａ、b和c分别赋值为'O'、'K'和'!'，显示各变量的字符值和ASCII码。
【程序】
void main()
{
printf("%c:%d %c:%d %c:%d\n",a,a,b,b,c,c);
}
【例题3.300e】ASCII码和字符
编写程序，先将67，72，78分别赋给整型变量a，b，c，然后显示三个变量值及其作为ASCII码所对应的字符。
【程序】
void main()
{ int a,b,c;
a=67,b=72,c=78;
printf("%d:%c %d:%c %d:%c\n",a,a,b,b,c,c);
}
【习题3.303】ASCII码对应的字符
在以下程序空缺处填写合适内容，使得程序能够对整型变量ａ、b和c分别赋值为79、75和33，显示各变量的值和以其为ASCII码的字符。
【程序】
void main()
{
printf("%d:%c %d:%c %d:%c\n",a,a,b,b,c,c);
}
【习题3.305】ASCII码对应的字符
在以下程序空缺处填写合适内容，使得程序能够对整型变量ａ、b、c、d和e分别赋值为83、116、117、100和121，显示以各变量的值作为ASCII码的字符。
【程序】
void main()
{
printf("%c%c%c%c%c\n",a,b,c,d,e);
}
【习题3.542】a和b是系统给定的外部整型变量（不需要自行定义）。编写程序，取a的值并将其个位数清0后存放到b。例如，若a=1,则b=0；若a=12,则b=10；若a=123,则b=120。
【习题3.544】a和b是系统给定的外部整型变量（不需要自行定义）。编写程序，取a的值并将其个位和十位数清0后存放到b。例如，若a=1,则b=0；若a=12,则b=0；若a=123,则b=100。
【习题3.546】a和b是系统给定的外部整型变量（不需要自行定义）。编写程序，取a的值并将其十位数清0后存放到b。例如，若a=1,则b=1；若a=12,则b=2；若a=123,则b=103。
【习题3.554】a和b是系统给定的外部整型变量（不需要自行定义）。编写程序，将a的十位数和个位数“组成”一个整数，并将结果存放到b。例如，若a=12,则b=12；若a=123,则b=23。
【习题3.555】a和b是系统给定的外部整型变量（不需要自行定义）。编写程序，将a的个位数和十位数逆位“组成”一个整数，并将结果存放到b。例如，若a=12,则b=21；若a=123,则b=32。
【习题3.556】a是系统给定的外部整型变量（不需要自行定义）。编写程序，将a的个位数和十位数互换。例如，若a=12,则互换后a=21；若a=123,则互换后a=132。
【习题3.557】a是系统给定的外部整型变量（不需要自行定义），其值是一个3位十进制数。编写程序，将a的值循环右移1位。例如，若a=123,则移位后a=312；若a=360,则移位后a=36。
【习题3.558】a是系统给定的外部整型变量（不需要自行定义），其值是一个3位十进制数。编写程序，将a的值循环左移1位。例如，若a=123,则移位后a=231；若a=408,则移位后a=84。
【习题3.560】 a、b和c是系统给定的外部整型变量（不需要自行定义）。编写程序，将a和b的个位数顺位“拼接”为整数，并将结果存放到c。例如，若a=123,b=456,则c=36；若a=100,b=357,则c=7。
【习题3.561】 a、b和c是系统给定的外部整型变量（不需要自行定义）。编写程序，将a和b的个位数逆位“拼接”为整数，并将结果存放到c。例如，若a=123,b=456,则c=63；若a=100,b=357,则c=70。
【习题3.562】 a、b和c是系统给定的外部整型变量（不需要自行定义）。编写程序，将a和b的低2位数顺位“拼接”为整数，并将结果存放到c。例如，若a=123,b=456,则c=2356；若a=300,b=108,则c=8。
【习题3.563】 a、b和c是系统给定的外部整型变量（不需要自行定义）。编写程序，将a和b的低2位数逆位“拼接”为整数，并将结果存放到c。例如，若a=123,b=456,则c=3265；若a=300,b=108,则c=80。
【习题3.566】 系统给定外部整型变量a和b，长整型变量c（不需要自行定义）。编写程序，将a和b的低3位数顺位“拼接”为整数，并将结果存放到c。例如，若a=1234,b=4567,则c=234567；若a=3000,b=1080,则c=80。
【习题3.567】 系统给定外部整型变量a和b，长整型变量c（不需要自行定义）。编写程序，将a和b的低3位数逆位“拼接”为整数，并将结果存放到c。例如，若a=1234,b=4567,则c=432765；若a=6003,b=2800，则c=300008。
【例题3.710e】用scanf输入
编写程序，用scanf输入一个整数并将其显示。
【程序】
void main()
{ int a;
scanf("%d",&a);
printf("%d\n",a);
}
【习题3.713】输入整数
在以下程序空缺处填写合适内容，使得程序能够通过scanf语句输入一个整数到整型变量ａ，计算a的立方值并赋给整型变量b。
【程序】
void main()
{
printf("%d^3=%d\n",a,b);
}
【例题3.720e】用scanf输入
编写程序，用scanf输入2个整数到变量a和b，求其之积并显示等式。
【程序】
void main()
{ int a,b,c;
scanf("%d",&a);
scanf("%d",&b);
c=a*b;
printf("%d*%d=%d\n",a,b,c);
}
【习题3.723】输入整数
在以下程序空缺处填写合适内容，使得程序能够通过两个scanf语句分别输入整数到整型变量ａ和b，计算a和b的平方和并赋给整型变量c。
【程序】
void main()
{
printf("%d^2+%d^2=%d\n",a,b,c);
}
【例题3.730e】用一个scanf语句输入两个整数
编写程序，用一个scanf语句输入两个整数，求其和并显示等式。
【程序】
void main()
{ int a,b,c;
scanf("%d %d",&a,&b);
c=a+b;
printf("%d+%d=%d\n",a,b,c);
}
【例题3.740e】用一个scanf语句输入两个实数
编写程序，用一个scanf语句输入两个实数，求其差并显示等式。
【程序】
void main()
{ float a,b,c;
scanf("%f %f",&a,&b);
c=a-b;
printf("%f-%f=%f\n",a,b,c);
}
【例题3.750e】用scanf语句输入一个字符
编写程序，用scanf语句输入1个字符到字符变量a，显示其字符值和ASCII码。
【程序】
void main()
{ char a;
scanf("%c",&a);
printf("%c:%d\n",a,a);
}
【例题3.760e】用一个scanf语句输入两个字符
编写程序，用一个scanf语句输入两个字符到字符变量a和b，显示其字符值和ASCII码。
【程序】
void main()
{
char a,b;
scanf("%c%c",&a,&b);
printf("%c:%d %c:%d\n",a,a,b,b);
}
【例题3.770e】用一个scanf语句输入两个字符（忽略分隔空格）
编写程序，用一个scanf语句,忽略分隔空格，输入两个字符到字符变量a和b，显示其字符值和ASCII码。
【程序】
void main()
{ char a,b;
scanf("%c %c",&a,&b);
printf("%c:%d %c:%d\n",a,a,b,b);
}
【例题3.780e】用两个scanf语句各输入一个字符
编写程序，用两个scanf语句各输入一个字符到字符变量a和b，显示其字符值和ASCII码。
【程序】
void main( )
{
char a,b;
scanf("%c",&a);
scanf("%c",&b);
printf("%c:%d %c:%d\n",a,a,b,b);
}
【例题3.790e】忽略中间一个字符的输入
编写程序，用两个scanf语句，忽略中间一个字符，分别输入一个字符到字符变量a和b，显示其字符值和ASCII码。
【程序】
void main()
{ char a,b;
scanf("%c",&a);
scanf("%*c%c",&b);
printf("%c:%d %c:%d\n",a,a,b,b);
}
【例题3.800e】16进制数和8进制数的输出
编写程序，显示175的16进制表示和23的8进制表示。
【程序】
void main()
{ int a,b;
a=175;
b=23;
printf("a=(%d)10#=(%x)16#\n",a,a);
printf("b=(%d)10#=(%o)8#\n",b,b);
}
【例题3.810e】科学记数法
编写程序，分别赋值变量a为123.4567和b为97531.68，并用科学记数法形式显示。
【程序】
void main()
{ float a,b;
a=123.4567;
b=97531.68;
printf("a=%f=%e\n",a,a); /*a=123.456700=1.234567e+002*/
printf("b=%f=%e\n",b,b); /*b=97531.680000=9.753168e+004*/
}
【例题3.820e】输入和显示16进制数
编写程序，用scanf语句输入一个16进制数到变量a，并显示其16进制和10进制表示。
【程序】
void main()
{ int a;
scanf("%x",&a);
printf("a=(%x)16#=(%d)10#\n",a,a);
}
【例题3.830e】输入和显示8进制数
编写程序，用一个scanf语句输入两个8进制数到变量a和b，显示a和b的乘积。
【程序】
void main()
{
int a,b;
scanf("%o %o",&a,&b);
printf("%o*%o=%o\n",a,b,a*b);
}
【例题3.840e】long长整型变量
编写程序，将123456789和87654321分别赋给长整型变量a和b，求其和赋给sum并显示结果。
【程序】
void main()
{ long a,b,sum;
a=123456789;
b=87654321;
sum=a+b;
printf("%ld+%ld=%ld\n",a,b,sum);
}
【例题3.850e】unsigned int无符号整型变量
编写程序，将88、89和90分别赋给无符号整型变量a、b和c，显示其值和相应字符。
【程序】
void main()
{ unsigned int a,b,c;
a=88;
b=89;
c=90;
printf("%d:%c %d:%c %d:%c\n",a,a,b,b,c,c);
}
【例题3.860e】指定显示位数
编写程序，将135、43和6789依次赋给整型变量a、b和c，分别用域宽5位、3位、9位进行显示。
【程序】
void main()
{ int a,b,c;
a=135,b=43,c=6789;
printf("123456789\n");
printf("%5d\n",a);
printf("%3d\n",b);
printf("%9d\n",c);
}
【例题3.870e】指定浮点数的显示格式
编写程序，将543.3456和23.4567赋给浮点型变量a和b，求其和、差、积、商，并在显示时分别指定了不同的域宽和小数点后的位数。
【程序】
void main()
{ float a,b,sum,min,tim,sep;
a=543.3456;
b=23.4567;
sum=a+b;
min=a-b;
tim=a*b;
sep=a/b;
printf("%10.4f+%10.4f=%10.4f\n",a,b,sum);
printf("%10.2f-%10.2f=%10.2f\n",a,b,min);
printf("%10.5f*%10.5f=%10.5f\n",a,b,tim);
printf("%10.4f/%10.4f=%5.2f\n",a,b,sep);
}
【例题3.880e】指定小数点后的显示位数
编写程序，输入一个浮点数，分别按小数点后3位、2位和1位的格式显示。
【程序】
void main()
{ float a;
scanf("%f",&a);
printf("%.3f %.2f %.1f\n",a,a,a);
}
【例题3.890e】字符显示格式
编写程序，将'X'赋给字符变量a，分别按1位、2位、3位和4位域宽的格式显示。
【程序】
void main()
{ char a;
a='x';
printf("%1c%2c%3c%4c\n",a,a,a,a);
}
【例题3.900e】显示字符图案
编写程序，显示字符图案:
x x
x x
xx
xx
x x
x x
【程序】
void main()
{ char a;
a='x';
printf("%1c%5c\n",a,a);
printf("%2c%3c\n",a,a);
printf("%3c%1c\n",a,a);
printf("%3c%1c\n",a,a);
printf("%2c%3c\n",a,a);
printf("%1c%5c\n",a,a);
}
【习题3.905】显示多个相关字符
s是系统给定的外部字符型变量（不需要自行定义）。编写程序，依次以空格分隔输出s字符的前导字符、s字符和s的后续字符。例如，若s='b',则输出 a b c
【程序】
void main()
{
printf("%c %c %c\n", , s, );
}
【例题3.910e】指定有效输入位数
编写程序，输入一个不超过3位的整数。
【程序】
void main()
{ int a;
scanf("%3d",&a);
printf("%d\n",a);
}
【例题3.920e】指定有效输入位数
编写程序，分别按1位和2位输入两个整数到整型变量a和b，求其积赋给c并显示。
【程序】
void main()
{ int a,b,c;
scanf("%1d%2d",&a,&b);
c=a*b;
printf("%d*%d=%d\n",a,b,c);
}
第4章 选择结构程序设计(例题13—习题0/13)
【例题4.010e】if语句
编写程序，输入一个整数到变量a，若其值为0或正数，则显示其值。
【程序】
void main()
{ int a;
scanf("%d",&a); /*输入a*/
if(a>=0)
printf("a=%d\n",a);
}
【习题4.011】关系表达式，if语句第一种形式
在以下程序空缺处填写合适内容，使得程序能够判断用户输入的字符是否为'@'，若是则显示："输入正确"。
【程序】
#include<stdio.h>
void main()
{ char c;
scanf("%c",&c);
if( ) printf("输入正确\n");
}
【习题4.012】关系表达式，if语句第一种形式
在以下程序空缺处填写合适内容，使得程序能够输入一个整数赋给变量a，计算并输出a的绝对值a1。
【程序】
#include<stdio.h>
void main( )
{ int a,a1;
scanf("%d",&a);
printf("|%d| = %d\n",a,a1);
}
【习题4.013】逻辑表达式，if语句第一种形式
在以下程序空缺处填写合适内容，使得程序能够对输入的整型变量x的值进行判断，若变量x值为“假”时输出
“False”。
【程序】
#include<stdio.h>
int main( )
{ int x;
scanf("%d",&x);
if( )
printf("False!\n");
return 0;
}
【例题4.015e】if语句
编写程序，输入两个整数到变量a和b，使用if语句由小到大显示这两个数。
【程序】
void main()
{ int a,b,t;
scanf("%d %d",&a,&b);
if(a>b){
t=a; a=b; b=t;
}
printf("%d %d\n",a,b);
}
【习题4.016】if语句的子句为复合语句
在以下程序空缺处填写合适内容，使得程序能够将输入到变量a和b的两个整数按照由大到小的顺序输出。
【程序】
#include<stdio.h>
void main( )
{ int a,b,t;
scanf("%d %d",&a,&b);
if( )
{ }
printf("%d %d\n",a,b);
}
【例题4.020e】if-else语句
编写程序，输入两个整数到变量a和b，使用if-else语句由小到大显示这两个数。
【程序】
void main()
{ int a,b;
scanf("%d %d",&a,&b);
if(a<b)
printf("%d %d\n",a,b);
else
printf("%d %d\n",b,a);
}
【例题4.025e】条件表达式
编写程序，输入两个整数到变量a和b，使用条件表达式显示这两个数中的较大者。
【程序】
void main()
{ int a,b;
scanf("%d %d",&a,&b);
printf("%d\n",a>b?a:b);
}
【例题4.030e】if-else语句
编写程序，输入一个整数到变量a，若为0或正数，则显示：其值及“is positive”；若为负数，则显示：其值及“is negative”。
【程序】
void main()
{ int a;
scanf("%d",&a); /*输入a*/
if (a>=0)
printf("%d is positive\n", a); /*a为0或正数*/
else
printf("%d is negative\n", a); /*a为负数*/
}
【例题4.040e】if-else语句
编写程序，输入两个整数到变量a和b，若a<=b，则求其积赋给c并显示，否则求其商赋给c并显示。
【程序】
void main()
{ int a,b,c;
scanf("%d %d",&a,&b);
if (a<=b) {
c=a*b;
printf("%d*%d=%d\n",a,b,c);
} else {
c=a/b;
printf("%d/%d=%d\n",a,b,c);
}
}
【例题4.050e】嵌套if-else语句
编写程序，输入一个整数到变量a，按其数值小于10、10-99、100-999、1000以上等四种情形分类并显示。例如：输入248时，显示：“248∈[100,999]”。
【程序】
void main()
{ int a;
scanf("%d",&a);
if (a>=100) {
if (a>=1000)
printf("%d∈[1000,+∞)\n",a);
else
printf("%d∈[100,999]\n",a);
} else {
if (a<10)
printf("%d∈(-∞,10]\n",a);
else
printf("%d∈[10,99]\n",a);
}
}
【例题4.060e】switch语句
编写程序，输入一个整数到变量x，若x的值在1到4之间，则显示x个城市的市名，否则不显示。
【程序】
void main()
{ int x;
scanf("%d",&x);
switch (x) {
case 4: printf("Shenzhen\n");
case 3: printf("Guangzhou\n");
case 2: printf("Beijing\n");
case 1: printf("Shanghai\n");
}
}
【例题4.070e】switch和break语句
编写程序，输入“brics”中的一个字母到变量x，显示“金砖5国”中以该字母打头的国家名称。
【程序】
void main()
{ char x;
scanf("%c",&x);
switch (x) {
case 'b':
printf("Brazil\n") ;
break;
case 'r':
printf("Russia\n");
break;
case 'i':
printf("India\n");
break;
case 'c':
printf("China\n");
break;
case 's':
printf("South Africa\n");
}
}
【例题4.080e】switch和break语句
编写程序，输入三个整数到变量a、b和c，当a为1时显示b和c之和，a为2时显示b与c之差，a为3时显示b和c之积，a为其他值时显示b+c和b-c之积。
【程序】
void main()
{ int a,b,c;
scanf("%d %d %d",&a,&b,&c);
switch (a) {
case 1:
printf("%d+%d=%d\n",b,c,b+c);
break;
case 2:
printf("%d-%d=%d\n",b,c,b-c);
break;
case 3:
printf("%d*%d=%d\n",b,c,b*c);
break;
default:
printf("(%d+%d)*(%d-%d)=%d\n",b,c,b,c,(b+c)*(b-c));
}
}
【例题4.200e】条件运算（3目运算）
编写程序，令整型变量a取值52，b取值25，若a>b成立则将a的值赋予c，否则将b的值赋予c。同时，若a<b成立则将a的值赋予d，否则将b的平方值赋予d。
【程序】
void main()
{ int a=52,b=25;
int c,d;
c=((a>b)?a:b);
d=((a<b)?a:b*b);
printf("%d\n",c);
printf("%d\n",d);
}
【习题4.203】条件运算（3目运算）
编写程序，先令整型变量a取值0，b取值-20；然后用条件运算实现：若a>b成立则将b的平方值赋予c，否则将0赋予c；最后显示c的值。
【程序】
void main()
{ int a=0,b=-20,c;
c=
printf("c=%d\n",c);
}
【习题4.211】已知3个非零整数被分别输入到整型变量a,b和c。编写一个条件表达式，判定这3个值能否作为一个三角形的3条边的长度？若能，则该表达式的值为1，否则值为0。
【习题4.213】已知3个非零整数被分别输入到整型变量a,b和c。编写一个条件表达式，判定这3个值能否作为一个等腰三角形的3条边的长度？若能，则该表达式的值为1，否则值为0。
【习题4.215】已知3个非零整数被分别输入到整型变量a,b和c。编写一个条件表达式，判定这3个值能否作为一个等边三角形的3条边的长度？若能，则该表达式的值为1，否则值为0。
【习题4.223】已知3个非零整数被分别输入到整型变量a,b和c。编写一个条件表达式，判定这3个值能否作为一个直角三角形的3条边的长度？若能，则该表达式的值为1，否则值为0。
【习题4.225】已知3个非零整数被分别输入到整型变量a,b和c。编写一个条件表达式，判定这3个值能否作为一个锐角三角形的3条边的长度？若能，则该表达式的值为1，否则值为0。
【习题4.227】已知3个非零整数被分别输入到整型变量a,b和c。编写一个条件表达式，判定这3个值能否作为一个钝角三角形的3条边的长度？若能，则该表达式的值为1，否则值为0。
【例题4.250e】逻辑运算：&&和||
编写程序，先将6赋予a、9赋予b、0赋予c，然后依次求a&&b，a||b和a&&c并显示结果。
【程序】
void main()
{ int a=6,b=9,c=0;
int d,e,f;
d=a&&b;
e=a||b;
f=a&&c;
printf("%d&&%d=%d\n",a,b,d);
printf("%d||%d=%d\n",a,b,e);
printf("%d&&%d=%d\n",a,c,f);
}
【习题4.253】逻辑运算：&& 和 ||
编写程序，先令整型变量a和b的值均为34，c的值为78，然后依次将a和b的逻辑与赋给d，a和c的逻辑或赋给e，a和c的逻辑与赋给f，最后分行显示d，e和f的值。
【程序】
void main()
{ int a=34,b=34,c=78;
int d,e,f;
d=
e=
f=
printf("%d && %d = %d\n",a,b,d);
printf("%d || %d = %d\n",a,c,e);
printf("%d && %d = %d\n",a,c,f);
}
【例题4.260e】逻辑运算：!（逻辑非）
编写程序，先对整型变量a赋值1，b赋值0，然后分别求其逻辑非。
【程序】
void main()
{ int a=1,b=0;
int c,d;
c=!a;
d=!b;
printf("!%d=%d\n",a,c);
printf("!%d=%d\n",b,d);
}
【习题4.263】逻辑非运算：!
编写程序，先令整型变量a的值为700，b的值为-30，然后依次将a的逻辑非赋给c，b的逻辑非赋给d，最后分行显示c和d的值。
【程序】
void main()
{
c=
d=
printf("!%d=%d\n",a,c);
printf("!%d=%d\n",b,d);
}
第5章 循环结构程序设计（含：序列求和）(例题0—习题41)
【习题5.002】编写程序，利用while语句在同一行中逐个显示从1至5的数字，每个数字之前保留2个空格。
【习题5.003】编写程序，利用for语句在同一行中逐个显示从1至6的数字，每个数字之前保留2个空格。
【习题5.004】n是系统给定的外部整型变量（不需要自行定义）。编写程序，利用循环语句在同一行中逐个显示从1至n的数字，每个数字之前保留2个空格。
【习题5.012】请仅在程序空缺处填入合适内容，使其实现功能：依次入5个整数，计算它们之和并输出。
#include <stdio.h>
void main()
{ int i,sum=0, n;
for (i=1;i<=5;i++)
{ scanf("%d", );
sum= ;
}
printf("sum = %d",sum);
}
【习题5.020】n和s是系统给定的外部整型变量（不需要自行定义）。编写程序，求1到n之间的整数之和，并将结果存放到s。
【习题5.022】n是系统给定的外部变量。编写程序，求1到n间的自然数之和。请定义局部变量s存放求和的结果，并用下列语句输出结果
printf("1+2+...+n=%d\n",s);
【习题5.026】n和s是系统给定的外部整型变量（不需要自行定义）。编写程序，求1到n之间的奇数之和，并将结果存放到s。
【习题5.028】n和s是系统给定的外部整型变量（不需要自行定义）。编写程序，求1到n之间的偶数之和，并将结果存放到s。
【习题5.029】请仅在程序空缺处填入合适内容，使其实现功能：输入大于1的整数到n，在同一个循环语句中分别计算1到n之间的奇数和偶数之和。
#include<stdio.h>
void main()
{ int odd,even,i,n;
scanf("%d", &n);
printf("sum of odd=%d ",odd); /*奇数之和*/
printf("sum of even=%d\n", even);/*偶数之和*/
}
【习题5.030】系统给定外部整型变量n和长整型变量f（不需要自行定义）。编写程序，求n的阶乘n!，并将结果存放到f。
例如，当n=6时，f=6!=1*2*...*6=720。注意：0！=1。
【习题5.032】系统给定外部整型变量n和长整型变量f（不需要自行定义）。编写程序，求n的双阶乘n!！，并将结果存放到f。双阶乘的定义是：
当n是奇数时，n！为不大于n的所有奇数的乘积，如：7!!=1×3×5×7。
当n为偶数时表示不大于n的所有偶数的乘积(0除外），如：8!!=2×4×6×8。
【习题5.034】系统给定外部整型变量n和浮点变量f（不需要自行定义）。编写程序，求负整数n的阶乘n!，并将结果存放到f。假设m是正整数，负整数-m的阶乘定义是：(-m)!=1/(m+1)!。
【习题5.040】m,n和s是系统定义的外部整型变量（不需要自行定义）。编写程序，根据m的值求满足1+2+...+n>=m的最小n，并将1+2+...+n的结果存放到s。例如，若m=50，则n=10，s=55。
【习题5.042】 m,n和s是系统定义的外部整型变量（不需要自行定义）。编写程序，根据m的值求满足1+2+...+n<m的最大n，并将1+2+...+n的结果存放到s。例如，若m=50，则n=9，s=45。
【习题5.050】n和s是系统给定的外部整型变量（不需要自行定义）。编写程序，求1+1/2+1/3+...+1/n，并将结果存放到s。
【习题5.051】系统给定外部整型变量n和浮点型变量s（不需要自行定义）。编写程序，求1-1/2+1/3-1/4+...1/n，并将结果存放到s。
【习题5.053】系统给定外部整型变量n和浮点型变量s（不需要自行定义）。编写程序，求1+1/(1+2)+1/(1+2+3)+...+1/(1+2+...+n)，并将结果存放到s。
【习题5.055】系统给定外部整型变量n和浮点型变量pi（不需要自行定义）。编写程序，求序列4,-4/3,4/5,-4/7,4/9,-4/11...的前n项和，并将结果存放到pi。
【习题5.056】系统给定外部整型变量n和浮点型变量pi2（不需要自行定义）。编写程序，求1+1/3+1*2/(3*5)+1*2*3/(3*5*7)+1*2*3*4/(3*5*7*9)+...+1*2*...*n/(3*5*7*...*(2n+1))，并将结果存放到pi2。
【习题5.062】请仅在程序空缺处填入合适内容，使其实现功能：逐个输入整数，直到输入0为止，计算所输入数值之和并输出。
#include <stdio.h>
void main()
{ int sum=0, n=0;
scanf("%d",&n);
while( )
{
}
printf("sum = %d",sum);
}
【习题5.095】n和s是分别是系统给定的外部整型变量和实型变量（不需要自行定义）。编写程序，求分数序列2/1,3/2,5/3,8/5,13/8,21/13,...的前n项和，并将结果存放到s。
【习题5.112】请仅在程序空缺处填入合适内容，使其实现功能：计算正整数n的各位数字之和。例如,输入n的值是12345时，1+2+3+4+5=15，输出sum=15。
#include <stdio.h>
void main()
{ int n,sum=0;
scanf("%d",&n);
do
{ sum=sum+ ;
n= ;
}while(n);
printf("sum = %d",sum);
}
【习题5.125】请仅在程序空缺处填入合适内容，使其实现功能：从键盘输入一批整数，直到输入0时结束，输出其中百位数字是3的整数之和。
#include <stdio.h>
void main()
{ int num,sum=0;
scanf("%d",&num);
do
{ if( ) ;
scanf("%ld",&num);
}while( );
printf("sum = %ld",sum);
}
【习题5.132】请仅在程序空缺处填入合适内容，使其实现功能：输入大于1的整数到n，计算1至n中是7的倍数的整数之和。
#include<stdio.h>
void main()
{ int i,sum,n;
scanf("%d",&n);
printf("sum = %d",sum);
}
【习题5.161】n和s是分别是系统给定的外部整型变量和长整型变量（不需要自行定义）。编写程序，求1!+2!+3!+4!+5!+…+n!，并将结果存放到s。
【习题5.163】n和e是分别是系统给定的外部整型变量和浮点型变量（不需要自行定义）。编写程序，求1+1/1!+1/2!+1/3!+…+1/n!，并将结果存放到e。
【习题5.165】系统给定外部整型变量n和浮点型变量x和e（不需要自行定义）。编写程序，求1+x/1!+x^2/2!+x^3/3!+…+x^n/n!，并将结果存放到e，其中，^是幂运算，x^2表示x的平方，x^n表示x的n次方。
【习题5.172】系统给定外部长整型变量s，整型变量a和n，且a和n的值均在0和9之间（不需要自行定义）。编写程序，求a+aa+aaa+…+aa…aaa（有n个a）之值，并将结果存放到s。例如：a=3和n=5时，求3+33+333+3333+33333。
【习题5.175】系统给定外部长整型变量s，整型变量a、m和n，1<=a<=9且1<=m<=n<=9（不需要自行定义）。编写程序，求序列a,aa,aaa,…,aa…a(第n项为n个a）中，第m项至第n项之和，并将结果存放到s。例如：当a=8，m=3且n=6时，置s=888+8888+88888+888888。
【习题5.176】系统给定外部长整型变量s，整型变量a、m和k，1<=a<=9，1<=m<=9且m+k<=9（不需要自行定义）。编写程序，求数列a,aa,aaa,…,aa…a,…(第i项为i个a）中，第m项起的k项之和，并将结果存放到s。例如：当a=6，m=4且k=3时，置s=6666+66666+666666。
【习题5.183】系统给定外部长整型变量s和整型变量n，且n的值在0和9之间（不需要自行定义）。编写程序，求1+12+123+…+12…n之值，并将结果存放到s。例如，n=5时，置s=1+12+123+1234+12345。
【习题5.184】系统给定外部长整型变量s和整型变量n，且n的值在0和9之间（不需要自行定义）。编写程序，求1+21+321+…+n…21之值，并将结果存放到s。例如，n=5时，置s=1+21+321+4321+54321。
【习题5.186】系统给定外部长整型变量s，整型变量m和n，且1<=m<=n<=9（不需要自行定义）。编写程序，求12…m+12…(m+1)+…+12…n之值，并将结果存放到s。例如，m=3且n=6时，置s=123+1234+12345+123456。
【习题5.187】系统给定外部长整型变量s，整型变量m和n，且1<=m<=n<=9（不需要自行定义）。编写程序，求m…21+(m+1)…21+…+n…21之值，并将结果存放到s。例如，m=3且n=6时，置s=321+4321+54321+654321。
【习题5.203】已知鸡和猫共有30只，脚共有90只。请仅在程序空缺处填入合适内容，实现功能：计算鸡和猫各有几只?
#include <stdio.h>
void main()
{ int x,y,heads=30,feet=90;
for(x=1; )
{ y=
if( )
{ printf("chicken:%d, cat:%d\n",x,y);
break;
}
}
}
【习题5.205】有一堆苹果（数量在100到200之间），如果分成4个苹果一组的若干组，则多2个苹果；若分成7个苹果一组，则多4个苹果； 若分成9个苹果一组，则多5个苹果。请仅在程序空缺处填入合适内容，实现功能：求这堆苹果的总数。
#include <stdio.h>
void main()
{ int i;
for(i=100;i<=200;i++)
{
if( )
{
printf("total: %d",i);
}
}
}
【习题5.215】请仅在程序空缺处填入合适内容，实现功能：求等式xyz+yzz=532中x,y和z的值（其中xyz和yzz分别表示一个三位数）。
#include<stdio.h>
void main()
{ int x,y,z,i,result=532;
//程序输出要用语句 printf("x=%d,y=%d,z=%d\n",x,y,z);
}
【习题5.223】请仅在程序空缺处填入合适内容，使其实现功能：输入并计算一个只包含加减运算的表达式，其中每个运算数都是正整数，运算符都是“+”或“-”，除第一个数以外，其余每个数前面都有一个运算符，当运算数为0时表达式终止。
#include<stdio.h>
void main()
{ int term,result;
char ch;
scanf("%d",&result);
ch=getchar();
//可以使用while循环
printf("result: %d\n",result);
}
【习题5.225】请仅在程序空缺处填入合适内容，使其实现功能：输入并计算一个只包含加减运算的表达式，其中每个运算数都是正整数，运算符都是“+”或“-”，除第一个数以外，其余每个数前面都有一个运算符，表达式以分号“;”终止,例如“23+43-234+157;”。
#include<stdio.h>
void main()
{ int term,result;
char ch;
scanf("%d",&result);
ch=getchar();
//可以使用while循环
printf("result: %d\n",result);
}
【习题5.233】请仅在程序空缺处填入合适内容，使其实现功能：输入并计算一个只包含乘除运算的表达式，其中每个运算数都是正整数，运算符都是“*”或“\”，除第一个数以外，其余每个数前面都有一个运算符，表达式以分号“;”终止,例如“9/3*7;”。
#include<stdio.h>
void main()
{ int term,result;
char ch;
scanf("%d",&result);
ch=getchar( );
//可以使用while循环
printf("result: %d\n",result);
}
【习题5.255】请仅在程序空缺处填入合适内容，使其实现功能：输入非负整数到变量n和0到9中的某一个数到变量d，统计n的各位数字中值为d的个数num，并求各位数字中的最小值m。
#include<stdio.h>
void main()
{ long int n;
int d,num,m=9,t;
num=0;
scanf("%d %d",&n,&d);
do
{
}while(n);
printf("num=%d, min=%d",num,m);
}
第6章 利用数组处理批量数据(例题0—习题24+13)
【习题6.033】系统给定外部整型数组a、整型变量n、max、min和实型变量avg（不需要自行定义）。编写程序，求数组a中前n个元素的最大值max、最小值min及平均值avg。
【习题6.043】系统给定外部整型变量n和整型数组a（不需要自行定义）。编写程序，找出数组a中前n个元素中的最小元素及其下标，然后把它和数组中最前面的元素a[0]交换位置。
【习题6.050】系统给定外部字符串s和整型数组c[26]（不需要自行定义）。编写程序，将字符串s中26个小写字母出现的次数依次统计到数组c中。例如，当s=“abcijkabcdexyzuvwx”时，数组c的26个元素值依次为：2 2 2 1 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 2 1 1。
【习题6.051】系统给定外部字符串s和整型数组c[26]（不需要自行定义）。编写程序，将字符串s中26个字母(不区分大小写)出现的次数依次统计到数组c中。例如，当s=“AbcijKaBcdEXyzuvwx”时，数组c的26个元素值依次为：2 2 2 1 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 2 1 1。
【习题6.110】系统给定外部字符数组变量s和数组长度n（不需要自行定义）。main函数的功能是：把字符串s中所有小写字母转换为大写字母，其他字符不变。例如，当s="68abcdEFGhijkLM86"时，转换后s="68ABCDEFGHIJKLM86"。
请仅在空缺处填入合适内容，使其实现上述功能。
【习题6.120】系统给定外部长整型变量n和字符数组变量s（不需要自行定义）。main函数的功能是：把n的整数值转换成字符串，并逆序保存在s中。例如，当n=20120826时，由n转换得到s="62802102"。
请仅在空缺处填入合适内容，使其实现上述功能。
【习题6.121】系统给定外部长整型变量n和字符数组变量s（不需要自行定义）。main函数的功能是：把n的整数值转换成字符串，并保存在s中。例如，当n=20120826时，由n转换得到s="20120826"。
请仅在空缺处填入合适内容，使其实现上述功能。
【习题6.225】系统给定外部整型变量n、e和整型数组a（不需要自行定义），其中数组a中前n个元素（a[0],a[1],…,a[n-1]）已经按元素值由小到大排序。编写程序，把变量e的值插入到数组a中，并且仍然保持a中元素由小到大的排列顺序。若e的值比原有所有的数都大时，插入在末尾的a[n]。若比原有的数都小时，则插入在最前面的a[0]。
【习题6.255】系统给定外部整型变量n和整型数组a（不需要自行定义）。编写程序，用起泡法对数组a中前n个元素（a[0],a[1],…,a[n-1]）进行分段排序，其中前一半为从小到大排序，后一半为从大到小排序，n为奇数时，位于中间点的数不需要排序。
【习题6.265】系统给定外部整型变量n和整型数组a（不需要自行定义）。编写程序，用起泡法对数组a中前n个元素（a[0],a[1],…,a[n-1]）进行分段排序，其中前一半为从大到小排序，后一半为从小到大排序，并把n个数的平均值存在a[n]中，n为奇数时，位于中间点的数不需要排序。
【习题6.425】系统给定外部整型变量n和整型数组a（不需要自行定义）。编写程序，求某数列中前n个数，并依次存放在数组a中，该数列的前两个数为2和3，以后每一个数都是前两个数之差（后面的数减去前面的数)的2倍，如前6个数依次为：2，3，2，-2，-8，-12）。
【习题6.435】系统给定外部整型变量n和整型数组a和b（不需要自行定义）。编写程序，对数组a的前n个元素依次赋予从2开始的偶数，然后按顺序每5个数求出一个平均值并依次存储在另一数组b中。
【习题6.615】系统给定外部整型变量m、n和整型二维数组a和b（不需要自行定义）。编写程序，将m´n二维数组a的行和列元素互换，存到n´m二维数组b中。
【习题6.621】系统给定外部整型变量n、i、imin和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a中第i行的元素最小值imin。
【习题6.622】系统给定外部整型变量n、i、imax和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a中第i行的元素最大值imax。
【习题6.623】系统给定外部整型变量n、j、jmin和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a中第j列的元素最小值jmin。
【习题6.624】系统给定外部整型变量n、j、jmax和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a中第j列的元素最大值jmax。
【习题6.625】系统给定外部整型变量n、dmin和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a的主对角线元素的最小值dmin。
【习题6.626】系统给定外部整型变量n、dmax和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a的主对角线元素的最大值dmax。
【习题6.633】系统给定外部整型变量n、min和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a中的元素最小值min。
【习题6.634】系统给定外部整型变量n、max和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a中的元素最大值max。
【习题6.636】系统给定外部整型变量n、d2min和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a的两条对角线上的元素的最小值d2min。
【习题6.637】系统给定外部整型变量n、d2max和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a的两条对角线上的元素的最大值d2max。
【习题6.641】系统给定外部整型变量n、i、isum和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a中第i行的元素之和isum。
【习题6.642】系统给定外部整型二维数组a、整型变量n、i和实型变量iavg（不需要自行定义）。编写程序，求n*n二维数组a中第i行的元素平均值iavg。
【习题6.643】系统给定外部整型变量n、j、jsum和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a中第j列的元素之和jsum。
【习题6.644】系统给定外部整型二维数组a、整型变量n、j和实型变量javg（不需要自行定义）。编写程序，求n*n二维数组a中第j列的元素平均值javg。
【习题6.645】系统给定外部整型变量n、dsum和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a的主对角线元素之和dsum。
【习题6.646】系统给定外部整型变量n、整型二维数组a和实型变量davg（不需要自行定义）。编写程序，求n*n二维数组a的主对角线元素平均值davg。
【习题6.653】系统给定外部整型变量n、sum和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a的全部元素之和sum。
【习题6.654】系统给定外部整型二维数组a、整型变量n和实型变量avg（不需要自行定义）。编写程序，求n*n二维数组a的全部元素平均值avg。
【习题6.656】系统给定外部整型二维数组a和整型变量n、d2s（不需要自行定义）。编写程序，求n*n二维数组a的两条对角线上各元素值之和d2s。注意：对角线的元素只能计算一次。
【习题6.657】系统给定外部整型二维数组a、整型变量n和实型变量d2avg（不需要自行定义）。编写程序，求n*n二维数组a的两条对角线上各元素值的平均值d2avg。注意：对角线的元素只能计算一次。
【习题6.662】系统给定外部整型变量n、ss和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a的周边元素之和ss。
【习题6.663】系统给定外部整型二维数组a、整型变量n和实型变量savg（不需要自行定义）。编写程序，求n*n二维数组a的周边元素的平均值savg。
【习题6.664】系统给定外部整型变量n、smin和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a的周边元素的最小值smin。
【习题6.665】系统给定外部整型变量n、smax和整型二维数组a（不需要自行定义）。编写程序，求n*n二维数组a的周边元素的最大值smax。
【习题6.725】系统给定外部整型变量n和整型二维数组a（不需要自行定义）。编写程序，检验n×n的二维整型数组a，是否为魔方矩阵。说明：每一行、每一列、每一对角线上的元素之和都是相等的为魔方矩阵。（初始化值为如下矩阵）
17 24 1 8 15
23 5 7 14 16
4 6 13 20 22
10 12 19 21 3
11 18 25 2 9
【习题6.755】找出一个二维数组的鞍点，即该位置上的元素在该行上最大，在该列上最小。也可能没有鞍点。如：下面数组存在鞍点6。
12223
365
179
第7章 用函数实现模块化程序设计(例题0—习题42)
【习题7.010】写一函数求3个整数中最小的数。
要求实现下列函数：
int min(int x,int y,int z);
【习题7.020】编写函数，求将整笔钱换为1元、5元和10元的零钱共有多少种换法？
要求实现下列函数：
int change(int n);
【习题7.030】先编写一个判断素数的函数。再编写一个函数将一个偶数表示为两个素数之和，并返回其中较小的素数。注：素数指只能被1和自身整除的正整数。规定0，1不是素数。
要求实现下列2个函数：
int prime(int n);
/* 判断素数，如果是素数返回1，不是素数则返回0 */
int f(int i);
/* 将偶数i表示为两个素数之和，返回其中较小的素数*/
【习题7.050】编写函数，将字符串中ASCII码最小的字符放在第一个字符位置，其余字符依次往后移。
要求实现下列函数：
void func(char str[]);
【习题7.060】编写函数将一个nxn的二维数组按“次对角线”翻转。
例如：翻转前的数组 翻转后的数组
1 2 3 9 6 3
4 5 6 ---> 8 5 2
7 8 9 7 4 1
要求实现的函数原型为：
void invert(char a[N][N]);
【习题7.064】编写函数将一个NxN的二维数组“水平”翻转。
例如：翻转前的数组 翻转后的数组
1 2 3 7 8 9
4 5 6 ---> 4 5 6
7 8 9 1 2 3
要求实现的函数原型为：
void invertH(char a[N][N]);
【习题7.065】编写函数将一个NxN的二维数组“垂直”翻转。
例如：翻转前的数组 翻转后的数组
1 2 3 3 2 1
4 5 6 ---> 6 5 4
7 8 9 9 8 7
要求实现的函数原型为：
void invertV(char a[N][N]);
【习题7.067】编写函数将一个NxN的二维数组的周边元素“顺时针”轮转1位。
例如：轮转前的数组 轮转后的数组
1 2 3 4 1 2
4 5 6 ---> 7 5 3
7 8 9 8 9 6
要求实现的函数原型为：
void turningClockwise(char a[N][N]);
【习题7.068】编写函数将一个NxN的二维数组的周边元素“逆时针”轮转1位。
例如：轮转前的数组 轮转后的数组
1 2 3 2 3 6
4 5 6 ---> 1 5 9
7 8 9 4 7 8
要求实现的函数原型为：
void turningAnticlockwise(char a[N][N]);
【习题7.072】编写函数将一个NxN的二维数组a的元素按行向右轮转1位。
例如：轮转前的数组 轮转后的数组
1 2 3 3 1 2
4 5 6 ---> 6 4 5
7 8 9 9 7 8
要求实现的函数原型为：
void turningRight(char a[N][N]);
【习题7.075】编写函数将一个NxN的二维数组a的元素按行向左轮转1位。
例如：轮转前的数组 轮转后的数组
1 2 3 2 3 1
4 5 6 ---> 5 6 4
7 8 9 8 9 7
要求实现的函数原型为：
void turningLeft(char a[N][N]);
【习题7.082】编写函数将一个NxN的二维数组a的元素按列向下轮转1位。
例如：轮转前的数组 轮转后的数组
1 2 3 7 8 9
4 5 6 ---> 1 2 3
7 8 9 4 5 6
要求实现的函数原型为：
void turningDown(char a[N][N]);
【习题7.085】编写函数将一个NxN的二维数组a的元素按列向上轮转1位。
例如：轮转前的数组 轮转后的数组
1 2 3 4 5 6
4 5 6 ---> 7 8 9
7 8 9 1 2 3
要求实现的函数原型为：
void turningUp(char a[N][N]);
【习题7.103】编写函数，求整数m和n的最大公约数，并作为函数的返回值。
要求实现的函数原型为：
int gdc(int m, int n);
【习题7.105】编写函数，求整数m和n的最小公倍数，并作为函数的返回值。
要求实现的函数原型为：
int lcm(int m, int n);
【习题7.115】 编写函数，将两个两位数的正整数a、b合并形成一个整数c且作为函数值返回。合并的方式是：将a的十位和个位数分别作为c的千位和十位数，b的十位和个位数分别作为c的百位和个位数。例如，若a=45，b=12，则该函数返回值为4152。
要求实现的函数原型为：
int func(int a, int b);
【习题7.125】编写函数，对非负浮点数r的值的第三位小数四舍五入，返回保留2位小数的值。例如：若r的值为8.32488，则函数返回8.32；若r的值为8.32533，则返回8.33。
要求实现的函数原型为：
float func(float r);
【习题7.135】假设n是一个k(k≥2)位的正整数，编写函数，求出由n的低k-1位构成的数并作为函数值返回。例如：若n值为5923，则函数返回923；若n值为923，则函数返回23。
要求实现的函数原型为：
int func(int n);
【习题7.175】编写函数，求n以内（不包括n）同时能被3与7整除的所有自然数之和的平方根，并作为函数值返回。例如，若n为100时，函数返回值应为14.491。
要求实现的函数原型为：
float func(int n);
【习题7.184】编写函数，根据公式s=1+1/(1+2)+1/(1+2+3)+……+1/(1+2+3+…+n)计算s，并作函数值返回。例如：若n的值为11时，函数的值为1.833333。
要求实现的函数原型为：
float func(int n);
【习题7.187】编写函数，计算下列级数和：1/(1*2)+1/(2*3)+1/(3*4)+ … +1/(n*(n+1))，并返回结果。例如，当n=10时，函数值为0.90909。
要求实现的函数原型为：
float func(int n);
【习题7.195】编写函数，求m!/(n!(m-n)!)的值，结果由函数值返回。m与n为两个正整数且要求m>n。例如：m=12，n=8时，运行结果为495.000000。
要求实现的函数原型为：
float func(int m, int n);
【习题7.205】编写函数，计算并返回给定整数n除了1与自身之外的所有因子之和。例如，若n=8，则函数返回6（=2+4）。
要求实现的函数原型为：
int func(int n);
【习题7.255】编写函数，根据以下公式返回π的值
π/2 = 1+1!/3+2!/(3*5)+...+n!/(3*5*7*...*(2*n+1))
要求满足精度eps，即一旦有小于eps的项值加入后停止迭代。例如，若精度eps=0.0005，则返回值为3.141106。
要求实现的函数原型为：
float func(float eps);
【习题7.265】编写函数，将数组s所存字符串中下标和ASCII码均为偶数的字符，依次存入数组t中，并构成一个新串。例如，若s中的字符串值为ABCD123456，则t中的串值应为246。
要求实现的函数原型为：
void func(char s[], char t[]);
【习题7.275】假定字符串s中可能含有字符'*'。请编写函数，若字符串s的尾部连续的'*'多于n个，则删除多余的'*'。例如，若s="*****A*BCDE**F*******"且n=4，则调用函数后，字符串s="****A*BCDE**F****"；若n≥7，则字符串s中的内容不变。注意：函数中不得调用C语言提供的字符串函数。
要求实现的函数原型为：
void func(char s[], int n);
【习题7.315】编写函数，求出1到n之间(含n)能被7或11整除的所有整数并依次存入数组a中，函数值为这些数的个数。例如，若n=15，则依次存入数组a中的数为7、11和14，函数值为3。
要求实现的函数原型为：
int func(int n, int a[]);
【习题7.317】编写函数，求出1到n之间(含n)都能被c和d整除的所有整数并依次存入数组a中，函数值为这些数的个数。例如，若n=20，c=2，d=3，则依次存入数组a中的数为6、12和18，函数值为3。
要求实现的函数原型为：
int func(int n, int c, int d, int a[]);
【习题7.325】假设数组a存放了n个人的年龄。编写函数，用数组c统计各年龄段的人数，其中c[0]为0至9岁年龄段的人数，c[1]为10至19岁年龄段的人数，c[2]为20至29岁年龄段的人数，其余依此类推，c[10]为100岁(含100)以上年龄的人数。
要求实现的函数原型为：
void func(int n, int a[], int c[]);
【习题7.335】假设字符数组a中存放了按由小到大连续存放的字符构成的字符串（后跟一个'\0'作为结束符）。编写函数，删去字符串中所有重复的字符（各自只保留一个），并使得保留的字符仍构成一个字符串（连续存放，'\0'作为结束符）。函数返回a中保留的字符串长度。例如，若a中的字符串值为：AAABBCDFFFHHHKLMMM，则删除重复字符之后，函数返回值为9，a中的字符串值为：ABCDFHKLM
要求实现的函数原型为：
int func(char a[]);
【习题7.345】假设字符数组s中存放了一行字符串,含有由小写字母组成的若干单词，单词之间由若干个空格隔开（串的开头没有空格）。编写函数，统计一行字符串中单词的个数，并作为函数值返回。
要求实现的函数原型为：
int func(char s[]);
【习题7.355】假定字符串s中可能含有字符'*'。请编写函数，将字符串s中前导'*'全部移到字符串的尾部。例如，若s的串值为***A*BC*DEF*G**，移动后，串值应为A*BC*DEF*G*****。注意：不得调用C语言提供的字符串函数。
要求实现的函数原型为：
int func(char s[]);
【习题7.513】编写函数，计算并返回数组a中头n个元素的乘积。
要求实现的函数原型为：
long func(int a[], int n);
【习题7.523】编写函数，计算并返回数组a中头n个元素的平方和。
要求实现的函数原型为：
long func(int a[], int n);
【习题7.533】假设某班选举班长，k位候选人的号码分别为1至k，n张选票已存入数组v（每个元素值在1至k之间）。编写函数，用数组c统计各位候选人的得票（c[i]为i号候选人的得票数）。
要求实现的函数原型为：
void func(int v[], int n, int k, int c[]);
【习题7.535】假设某班选举班长，k位候选人的号码分别为1至k，n张选票已存入数组v（每个元素值在1至k之间）。编写函数，用数组c统计各位候选人的得票（c[i]为i号候选人的得票数），并返回得票最高的人的号码。
要求实现的函数原型为：
int func(int v[], int n, int k, int c[]);
【习题7.563】编写函数，把长整数n的各位数字从低位到高位依次存储在数组d中，并返回n的位数。例如，若n=2579，则n的位数为4，d[0..3]=9,7,5,2。
要求实现的函数原型为：
int func(long n, int d[]);
【习题7.563】编写函数，把长整数n的各位数字从高位到低位依次存储在数组d中，并返回n的位数。例如，若n=2579，则n的位数为4，d[0..3]=2,5,7,9。
要求实现的函数原型为：
int func(long n, int d[]);
【习题7.655】编写函数，用数组num统计字符串s中各元音字母（即：A、E、I、O、U）的个数。注意：不分大、小写。例如，若s="THIs is a book"，则num[0..4]={1,0,2,2,0}。
要求实现的函数原型为：
void func(char *s, int *num);
/* 功能：用数组num统计符串s中元音字母出现的个数 */
【习题7.675】假设在数组s中存放了n位学生的成绩。编写函数，用数组p统计各分数段的人数，其中p[0]为不足60分的人数，p[1]为60至69分的人数，p[2]为70至79分的人数，p[3]为80至89分的人数，p[4]为90至100分的人数。
要求实现的函数原型为：
void func(int s[], int n, int p[]);
【习题7.685】编写函数，从小到大依次求出能整除m的各整数，并存放在数组d中，这些除数的个数由n返回。例如，若m=20，则有6个数能整除它，依次是1,2,4,5,10,20。
要求实现的函数原型为：
void func(int m, int d[], int *n);
【习题7.755】通信时经常用到加密技术，把消息加密后再传输。编写一个用于加密消息的函数，把字符串str中的小写字母改成“(其ASCII码 + key字符串中每个字符ASCII码平方)除以128的余数”所对应的字符，其它的字符不变，其中str称为消息原文，key称为密钥。
请思考：如何解密恢复原文,这种加密方法能准确地恢复原文吗?
要求实现的函数原型为：
void func(char *str,char *key);
/* 功能：用key作为密钥对字符串str进行加密处理 */
第8章 善于利用指针（数组、指针和字符串）(例题0—习题29)
【习题8.011】请编写一个函数func(char s[], char t[], int n)，由数组s中长度为n的字符序列构造其逆序列，并存储在数组t中。例如，由给定字符序列s=“are”求得逆序列t=“era”；由s=“time”求得t=“emit”。
要求实现函数：
void func(char s[], char t[], int n);
/* 数组s的前n个元素存放给定的字符序列，
数组t的前n个元素存放s的逆序列。
注意：数组的下标从0开始。
*/
【习题8.012】请编写一个函数func(char*s, char *t)，由字符串s构造其逆串t。
例如，由给定串s=“are”求得逆串t=“era”；由s=“time”求得t=“emit”。
要求实现函数：
void func(char *s, char *t);
/* s是给定字符串的起始地址，
t是新字符串的起始地址
*/
【习题8.015】对长度为n的字符串s1，除首、尾字符外，将其余字符按ASCII码降序排列，组合成一个新的字符串s2。
要求实现函数：
void func(char *s1, char *s2, int n);
/* s1为字符串的起始地址，
s2为新字符串的起始地址，
n是字符串的长度。
要求：s1串不能发生改变，
s2串存放新的字符串。
*/
【习题8.016】对字符串s1，除首、尾字符外，将其余字符按ASCII码降序排列，组合成一个新的字符串s2。
要求实现函数：
void func(char *s1, char *s2);
/* s1为字符串的起始地址，
s2为新字符串的起始地址，
注意：字符串尾字符之后跟随着一个结束符‘\0’，
即ASCII码为0的字符，结束符不属于字符串。
要求：s1串不能发生改变，
s2串存放新的字符串。
*/
【习题8.018】以字符串s第m(>=0)个字符开始的所有字符，按升序的次序构成字符串t。
要求实现函数：
void substr(char *s, int m, char *t);
/* s为字符串的起始地址，
m>=0，
t为新字符串的起始地址，
注意：字符串尾字符之后跟随着一个结束符‘\0’，
即ASCII码为0的字符，结束符不属于字符串。
要求：s串不能发生改变，
t串存放新的字符串。
*/
【习题8.020】在字符串s中查找字符c，如果找到，返回字符c首次出现在字符串s中的位置指针；否则，返回空指针NULL。
要求实现函数：
char *match(char *s, char c);
/* s为字符串的起始地址，
c为要查找的字符，
返回值为字符c在字符串s中首次出现的位置指针，
若c未在s中出现，则返回空指针NULL。
*/
【习题8.033】编写函数，计算年份year中第yearday天相应的月和日。例如，调用函数month_day(2000,61,&m,&d)之后，m=3，d=1，即2000年的第61天是3月1日。
要求实现函数：
int month_day(int year, int yearday, int *pmonth, int *pday)
/* year是年，
yearday是天数，
若year和yearday合理，
则*pmonth和*pday是计算得出的月和日，函数返回1；
否则，函数返回0。
*/
【习题8.044】请编写一个函数func，通过略去非数字字符，将字符串s转换为一个整数(不得调用C语言提供的将字符串转换为整数的函数)。
要求实现函数：
long func(char *s);
/* s是一个数字字符串的地址，
函数返回值为由s含有的数字字符转换得到的数（包含正负数情况）
*/
【习题8.105】请编写一个函数findmax(int s[], int n)，返回数组s中n(>0)个整数中的最大值。注意：要求在函数中采用指针（而不是下标）来处理数组元素。
要求实现函数：
int findmax(int s[], int n);
/* 返回s中n(>0)个整数的最大值。
注意：要求在函数中采用指针（而不是下标）来处理数组元素。
*/
【习题8.124】请编写一个函数min3adj(int s[], int n)，数组s中有n(>0)个整数，返回在s中相邻三个数的和中的最小值。
要求实现函数：
int min3adj(int s[], int n);
/* 数组s含n(>0)个整数，
返回在s中相邻三个数的和中的最小值。
*/
【习题8.132】编写函数，通过指针参数sum将x和y的和赋给相应实际参数。例如，若x=134、y=378，则sum的实参变量被赋值512。
要求实现的函数原型为：
void func(int x, int y, int *sum);
【习题8.136】编写函数，返回指针参数x和y所指向的变量的值之和。
要求实现的函数原型为：
int func(int *x, int *y);
【习题8.138】编写函数，比较指针参数x和y分别指向的变量，若前者的值较大，则交换两者的值，并返回1；否则无须交换，返回0。
要求实现的函数原型为：
int func(int *x, int *y);
【习题8.143】假设指针a指向某数组中的一个元素。编写函数，在从元素*a开始的n个元素范围内，向后查找给定值x，一旦找到值等于x的元素，则返回该元素的序号；若找不到，则返回0。例如，假定a指向的10个元素依次为5,6,3,0,-4,8,9,-6,8,-7，若x=5，则返回1；若x=8，则返回6；若y=4，则返回0。
要求实现的函数原型为：
int func(int n, int *a, int x);
【习题8.146】假设指针a指向某数组中的一个元素。编写函数，对从元素*a开始的n个元素，统计并返回值为x的元素个数（若不存在这样的元素，则返回0）。
要求实现的函数原型为：
int func(int n, int *a, int x);
【习题8.203】编写函数，返回指针参数s所指向的字符串的长度。例如，若该串为"I am a teacher."，则函数返回值是15。注意：字符串结束符是'\0'，不计入长度。不允许调用库函数strlen()。
要求实现的函数原型为：
int func(char *s);
【习题8.212】编写函数，在指针参数s所指向的字符串中顺序查找由c指定的字符。一旦找到，则返回该字符在串中的序号（串的首个字符的序号为1），否则返回0。例如，若该串为"I am a student."，c='t'，则函数返回值为9。注意：字符串结束符是'\0'，不允许调用字符串库函数。
要求实现的函数原型为：
int func(char *s, char c);
【习题8.215】编写函数，在指针参数s所指向的字符串中统计并返回由c指定的字符的个数。例如，若该串为"I am a student."，c='t'，则函数返回值为2。注意：字符串结束符是'\0'，不允许调用字符串库函数。
要求实现的函数原型为：
int func(char *s, char c);
【习题8.222】编写函数，复制指针参数s指向的字符串到由指针参数t已经指向的存储区域。注意：字符串结束符是'\0'，不允许调用字符串库函数。
要求实现的函数原型为：
void func(char *s, char *t);
【习题8.225】编写函数，由指针参数s指向的字符串头n个字符构造一个字符串，并存储到到由指针参数t已经指向的存储区域。例如，若s指向的字符串为"I am a student."，n=4，则t指向的串为"I am"。注意：字符串结束符是'\0'，不允许调用字符串库函数。
要求实现的函数原型为：
void func(char *s, int n, char *t);
【习题8.228】编写函数，由指针参数s指向的字符串后n个字符构造一个字符串，并存储到到由指针参数t已经指向的存储区域。例如，若s指向的字符串为"I am a student."，n=8，则t指向的串为"student."。注意：字符串结束符是'\0'，不允许调用字符串库函数。
要求实现的函数原型为：
void func(char *s, int n, char *t);
【习题8.231】编写函数，由指针参数s指向的字符串中第i个字符开始的n个字符构造一个字符串，并存储到到由指针参数t已经指向的存储区域。例如，若s指向的串为"I am a student."，i=8，n=7，则t指向的串为"student"。注意：字符串结束符是'\0'，不允许调用字符串库函数。
要求实现的函数原型为：
void func(char *s, int i, int n, char *t);
【习题8.234】编写函数，通过将s字符串中所有小写字母转换成大写字母,构造一个字符串并存储在t已经指向的存储区域，但原来的s串不改变。例如，若s字符串为"I am a student.",则构造的t串为"I AM A STUDENT.”。
要求实现的函数原型为：
void func(char *s, char *t);
【习题8.237】编写函数，通过将s字符串中所有大写字母转换成小写字母,构造一个字符串并存储在t已经指向的存储区域，但原来的s串不改变。例如，若s字符串为"I Am a Student.",则构造的t串为"i am a student.”。
要求实现的函数原型为：
void func(char *s, char *t);
【习题8.243】编写函数，在字符串s中顺序查找字符串t，若找到，则返回其出现的位置，否则返回0。例如，设s="I am a student."，若t="stu"，则返回值是8；若t="an"，则返回值是0。注意：字符串结束符是'\0'，不允许调用字符串库函数。
要求实现的函数原型为：
int func(char *s, char *t);
【习题8.246】假设字符串中每个连续字母序列称为“单词”。编写函数，在字符串s中顺序获取每个单词，依次存入w指示的二维数组,并返回单词个数。例如，若有s="I am a student"，则w={"I","am","a","student"}。注意：字符串结束符是'\0'，不允许调用字符串库函数。
要求实现的函数原型为：
int func(char *s, char (*w)[10]);
【习题8.282】编写函数，查找并返回p指示的二维数组中的元素最大值。例如，二维数组的元素值依次为{{45,38,-6,78},{34,48,70,4},{-9,0,4,20}}，则函数返回值为78。
要求实现的函数原型为：
int func(int (*p)[4], int n);
/* 求二维数组中的最大值 */
【习题8.285】编写函数，依次对p指示的二维数组的每一行元素值求和，并存入数组sum中。例如，若二维数组的元素值依次为{{45,38,-6,78},{34,48,70,4},{-9,0,4,20}}，则sum[0..2]={155,156,15}。
要求实现的函数原型为：
void func(int (*p)[4], int n, int *sum);
/* 求二维数组中各行元素值的和 */
【习题8.288】编写函数，依次对p指示的二维数组的每一列元素值求平均值，并存入数组avg中。例如，若二维数组的元素值依次为{{45,38,-6,78},{34,48,70,4},{-9,0,4,20}}，则avg[0..2]={23.33,28.67,34.00}。
要求实现的函数原型为：
void func(int (*p)[4], int n, float *avg);
/* 求二维数组中各列元素值的平均值 */
第9章 用户自己建立数据类型（结构体和链表）(例题0—习题14)
【习题9.023】结构体类型定义如下：
struct date{int year; int month; int day;}; //定义日期结构体类型
struct student
{ char name[10]; //人名
struct date birth; //出生日期
};
结构体数组s存储了n个人的名字和出生日期。写一函数，求这n个人中年龄最大（即出生日期最小）者的姓名。
要求实现下列函数：
char *oldest(struct student s[], int n);
【习题9.025】结构体类型定义如下：
struct date{int year; int month; int day;}; //定义日期结构体类型
struct student
{ char id[10]; //学号
char name[20]; //姓名
struct date birth; //出生日期
};
结构体数组s存储了n个人的学号、名字和出生日期。写一函数，以结构体的形式返回这n个人中年龄最大（即出生日期最小）者的信息。
要求实现下列函数：
struct student oldest(struct student s[], int n);
【习题9.027】结构体类型定义如下：
struct student
{ char id[10]; //学号
char name[10]; //姓名
int score[5]; //各门课成绩
};
结构体数组s存储了n个学生的学号、名字和各门课成绩。编写函数，返回这n个人中第i门课成绩最高者的学号。
要求实现下列函数：
char *best(struct student s[], int n, int i);
【习题9.029】结构体类型定义如下：
struct student
{ char id[10]; //学号
char name[10]; //姓名
int score[5]; //各门课成绩
};
结构体数组s存储了n个学生的学号、名字及其5门课成绩。编写函数，返回这n个人中5门课成绩总分最高者的学号。
要求实现下列函数：
char *best(struct student s[], int n);
【习题9.033】日期和链表结点的结构体类型定义如下：
struct date{int year; int month; int day;}; //日期结构体类型
struct studentNode //链表结点的结构体类型
{ char name[10]; //人名
struct date birth; //出生日期
struct studentNode *next
};
结构体链表L存储了n个人的名字和出生日期。写一函数，求这n个人中年龄最大（即出生日期最小）者的名字。
要求实现下列函数：
char *oldest(struct studentNode *L);
/* 若L是空表，则返回空指针null
否则返回表中年龄最大者的名字
*/
【习题9.053】结构体类型定义如下：
struct person
{ int id; //员工号
char name[10]; //姓名
int age; //年龄
char sex; //性别
};
结构体数组personnel[n]存储了n位员工的信息。写一函数，返回年龄在a及以上的员工数。
要求实现下列函数：
int count(struct person personnel[], int n, int a);
【习题9.055】结构体类型定义如下：
struct person
{ int id; //员工号
char name[10]; //姓名
int age; //年龄
char sex; //性别
};
结构体数组personnel[n]存储了n位员工的信息。写一函数，返回年龄在a及以上的x性别的员工数。
要求实现下列函数：
int count(struct person personnel[], int n, int a, char x);
【习题9.063】结构体类型定义如下：
struct course
{ int cID; //课程号，取值0~99
char name[10]; //课程名
float credit; //学分，取值0~5
int semester; //学期，取值1~8
};
结构体数组c存储了n门课程的信息。写一函数，求学期s的总学分。
要求实现下列函数：
float creditSum(struct course c[], int n, int s);
【习题9.073】课程链表结点的结构体类型定义如下：
struct courseNode //课程链表结点的结构体类型
{ int cID; //课程号，取值0~99
char name[10]; //课程名
float credit; //学分，取值0~5
int semester; //学期，取值1~8
struct courseNode *next;
};
结构体链表Lc存储了各学期多门课程的信息。写一函数，求学期s的总学分。
要求实现下列函数：
float creditSum(struct courseNode *Lc, int s);
/* 若Lc是空表，则返回0;
否则返回学期s的总学分
*/
【习题9.133】日期和结构体类型定义如下：
struct date{int year; int month; int day;}; //日期结构体类型
struct student //结构体类型
{ char name[10]; //人名
struct date birth; //出生日期
};
结构体数组s存储了n个人的名字和出生日期。写一函数，由数组s中n个人
的信息及其顺序构造相应的链表。链表的结点的结构体类型定义如下：
struct studentNode //结构体类型
{ char name[10]; //人名
struct date birth; //出生日期
struct studentNode *next
};
要求实现下列函数：
struct studentNode *CreateLinkList(struct student s[], int n);
【习题9.173】课程链表结点的结构体类型定义如下：
struct courseNode //课程链表结点的结构体类型
{ int cID; //课程号，取值0~99
char name[10]; //课程名
float credit; //学分，取值0~5
int semester; //学期，取值1~8
struct courseNode *next;
};
结构体链表Lc存储了多门课程的信息。写一函数，将课程号为c的课程的学分修改为t。
要求实现下列函数：
struct courseNode *creditChange(struct courseNode *Lc, int c, float t);
/* 若课程c不存在，则修改不成功，返回null;
否则修改该课程的学分为t，返回指向该课程结点的指针。
*/
【习题9.183】课程链表结点的结构体类型定义如下：
struct courseNode //课程链表结点的结构体类型
{ int cID; //课程号，取值0~99
char name[10]; //课程名
float credit; //学分，取值0~5
int semester; //学期，取值1~8
struct courseNode *next;
};
结构体链表Lc存储了多门课程的信息。写一函数，将课程号为c的课程结点删除。
要求实现下列函数：
struct courseNode *deleteCourse(struct courseNode **Lc, int c);
/* 若在链表Lc中课程c不存在，则删除不成功，返回null;
否则从链表Lc中删除该课程结点，并返回指向该课程结点的指针。
*/
【习题9.302】单向链表的结点类型定义如下：
struct node{
char ch;
struct node *next;
};
编写函数，对单向链表L实现就地逆置，即将所有结点的指针反向，原链头当作链尾，原链尾当作链头，并返回逆置后链表的头指针。
实现下列函数：
struct node *inverse(struct node *L);
/* 对单向链表L实现就地逆置，并返回逆置后链表的头指针。*/
【习题9.352】单向链表的结点类型定义如下：
struct node{
char ch;
struct node *next;
};
编写函数，对单向链表L实现排序，即按结点的ch值，从小到大重构链表L，并返回排序后的链表的头指针。
实现下列函数：
struct node *sorting(struct node *L);
/* 对单向链表L实现从小到大排序，并返回重构后的链表的头指针。*/