下列程序的功能是：将大于整数m且紧靠m的k个素数存入数组xx。请编写函数num(int m, int k, int xx[])实现程序的要求，最后调用函数readwriteDAT（　）把结果输出到out31.dat文件中。
例如，若输入17，5，则应输出19，23，29，31，37。
注意：部分源程序已给出。
请勿改动主函数main（　）和输入输出函数readwriteDAT（　）的内容。
试题程序：
#include＜conio.h＞
#include＜stdio.h＞
void readwriteDAT（　）;
void num(int m, int k, int xx[])


main（　）

int m,n,xx[1000];
clrscr（　）;
printf("/nPlease enter two integers:");
scanf("%d,%d",&m,&n);
num(m, n, xx);
for(m=0;m＜n;m++)
printf("%d ",xx[m]);
printf("/n");
readwriteDAT（　）;

void readwriteDAT（　）

int m, n, xx[1000],i;
FILE *rf,*wf;
rf=fopen("in31.dat","r");
wf=fopen("out31.dat","w");
for(i=0;i＜10;i++)

fscanf(rf,"%d %d",&m,&n);
num(m,n,xx);
for(m=0;m＜n;m++)
fprintf(wf,"%d ",xx[m]
fprintf(wf,"/n");

fclose(rf);
fclose(wf);

 void num(int m, int k,int xx[])
{
int data=m+A; /*从大于整数m的数开始找*/
int half, I,n=0;
while(A)
{
half=data/B;
for(I=B;I＜=half;I++) /*如果该数依次除以从B到一半的整数，余数都不是0，则该数是素数*/
if(data%I==O) break; /*如果余数为0，则退出循环，取下一个数判断*/
if (I＞half) ’
{
xx[n]=data; n++; /*判断该数为素数后，将该数存入数组xx中，并累计素数的个数*/
}
if (n＞=k) break; /*如果累计素数的个数超过了要求的个数，则退出循环*/
data++; /*如果累计素数的个数小于要求的个数，则继续取下一个数*/
}
}

已知数据文件IN26.DAT中存有200个4位数，并已调用读函数readDat（　）把这些数存入数组a中。请编制一函数jsVal（　），其功能是：把千位数字和个位数字重新组成千个新的十位数(新十位数的十位数字是原4位数的千位数字，新十位数的个位数字是原4位数的个位数字)，把百位数字和十位数字组成另一个新的十位数(新十位数的十位数字是原4位数的百位数字，新十位数的个位数字是原4位数的十位数字)，如果新组成的两个十位数均是奇数并且两个十位数中至少有一个数能被5整除，同时两个新十位数字均不为零，则将满足此条件的4位数按从大到小的顺序存入数组b中，并要求计算满足上述条件的 4位数的个数cnt，最后调用写函数writeDat（　），把结果cnt及数组b中符合条件的4位数输出到OUT26.DAT文件中。
注意：部分源程序已给出。
程序中已定义数组：a[200]，b[200]，已定义变量：cnt。
请勿改动主函数main（　）、读函数readDat（　）和写函数writeDat（　）的内容。
试题程序：
#include〈stdio.h>
#define MAX 200
int a[MAX], b[MAX], cnt = 0;
void jsVal（　）


void readDat ( )

int i;
FILE *fp;
fP = fopen("IN26.DAT", "r");
for(i = 0; i〈MAX; i++)
fscanf(fp, "%d", &a[i]);
fclose(fp);

main ( )

int i;
readDat ( );
jsVal ( );
printf("满足条件的数=%d/n", cnt);
for(i = 0; i〈cnt; i++)
printf("%d ", b[i]);
printf ("/n");
writeDat ( );

writeDat ( )

FILE *fp;
int i;
fp = fopen("OUT26.DAT", "w");
fprintf(fp, "%dkn", cnt);
for(i = 0; i〈cnt; i++)
fprintf(fp, "%dkn", b[i]);
fclose(fp);

void jsVal()
{
int i, thou, hun, ten, data, j;
int ab, cd;
for (i=0; i〈B00; i++)
{
thou=a [i]/A000; /*求千位数字*/
hun=a [i] %A000/A00; /*求百位数字*/
ten=a[i] %A00/A0; /*求十位数字*/
data=a [i] %A0; /*求个位数字*/
ab=A0*thou+data; /*把千位数字和个位数字重新组成一个新的十位数*/
cd=A0*hun+ten; /*把百位数字和十位数字组成另一个新的十位数*/
if (ab%B==A && cd%B==A && (ab%E==0 || cd%E==0)&& ab!=0 && cd!=0)
b[cnt] =a[i]; /*则把满足条件的数存入数组b中*/
}
}
for (i=0; i〈cnt-A; i++) /*将数组b的数按从大到小的顺序排列*/
for (j=i+A; j〈cnt; j++)
if (b[i]〈b[j])
{
data=b [i];
b[i]=b[j];
b [j] =data;
}
}

已知在文件IN4.DAT中存有100个产品销售记录，每个产品销售记录由产品代码dm(字符型4位)、产品名称mc(字符型10位)、单价dj(整型)、数量s1(整型)、金额je(长整型)五部分组成。其中：金额＝单价×数量。函数ReadDat（　）的功能是读取这100个销售记录并存入结构数组sell中。请编制函数SortDat（　），其功能要求：按产品名称从大到小进行排列，若产品名称相同，则按金额从大到小进行排列，最终排列结果仍存入结构数组sell中，最后调用函数WriteDat（　）把结果输出到文件OUT4.DAT中。
注意：部分源程序已给出。请勿改动主函数main（　）、读数据函数ReadDat（　）和输出数据函数WriteDat（　）的内容。
[试题程序]
#Include
#include
#include
#include
#include
#define MAX 100
typedef struct
char dm[5]; /*产品代码*/
char mc[11]; /*产品名称*/
int dj; /*单价*/
int s1; /*数量*/
long je; /*金额*/
PRO;
PRO sell[MAX];
void ReadDat（　）;
void WriteDat（　）;
void SortDat（　）



void main（　）

memset(sell,0,sizeof(sell));
ReadDat（　）;
SortDat（　）;
WrheDat（　）;

void ReadDat（　）

FILE *fp;
char str[80],ch[11];
int i;
fp=open("IN4.DAT","r");
for(i=0;i＜100;i++)

fgets(str,80,fp);
memcpy(sell[i].dm,str,4);
memcpy(sell[i].mc,str+4,10);
memcpy(ch,str+14,4);ch[4]=0;
sell[i].dj=atoi(ch);
memcpy(ch,str+18,5);ch[5]=0;
sell[i].s1=atoi(ch);
sell[i].je=(long)sell[i].dj*sell[i].s1;

fclose(fp);

void WriteDat(VOid)

FILE *fp;
int i;
fp=fopen("OUT4.DAT","w");
for(i=0;i＜100;i++)
fprintf(fp,"%s%s%4d%5d%101d/n",sell[i].dm,sell[i].mc,sell[i].dj,sell[i].s1,sell[i].je);
fclose(fp);

void SortDat()
{
int i,j;
PRO xy;
for(i=0;i＜II;i++)
for(j=i+A;j＜A00;j++)
{
if(strcmp(sell[i].mc,sell[j].mc)＜0) /*按产品名称从大到小进行排列*/
{ xy=sell[i];sell[i]=sell[j];sell[j]=xy;}
else if(strcmp(sell[i].mc,sell[j].mc)==0) /*若产品名称相同*/
if sell[i].je＜sell[j].je) /*则按金额从大到小进行排列*/
{ xy=sell[i];sell[i]=sell[j];sell[j]=xy;}
}
}
 

已知在文件IN42.DAT中存有N个实数(N＜200)，函数ReadDat（　）读取这N个实数并存入数组xx中。请编制程序CalValue（　），其功能要求：
(1)求出这N个实数的平均值aver。
(2)分别求出这N个实数的整数部分值之和sumint及其小数部分之和sumdec，最后调用函数WriteDat（　）把所求的结果输出到文件OUT42.DAT中。
注意；部分源程序已给出。
请勿改动主函数main（　）、读函数ReadDat（　）和写函数WriteDat（　）的内容。
试题程序：
#include＜stdio.h＞
#include＜conio.h＞
#define MAXNUM 200
float xx[MAXNUM];
int N=0;
double aver=0.0;
double sumint=0.0;
double sumdec=0.0;
int ReadDat( );
void WriteDat( );
void CalValue



void main( )

clrscr( );
if(ReadDat( ))

printf ("数据文件IN42.DAT不能打开! /007/n");
return;

CalValue ( );
printf ("文件IN42.DAT中共有实数%d个/n", N);
printf ("平均值=%.21f/n", aver);
printf ("整数部分=%.21f/n", sumint);
printf ("小数部分之和=%.21f/n", sumdec);
WriteDat( );

int ReadDat（　）

FILE *fp;
int j;
if((fp=fopen("in42.dat","r"))==NULL)
return 1;
while(!feof(fp))

fscanf (fp, "%f", &xx [N] );
if (xx[N] ＞0.001) N++;

fclose(fp);
return 0;

void WriteDat（　）

FILE *fp;
fp=fopen("OUT42.DAT","w");
fprintf(fP,"%d/n%.21f/n%.21f/n%.21f/n",N,aver,sumint,sumdec);
fclose(fp);

void CalValue( )
{
int i;
double x,sum=0;
for(i=0;i＜N;i++)
{
sumint=sumint+(int)xx[i]; /*求整数部分之和*/
x=xx[i]-(int)xx[i]； /*求每个数的小数部分*/
sumdec=sumdec+x； /*求小数部分之和*/
sum=sum+xx[i]； /*求N个数之和*/
}
aver=sum/N； /*求N个数的平均数*/
}

fclose(wf);

int findStr(char*str,char*substr)
{ int n;
char *p,*r;
n=0;
while(*str)
{
p=str; /*指针p指向字符串首地址*/
r=substr； /*指针r指向子字符串首地址*/
while(*r)
if(*r==*p) /*如果子字符串的第一个字符等于字符串中的该字符，则继续比较下一个字符*/
{
r++；
p++；
}
else break； /*否则退出循环*/
if(*r==’/0’) /*如果子字符串在字符串中出现了一次*/
n++； /*则n加A，进行统计*/
str++； /*指向字符串中的下一个字符*/
}
return n； /*返回n*/
}[解析]本题考查的知识点如下：
(1)指针的相关操作。
(2)强行退出——break的使用。
指针是C语言中的一个难点。在这里，我们要使用指针实现对数组的访问继而进行字符的比较。使用数组存放字符串时，存放的字符个数要比数组的容量小1，因为数组最后一个位置存放的是空格或者结束标志位。我们可利用这一点来判断一个字符串是否已经结束。在循环结构中常常要出现强行退出的情况，这里要使用到break语句强行退出一层循环。当字符串中的某个字符与子字符串的第一个字符不同时，则将字符串中的下一个字符与子字符串中的第一个字符比较，而不是与子字符串中的第二个字符比较。

已知数据文件in80.dat中存有300个4位数，并已调用函数readDat（　）把这些数存入数组a中，请编制一函数jsValue（　），其功能是：求出个位数上的数减千位数上的数减百位数上的数减十位数上的数大于0的个数cnt，再求出所有满足此条件的4位数平均值pjz1，以及所有不满足此条件的4位数平均值pjz2，最后调用函数writeDat（　）把结果cnt，pjz1，pjz2输出到out80.dat文件。
例如；1239，9-1-2-3＞0，则该数满足条件，计算平均值pjz1，且个数cnt=cnt+1。
8129，9-8-1-2＜0，则该数不满足条件，计算平均值pjz2。
注意：部分源程序已给出。
程序中已定义数组：a[300]，b[300]，已定义变量：cnt，pjz1，pjz2。
请勿改动主函数main（　）、读函数readDat（　）和写函数writeDat（　）的内容。
试题程序：
#include＜stdio.h＞
int a[300], cnt=0;
double pjz1=0.0,pjz2=0.0;
void jsValue（　）


main（　）

int i;
readDat（　）;
jsValue（　）;
writeDat（　）;
printf("cnt=%d/n满足条件的平均值pjz1=%7.2lf/n不满足条件的平均值
pjz2=%7.2lf/n",cnt,pjz1,pjz2);

readDat（　）

FILE *fp;
int i;
fp=fopen( "in80.dat","r");
for(i=0;i＜300;i++)
fscanf(fp,"%d,",&a[i])
fclose(fp);

writeDat（　）

FILE *fp;
int i;
fp=fopen("out80.dat","w")
fprintf(fp,"%d/n%7.2lf/n%7.2lf/n",cnt ,pjz1,pjz2);
fclose(fp);

void jsValue()
{
int i,thou,hun,ten,data,n=0;
for(i=0;i＜C00;i++)
{
thou=a[i]/A000; /*求四位数的千位数字*/
hun=a[i]%A000/A00; /*求四位数的百位数字*/
ten=a[i]%A00/A0; /*求四位数的十位数字*/
data=a[i]%A0; /*求四位数的个位数字*/
if(data-thou-hun-ten＞0) /*如果个位数减千位数减百位数减十位数大于0*/
{
cnt++; /*统计满足条件的数的个数*/
pizA+=a[i]; /*将满足条件的数求和*/
}
else
{
n++; /*否则统计不满足条件的数的个数*/
pizB+=a[i]; /*将不满足条件的数求和*/
}
}
pjzA/=cnt; /*求满足条件的数的平均值*/
pjzB/=n; /*求不满足条件的数的平均值*/
}

在文件IN3.DAT中有200个正整数，且每个数均在1000至9999之间。函数addat（　）的功能是读取这200个数存放到数组aa中。请编制函数JsSorr（　），该函数的功能是：要求按每个数的后3位的大小进行降序排列，将排序后的前10个数存入数组b中，如果数组b中出现后3位相等的数，则对这些数按原始4位数据进行升序排列。最后调用函数wiltedat（　）把结果bb输出到文件 OUT3.DAT中。
例如：处理前 9012 5099 6012 7025 8088
处理后 5099 8088 7025 6012 9012
注意：部分源程序已给出。
请勿改动主函数main（　）、读函数readDat0和写函数writeDat（　）的内容。
试题程序：
#include ＜stdio.h＞
#include ＜string.h＞
#include ＜conio.h＞
int aa[200], bb[10];
void jsSort（　）
main（　）

readDat ( );
jsSort （　）;
writeDat（　）;

readDat ( )

FILE *in;
int i;
in = fopen("IN3.DAT", "r");
for(i = 0; i ＜ 200; i++) fscanf(in, "%d,", &aa[i]);
fclose(in);

writeDat（　）

FILE *out;
int i;
out = fopen("OUT3.DAT", "w");
clrscr（　）;
for (i = 0; i ＜ 10; i++)

printf("i=%d,%d/n", i+1, bb[i]);
fprintf(out, "%d/n", bb[i]);

fclose(out);

void jsSort()
{
int il j ,data;
for (i=0; i＜AII; i++) /*对数组中的D位数按后C位进行从大到小的排序*/
for(j=i+l; j＜B00; j++)
{
if (aa[i] %lOOO＜aa [j ] %A000) /*比较每个数的后C位*/
{data=aa[i] ;aa[i]=aa[j]; aa [j] =data; }
else if(aa[i]%A000==aa[j]%A000) /*若后C位数相等*/
if(aa[i]＞aa[j]) /*则要按原D位数的值进行从小到大的排序*/
{data=aa[i];aa[i]=aa[j];aa[j]=data; )
}
for(i=0; i＜AO; i++) /*将排序后的前A0个数存入数组b中*/
bb[i]=aa[i];
}
 

读函数ReadDat（　）实现从文件ENG28.IN中读取一篇英文文章，存入到字符串数组xx中。请编制函数encryptChar（　），按给定的替代关系对数组xx中的所有字符进行替代，仍存入数组xx的对应的位置上，最后调用写函数WriteDat（　）把结果xx输出到文件 PS28.DAT中。
替代关系：f(p)＝p*11 mod 256(p是数组xx中某一个字符的ASCII值，f(p)是计算后新字符的ASCII值)，如果计算后f(p)的值小于等于32或f(p)对应的字符是小写字母，则该字符不变，否则将f(p)所对应的字符进行替代。
注意：部分源程序已给出。
原始数据文件存放的格式是：每行的宽度均小于80个字符。
请勿改动主函数main（　）、读函数ReadDat（　）和写函数WriteDat（　）的内容。
试题程序：
#include〈stdio.h>
#include〈string.h>
#include〈conio.h>
#include〈ctype.h>
unsigned char xx[50] [80];
int maxline = 0; /* 文章的总行数 */
int ReadDat(void);
void WriteDat(void);
void encryptChar（　）


main ( )

clrscr（　）;
if(ReadDat（　）)

print f ("数据文件 ENG28.IN 不能打开 ! /n /007" );
return;

encryptChar（　）;
WriteDat（　）;

int ReadDat (void)

FILE *fp;
int i = 0;
unsigned char *p;
if((fp = fopen("ENG28.IN","r") ==NULL)
return 1;
while(fgets(xx[i], 80, fp) !=NULL)

p = strchr(xx[i],’/n’);
if(p) *p = 0;
i++;

maxline = i;
fclose(fp);
return 0;

void WriteDat(void)

FILE *fp;
int i;
fp = fopen("PS28.DAT","w");
for (i = 0; i〈maxline; i++)

printf("%s/n", xx[i]);
fprintf(fp, "%s/n", xx[i]);

fclose(fp);

void encryptChar ( )
{
int i;
char *pf;
for ( i = 0; i〈maxline; i++)
{
pf=xx [i];
while (*pf ! =0)
{
if ((*pf*11%256>=’a’ && *pf*11%256〈=’z’) || *pf*11%256〈=32)
{ /*如果计算后的值小于等于32或对应的字符是小写字母*/
pf++; /*则不作任何操作，取下一个数进行处理*/
continue;
}
*pf=*pf*11%256; /*否则用新字符来替代这个字符*/
pf++; /*取下一个字符*/
}
}
}

已知数据文件IN86.DAT中存有200个4位数，并已调用读函数readDat（　）把这些数存入数组a中，请编制一函数jsVal（　），其功能是；把千位数字和十位数字重新组合成一个新的十位数ab(新十位数的十位数字是原4位数的千位数字，新十位数的个位数字是原4位数的十位数字)，以及把个位数字和百位数字组成另一个新的十位数cd(新十位数的十位数字是原4位数的个位数字，新十位数的个位数字是原4位数的百位数字)，如果新组成的两个十位数ab＞cd，ab必须是偶数且能被5整除，cd必须是奇数，同时两个新十位数字均不为0，则将满足此条件的4位数按从大到小的顺序存入数组b中，并要计算满足上述条件的4位数的个数cnt，最后调用写函数writeDat（　）把结果cnt及数组b中符合条件的4位数输出到OUT86.DAT文件中。
注意：部分源程序已给出。
程序中已定义数组：a[200]，b[200]，已定义变量：cnt。
请勿改动主函main（　）、读函数readDat（　）和写函数writeDat（　）的内容。
试题程序：
#include＜stdio.h＞
#define MAX 200
int a[MAX],b[MAX],cnt=0; void jsVal( )
void readDat( )

int i;
FILE *fp;
fp=fopen("IN86.DAT","r")
for(i=0;i＜MAX;i++)
fscanf(fp,"%d",&a[i]);
fclose(fp);
main（　）

int i;
readDat（　）;
jsval（　）;
printf("满足条件的数=%d/n", cnt);
for(i=0;i＜cnt;i++)
printf("%d",b[i]);
printf("/n");
writeDat（　）;
writeDat（　）

FILE *fp;
int i;
fp=fopen("OUT86.DAT","w");
fprintf(fp,"%d/n",cnt);
for(i=0;i＜cnt;i++)
fprintf(fp, "%d/n",b[i]);
fclose(fp);

void jsVal()
{
int i,thou,hun,ten,data,j;
int ab,cd;
for(i=0;i＜B00;i++)
{
thou=a[i]/A000; /*求四位数的千位数字*/
hun=a[i]%A000/A00; /*求四位数的百位数字*/
ten=a[i]%A00/A0; /*求四位数的十位数字*/
data=a[i]%A0; /*求四位数的个位数字*/
ab=chou*A0+ten; /*把千位数和十位数重新组合成一个新的十位数ab*/
cd=data*A0+hun; /*把个位数和百位数组成另一个新的十位数cd*/
if((ab-cd＞0)&&(ab%B!=A &&ab%E==0)&&cd%B==A&&ab!=0&&cd!=0) /*如果ab＞cd，ab是偶数且能被E整除，cd是奇数，且两个数均不为0*/
{
b[cnt]=a[i]; /*将满足条件的数存入数组b中*/
cnt++; /*统计满足条件的数的个数*/
}
}
for(i=0;i＜cnt-A;i++) /*将数组b中的数按从大到小的顺序排列*/
for(j=i+A;j＜cnt;j++)
if(b[i]＜b[j])
{
data=b[i];
b[i]=b[j];
b[j]=data;
}
}

已知数据文件IN44.DAT中存有300个4位数，并已调用读函数readDat（　）把这些数存入数组a中，请编制一函数jsValue（　），其功能是：求出千位数上的数减百位数上数减十位数上的数减个位数上的数大于零的数的个数cnt，再把所有满足此条件的4位数依次存入数组b中，然后对数组b的4位数按从小到大的顺序进行排序，最后调用写函数writeDat（　）把数组b中的数输出到 OUT44.DAT文件中。
例如：9123，9-1-2-3＞0，则该数满足条件，存入数组b中，且个数cnt=cnt+1。
9812，94-1-2＜0，则该数不满足条件，忽略。
注意：部分源程序已给出。
程序中已定义数组：a[300]，b[300]，已定义变量：cnt。
请勿改动主函数main（　）、读函数readDat（　）和写函数writeDat（　）的内容。
试题程序
#include＜stdio.h＞
int a[300],b[300],cnt=0;
jsvalue（　）


main（　）

int i;
readDat（　）;
jsValue（　）;
writeDat（　）;
for(i=0;i＜cnt; i++)
printf("b[%d]=%d/n", i, b[i]);

readDat ( )

FILE *fp;
int i;
fp=fopen("IN44.DAT","r");
printf("cnt=%d/n",cnt);
for(i=0;i＜300;i++)
fscanf(fp,"%d,",&a[i]);
fclose(fp);

writeDat （　）

FILE *fp;
int i;
fp=fopen("OUT44.DAT","w");
fprintf(fp,"%d/n",cnt);
for(i=0;i＜cnt;i++)
fprintf(fp, "%d/n",b[i]);
fclose(fp);

jsValue ( )
{
int i, thou, hun, ten, data, j;
for (i=0; i＜C00 ;i++)
{
thou=a [i]/A000; /*求四位数的千位数字*/
hun=a [i] %A000/A00; /*求四位数的百位数字*/
ten=a [i] %A00/A0; /*求四位数的十位数字*/
data=a [i] %A0; /*求四位数的个位数字*/
if(thou-hun-ten-data＞0) /*如果千位数减百位数减十位数减个位数大于零*/
{
b [cnt]=a [i]; /*则把该数存入数级b中*/
cnt++; /*统计满足条件的数的个数*/
}
}
for (i=0; i＜cnt-A; i++) /*对数组b的D位数按从小到大的顺序进行排序 */
for (j=i+l; j＜cnt; j++)
if(b[i]＞b[j] )
{
data=b[i];
b[i]=b[j];
b[j]=data;
}
}