chen_shiqiang

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;

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;

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=

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=

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=

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;

printf("y=%f\n",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", );

}

【习题3.184】增1运算：++

编写程序，先对整型变量a赋值为10，然后依次分行显示a++，a，++a，和a的值。

【程序】

void main()

{ int a=10;

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);

printf("b=%d ",b);

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", );

}

【习题3.194】减1运算：--

编写程序，先对整型变量a赋值为10，然后依次分行显示a--，a，--a，和a的值。

【程序】

void main()

{ int a=10;

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);

printf("b=%d ",b);

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;

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()

{

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);

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

【程序】

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("%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;

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;

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()

{

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);

{ 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);

{ 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);

{

}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实现从小到大排序，并返回重构后的链表的头指针。*/

AnyviewC编程作业系统——支持程序可视化运行、调试和测评

AnyviewC编程作业系统——支持程序可视化运行、调试和测评

AnyviewC题库：C程序设计 例题62--习题239（2012-4-27）

1.025 编写一个C程序，用函数printf(char *s)输出以下3行信息：第1章 程序设计和C语言(例题0--习题0/2)

第2章 算法——程序的灵魂

第3章 最简单的程序设计——顺序结构程序设计(例题49--习题0/61)

第4章 选择结构程序设计(例题13—习题0/13)

第5章 循环结构程序设计（含：序列求和）(例题0—习题41)

第6章 利用数组处理批量数据(例题0—习题24+13)

第7章 用函数实现模块化程序设计(例题0—习题42)

第8章 善于利用指针（数组、指针和字符串）(例题0—习题29)

第9章 用户自己建立数据类型（结构体和链表）(例题0—习题14)

你可能感兴趣的:(AnyviewC编程作业系统——支持程序可视化运行、调试和测评)

AnyviewC题库：C程序设计例题62--习题239（2012-4-27）

1.025 编写一个C程序，用函数printf(char *s)输出以下3行信息：第1章程序设计和C语言(例题0--习题0/2)

第2章算法——程序的灵魂

第3章最简单的程序设计——顺序结构程序设计(例题49--习题0/61)

第4章选择结构程序设计(例题13—习题0/13)

第5章循环结构程序设计（含：序列求和）(例题0—习题41)

第6章利用数组处理批量数据(例题0—习题24+13)

第7章用函数实现模块化程序设计(例题0—习题42)

第8章善于利用指针（数组、指针和字符串）(例题0—习题29)

第9章用户自己建立数据类型（结构体和链表）(例题0—习题14)