数据筛选排序求平均值
（1）调用函数rwdata（），从IN.dat文件中读取10组数据（m，k），并嵌套调用primenum函数分别得出array[]数组。请编写函数primenum（int m，int k，int array[]）,该函数的功能是：将紧靠m的k个素数存入数组array并在屏幕上显示。最后把结果输出到文件OUT.dat中。
void primenum（int m，int k，int array[]）
{
int value=m+1;
int half,n=0,i;
while(1)
{half=value/2;
for(i=2;i<=half;i++)
if(value%i==0)break;
if(i>half)
{array[n]=value;
n++;}if(n>=k)break;
value++;
}
}
（2）在IN.dat文件中有200个正整数，且每个数均在1000-9999之间。在函数RAdata（）中读取着200个数字存放到数组original中。请编写函数numAscend（），其功能是：要求按每个数后3位的大小进行升序排列，然后取出满足条件的前10个数依次存入数组result中，如果后三位的数值相等，则按原先的数值降序排列。最后调用函数WAdata（），把结果result输出到文件OUT.dat中。
void numascend()
{int i,j,data;
for(i=0;i<199;i++)
for(j=i+1;j<200;j++)
{if (original[i]%1000>original[j]%1000)
{data=original[i];
original[i]=original[j];
original[j]=data;
}
else if (original[i]%1000==original[j]%1000)
{if(original[i]
original[i]=original[j];
original[j]=data;
}
}
}
for(i=0;i<10;i++)
result[i]=original[i];
}
8请编写函数CountValue（），它的功能是：求n以内（不包括n），同时被3与7整出的所有自然数之和的平方根s，并作为函数值返回。主函数最后调用progReadWrite（）从IN.dat文件中读取10组数据，分别得出结果，且把结果输出到文件OUT.dat中。例如，若n为1000时，函数值应为：s=153.909064
double CountValue(int n)
{double xy=0.0;
int i;
for(i=1;i
xy+=i;
xy=sqrt((double)xy);
return xy;
}
9已知IN.dat文件中存有N个（N<200）实数，函数RData（）读取这N个实数并存入数组original中。请编写函数CalValue（），要求实现的功能有：（1）求出这N个实数的平均值（aver）（2)分别求出这N个实数的整数部分之和（sumint）以及小数部分之和（sumdec），最后调用函数WData（），把结果输出到文件OUT.dat中。
void CalValue(void)
{int i;
double x,sum=0;
for(i=0;i
x=original[i]-(int)original[i];
sumdec=sumdec+x;
sum=sum+original[i];
}
aver=sum/MAXNUM;
}
10已知IN.dat文件中存有300个四位数，并以调用读函数Rdata（）把这些数存入数组a中，请编写函数primeNum（），其功能是：求出所有这些四位数中素数的个数count，再把所有满足此条件的四位数一次存入数组b中，然后对数组b的四位数按从小到大的顺序进行排序，最后调用函数Wdata（），把结果输出到文件OUT.dat中。
void primeNum()
{int j,i,value;
for(i=0;i<30
0;i++)
if(isP(a[i]))
{b[count]=a[i];
count++;
}
for(i=0;i
{value=b[i];
b[i]=b[j];
b[j]=value;
}
}
12下列程序的功能是：找出所有100以内（含100）满足i,i+4,i+10都是素数的整数i(i+10也在100以内）的个数count以及这些i之和sum，编写函数primeNum（）实现程序要求的功能，最后调用函数writeDat（），把结果count和sum输出到OUT.dat文件中
void primeNum()
{int i;
for(i=2;i<=90;i++)
if(isPrime(i)&&isPrime(i+4)&&isPrime(i+10))
{count++;
sum+=i;
}
}
}
14编写函数countValue（），其功能是：求出1—1000内能被7或11整除但不能同时被7和11整除的所有整数，将它们放在数组a中，并通过n返回这些数的个数，主函数最后调用函数WData（），把结果输出到OUT.dat文件中
void countValue(int *a,int*n)
{int i;
*n=0;
for(i=0;i<=1000;i++)
if(i%7==0&&i%11)
{*a=i;
*n=*n+1;
a++;
}
else if(i%7&&i%11==0)
{*a=i;
*n=*n+1;
a++;
}
}
15已知文件IN.dat中存有300个四位数，并已调用函数Rdatd（）把这些数存入数组a中，请编写函数primeCal（），其功能是：求出这些四位数中素数的个数count，再求出所有满足此条件的四位数的平均值Ave1以及不满足此条件的四位数的平均值Ave2.最后调用函数WData（），把结果count,Ave1，Ave2输出到OUT.dat文件中
void primeCal()
{int i;
for(i=0;i<300;i++)
if(isP(a[i]))
{Ave1+=a[i];
count++;
}
else
{Ave2+=a[i];
}
Ave1=Ave1/count;
Ave2=Ave2/(300-count);
}
16下列程序的功能是：寻找并输出11-999之间的数m，它满足m，m^2和m^3均为回文数。所谓回文数是指各位数字左右对称的整数，例如121.满足上述条件的数如m=11，m^2=121，m^3=1331皆为回文数。编写函数intpalindromevalue(long n)实现功能：如果是回文数，则函数返回1，反之返回0.最后，把结果输出到OUT.dat文件中
void palindromevalue(long n)
{int i,strl,half;
char temp[20];
ltoa(n,temp,10);
strl=strlen(temp);
half=strl/2;
for(i=0;i
break;
if(i>=half)
return 1;
else
return 0;
}
17补充程序，实现以下功能：从文件IN.dat中读取200个整数至数组number中，求出奇数的个数cnt1和偶数的个数cnt2以及数组number下标为偶数的元素值的算术平均值ave（保留2位小数）把结果cnt1，cnt2，ave输出到OUT.dat文件中
for(i=0,j=0,cnt1=0,cnt2=0;i
cnt1++;
else
cnt2++;
if(i%2==0)
j+=number[i];
}
ave=(float)j/(N/2);
19已知文件IN.dat中存有200个四位数，并已调用函数rdatd（）把这些数存入数组a中，请编写函数evenvalue（），其功能是：如果四位数每位上的数字均是0，2，4，6或8，则统计满足此条件的四位数的个数count，并把这些四位数按从大到小的顺序存入到数组b中，最后main（）函数调用写函数wdata（），把
结果count以及数组b中满足条件的四位数输出到OUT.dat文件中
void evenvalue()
{int bb[4];
int i,j,k,flag;
for(i=0;i<200;i++)
{bb[0]=a[i]/1000;
bb[1]=a[i]%1000/100;
bb[2]=a[i]%100/10;
bb[3]=a[i]%10;
for(j=0;j<4;j++)
{if(bb[j]%2==0)
{flag=1;
}
else
{flag=0;
break;
}
}
if(flag==1)
{b[count]=a[i];
count++;
}
}
for(i=0;i
b[i]=b[j];
b[j]=k;
}
}
24已知文件IN.dat中存有200个四位数，并已调用函数rdatd（）把这些数存入数组a中，请编写函数evenval（），其功能是：若一个四位数的千位上的数字值小于等于百位上的数字值，百位上的数字值小于等于十位上的数字值，以及十位上的数字值小于等于个位上的数字值，且该四位数是偶数，则统计出满足此条件的个数count，并把这些四位数按从大到小的顺序存入到数组b中，最后调用写函数wdata（），把结果count以及数组b中满足条件的四位数输出到OUT.dat文件中
程序中已定义数组a[200],b[200]已定义变量count
void evenVal()
{int i,j;
int a1,a2,a3,a4,k;
for(i=0;i
a2=a[i]%1000/100;
a3=a[i]%100/10;
a4=a[i]%10;
if((a1<=a2) && (a2<=a3) && (a3<=a4) && (a[i]%2==0))
{b[count]=a[i];
count++;
}
}
for(i=0;i
{k=b[i];
b[i]=b[j];
b[j]=k;
}
}
25下列程序的功能是：在三位整数（100-999）中寻找符合条件的整数并依次从小到大存入数组中；该整数既是完全平方数又有两个数字相同，如144.编写函数SearchVal实现此功能，满足此条件的整数的个数通过所编写的函数返回。最后调用函数WData（），把结果输出到OUT.dat文件中
searchVal(int bb[])
{int i,a,b,c,cnt=0;
for(i=10;i*i<1000;i++)
{a=i*i/100;
b=i*i/10%10;
c=i*i%10;
if(a==b||b==c||c==a)
bb[cnt++]=i*i;
}
return cnt;
}
26已知文件IN.dat中存有300个四位数，并已调用函数rdatd（）把这些数存入数组a中，请编写函数jsValue（），其功能是：求出千位上得数减百位上得数减十位上得数减个位上得数大于0得数的个数count，把所有满足条件的数依次存入到数组b中，然后对数组b中的四位数从小到大排列。最后调用函数WData（），把结果输出到OUT.dat文件中
void jsValue（）
{int i,thou,hun,ten,data,j;
for(i=0;i<300;i++)
{thou=a[i]/1000;
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if(thou-hun-ten-data>0)
{b[count]=a[i];
count++;
}
}
for(i=0;i
{data=b[i];
b[i]=b[j];
b[j]=data;
}
}
28已知文件IN.dat中存有若干个（<200）四位数字的正整数，函数RWData（）读取着若干个正整数并存入数组original中，请编写函数CalValue（），其功能是：（1求出这个文件中共有多少个正整数totNum；（2求这些数右移1位后，产生的新
数是偶数的个数toteven，以及满足此条件的这些数（有以前的值）的算术平均值totavg，最后调用函数WData（），把结果输出到OUT.dat文件中
void CalValue（void）
{int i,data;
for(i=0;i
break;
if(original[i]>0)
totNum++;
data=original[i]>>1;
if(data%2==0)
{toteven++;
totavg+=original[i];
}
}
totavg/=toteven;
}
30在IN.dat文件中有200个四位数，并已调用函数rdatd（）把这些数存入数组a中，请编写函数seVal（），其功能是：依次从数组a中取出一个四位数，如果该四位数连续小于该四位数以后的5个数且是偶数（该四位数以后不满四位则不统计）则统计出满足此条件的个数count并把这些四位数按从小到大的顺序存入到数组b中，最后调用函数WData（），把结果count以及数组b中符合条件的四位数输出到文件OUT.dat中。
void seVal（）
{int i,j,flag=0;
for(i=0;i
if(a[i]
}
else
{flag=0;
break;
}
if(flag==1 && a[i]%2==0)
{b[count]=a[i];
count++;
}
}
for(i=0;i
{flag=b[i];
b[i]=b[j];
b[j]=flag;
}
}
32补充完整RData（）函数，实现从文件IN.dat中读取1000个十进制整数到数组evennum中，编写函数Compute（）分别计算evennum中奇数的个数odd,偶数的个数even，奇数的平均值ave1，偶数的平均值ave2以及所有偶数的方差totfc的值，最后调用函数WData（），把结果输出到文件OUT.dat中。计算方差的公式如下：N偶数的个数，evennum[i],ave2偶数的平均值
原始数据的存放格式：每行存放10个数（每个数均大于=且小于等于2000）并用逗号隔开
void Compute(void)
{int i,result[MAX];
for(i=0;i<1000;i++)
if(evennum[i]%2)
{odd++;
ave1+=evennum[i];
}
else
{even++;
ave2+=evennum[i];
result[even-1]=evennum[i];
}
ave1/=odd;
ave2/=even;
for(i=0;i
}
33下列程序的功能是：讲一个正整数序列{k1……k9}重新排列成一个新的序列，新序列中比k1小的数都在k1的前面，比k1大的数都在k1的后面，编写函数NumSort（）实现此功能，最后调用函数WData（），把结果输出到文件OUT.dat中。说明：在序列中已给出10个序列，每个序列有9个正整数，并存入数组a[10][9]中，分别求出这十个新序列
NumSort(int a[10][9])
{int value,i,j,k,num;
for(i=0;i<10;i++)
{value=a[i][0];
for(j=0;j<9;j++)
if(a[i][j]
for(k=j;k>0;k--)
a[i][k]=a[i][k-1];
a[i][0]=num;
}
}
}
34下列程序的功能是：选出100以上，1000之内的所有个位数字于十位数字之和被10除的余数恰好是百位数字的素数，计算并输出上述这些素数的个数count以及这些素数值得和sum，编写函数countValue（）实现程序要求，最后调用函数WData（），把结
果count和sum输出到文件OUT.dat中。
void countValue()
{int i,j,half,hun,ten,data;
for(i=101;i<1000;i++)
{hun=i/100;
ten=i%100/10;
data=i%10;
if(hun==(ten+data)%10)
{half=i/2;
for(j=2;j
break;
if(j>=half)
{count++;
sum+=i;
}
}
}
}
38已知文件IN.dat中存有若干个（<200）四位数字的正整数，函数RWData（）读取着若干个正整数并存入数组original中，请编写函数CalValue（），其功能是：（1求出这个文件中共有多少个正整数totNum；（2求这些数个位数字之和是偶数的个数totCnt，以及满足此条件的这些数的算术平均值totave，最后调用函数WData（），把结果输出到OUT.dat文件中
void CalValue（void）
{int i,thou,hun,ten,data;
int ab;
long sum=0;
for(i=0;i
totNum++;
thou=original[i]/1000;
hun=original[i]%1000/100;
ten=original[i]%100/10;
data=original[i]%10;
ab=thou+hun+ten+data;
if(ab%2==0)
{totCnt++;
sum=sum+original[i];
}
}
totave=(double)sum/totCnt;
}
42在IN.dat文件中有200个四位数，并已调用函数rdatd（）把这些数存入数组a中，请编写函数seVal（），其功能是：依次从数组a中取出一个四位数，如果该四位数连续大于该四位数以前的5个数且是偶数（该四位数以后不满四位则不统计）则统计出满足此条件的个数count并把这些四位数按从大到小的顺序存入到数组b中，最后调用函数WData（），把结果count以及数组b中符合条件的四位数输出到文件OUT.dat中。
void evenVal（）
{int i,j,flag=0;
for(i=5;i
{flag=1;
}
else
{flag=0;
break;
}
if(flag==1 && a[i]%2==0)
{b[count]=a[i];
count++;
}
}
for(i=0;i
b[i]=b[j];
b[j]=flag;
}
}
45已知文件IN.dat中存有300个四位数，并已调用函数rdatd（）把这些数存入数组a中，请编写函数spellVal（），其功能是：求出千位上得数加个位上得数等于百位上得数加十位上得数大于0得数的个数count，把所有满足条件的数依次存入到数组b中，然后对数组b中的四位数从小到大排列。最后调用函数WData（），把结果输出到OUT.dat文件中
void spellValue（）
{int i,thou,hun,ten,data,j;
for(i=0;i<300;i++)
{thou=a[i]/1000;
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if(thou+data==hun+ten)
{b[count]=a[i];
count++;
}
}
for(i=0;i
{data=b[i];
b[i]=b[j];
b[j]=data;
}
}
46已知文件IN.dat中存有300个四位数，并已调用函数rdatd（）把这些数存入数组a中，请编写函数jsValue（），其功能是：求出千位上得数减百位上得数减十位上得数减个位上得数大于0得数的个数count，再求出所有满足条件的四位数的平均值ave1，以及不满足条件的四位数的平均值ave
2，最后调用函数WData（），把结果输出到OUT.dat文件中
void diffVal（）
{int i,thou,hun,ten,data,n=0;
for(i=0;i<300;i++)
{thou=a[i]/1000;
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if(thou-hun-ten-data>0)
{
count++;
ave1+=a[i];
}
else
{n++;
ave2+=a[i];
}
}
ave1/=count;
ave2/=n;
}
50已知文件IN.dat中存有300个四位数，并已调用函数Rdatd（）把这些数存入数组a中，请编写函数diffNum（），其功能是：求出千位上得数减百位上得数减十位上得数减个位上得数大于0得数的个数count，把所有满足条件的数依次存入到数组b中，然后对数组b中的四位数从小到大排列。最后调用函数WData（），把结果输出到OUT.dat文件中
void diffNum（）
{int i,thou,hun,ten,data,j;
for(i=0;i<300;i++)
{thou=a[i]/1000;
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if(thou-hun-ten-data>0)
{b[count]=a[i];
count++;
}
}
for(i=0;i
{data=b[i];
b[i]=b[j];
b[j]=data;
}
}
52在IN.dat文件中有200组数据，每组有3个数，每个数均是三位数。函数Rdata（）读取这200数据存放到结构数组aa中，编写函数numSort，其功能是要求在200组数据中找出条件为每组中的第2个数大于第1个数加第3个数之和，其中满足条件的组数作为函数numSort（）的返回值，同时把满足条件的数据存入结构数组bb中，再对bb数据按照每组据的第2个数加第3个数之和的大小进行降序排列（第2个数加第3个数之和均不相等），排序后的结果仍重新存入结构数组bb中，最后调用函数WData（），把结果bb输出到OUT.dat文件中
int numSort()
{int i,cnt=0,j;
data ch;
for(i=0;i<200;i++)
if(aa[i].x2>aa[i].x1+aa[i].x3)
{bb[cnt]=aa[i];
cnt++;
}
for(i=0;i
bb[i]=bb[j];
bb[j]=ch;
}
return cnt;
}
53已知文件IN.dat中存有200个四位数，并已调用函数Rdatd（）把这些数存入数组a中，请编写函数CalVal（），其功能是：若一个四位数的千位上的数字值加上十位上的数字值恰好等于百位上的数字值加上个位上的数字值，且原四位数是偶数，则统计出满足此条件的四位数个数count，并把这些四位数按从小到大的顺序存入到数组b中，最后调用写函数w Data（），把结果count以及数组b中满足条件的四位数输出到OUT.dat文件中
程序中已定义数组a[200],b[200]已定义变量count
void CalVal（）
{int i,thou,hun,ten,data,j;
for(i=0;i
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if((thou+ten==hun+data) && a[i]%2!=1)
{b[count]=a[i];
count++;
}
}
for(i=0;i
{data=b[i];
b[i]=b[j];
b[j]=data;
}
}
55已知文件IN.dat中存有若干个（<200）四位数字的正整数
，函数RWData（）读取着若干个正整数并存入数组number中，请编写函数CalValue（），其功能是：（1求出这个文件中共有多少个正整数totNum；（2求这些数个位数字之和是奇数的个数totCnt，以及满足此条件的这些数的算术平均值totave，最后调用函数WData（），把结果输出到OUT.dat文件中
void CalValue（void）
{int i,thou,hun,ten,data;
for(i=0;i
break;
if(number[i]>0)
totNum++;
thou=number[i]/1000;
hun=number[i]%1000/100;
ten=number[i]%100/10;
data=number[i]%10;
if((thou+hun+ten+data)%2)
{totCnt++;
totave+=number[i];
}
}
totave/=totCnt;
}
56下列程序的功能是：计算500-800区间内素数的个数count，并按所求素数的值从大到小的顺序排列，再计算其间隔加减之和，即第1个素数—第2个素数+第3个素数-第4个素数+第5个素数……的值sum，编写函数primeValue（）实现程序的要求。最后调用函数writeDat（），把结果count和sum输出到OUT.dat文件中
void primeValue()
{int i,j,half,yy[100];
for(i=800;i>=500;i--)
{half=i/2;
for(j=2;j
break;
if(j>=half)
{yy[count]=i;
count++;
}
}
for(i=0,j=1;i
j=j*-1;
}
}
57下列程序的功能是：千位数字与百位数字之和等于十位数字与个位数字之和，且千位数字与百位数字之和等于个位数字与千位数字之差的10倍，计算并输出这些四位自然数的个数count以及这些数的和sum。编写函数calValue（）实现程序的要求，最后调用函数writeDat（），把结果count和sum输出到OUT.dat文件中
void spellValue（）
{int i,thou,hun,ten,data;
for(i=5000;i>=1000;i--)
{thou=i/1000;
hun=i%1000/100;
ten=i%100/10;
data=i%10;
if(thou+hun==ten+data && thou+hun==(data-thou)*10)
{
count++;
sum+=i;
}
}
}
58已知IN.dat文件中存有200个四位数，并以调用读函数Rdata（）把这些数存入数组a中，请编写函数primecount（），其功能是：如果四位数各个位上的数字均是奇数，则统计出满足此条件的个数count并把这些四位数按从大到小的顺序存入数组b中，最后main()函数调用函数WriteData（），把结果count以及数组b中符合条件的四位数输出到文件OUT.dat中。
void primecount（）
{int i,thou,hun,ten,data,j;
for(i=0;i<200;i++)
{thou=a[i]/1000;
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if(thou%2!=0 && hun%2!=0 && ten%2!=0 && data%2!=0)
{b[count]=a[i];
count++;
}
}
for(i=0;i
b[i]=b[j];
b[j]=data;
}
}
60已知文件IN.dat中存有200个四位数，并已调用函数reaDat（）把这些数存入数组a中，请编写函数diffVal（），其功能是：把一个数字的千位数字上得值，减百位上得值，再减十位上得值，最后减个位的值，如果最后得出的值大于0且原四位数是奇数
，则统计满足条件的个数count并把这些四位数从小到大存入数组b中。最后调用函数writeData（），把结果count以及数组b中符合条件的四位数输出到OUT.dat文件中
void diffVal（）
{int i,thou,hun,ten,data,j;
for(i=0;i
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if((thou-hun-ten-data>=0) && a[i]%2==1)
{b[count]=a[i];
count++;
}
}
for(i=0;i
{data=b[i];
b[i]=b[j];
b[j]=data;
}
}
67函数Rdata（）中实现从文件IN.dat中读取一篇英文文章存放到字符串数组string中，请编写函数SortCharA（），其功能是：以行为单位对字符从大到小的顺序进行排序，排序后的结果仍按行从新存入到字符串数组string中，最后调用函数Wdata（），把结果string输出到文件OUT.dat中。原始数据存放的格式是：每行的宽度均小于80个字符
void SortCharA(void)
{int i,j,k,strl;
char ch;
for(i=0;i
for(j=0;j
{ch=string[i][j];
string[i][j]=string[i][k];
string[i][k]=ch;
}
}
}
61已知文件IN.dat中存有若干个（<200）四位数字的正整数，函数RWData（）读取着若干个正整数并存入数组number中，请编写函数CalValue（），其功能是：（1求出这个文件中共有多少个正整数totNum；（2求这些数右移移位一后，产生的新数是奇数的个数totCnt，以及满足此条件的这些数（右移前的值）的算术平均值totAve，最后调用函数writeDat（），把结果输出到OUT.dat文件中
void CalValue（void）
{int i，data;
for(i=0;i
break;
if(number[i]>0)
totNUM++;
data=number[i]>>1;
if(data%2)
{totCnt++;
totAve+=number[i];
}
}
totAve/=totCnt;
}
63在IN.dat文件中有200组数据，每组有三个数，每个数均是三位数，函数Rdata（）读取这200组数据存放到结构数组aa中，编写函数greatSort（），其功能是：要求在200组数据中找出条件为每组中的第一个数大于第二个数加第三个数之和 ，其中满足条件的数组作为函数greatSort（）的返回值，同时把满足条件的数组存入结构数组bb中，再对bb中的数据按照每组数据的第一个数加第三个数之和的大小进行升序排列（第一个数加第三个数之和均不相等），排序后的结果仍重新存入结构数组bb中。最后调用函数Wdata（），把结果bb输出到OUT.dat文件中
int greatSort()
{int i,j,count=0;
data va1;
for(i=0;i<200;i++)
if(aa[i].x1>aa[i].x2+aa[i].x3)
{bb[count]=aa[i];
count++;
}
for(i=0;i
{va1=bb[i];
bb[i]=bb[j];
bb[j]=va1;
}
return count;
}
65已知文件IN.dat中存有200个四位数，并已调用函数Rdatd（）把这些数存入数组a中，请编
写函数diffCal（），其功能是：把一个四位数的个位上的值减千位上得值再减百位上得数减十位上得数，如果得出的值大于0且原四位数是偶数，则统计出满足此条件的数的个数count，把所有满足条件的数依次存入到数组b中，然后对数组b中的四位数从小到大排列。最后调用函数WData（），把结果count和数组b中满足条件的四位数输出到OUT.dat文件中
void diffCal（）
{int i,thou,hun,ten,data,j;
for(i=0;i
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if(data-thou-hun-ten>=0 && a[i]%2!=1)
{b[count]=a[i];
count++;
}
}
for(i=0;i
{data=b[i];
b[i]=b[j];
b[j]=data;
}
}
66已知文件IN.dat中存有300个四位数，并已调用函数rdatd（）把这些数存入数组a中，请编写函数NumCal（），其功能是：求出千位上得数加个位上得数等于百位上得数加十位上得数四位数的个数count，再求出所有满足条件的四位数的平均值Ave1，以及不满足条件的四位数的平均值Ave2，最后调用函数Wdata（），把结果输出到OUT.dat文件中
void NumCal（）
{int i,n=0,thou,hun,ten,data;
for(i=0;i<300;i++)
{thou=a[i]/1000;
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if(thou+data==ten+hun)
{
count++;
Ave1+=a[i];
}
else
{n++;
Ave2+=a[i];
}
}
Ave1/=count;
Ave2/=n;
}
68已知文件IN.dat中存有200个四位数，并已调用函数Rdatd（）把这些数存入数组a中，请编写函数NumCal（），其功能是：若一个四位数的千位上的数字值加上个位上的数字值恰好等于百位上的数字值加上十位上的数字值，且原四位数是奇数，则统计出满足此条件的四位数个数count，并把这些四位数按从小到大的顺序存入到数组b中，最后调用写函数Wdata（），把结果count以及数组b中满足条件的四位数输出到OUT.dat文件中
程序中已定义数组a[200],b[200]已定义变量count
void NumCal（）
{int i,thou,hun,ten,data,j;
for(i=0;i
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if((thou+data==hun+ten) && a[i]%2==1)
{b[count]=a[i];
count++;
}
}
for(i=0;i
{data=b[i];
b[i]=b[j];
b[j]=data;
}
}
69已知文件IN.dat中存有300个四位数，并已调用函数Rdatd（）把这些数存入数组a中，请编写函数diffVal（），其功能是：求出个位上得数减千位上得数等于百位上得数减十位上得数大于0的个数count，再求出所有满足条件的四位数的平均值Ave1，以及不满足条件的四位数的平均值Ave2，最后调用函数Wdata（），把结果输出到OUT.dat文件中
void diffVal（）
{int i,n=0,thou,hun,ten,data;
for(i=0;i<300;i++)
{thou=a[i]/1000;
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if(data-thou-hun-ten>0)
{
count++;
Av
e1+=a[i];
}
else
{n++;
Ave2+=a[i];
}
}
Ave1/=count;
Ave2/=n;
}
70补充完整RData（）函数，实现从文件IN.dat中读取1000个十进制整数到数组xx中，编写函数Compute（）分别计算xx中奇数的个数odd,偶数的个数even，奇数的平均值ave1，偶数的平均值ave2，以及所有奇数的方差totfc的值，最后调用函数WriteDat（），把结果输出到文件OUT.dat中。计算方差的公式如下：N奇数的个数，xx[i],ave1偶数的平均值
原始数据的存放格式：每行存放10个数（每个数均大于=且小于等于2000）并用逗号隔开
void Compute(void)
{int i,yy[MAX];
for(i=0;i<1000;i++)
if(xx[i]%2)
{odd++;
ave1+=xx[i];
yy[odd-1]=xx[i];
}
else
{even++;
ave2+=xx[i];
}
ave1/=odd;
ave2/=even;
for(i=0;i
}
71补充完整程序，是实现以下功能：从文件IN.dat中读取200个整数至数组number中，求出最大数max及最大数的个数cnt和数组number中能被3或7整除的算术平均值ave（保留2位小数）把结果max，cnt，ave输出到OUT.dat文件中
max=number[0];
for(i=1,k=0;i
max=number[i];
if(number[i]%3==0||number[i]%7==0)
{j+=number[i];
k++;
}
}
for(i=0,cnt=0;i
cnt++;
ave=(float)(j*100/k)/100;
73补充完整RData（）函数，实现从文件IN.dat中读取1000个十进制整数到数组xx中，编写函数Compute（）分别计算xx中奇数的个数odd,偶数的个数even，以及所有数的平均值ave和方差totfc的值，最后调用函数WriteDat（），把结果输出到文件OUT.dat中。计算方差的公式如下：
原始数据的存放格式：每行存放10个数（每个数均大于=且小于等于2000）并用逗号隔开
void Compute(void)
{int i;
for(i=0;i<1000;i++)
{if(xx[i]%2)
odd++;
else
even++;
aver=aver+xx[i];
}
aver/=MAX;
for(i=0;i<1000;i++)
totfc+=(xx[i]-aver)*(xx[i]-aver)/MAX;
}
75在IN.dat文件中有200个四位数，并已调用函数Rdata（）把这些数存入数组a中，请编写函数cgVal（），其功能是：依次从数组a中取出一个四位数，如果该四位数连续大于该四位数以后的5个数且是奇数，则统计出满足此条件的个数count并把这些四位数按从小到大的顺序存入到数组b中，最后调用函数WData（），把结果count以及数组b中符合条件的四位数输出到文件OUT.dat中。
void cgVal（）
{int i,j,flag=0;
int k;
for(i=0;i
if(a[i]>a[j])
{flag=1;
}
else
{flag=0;
break;
}
if(flag==1 && a[i]%2)
{b[count]=a[i];
count++;
}
}
for(i=0;i
{k=b[i];
b[i]=b[j];
b[j]=k;
}
}
84在IN.dat文件中有200个正整数，且每个数均在1000-9999之间。在函数RData（）中读取着200个数字存放到数组original中。请编写函数DescSort（），其功能是：要求按每个数后
3位的大小进行降序排列，然后取出满足条件的前10个数依次存入数组result中，如果后三位的数值相等，则按原先的数值降序排列。最后调用函数Wdata（），把结果result输出到文件OUT.dat中。
void DescSort()
{int i,j,data;
for(i=0;i<199;i++)
for(j=i+1;j<200;j++)
{if (original[i]%1000
original[i]=original[j];
original[j]=data;
}
else if (original[i]%1000==original[j]%1000)
{if(original[i]>original[j])
{data=original[i];
original[i]=original[j];
original[j]=data;
}
}
}
for(i=0;i<10;i++)
result[i]=original[i];
}
87补充程序，实现以下功能：从文件IN.dat中读取200个整数至数组number中，求出奇数的个数cnt1和偶数的个数cnt2以及数组number下标为奇数的元素值的算术平均值ave（保留2位小数）把结果cnt1，cnt2，ave输出到OUT.dat文件中
i=j=k=cnt1=cnt2=0;
ave=0.0;
for(i=0;i
cnt1++;
else
cnt2++;
if (i%2)
{
k+=number[i];
j++;
}
}
ave=(float)k/j;
89已知文件IN.dat中存有200个四位数，并已调用函数rdatd（）把这些数存入数组a中，请编写函数CalVal（），其功能是：若一个四位数的千位上的数字值大于等于百位上的数字值，百位上的数字值大于等于十位上的数字值，以及十位上的数字值大于等于个位上的数字值，且该四位数是奇数，则统计出满足此条件的个数count，并把这些四位数按从小到大的顺序存入到数组b中，最后调用写函数WData（），把结果count以及数组b中满足条件的四位数输出到OUT.dat文件中
void CalVal（）
{int i,thou,hun,ten,data,j;
for(i=0;i
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if((thou>=hun) && (hun>=ten) && (ten>=data) && a[i]%2!=0)
{b[count]=a[i];
count++;
}
}
for(i=0;i
{data=b[i];
b[i]=b[j];
b[j]=data;
}
}
93在IN.dat文件中有200个四位数，并已调用函数RData（）把这些数存入数组a中，请编写函数oddVal（），其功能是：依次从数组a中取出一个四位数，如果该四位数连续大于该四位数以后的5个数且是奇数，并且该数能7整除（该四位数前不满五个数，则不统计），则统计出满足此条件的个数count并把这些四位数按从大到小的顺序存入到数组b中，最后调用函数WData（），把结果count以及数组b中符合条件的四位数输出到文件OUT.dat中。
void cgVal（）
{int i,j,flag=0;
for(i=5;i
{flag=1;
}
else
{flag=0;
break;
}
}
if(flag==1 && a[i]%2==1 && a[i]%7==0)
{b[count]=a[i];
count++;
}
}
for(i=0;i
b[i]=b[j];
b[j]=flag;
}
}
94已知文件IN.dat中存有300个四位数，并已调用函数rdatd（）把这些数存入数组a中，请编写
函数NumCal（），其功能是：求出千位上得数加百位上得数加十位上得数加个位上得数的个数count，再求出所有满足条件的四位数的平均值Ave1，以及不满足条件的四位数的平均值Ave2，最后调用函数Wdata（），把结果输出到OUT.dat文件中
void diffVal（）
{int i,thou,hun,ten,data,n=0;
for(i=0;i<300;i++)
{thou=a[i]/1000;
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if(thou+hun==ten+data)
{
count++;
Ave1+=a[i];
}
else
{n++;
Ave2+=a[i];
}
}
Ave1/=count;
Ave2/=n;
}
96已知文件IN.dat中存有300个四位数，并已调用函数Rdatd（）把这些数存入数组a中，请编写函数NumCal（），其功能是：求出千位上得数加百位上得数加十位上得数加个位上得数的个数count，再把所有满足条件的四位数依次存入到数组b中，然后对数组b中的四位数从大到小排列。最后调用函数WData（），把结果输出到OUT.dat文件中
void addNum（）
{int i,thou,hun,ten,data,j;
for(i=0;i<300;i++)
{thou=a[i]/1000;
hun=a[i]%1000/100;
ten=a[i]%100/10;
data=a[i]%10;
if(thou+hun==data+ten)
{b[count]=a[i];
count++;
}
}
for(i=0;i
b[i]=b[j];
b[j]=data;
}
}