程序test.c的功能是：将大于整数m且紧靠m的k个素数存入数组xx。请考生编写函数num（int m,int k,int xx[]）实现程序的要求......
Int c程序nt=0;
While(cnt
If(isp(m)) xx[cnt++]=m;}
已知数据文件in.dat中存有300个四位数，并已调用读函数readDat（）把这些数存入数组a中，请编制一函数jsValue（），其功能是：求出所有这些四位数是素数的个数cnt，writeDat，pjz2
int i; //定义变量i
for(i = 0; i < 300; i++) //循环变量i从0依次递增到299
{
if(isP(a[i])) //判断数组元素a[i]是否素数
{
pjz1 += a[i]; //把a[i]累加到变量pjz1
cnt++; //变量cnt加1
}
else pjz2 += a[i]; //否则,把数组元素a[i]累加到变量pjz2
}
pjz1 /= cnt; //所有素数的和pjz1除以素数的个数cnt,得到素数的平均值并赋给变量pjz1
pjz2 /= (300 - cnt); //所有非素数的和pjz2除以非素数的个数300-cnt,得到非素数的平均值并赋给变量pjz2
3.。。计算100以内满足以下条件的所有整数i的个数cnt以及这些i之和sum。条件：i，i+4，i+10都是素数，编写函数countValue（）实现程序要求，writeDAT（）把结果cnt和sum
int i; //定义变量i
for(i = 3; i < 90; i++) //循环变量i从3开始，依次递增，直到小于90
{
if(isPrime(i) && isPrime(i + 4) && isPrime(i + 10)) //如果i，i+4，5i+10同时为素数
{
cnt++; sum += i; //变量cnt加1，变量i累加到sum
}
}
4.已知数据文件in。Dat中存有300个四位数，并已调用读函数readDat（）把这些数存入数组a中，请编制一函数jsValue（），其功能是：求出所有这些四位数是素数的个数cnt，再把所有满足此条件的四位数依次存入数组b中，然后对数组b的四位数按从小到大的顺序进行排序。。。。
int i, j, tmp; //定义整型变量i, j, tmp
for(i = 0; i < 300; i++) //循环变量i从0依次递增到299
if(isP(a[i])) b[cnt++] = a[i]; //如果数组元素a[i]是素数，则把a[i]赋给b[cnt]，同时数组下标变量cnt加1
for(i = 0; i < cnt; i++) //循环变量i从0开始依次递增，直到其值等于cnt
{
for(j = i + 1; j < cnt; j++) //循环变量j从i + 1开始依次递增，直到其值等于cnt
{
if(b[i] > b[j]) //如果数组元素b[i]大于b[j]，则进行互换
{
tmp = b[j]; //把b[j]的值赋给变量tmp
b[j] = b[i]; //把b[i]的值赋给b[j]
b[i] = tmp; //把变量tmp的值赋给b[i]
}
}
}
5.程序test。C的功能是：选出大于100小于1000的所有个位数字与十位数字之和被10除所得余数恰是百位数字的所有素数（如293）。
int i, bw, sw, gw; //定义整型变量i, bw, sw, gw
for(i = 100; i < 1000; i++) //循环变量i从100开始，每次递增1，直到其值等于1?000
{
bw = i / 100; //i除以100，得到i百位上的数值
sw = (i - bw * 100) / 10; //i减去其百位值的
差再除以10，得到i十位上的数值
gw = i % 10; //i对10求余数得到其个位上的数值
if((gw + sw) % 10 == bw && isP(i)) //如果i个位数字与十位数字之和对10求余所得余数等于其百位上的数字并且i是素数
{
cnt++; //变量cnt加1
sum += i; //把变量i累加到变量sum上
}
}
6.计算500~800区间内素数的个数cnt，并按所求素数的值从大到小的顺序，计算其间隔减、加之和，即第1个素数-第2个素数+第3个素数-第4个素数。。。。的值sum。
【审题关键句】计算500～800区间内素数的个数，素数的值从大到小排序，再计算其间隔减、加之和，即第1个素数-第2个素数+第3个素数-第4个素数+第5个素数……的值。
【解题思路】
①首先定义一个循环变量循环i和用于正负号转换的变量j，同时赋j的初值为-1。
②通过for循环对800到500的每个数字进行逐个的扫描，指定循环变量i的初值为800，当i值等于500停止循环，每执行一次循环，i的值便减1。（注意，本题for循环从大到小依次读取数据是根据题目要求设计的，这样得到的素数值其排序方式就是从大到小排序。）
③在每次执行for循环时，都调用素数判断函数isPrime()判断当前的i值是否为素数，如果是素数，则素数计数变量cnt值加1，正负号转换变量j的值乘以-1，实现正负数的交替转换，最后将每次循环得到的i*j的值累加到求和变量sum中。
【参考答案】
int i, j = -1; //定义整型变量i, j，并且变量j的初值赋予-1
for(i = 800; i > 500; i--) //循环变量i从800开始，每次减1，直到其值等于500
{
if(isPrime(i)) //如果i是素数
{
cnt++; //变量cnt加1
j *= -1; //变量j乘以-1，变号
sum += j * i; //把变量j与i的积累加到变量sum上
}
}
7.在数据文件in。Dat中有二百个正整数，且每个数都在1000至9999之间。函数readDat（）是读取这200个数存放到数组aa中。编制函数的功能是：要求按每个数的后三位的大小进行升序排列，如果出现后三位相等的数值，则对这些数值按原始四位数据进行降序排列，将排序后的10个数存入数组bb中。。。
【审题关键句】按每个数的后三位升序排列，然后取出满足此条件的前10个数依次存入数组，如果后三位的数值相等，则按原先的数值进行降序排列。
【解题思路】
①首先定义两个循环变量循环i、j和一个用于数据交换的整型变量m。
②然后通过两个for循环对数组aa[]中的两个相邻元素按照其后三位值的大小进行从小到大的排序，本题中已给出所有的整数都是四位数，因此，可以通过aa[i] % 1000或aa[j] % 1?000计算得到当前数组元素的后三位值，然后再进行比较，如果两个数需要转换位置，可通过中间变量m
进行转换。
③上一步骤是两个元素后三位不相同的情况，根据题意，需要再增加一个else if语句判断两个相邻元素的后三位数一样的情况，如果相同，则需要继续判断两个四位数的大小，并按从大小的顺序排序。
④最后，通过一个for循环依次读取aa[i]数组中前10个元素并保存到数组bb[i]中。
【参考答案】
int i, j, m; //定义整型变量i, j, m
for(i = 0; i < 199; i++) //循环变量i从0开始,每次递增1,直到其值等于199
for(j = i + 1; j < 200; j++) //循环变量j 从i + 1开始,每次递增1,直到其值等于200
{
if((aa[i] % 1000) > (aa[j] % 1000)) //如果aa[i]的后三位大于aa[j]的后三位,则进行互换
{
m = aa[i]; //把aa[i]的值赋给m
aa[i] = aa[j]; //把aa[j]的值赋给aa[i]
aa[j] = m; //把m的值赋给aa[j]
}
else if((aa[i] % 1000) == (aa[j] % 1000)) //如果aa[i]的后三位等于aa[j]的后三位
{
if(aa[i] < aa[j]) //如果aa[i]小于aa[j],则进行互换
{
m = aa[i]; //把aa[i]的值赋给m
aa[i] = aa[j]; //把aa[j]的值赋给aa[i]
aa[j] = m; //把m的值赋给aa[j]
}
}
}
for(i = 0; i < 10; i++)
bb[i] = aa[i]; //循环变量从0开始,每次递增1,直到等于10,把数组元素aa[i]赋给bb[i]
8.在文件in。Dat中已存有200个正整数，求每个数均在1000至9999之间。函数readDat（）是读取这200个数存放到数组aa中。编制函数jsSort（），函数功能是：要求按每个数的后三位的大小进行降序排列，如果出现三位相等的数值，则对这些数值按原始四位数据进行升序排列，将排序后的10个数存入数组bb中。
【审题关键句】按每个数的后三位降序排列，然后取出满足此条件的前10个数依次存入数组；如果后三位的数值相等，则按原先的数值进行升序排列。
【解题思路】本题类似第7套试题，通过审题可以发现主要有两个不同点：①按每个数的后三位降序排列，参考答案的第5条语句，修改两数组元素的大小比较符即可；②后三位的数值相等则按原先的数值进行升序排列，参考答案的第13条语句，同样也是修改两数组元素的大小比较符即可。
【参考答案】
int i, j, m;
for(i = 0; i < 199; i++)
for(j = i + 1; j < 200; j++)
{
if((aa[i] % 1000) < (aa[j] % 1000)) //如果aa[i]的后三位小于aa[j]的后三位,则进行互换
{
m = aa[i];
aa[i] = aa[j];
aa[j] = m;
}
else if((aa[i] % 1000) == (aa[j] % 1000))
{
if(aa[i] > aa[j]) //如果aa[i]大于aa[j],则进行互换
{
m = aa[i];
aa[i] = aa[j];
aa[j] = m;
}
}
}
for(i = 0; i < 10; i++)
bb[i] = aa[i];
9.数据文件in。dat中存有200个四位数，并已调用读函数readDat（）吧这些数存入数组a
中，编制一函数jsVal（），其功能是：若一个四位数的千位数位置上的值小于等于百位数位置上的值，百位数位置上的值小于等于十位数位置上的值，以及十位数位置上的值小于等于个位数位置上的值，并且远四位数十偶数。。。。。
【审题关键句】四位数的千位<=百位<=十位<=个位，且四位数是偶数，统计出满足此条件的个数，按从小到大的顺序存入数组。
【解题思路】
①首先，本题要定义多个变量，包括两个循环变量循环i、j，一个用于数据交换的整型变量ab，以及分别用来存放四位数分解之后各位数的变量qw（千位）、bw（百位）、sw（十位）和gw（个位）。
②通过for循环依次对数组中的每个四位数进行分解，每分解一个四位数，根据题目要求，判断其“千位<=百位<=十位<=个位”的条件是否满足，并通过a[i] % 2 == 0表达式判断该四位数是否为偶数，各判断表达式之间用&&运算符进行连接，当满足条件时，则将a[i]的值赋给数组变量b[cnt]，同时数组下标变量cnt的值加1。循环结束后，所有满足条件的四位数都将保存到数组b[cnt]中。
③将所有的四位数判断完毕后，最后通过两个for循环，对b[cnt]数组中的元素按从小到大的顺序排序。
【参考答案】
int qw, bw, sw, gw, i, j, ab;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000; //a[i]除以1?000得到a[i]的千位上的数值,并赋给变量qw
gw = a[i] % 10; //a[i]对10求余得到a[i]的个位上的数值,并赋给变量gw
bw = (a[i] - qw * 1000) / 100; //a[i]与其千位数的差除以100,得到其百位上的数值
sw = (a[i] - qw * 1000 - bw * 100) / 10; //a[i]减去其千位数再减去其百位数值再除以10,得到其十位上的数值
if((qw <= bw && bw <= sw && sw <= gw) && (a[i] % 2 == 0)) //如果a[i] 千位数小于等于百位数，百位数小于等于十位数，十位数小于等于个位数，并且a[i]是偶数
b[cnt++] = a[i]; //把a[i]赋给b[cnt],同时数组下标变量cnt加1
}
for(i = 0; i < cnt - 1; i++) //循环变量i从0开始,每次加1,直到其值大于等于cnt - 1
for(j = i + 1; j < cnt; j++) //循环变量j从i + 1开始,每次加1,直到其值大于等于cnt
if(b[i] > b[j]) //如果数组元素b[i]大于b[j],则进行两者互换
{
ab = b[j]; //把b[j]的值赋给变量ab
b[j] = b[i]; //把 b[i]的值赋给b[j]
b[i] = ab; //把ab的值赋给b[i]
}
10.已知数据文件in。dat中存有200个四位数，并已调用读函数readDat（）把这些数存入数组a中，。其功能是：若一个四位数的千位数位置上的值大于等于百位数位置上的值，百位数位置上的值大于等于十位数位置上的值，以及。。。。。。。
【审题关键句】四位数的千位>=百位>=十位>=个位，且四位数是奇数，统计出
满足此条件的个数，按从小到大的顺序存入数组。
【解题思路】
本题类似第9套试题，通过审题可以发现主要有两个不同点：一是要求统计的四位数的条件是“千位>=百位>=十位>=个位”，二是要求该四位数是奇数，这两个不同点都体现在参考答案的第8条语句中，对该语句进行修改即可，其中，可以判断奇数的表达式是“a[i] % 2”。
【参考答案】
int qw, bw, sw, gw, i, j, ab;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
if((qw >= bw && bw >= sw && sw >= gw) && (a[i] % 2)) //如果a[i] 千位数大于等于百位数，百位数大于等于十位数，十位数大于等于个位数，并且a[i]是奇数
b[cnt++] = a[i];
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] > b[j])
{
ab = b[j];
b[j] = b[i];
b[i] = ab;
}
11.已知数据文件in。dat中存有200个四位数，并已调用读函数readDat（）吧这些数存入数组a中，编制函数jsVal（），功能是：把一个四位数的千位数位置上的值减去百位数位置上的值再减去十位数位置上的值最后减去个位数位置上的值，如果得出的值大于等于零且原四位数是奇数。。。。。。
【审题关键句】千位-百位-十位-个位，结果大于等于零且原四位数是奇数，统计出满足此条件的个数，并按从小到大的顺序存入数组。
【解题思路】
本题类似第9套试题，通过审题可以发现主要有两个不同点：一是要求统计的四位数的条件是“千位-百位-十位-个位>=0”，二是要求该四位数是奇数，这两个不同点都体现在参考答案的第8条语句中，对该语句进行修改即可，其中，可以判断奇数的表达式是“a[i] % 2”。
【参考答案】
int qw, bw, sw, gw, i, j, ab;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
if((qw - gw - bw - sw >= 0) && (a[i] % 2)) //如果a[i]千位数减去个位数再减去百位数再减去十位数大于等于零且a[i]是奇数
b[cnt++] = a[i];
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] > b[j]) //如果b[i]大于b[j],则两者进行互换,对数组b进行升序排序
{
ab = b[j];
b[j] = b[i];
b[i] = ab;
}
12．数据文件in。Dat中存有200个四位数，并已调用读函数readDat（）吧这些数存入数组a中，功能是：把一个四位数的个位数位置上的值减去千位数位置上的值再减去百位数位置上的值最后减去十位数位置上的值，如果得出的值大于等于零且原四位数是偶数。。。。
【审题关键句】个位-千位-百位-十位，结果大于等于零且原四位数是偶
数，统计出满足此条件的个数，并按从小到大的顺序存入数组。
【解题思路】
本题类似第9套试题，通过审题可以发现仅有一个不同点，即要求统计的四位数的条件是“个位-千位-百位-十位>=0”，参考答案的第8条语句，修改if条件语句的判断条件即可。
【参考答案】
int qw, bw, sw, gw, i, j, ab;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
if((gw - qw - bw - sw >= 0) && (a[i] % 2==0)) //如果a[i]个位数减去千位上的数减百位上的数减去十位上的数大于等于零并且a[i]是偶数
b[cnt++] = a[i];
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] > b[j]) //如果数组元素b[i]大于b[j],则两者进行互换
{
ab = b[j];
b[j] = b[i];
b[i] = ab;
}
13. 数据文件in。Dat中存有200个四位数，并已调用读函数readDat（）吧这些数存入数组a中，功能是：把一个四位数的千位数位置上的值加上个位数位置上的值恰好等于百位数位置上的值加上十位数位置上的值，并且原四位数是奇数。。。。。。
【审题关键句】千位+个位等于百位+十位，且原四位数是奇数，统计出满足此条件的个数，并按从小到大的顺序存入数组。
【解题思路】
本题类似第9套试题，通过审题可以发现主要有两个不同点：一是要求统计的四位数的条件是“千位+个位=百位+十位”，二是要求该四位数是奇数，这两个不同点都体现在参考答案的第8条语句中，对该语句进行修改即可，其中，可以判断奇数的表达式是“a[i] % 2”。
【参考答案】
int qw, bw, sw, gw, i, j, ab;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
if((qw + gw - bw - sw == 0) && (a[i] % 2)) //如果a[i]千位上的数字加上其个位上的数字减去其百位上的数字减去其十位上的数字等于零并且a[i]是奇数
b[cnt++] = a[i];
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] > b[j])
{
ab = b[j];
b[j] = b[i];
b[i] = ab;
}
14.数据文件in。Dat中存有200个四位数，并已调用读函数readDat（）吧这些数存入数组a中，功能是：把一个四位数的千位数位置上的值加上十位数位置上的值恰好等于百位数位置上的值加上个位数位置上的值，并且原四位数是偶数。。。。。。
【审题关键句】千位+十位等于百位+个位，且四位数是偶数，统计出满足此条件的个数，并把这些四位数按从小到大的顺序存入数组。
【解题思路】
本题类似第9套试题，通过审题可以发现仅有一个不同点，即要求统计的四位数的条件是“千位+
十位=百位+个位”，参考答案的第8条语句，修改if条件语句的判断条件即可。
【参考答案】
int qw, bw, sw, gw, i, j, ab;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
if((qw + sw - bw - gw == 0) && (a[i] % 2)==0) //如果a[i]千位上的数字加上十位上的数字减去百位上的数字减去个位上的数字等于零并且a[i]是偶数
b[cnt++] = a[i];
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] > b[j])
{
ab = b[j];
b[j] = b[i];
b[i] = ab;
}
15.已知数据文件in。Dat中存有300个四位数，编写函数jsValue（），功能是：求出千位数上的数减百位数上的数减十位数上的数减个位数上的数大于零的个数cnt
【审题关键句】千数-百位-十位-个位数大于零的个数，把所有满足此条件的数依次存入数组，按从小到大的顺序排序。
【解题思路】
本题类似第9套试题，通过审题可以发现仅有一个不同点，即要求统计的四位数的条件是“千数-百位-十位-个位数大于零”，参考答案的第8条语句修改if语句的判断条件。另外，对于数据交换的整型变量tmp可以自定义其变量名。
【参考答案】
int i, j, qw, bw, sw, gw, tmp;
for(i = 0; i < 300; i++)
{
qw = a[i] / 1000;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
gw = a[i] % 10;
if(qw - bw - sw - gw > 0) //如果a[i] 千位上的数减百位上的数减十位上的数减个位数大于零
b[cnt++] = a[i];
}
for(i = 0; i < cnt-1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] > b[j])
{
tmp = b[j];
b[j] = b[i];
b[i] = tmp;
}
16. 已知数据文件in。Dat中存有300个四位数，编写函数jsValue（），功能是：求出个位数上的数减千位数上的数减百位数上的数减十位数上的数大于零的个数cnt
【审题关键句】个位-千位-百位-十位数大于零的个数，把所有满足此条件的数依次存入数组，按从大到小的顺序排序。
【解题思路】
本题类似第9套试题，通过审题可以发现有两个不同点：①要求统计的四位数的条件是“个位-千位-百位-十位数大于零的个数”，参考答案的第8条语句修改if语句的判断条件即可。②将统计结果按从大到小的顺序排序，参考答案的第13条语句，修改两数组元素的大小比较符即可。另外，对于数据交换的整型变量tmp可以自定义其变量名。
【参考答案】
int i, j, qw, bw, sw, gw, tmp;
for(i = 0; i < 300; i++)
{
qw = a[i] / 1000;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
gw = a[i] % 10;
if(gw - qw - bw - sw > 0) //如果a[i] 个位数减千位数减百位数减十位数大于零
b[cnt++] = a[i];
}
for(i = 0; i < cnt-1;
i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j]) //如果b[i]小于b[j],则两者进行互换,对数组b中的元素按从大到小的顺序排序
{
tmp = b[j];
b[j] = b[i];
b[i] = tmp;
}
17. 已知数据文件in。Dat中存有300个四位数，编写函数jsValue（），功能是：求出千位数上的数加百位数上的数等于十位数上的数加个位数上的数cnt，把数组b中的四位数按从大到小的顺序进行排序
【审题关键句】千位+百位等于十位+个位的数的个数，把所有满足此条件的四位数依次存入数组，然后对数组按从大到小的顺序进行排序。
【解题思路】
本题类似第9套试题，通过审题可以发现有两个不同点：①要求统计的四位数的条件是“千位+百位=十位+个位”，参考答案的第8条语句修改if语句的判断条件即可。②将统计结果按从大到小的顺序排序，参考答案的第13条语句，修改两数组元素的大小比较符即可。另外，对于数据交换的整型变量tmp可以自定义其变量名。
【参考答案】
int i, j, qw, bw, sw, gw, tmp;
for(i = 0; i < 300; i++)
{
qw = a[i] / 1000;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
gw = a[i] % 10;
if(qw + bw - sw - gw == 0) //如果a[i]千位上的数字加上其百位上的数字减去其十位上的数字减去个位上的数字等于零
b[cnt++] = a[i];
}
for(i = 0; i < cnt; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j]) //如果b[i]的值小于b[j]的值,则两者进行互换,对数组b进行降序排列
{
tmp = b[j];
b[j] = b[i];
b[i] = tmp;
}
18. 已知数据文件in。Dat中存有300个四位数，编写函数jsValue（），功能是：求出千位数上的数加个位数上的数等于百位数上的数加十位数上的个数cnt，把数组b中的四位数按从小到大的顺序进行排序
【审题关键句】千位+个位等于百位+十位个数，把所有满足此条件的数依次存入数组，按从小到大的顺序排序。
【解题思路】
本题类似第9套试题，通过审题可以发现仅有一个不同点，即要求统计的四位数的条件是“个位+千位=百位+十位”，参考答案的第8条语句，修改if条件语句的判断条件即可，对于数据交换的整型变量tmp可以自定义其变量名。
【参考答案】
int i, j, qw, bw, sw, gw, tmp;
for(i = 0; i < 300; i++)
{
qw = a[i] / 1000;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
gw = a[i] % 10;
if(qw + gw - bw - sw == 0) //如果a[i]千位上数加上其个位上的数减去其百位上的数减去其十位上的数等于0
b[cnt++] = a[i];
}
for(i = 0; i < cnt-1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] > b[j])
{
tmp = b[j];
b[j] = b[i];
b[i] = tmp;
}
19.程序test。C的
功能是：选出1000至5000范围内（包括1000、5000）符合下面条件的四位自然数。条件是：千位数字与百位数字之和等于十位数字与个位数字之和，且千位数字与百位数字之和等于个位数字与千位数字之差的整10倍。
【审题关键句】千位+百位等于十位+个位，且千位+百位等于个位-千位的10倍。计算并输出这些四位自然数的个数cnt以及这些数的和。
【解题思路】
①首先定义一个循环变量i，以及分别用来存放四位数分解之后各位数的变量qw（千位）、bw（百位）、sw（十位）和gw（个位）。
②通过for循环依次对数组中的每个四位数进行分解，循环初值为1?000，终值为5?000，每循环一次，循环变量i的值加1。每分解一个四位数，根据题目要求，判断其“千位+百位=十位+个位”的条件是否满足，同时判断“（千位+百位）=（个位-千位）*10”的条件是否满足，两个条件之间用&&运算符进行连接。当同时满足以上两个判断条件时，计数变量cnt的值加1，同时将该四位数累加到求和变量sum中，最终得到满足条件的四位自然数个数cnt及它们的和sum。
本题中cnt和sum变量在源程序中已经定义，在该子程序中就不需要再重新定义了。
【参考答案】
int i, qw, bw, sw, gw;
for(i = 1000; i <= 5000; i++) //循环变量i从1000开始,每次递增1,直到其值大于5000
{
qw = i / 1000;
bw = (i - qw * 1000) / 100;
sw = (i - qw * 1000 - bw * 100) / 10;
gw = i % 10;
if((qw + bw) == (sw + gw) && (qw + bw) == (gw - qw) * 10 ) //如果i的千位上的数字与其百位上的数字的和等于其十位上的数字与个位上的数字的和并且千位上的数字与百位上的数字的和等于个位上的数字与千位上的数字的差的10倍
{
cnt++; //变量cnt加1
sum += i; //把i累加到变量sum上
}
}
20.已知数据文件in。Dat中存有300个四位数，并已调用读函数readDat（）把这些数存入数组a中，编制一个函数jsValue（），其功能是：求出个位数上的数减千位数上的数减百位数上的数减十位数上的数大于零的个数cnt，再求出所有满足此条件的四位数平均值pjz1，以及所有不满足此条件的四位数平均值pjz2.
【审题关键句】个位-千位-百位-十位，结果大于零的数的个数，求满足此条件以及不满足此条件的四位数平均值ave1和ave2。
【解题思路】
①首先定义一个循环变量i，以及分别用来存放四位数分解之后各位数的变量qw（千位）、bw（百位）、sw（十位）和gw（个位）。
②通过for循环依次对数组中的每个四位数进行分解，每分解一个四位数，则根据题目要求，判断其“个位-百位-十位-千位>0”的条件是否满足，当满足条件时，则将a[i]的值累加到变量pjz1中，同时计数
变量cnt的值加1；如果不满足判断条件，则将四位数累加到变量pjz2中。当for循环结束之后，就能等到所有满足条件的四位数之和pjz1和个数，以及所有不满足条件的四位数之和pjz2。
③最后将变量pjz1的值除以变量cnt的值，得到所有满足条件的四位数的平均值并赋给变量pjz1，将变量pjz2的值除以300减去变量cnt的差，得到所有不满足条件的四位数的平均值并赋给变量pjz2。
本题中，pjz1、pjz2和cnt三个变量在源程序中已经定义，在该子程序中就不需要再重新定义了。
【参考答案】
int i, qw, bw, sw, gw;
for(i = 0; i < 300; i++)
{
qw = a[i] / 1000;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
gw = a[i] % 10;
if(gw - qw - bw - sw > 0) //如果a[i]的个位数减去千位数减去百位数减去十位的数大于零
{
pjz1 += a[i]; //把a[i]的值累加到变量pjz1
cnt++; //变量cnt加1
}
else pjz2 += a[i]; //如果a[i]的个位数减去千位数减去百位数减去十位的数小于等于零,把a[i]的值累加到变量pjz2
}
pjz1 /= cnt; //变量pjz1的值除以变量cnt的值,得到所有满足条件的四位数的平均值并赋给变量pjz1
pjz2 /= (300 - cnt); //变量pjz2的值除以300减去变量cnt的差,得到所有不满足条件的四位数的平均值并赋给变量pjz2
21 已知数据文件in.dat中存有300个四位数，并已调用函数readDat()把这些数存入数组a中,编制一函数，功能是：求出千位数上的数减百位数上的数减十位数上的数大于零的个数cnt,在求出所有满足此条件的四位数平均值pjz1，以及所有不满足此条件的四位数平均值pjz2答案：【参考答案】
int i, qw, bw, sw, gw;
for(i = 0; i < 300; i++)
{
qw = a[i] / 1000;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
gw = a[i] % 10;
if(qw - bw - sw - gw > 0) //如果a[i]千位上的数减去百位上数减去十位上的数减去个位上的数大于零
{
pjz1 += a[i];
cnt++;
}
else pjz2 += a[i];
}
pjz1 /= cnt;
pjz2 /= (300 - cnt);
22 已知数据文件in.dat中存有300个四位数，并已调用函数readDat()把这些数存入数组a中，功能是：求出千位数上的数加个位数上的数等于百位数上的数加十位数上的数的个数cnt, 在求出所有满足此条件的四位数平均值pjz1，以及所有不满足此条件的四位数平均值pjz2答案： int i, qw, bw, sw, gw;
for(i = 0; i < 300; i++)
{
qw = a[i] / 1000;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
gw = a[i] % 10;
if(qw + gw - bw - sw == 0) //如果a[i]的千位上的数字加上其个位上的数字减去其百位上的数字减去其十位上的数字等于零
{
pjz1 += a[i];
cnt++;
}
else pjz2 += a[i];
}
pjz
1 /= cnt;
pjz2 /= (300 - cnt);
23 已知数据文件in.dat中存有300个四位数，并已调用函数readDat()把这些数存入数组a中,功能是：求出 千位数上的数加百位数上的数等于十位数上的数加个位数上的数的个数cnt, 在求出所有满足此条件的四位数平均值pjz1，以及所有不满足此条件的四位数平均值pjz2答案【参考答案】
int i, qw, bw, sw, gw;
for(i = 0; i < 300; i++)
{
qw = a[i] / 1000;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
gw = a[i] % 10;
if(qw + bw - sw - gw == 0) //如果a[i]千位上的数字加上其百位上的数字减去其十位上的数字减去其个位上的数字等于零
{
pjz1 += a[i];
cnt++;
}
else pjz2 += a[i];
}
pjz1 /= cnt;
pjz2 /= (300 - cnt);
第3类 数位分解并重组后再筛选统计并排序
24 已知数据文件In.dat中存有200个四位数，并已调用函数readDat()把这些数存入数组a中，请考生编制一函数，功能是把千位数字和十位数字重新组成一个新的含有两位数字的数ab,以及把个位数字和百位数字组成另一个新的含有两位数字的数cd，如果组成的两个数ab-cd〉=0且ab-cd<=10且两个数均是奇数，同时两个新数的十位数字均不为零。则将满足此条件的四位数案从大到小的顺序存入数组b中，计算满足上述条件的四位数个数cnt答案：【参考答案】
int qw, bw, sw, gw, i, j, newV1, newV2;
for(i = 0; i < MAX; i++)
{
/*对四位数进行分解*/
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
/*分解后的四位数重新组合为两个十位数*/
newV1 = qw * 10 + sw; //a[i]的千位上的数字与其十位上的数字组成新的两位数newV1
newV2 = gw * 10 + bw; //a[i]的个位上的数字与其百位上的数字组成新的两位数newV2
if(qw && gw && (newV1 - newV2>0 && newV1-newV2<=10) && (newV1 % 2) && (newV2 % 2)) //如果a[i]的千位上的数字,个位上的数字均不等于零并且新组成的第一个数大于第二个数且第一个数与第二个数的差小于等于10且第一个数字,第二个数字均为奇数
b[cnt++] = a[i]; //把a[i]赋给b[cnt],同时下标变量cnt加1
}
/*对数组b[cnt]中的数字进行排序*/
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j]) //如果数组元素b[i]小于b[j],则两者交互换,对数组b进行降序排列
{
newV1 = b[j];
b[j] = b[i];
b[i] = newV1;
}
25 已知数据文件In.dat中存有200个四位数，并已调用函数readDat()把这些数存入数组a中，请考生编制一函数，功能是把千位数字和十位数字重新组成一个新的含有两位数字的数,以及把个位数字和百位数字组成另一个新的含有两位数字的数，如果组成的两个
数均是素数且新数的十位数均不为零，。则将满足此条件的四位数案从大到小的顺序存入数组b中，计算满足上述条件的四位数个数cnt答案：【参考答案】
int qw, bw, sw, gw, i, newV1, newV2, j;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
newV1 = qw * 10 + sw;
newV2 = gw * 10 + bw;
if(qw && gw && isprime(newV1) && isprime(newV2)) //如果a[i]千位上的数字和个位上的数字都不等于零且新组成的第一个数和第二个数都为素数
b[cnt++] = a[i];
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j])
{
newV1 = b[j];
b[j] = b[i];
b[i] = newV1;
}
26 已知数据文件In.dat中存有200个四位数，并已调用函数readDat()把这些数存入数组a中，请考生编制一函数，功能是把千位数字和十位数字重新组成一个新的含有两位数字的数ab,以及把个位数字和百位数字组成另一个新的含有两位数字的数cd，如果组成的两个数ab
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
newV1 = qw * 10 + sw;
newV2 = gw * 10 + bw;
if(qw && gw && (newV1
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j])
{
newV1 = b[j];
b[j] = b[i];
b[i] = newV1;
}
27 已知数据文件In.dat中存有200个四位数，并已调用函数readDat()把这些数存入数组a中，请考生编制一函数，功能是把千位数字和个位数字重新组成一个新的含有两位数字的数ab,以及把十位数字和百位数字组成另一个新的含有两位数字的数cd，如果组成的两个数均是偶数并且至少有一个数能被9整除，同时两个新数的十位数字均不为零，同时两个新数的十位数字均不为零，。则将满足此条件的四位数案从大到小的顺序存入数组b中，计算满足上述条件的四位数个数cnt答案：【参考答案】
int qw, bw, sw, gw, i, newV1, newV2, j;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
newV1 = gw * 10 + qw; //a[i]个位上的数字与
千位上的数字组成第一个新数newV1
newV2 = bw * 10 + sw; //a[i]百位上的数字与十位上的数字组成第二个新数newV2
if(gw && bw && (newV1 % 2 == 0) && (newV2 % 2 == 0) && (newV1 % 9 == 0 || newV2 % 9 == 0)) //如果 a[i]个位上的数字与百位上的数字都不为零且新组成的两个数都为偶数且至少有一个数能被9整除
b[cnt++] = a[i];
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j])
{
newV1 = b[j];
b[j] = b[i];
b[i] = newV1;
}
28已知数据文件In.dat中存有200个四位数，并已调用函数readDat()把这些数存入数组a中，请考生编制一函数，功能是从数组a中依次取出一个四位数，对每一个四位数组如下处理： 把千位数字和个位数字重新组成一个新的含有两位数字的数,以及把十位数字和百位数字组成另一个新的含有两位数字的数，如果组成的两个数一个是奇数，一个是偶数，并且至少有一个数能被17整数，同时两个新数的十位数字均不为零，同时两个新数的十位数字均不为零，。则将满足此条件的四位数案从大到小的顺序存入数组b中，计算满足上述条件的四位数个数cnt答案：【参考答案】
int qw, bw, sw, gw, i, newV1, newV2, j;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
newV1 = gw * 10 + qw; //a[i]个位上的数字与千位上的数字组成第一个新数newV1
newV2 = bw * 10 + sw; //a[i]百位上的数字与十位上的数字组成第二个新数newV2
if(gw && bw && (((newV1 % 2==0) && (newV2 % 2) && (newV1 % 17==0 || newV2 % 17==0)) || ((newV1 % 2) && (newV2 % 2==0) && (newV1 % 17==0 || newV2 % 17==0)))) //如果a[i]个位上的数字与百位上的数字都不为零且第一个新数为偶数,第二个新数为奇数且两者至少有一个能被17整除或者第一个新数为奇数,第二个新数为偶数且两者至少有一个能被17整除
b[cnt++] = a[i]; //把满足上述条件的a[i]赋给b[cnt],同时数组的下标变量cnt加1
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j]) //如果数组b中元素b[i]小于b[j],则两者互换,实现对数组b的降序排列
{
newV1 = b[j];
b[j] = b[i];
b[i] = newV1;
}
i
29 已知数据文件In.dat中存有200个四位数，并已调用函数readDat()把这些数存入数组a中，请考生编制一函数，功能是 把千位数字和个位数字重新组成一个新的含有两位数字的数,以及把十位数字和百位数字组成另一个新的含有两位数字的数，如果组成的两个数均是奇数并且至少有一个数能被5整除，同时两个新数的十位数字均不为零，同时两个新数的十位数字均不为零，。则将满足此条件的
四位数案从大到小的顺序存入数组b中，计算满足上述条件的四位数个数cnt答案：【参考答案】
int qw, bw, sw, gw, i, newV1, newV2, j;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
newV1 = qw * 10 + gw; //a[i]千位上的数字与个位上的数字组成第一个新数newV1
newV2 = bw * 10 + sw; //a[i]百位上的数字与十位上的数字组成第二个新数newV2
if(qw && bw && (newV1 % 2) && (newV2 % 2) && ((newV1 % 5) == 0 || (newV2 % 5)==0)) //如果a[i]千位上的数字与百位上的数字都不零且两个新组成的数均是奇数并且至少有一个数能被5整除
b[cnt++] = a[i]; //把满足上述条件的四位数a[i]赋给b[cnt],同时数组的下标变量cnt加1
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j]) //如果数组b中的元素b[i]小于b[j],则两者互换,实现数组b的降序排列
{
newV1 = b[j];
b[j] = b[i];
b[i] = newV1;
}
30 已知数据文件In.dat中存有200个四位数，并已调用函数readDat()把这些数存入数组a中，请考生编制一函数，功能是 把千位数字和十位数字重新组成一个新的含有两位数字的数ab,以及把个位数字和百位数字组成另一个新的含有两位数字的数cd，如果组成的两个数ab-cd〉=10，且ab-cd<=20且两个数均是偶数，同时两个新数的十位数字均不为零，同时两个新数的十位数字均不为零，。则将满足此条件的四位数案从大到小的顺序存入数组b中，计算满足上述条件的四位数个数cnt答案【参考答案】
int qw, bw, sw, gw, i, newV1, newV2, j;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
newV1 = qw * 10 + sw;
newV2 = gw * 10 + bw;
if(qw && gw && (newV1 - newV2>=10 && newV1-newV2<=20) && (newV1 % 2 == 0) && (newV2 % 2 == 0)) //如果a[i]千位上的数字与个位上的数字都不为零且第一个新数与第二个新数的差大于等于10而小于等于20并且新组成的两个新数都为偶数
b[cnt++] = a[i];
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j])
{
newV1 = b[j];
b[j] = b[i];
b[i] = newV1;
}
31 已知数据文件In.dat中存有200个四位数，并已调用函数readDat()把这些数存入数组a中，请考生编制一函数，功能是 把千位数字和十位数字重新组成一个新的含有两位数字的数ab,以及把个位数字和百位数字组成另一个新的含有两位数字的数cd，如果组成的两个数ab〉cd，ab必须是偶数且能被5整除，cd必须是奇数，同时两个新数的十位数字均不为零，同时两个新数的十位数字均不为零，。则将满足此条件
的四位数案从大到小的顺序存入数组b中，计算满足上述条件的四位数个数cnt答案【参考答案】
int qw, bw, sw, gw, i, newV1, newV2, j;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
newV1 = qw * 10 + sw;
newV2 = gw * 10 + bw;
if(qw && gw && (newV1> newV2) && (newV1 % 2 == 0 && newV1 % 5 == 0) && (newV2 % 2)) //如果a[i]千位上的数字与个位上的数字都不为零且第一个新数大于第二个新数且第一个新数必须是偶数且能被5整除，第二个新数必须是奇数
b[cnt++] = a[i];
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j])
{
newV1 = b[j];
b[j] = b[i];
b[i] = newV1;
}
32 已知数据文件in.dat中有200个四位数，并已调用读函数readDat()把这些数存入数组a中，编函数功能是：如果四位数各位上的数字均为或2或4或6或8中的一个数字，则统计出满足此条件的个数cnt,并把这些四位数按从大到小的顺序存入数组b中，答案是：【参考答案】
int qw, bw, sw, gw, i, j, ab;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
if((qw % 2==0) && (bw % 2==0) && (sw % 2==0) && (gw % 2==0)) //如果a[i] 各位上的数字均为偶数
b[cnt++] = a[i]; //把满足上述条件的四位数a[i]赋给b[cnt],同时数组下标变量cnt加1
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j]) //如果数组b中的元素b[i]小于b[j],则两者互换,对数组b进行降序排列
{
ab = b[j];
b[j] = b[i];
b[i] = ab;
}
33 已知数据文件in.dat中有200个四位数，并已调用读函数readDat()把这些数存入数组a中，编函数功能是：如果四位数各位上的数字均为奇数，则统计出满足此条件的个数cnt,并把这些四位数按从大到小的顺序存入数组b中，答案是：【参考答案】
int qw, bw, sw, gw, i, j, ab;
for(i = 0; i < MAX; i++)
{
qw = a[i] / 1000;
gw = a[i] % 10;
bw = (a[i] - qw * 1000) / 100;
sw = (a[i] - qw * 1000 - bw * 100) / 10;
if((qw % 2) && (bw % 2) && (sw % 2) && (gw % 2)) //如果a[i] 各位上的数字均为奇数
b[cnt++] = a[i];
}
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j])
{
ab = b[j];
b[j] = b[i];
b[i] = ab;
}
34 程序test.c的功能是：在三位整数（100至999）中寻找符合下面条件的整数，并依次从大到小存入数组b[]中。条件如下：某数既是完全平方数，又有两位数字相同，例如144，676等答案【参考答案】
int n, k, a, b, c, cnt = 0; //定义整型变量n, k, a, b, c, cnt,同时变量cnt的初值为0
for(k = 10;; k++) //循环变
量k从10开始,每次递增1
{
n = k * k; //把k的平方数赋给n
if(n < 100) continue; //如果n的值小于100,则进入下一次循环
if(n > 999) break; //如果n的值大于999,则退出for循环语句
a = n / 100; //n除以100得到n的百位上的数字
b = n % 100 / 10; //n对100求余再除以10,得到n的十位上的数字
c = n % 10; //n对10求余得到n个位上的数字
if((a-b)*(a-c)*(b-c) == 0) //如果n三个数位上的数字有两个相同
{
printf("N=%d=%d*%d\n", n, k, k);
bb[cnt++] = n; //把满足条件的三位数n赋给数组元素bb[cnt],同时数组下标变量cnt加1
}
}
return cnt; //返回满足条件的三位数的个数cnt
第4类 根据相邻数大小进行筛选统计并排序
35 有200个四位数，并已调用函数把这些数存入数组a中，功能是：依次从数组a中取出一个四位数，如果该四位数小于该四位数以后的连续五个数且该数是偶数，则统计出满足此条件的个数cnt,把这些四位数存入数组b中，而后对数组b进行升序排列，答案【参考答案】
int i, j, ab;
for(i = 0; i < MAX - 5; i++)
{
if((a[i] % 2==0) && a[i] < a[i+1] && a[i] < a[i+2] && a[i]
}
/*对数组b进行升序排序*/
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] > b[j]) //如果数组元素b[i]大于b[j],则两者互换
{
ab = b[j];
b[j] = b[i];
b[i] = ab;
}
36 有200个四位数，并已调用函数把这些数存入数组a中，功能是：依次从数组a中取出一个四位数，如果该四位数均大于该四位数以前的连续五位数且该数是偶数，则统计出满足此条件的个数cnt,把这些四位数按从大到小顺序存入数组b中，答案【参考答案】
int i, j, ab;
for(i = 5; i < MAX; i++)
{
if((a[i] % 2==0) && a[i] > a[i-1] && a[i] > a[i-2] && a[i] >a[i-3] && a[i] >a[i-4] && a[i] >a[i-5]) //判断a[i]连续大于该四位数以前的五个数且该数是偶数
b[cnt++] = a[i]; //把满足此条件的四位数a[i]存入数组元素b[cnt],同时数组下标变量cnt加1
}
/*对数组b进行降序排序*/
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j]) //如果数组元素b[i]小于b[j],则两者进行互换
{
ab = b[j];
b[j] = b[i];
b[i] = ab;
}
37 有200个四位数，并已调用函数把这些数存入数组a中，功能是：依次从数组a中取出一个四位数，如果该四位数均大于该四位数以前的连续五位数且该数是奇数，则统计出满足此条件的个数cnt,把这些四位数按从大到小顺序存入数组b中，答案【参
考答案】
int i, j, ab;
for(i = 0; i < MAX - 5; i++)
{
if((a[i] % 2) && a[i] > a[i+1] && a[i] > a[i+2] && a[i] >a[i+3] && a[i] >a[i+4] && a[i] >a[i+5]) //判断a[i]连续大于该四位数以后的连续五个数且该数是奇数
b[cnt++] = a[i]; //把满足此条件的四位数a[i]存入数组元素b[cnt],同时数组下标变量cnt加1
}
/*对数组b进行升序排序*/
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] > b[j]) //如果数组元素b[i]大于b[j],则两者进行互换
{
ab = b[j];
b[j] = b[i];
b[i] = ab;
}
38 有200个四位数，并已调用函数把这些数存入数组a中，功能是：依次从数组a中取出一个四位数，如果该四位数均大于该四位数以前的连续五位数且该数是奇数，且该数是奇数，且该数必须能被7整除，则统计出满足此条件的个数cnt,把这些四位数按从大到小顺序存入数组b中，答案【参考答案】
int i, j, ab;
for(i = 5; i < MAX; i++)
{
/* 判断a[i]连续大于该四位数以前的连续五个数且该数是奇数, 且该数必须能被7整除*/
if((a[i] % 2) && (a[i] % 7==0) && a[i] > a[i-1] && a[i] > a[i-2] && a[i] >a[i-3] && a[i] >a[i-4] && a[i] >a[i-5])
b[cnt++] = a[i]; //把满足此条件的四位数a[i]存入数组元素b[cnt],同时数组下标变量cnt加1
}
/*对数组b进行降序排序*/
for(i = 0; i < cnt - 1; i++)
for(j = i + 1; j < cnt; j++)
if(b[i] < b[j]) //如果数组元素b[i]小于b[j],则两者进行互换
{
ab = b[j];
b[j] = b[i];
b[i] = ab;
}
39 某级数的前两项A1=1，A2=1，以后各项具有关系：
An=An-2+2An-1
程序test.c功能是：要求依次对于整数M，求出级数前n的和Sn=A1+A2+….+An小于M的项数n，并依次把n值存入数组单元b[0]，b[1]和b[2]中，答案【参考答案】
int a1 = 1, a2 = 1, s= 2, n = 1, m = 10, i, t;
for(i = 0; i < 3; i++) //循环变量i从0开始,每次递增1,直到其值小于3
{
m *= 10; //m的值扩大10倍后,其值等于100
while(s < m) //当s的值小于m时,执行while循环语句
{
/*变量t 表示第n 项, a1表示第n-2 项, a2表示第n-1 项*/
t = a1 + 2 * a2; //根据级数第n项的递推关系,第n项等于第n-2项与2倍的第n-1项的和
s = s + t; //前n项的和等于前n-1项的和加上第n项的值
n = n + 1; //求级数第n 项的下一项,即第n +1项
a1 = a2; //把当前的第n-1 项赋给第n-2 项
a2 = t; //把当前的第n 项赋给第n-1 项
}
printf("m=%d,n=%d\n", m,n); //当退出while循环,把m值和求的n值在屏幕上显示出来
b[i] = n; //把求的n值存入数组元素b[i]中
}
40 功能：求Fibonacci数列中大于t的最小的一个数，结果由函数返回，其中Fibonacci数列F[n]的定义：
F[0]=0，F[1]=1
F[n]=F[n-1]+F[n-2]（n）=2）
最后调用函
数读取10个数据t，得出结果答案【参考答案】
int f0 = 0, f1 = 1, f2 = 1; //定义整型变量f0,f1,f2,并分别赋初值为0,1,1
/* f0表示数列中的第F(n-2)项,f1表示数列中的第F(n-1)项,f2表示数列中的第F(n)项*/
while(f2 < t) //当数列中的第F(n)项的值小于t时,执行while循环
{
f0 = f1; //把数列当前第F(n-1)项的值赋给f0
f1 = f2; //把数列当前第F(n)项的值赋给f1
f2 = f0 + f1; //数列当前第F(n-1)项的值加上第F(n)项的值得到数列第F(n+1)项的值
}
return f2; //退出while循环时,得到Fibonacci数列中大于t的最小的一个数f2,返回
41、程序test.c的功能是：利用一下所示的简单迭代方法求方程cos(x)-x=0的一个实根。迭代公式：xn+1=cos(xn)(n是迭代次数) 迭代步骤如下：取x1初值为0.0【审题关键句】Xn+1=cos(Xn)的迭代计算。
【解题思路】
①因为方程cos(x)-x=0的根为实数，所以定义两个双精度型变量x0, x1。并把变量x1的初值设为0.0。
②根据题目中给出的求方程一个实根的迭代算法，在while循环中，首先把变量x1的值赋给x0，然后利用表达式cos(x0)求出一个值x1，再调用vc6.0的求绝对值的库函数fabs()，判断如果x0与x1差的绝对值小于0.000001，就认为x1的值是方程cos(x)-x=0的一个实根，此时退出循环，把x1的值返回。
【参考答案】
double x0, x1= 0.0; //定义双精度型变量x0, x1, 变量x1赋初值为0.0
while(1) //执行while循环语句
{
x0 = x1; //把x1的值赋给x0
x1 = cos(x0); //求出一个新的x1
if(fabs(x0 - x1) < 0.000001) //如果x0-x1的绝对值小于0.000001,则退出循环
break; //退出循环
}
return x1; //此时x1的值就是方程的一个实根
42、将文件in.dat中的200个整数读至数组xx中。请编制js Value()函数，要求：求出数组xx中的数值为奇数的个数cntl和数值为偶数的个数cnt2以及数组xx下标为偶数的元素值的算术平均值pj。【审题关键句】读入数值，奇数个数，偶数个数，数组下标为偶数的平均值。
【解题思路】
①首先定义循环变量i，并对全局变量cnt1、cnt2和pj赋初值0。
②在for循环语句中，将数组xx中的每个数组元素xx[i]对2求余数，如果余数非零，则说明xx[i]是奇数，奇数的个数变量cnt1加1，否则，偶数的计数变量cnt2加1；接着将数组xx下标i对2求余，如果余数等于0，则把xx[i]的值累加到变量pj。
③退出循环时，变量pj的值除以100.0就得到数组xx下标i为偶数的元素值的算术平均值pj（因为数组中共有200个数组，下标为奇偶数的元素各占一半，因此直接将累加变量pj的值直接除100即可得到这些数的平均值）。
【参考答案】
int i; cnt1=0; cnt2=0; pj=0;
/* for循环语句计算数组xx中的数值为奇数的个数cnt1和数值为偶数的个数cnt2以
及数组xx下标为偶数的元素值的和*/
for(i = 0; i < N; i++) //循环变量i从0开始,每次递增1,直到其值小于N
{
if(xx[i] % 2) cnt1++; //如果xx[i]的值为奇数,变量cnt1加1
else cnt2++; //否则, xx[i]的值为偶数,变量cnt2加1
if(i % 2==0) pj += xx[i]; //如果数组xx下标i为偶数,则把xx[i]的值累加到变量pj
}
pj /= 100.0; //变量pj除以100.0得到数组xx下标i为偶数的元素值的平均值pj
43、将文件in.dat中的200个整数读至数组xx中。请编制js Value()函数，要求：求出数组xx中的数值为奇数的个数cntl和数值为偶数的个数cnt2以及数组xx下标为奇数的元素值的算术平均值pj。【审题关键句】读入数值，奇数个数，偶数个数，数组下标为奇数的平均值。
【解题思路】
本题类似第42套试题，通过审题可以发现仅有一个不同点，即本题是计算数组下标为奇数的元素的平均值，参考答案的第6条语句。
【参考答案】
int i; cnt1=0; cnt2=0;pj=0;
for(i = 0; i < N; i++)
{
if(xx[i] % 2) cnt1++;
else cnt2++;
if(i % 2) pj += xx[i]; //如果数组xx下标i为奇数,则把xx[i]的值累加到变量pj
}
pj /= 100.0;
44、已知在in.dat中存有若干个（个数<200）四位十进制数字组成的正整数，函数ReadDat（）读取这若干个正整数并存入数组xx中。请编制函数CalValue()，其功能要求：求出该文件中共有多少个正整数totNum【审题关键句】读取正数，统计个数，右移后为偶数的个数及平均值。
【解题思路】
①定义整型变量i、j和长整型he，并把其初始值设置为0。
②用for循环语句对数组xx进行扫描，如果当前数组元素xx[i]非零，则全局变量totNum加1。
③在for循环语句中，循环变量i从0开始递增到totNum-1，对数组xx中的每个元素xx[i]右移一位，把这个值赋给整型变量j，再对j的值对2求余数，如果余数等于0，则变量totCnt加1，并把数组元素xx[i]累加到变量he。
④退出循环时，把变量he的数据类型转换成双精度型再除以变量totCnt的值，就得到算术平均值totPjz。
【参考答案】
int i, j;
long he = 0; //符合条件的正整数的和
/*循环变量i从0开始,每次增加1,如果数组元素xx[i]非零,则变量totNum 加1,直到i 大于或等于MAXNUM ,退出循环时,变量totNum的值就是数组xx 中元素的个数*/
for(i = 0; i < MAXNUM; i++)
if(xx[i])
totNum++;
/*数组xx 的每一个元素xx[i]右移一位,得到新数j,如果j为偶数,则变量totCnt加1,同时把数组元素xx[i]累加到变量he */
for(i = 0; i < totNum; i++)
{
j = (xx[i] >> 1); //xx[i]右移一位,得到新数j
if(j % 2==0) //如果j是偶数
{
totCnt++; //totCnt加1
he += xx[i]; //数组元素xx[i]累加到变量he
}
}
totPjz = (double) he / totCnt; //变量he除以totCnt得
到符合条件的数的算术平均值totPjz
45、已知在in.dat中存有若干个（个数<200）四位十进制数字组成的正整数，函数ReadDat（）读取这若干个正整数并存入数组xx中。请编制函数CalValue()，其功能要求：求出该文件中共有多少个正整数totNum【审题关键句】读取正数，统计个数，右移后为奇数的个数及平均值。
【解题思路】
本题类似第44套试题，通过审题可以发现仅有一个不同点，即参与平均值计算的元素是数组xx[i]右移一位之后为奇数的元素，参考答案的第9条语句。
【参考答案】
int i, j;
long he = 0;
for(i = 0; i < MAXNUM; i++)
if(xx[i])
totNum++;
for(i = 0; i < totNum; i++)
{
j = (xx[i] >> 1);
if(j % 2) //如果j是奇数
{
totCnt++;
he += xx[i];
}
}
totPjz = (double) he / totCnt;
46、已知在in.dat中存有若干个（个数<200）四位十进制数字组成的正整数，函数ReadDat（）读取这若干个正整数并存入数组xx中。请编制函数CalValue()，其功能要求：求出该文件中共有多少个正整数totNum【审题关键句】读取正数，统计个数，各位数字之和为偶数的数的个数及平均值。
【解题思路】
①定义整型循环变量i、j，表示各位数字之和的长整型变量he以及存储一个四位数的字符数组num[5]。
②循环变量i从0开始，依次递增到4，对字符数组num[5]的每个元素赋初值0。
③循环变量i从0开始，依次递增到MAXNUM-1，对每个数组元素xx[i]进行判断，如果xx[i]的值非零，则变量totNum加1，退出循环时，totNum的值就是文件in.dat中存有的四位正整数的个数。
④循环变量i从0开始，依次递增到totNum-1，对于每个数组元素xx[i]调用库函数sprintf()以4个字符宽度形式输出到字符数组num中，用字符数组num中的每个元素减去0的ASCII码48，就分别得到xx[i]这个四位数每位上的数字，并把这四个数字相加赋给变量j。再对变量j对2求余数进行判断其值是否等于0，如果等于0，则说明j是偶数，变量totCnt加1，并把xx[i]的值累加到变量he。
⑤退出循环后，把变量he的类型转换成双精度型再除以totCnt得到符合条件的数的算术平均值totPjz。
【参考答案】
int i, j;
long he = 0;
char num[5];
for(i = 0; i < 5; i++)
num[i] = 0;
for(i = 0; i < MAXNUM; i++)
if(xx[i])
totNum++;
for(i = 0; i < totNum; i++)
{
sprintf(num, "%04d", xx[i]); //把xx[i]以4个字符宽度形式输出到字符数组num中
/*因为0的ASCII码值等于48，所以num[0]-48的差就是xx[i]的第一位数字，num[1]-48的差就是xx[i]的第二位数字，num[2]-48的差就是xx[i]的第三位数字，num[3]-48的差就是xx[i]的第四位数字*/
j = num[0]-48 + num[1]-48 + num[2]-48 + num[3]-48; //xx[i]的各位数字之和赋给j
if(j % 2 == 0) //