全国三级考试81-100

最新推荐文章于 2021-07-20 15:56:01 发布

海峰_云计算

最新推荐文章于 2021-07-20 15:56:01 发布

阅读量1k

点赞数 1

分类专栏：电脑

本文链接：https://blog.csdn.net/yanheven1/article/details/16824707

版权

电脑专栏收录该内容

47 篇文章 0 订阅

订阅专栏

081题已知在文件IN.DAT中存有100个产品销售记录，每个产品销售记录由产品代码dm(字符型4位)，产品名称mc(字符型10位)，单价dj(整型)，数量sl(整型)，金额je(长整型)四部分组成。其中：金额=单价*数量计算得出。函数ReadDat()是读取这100个销售记录并存入结构数组sell中。请编制函数SortDat()，其功能要求：按金额从小到大进行排列，若金额相等，则按产品代码从小到大进行排列，最终排列结果仍存入结构数组sell中，最后调用函数WriteDat()把结果输出到文件OUT1.DAT中。
部分源程序已给出。
　　请勿改动主函数main()、读数据函数ReadDat()和输出数据函数WriteDat()的内容。
#include<stdio.h>
#include<mem.h>
#include<string.h>
#include<conio.h>
#include<stdlib.h>
#define MAX 100
typedef struct{
char dm[5]; /*产品代码*/
char mc[11]; /*产品名称*/
int dj; /*单价*/
int sl; /*数量*/
long je; /*金额*/
}PRO;
PRO sell[MAX];
void ReadDat();
void WriteDat();
void SortDat()
{
int i,j;
PRO t;
for(i=0;i<MAX;i++)
for(j=i+1;j<MAX;j++)
if(sell[i].je>sell[j].je)
{
t=sell[i];
sell[i]=sell[j];
sell[j]=t;
}
else if(sell[i].je==sell[j].je)
        if(strcmp(sell[i].dm,sell[j].dm)>0)
       {
            t=sell[i];
                      sell[i]=sell[j];
                                     sell[j]=t;
                         }
　
}
void main()
{
memset(sell,0,sizeof(sell));
ReadDat();
SortDat();
WriteDat();
}
void ReadDat()
{
FILE *fp;
char str[80],ch[11];
int i;
fp=fopen(\ IN.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].sl=atoi(ch);
sell[i].je=(long)sell[i].dj*sell[i].sl;
}
fclose(fp);
}
void WriteDat()
{
FILE *fp;
int i;
fp=fopen(\ OUT1.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].sl,sell[i].je);
}
fclose(fp);
}
　
　
　
082题在文件in.dat存放了10位选手参赛，6位评委给选手打分的数据。计算各位选手的得分规则是去掉一个最高分和一个最低分，最后得分是剩下分数的算术平均值。
在下列程序中，函数readDat()是从文件df.dat中读取10位选手的评委打分数据并存入数组mark[10][6]中，要求编写函数jsValue()计算出每位选手的得分并依次存入数组score[10]中，最后调用函数writeDat()把数组score中的值输出到文件out.dat中。
说明：第1位选手的得分存入score[0]中，第2位选手的得分存入score[1]中，依此类推。
部分源程序已给出。
请勿改动主函数main()、读函数readDat()和写函数writeDat()的内容。 #include <stdio.h>
float mark[10][6]; /*存放10位选手，6位评委的打分数据*/
float score[10]; /*存放10位选手的得分*/
jsValue()
{
}
main()
{
int i;
readDat();
jsValue();
for(i=0;i<10;i++)printf(\ 第%d位选手得分=%7.3f\\n\ ,i+1,score[i]);
writeDat()
}
readDat()
{
FILE *fp;
int i,j;
fp=fopen(\ in.dat\ ,\ r\ );
for(i=0;i<10;i++)
for(j=0;j<6;j++)fscanf(fp,\ %f\ ,&mark[i][j]);
fclose(fp);
}

writeDat()
{
FILE *fp;
int i;

fp=fopen(\ out.dat\ ,\ w\ );
for(i=0;i<10;i++)fprintf(fp,\ %7.3f\\n\ ,score[i]);
fclose(fp);
}
_________________________________
本人只是为了上机能通过，不追求什么算法速度,答案仅供大家参考.
jsValue()
{
int i,j;
float max,min,sum;
for(i=0;i<10;i++)
{
max=mark[10][0];
min=mark[10][0];
sum=mark[10][0];
for(j=1;j<6;j++)
{
if(mark[i][j]>max) max=mark[i][j];
if(mark[i][j]<min) min=mark[i][j];
sum+=mark[i][j];
}
score[i]=(sum-max-min)/4;
}
}
　
　
083题已知在文件IN.DAT中存有100个产品销售记录，每个产品销售记录由产品代码dm(字符型4位)，产品名称mc(字符型10位)，单价dj(整型)，数量sl(整型)，金额je(长整型)四部分组成。其中：金额=单价*数量计算得出。函数ReadDat()是读取这100个销售记录并存入结构数组sell中。请编制函数SortDat()，其功能要求：按金额从大到小进行排列，若金额相等，则按产品代码从小到大进行排列，最终排列结果仍存入结构数组sell中，最后调用函数WriteDat()把结果输出到文件OUT3.DAT中。
部分源程序已给出。
　　请勿改动主函数main()、读数据函数ReadDat()和输出数据函数WriteDat()的内容。
#include<stdio.h>
#include<mem.h>
#include<string.h>
#include<conio.h>
#include<stdlib.h>
#define MAX 100
typedef struct{
char dm[5]; /*产品代码*/
char mc[11]; /*产品名称*/
int dj; /*单价*/
int sl; /*数量*/
long je; /*金额*/
}PRO;
PRO sell[MAX];
void ReadDat();
void WriteDat();
void SortDat()
{
int i,j;
PRO t;
for(i=0;i<MAX;i++)
for(j=i+1;j<MAX;j++)
if(sell[i].je<sell[j].je)
{
t=sell[i];
sell[i]=sell[j];
sell[j]=t;
}
else if(sell[i].je==sell[j].je)
        if(strcmp(sell[i].dm,sell[j].dm)>0)
       {
            t=sell[i];
                      sell[i]=sell[j];
                                     sell[j]=t;
                         }
　
}
void main()
{
memset(sell,0,sizeof(sell));
ReadDat();
SortDat();
WriteDat();
}
void ReadDat()
{
FILE *fp;
char str[80],ch[11];
int i;
fp=fopen(\ IN.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].sl=atoi(ch);
sell[i].je=(long)sell[i].dj*sell[i].sl;
}
fclose(fp);
}
void WriteDat()
{
FILE *fp;
int i;
fp=fopen(\ OUT3.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].sl,sell[i].je);
}
fclose(fp);
}
　
　
　
084题函数loop(s,m,n,str)对长为n的字符串str，从第s个字符开始的间隔为m的部分字符进行循环左移，即str[s]←str[s+m]←...←str[s+km]←...←str[s](k为正整数)且当字符位置s+k*m大于等于n时，要求用s+k*m-n作新的字符位置。要求编写此函数实现其功能，最后调用函数WriteDat()把结果输出到文件out.dat中。
例：loop(1,2,8,str)
位置      0 1 2 3 4 5 6 7
调用前str=A B C D E F G H
调用后str=A D C F E H G B
部分源程序已给出。
　　请勿改动主函数main()和写函数WriteDat()的内容。
#include <stdio.h>
#include <string.h>
loop(int s,int m,int n,char str[])
{
}
main()
{
char buf[81];
strcpy(buf,\ ABCDEFGH\ );
printf(\ 调用前=%s,\ ,buf);
loop(1,2,8,buf);
printf(\ 调用后=%s\\n\ ,buf);
writeDat();
}
writeDat()
{
FILE *in,*out;
char buf[81];
int i,s,m,n;
in=fopen(\ in.dat\ ,\ r\ );
out=fopen(\ out.dat\ ,\ w\ );
for(i=0;i<5;i++){
fscanf(in,\ %d,%d,%d,%s\ ,&s,&m,&n,buf);
loop(s,m,n,buf);
fprintf(out,\ %s\\n\ ,buf);
}
fclose(in);
fclose(out);
}
________________________________________
Viod Loop(int s,int m,int n,char str[])
{ int cuur,last,i=0;
char ch;
last=s;
ch=str[s];
while(++i)
{ cuur=last;
last=(s+i*m)%n;
if(last>=s&&s+i*m>n) break;
str[cuur]=str[last];
}
str[cuur]=ch;
}
/*解法2：*/
loop(int s,int m,int n,char str[])
{
int kk=s;
char ch=str[s];
while((kk+m)%n!=s)
{
str[kk]=str[(kk+m)%n];
kk=(kk+m)%n;
}
str[kk]=ch;
}
　
　
　
085题已知在文件IN.DAT中存有100个产品销售记录，每个产品销售记录由产品代码dm(字符型4位)，产品名称mc(字符型10位)，单价dj(整型)，数量sl(整型)，金额je(长整型)四部分组成。其中：金额=单价*数量计算得出。函数ReadDat()是读取这100个销售记录并存入结构数组sell中。请编制函数SortDat()，其功能要求：按产品名称从小到大进行排列，若产品名称相等，则按金额从小到大进行排列，最终排列结果仍存入结构数组sell中，最后调用函数WriteDat()把结果输出到文件OUT5.DAT中。
部分源程序已给出。
　　请勿改动主函数main()、读数据函数ReadDat()和输出数据函数WriteDat()的内容。
#include<stdio.h>
#include<mem.h>
#include<string.h>
#include<conio.h>
#include<stdlib.h>
#define MAX 100
typedef struct{
char dm[5]; /*产品代码*/
char mc[11]; /*产品名称*/
int dj; /*单价*/
int sl; /*数量*/
long je; /*金额*/
}PRO;
PRO sell[MAX];
void ReadDat();
void WriteDat();
void SortDat()
{int i,j;
         PRO t;
for(i=0;i<MAX;i++)
for(j=i+1;j<MAX;j++)
   if(strcmp(sell[i].mc,sell[j].mc)>0)
    {
        t=sell[i];
                 sell[i]=sell[j];
                                 sell[j]=t;
           }
     else   if(strcmp(sell[i].mc,sell[j].mc)==0)
                if(sell[i].je>sell[j].je)
                    {
                      t=sell[i];
                                  sell[i]=sell[j];
                                                  sell[j]=t;
                       }
　
}
void main()
{
memset(sell,0,sizeof(sell));
ReadDat();
SortDat();
WriteDat();
}
void ReadDat()
{
FILE *fp;
char str[80],ch[11];
int i;
fp=fopen(\ IN.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].sl=atoi(ch);
sell[i].je=(long)sell[i].dj*sell[i].sl;
}
fclose(fp);
}
void WriteDat()
{
FILE *fp;
int i;
fp=fopen(\ OUT5.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].sl,sell[i].je);
}
fclose(fp);
}
　
　
　
086题下列程序的功能是：寻找并输出11至999之间的数m，它满足m,m2和m3均为回文数。所谓回文数是指其各位数字左右对称的整数，例如121，676，94249等。满足上述条件的数如m=11,m2=121,m3=1331皆为回文数。请编制函数int jsValue(long m)实现此功能，如果是回文数，则函数返回1，反之则返回0。最后把结果输出到文件out.dat中。
部分源程序已给出。
　　请勿改动主函数main()的内容。
#include <stdio.h>
int jsValue(long n)
{
}
main()
{
long m;
FILE *out;
out=fopen(\ out.dat\ ,\ w\ );
for(m=11;m<1000;m++){
if(jsValue(m)&&jsValue(m*m)&&jsValue(m*m*m)){
printf(\ m=%41d,m*m=%61d,m*m*m=%81d\\n\ ,m,m*m,m*m*m);
}
}
fclose(out);
}
________________________________________
int jsvalue(long n)
{ int i,strl,half;
char xy[20];
itoa(n,xy,10);
strl=strlen(xy);
half=strl/2;
for(i=0;i if(xy[i]!=xy[--strl]) break;
if(i>=half) return 1;
else return 0;
}
　
_________________________________
本人只是为了上机能通过，不追求什么算法速度,答案仅供大家参考.
int jsValue(long n)
{
int i,aa[10],j=0,b=1; /*n为“long”型，n的三次方最多达到10位，所以定义为aa[10]*/
while(n)
{
aa[j++]=n%10;     /*将数拆散后依次按最高位到最低位（万-》千-》百-》十-》个位）的次序放入数组aa中*/
n=n/10;
}
for(i=0;i<j/2;i++)
{
if(aa[i]!=aa[j-i-1]) b=0;
}
return b;
}
　
　
087题已知在文件IN.DAT中存有100个产品销售记录，每个产品销售记录由产品代码dm(字符型4位)，产品名称mc(字符型10位)，单价dj(整型)，数量sl(整型)，金额je(长整型)四部分组成。其中：金额=单价*数量计算得出。函数ReadDat()是读取这100个销售记录并存入结构数组sell中。请编制函数SortDat()，其功能要求：按产品名称从大到小进行排列，若产品名称相等，则按金额从小到大进行排列，最终排列结果仍存入结构数组sell中，最后调用函数WriteDat()把结果输出到文件OUT7.DAT中。
部分源程序已给出。
　　请勿改动主函数main()、读数据函数ReadDat()和输出数据函数WriteDat()的内容。 #include<stdio.h>
#include<mem.h>
#include<string.h>
#include<conio.h>
#include<stdlib.h>
#define MAX 100
typedef struct{
char dm[5]; /*产品代码*/
char mc[11]; /*产品名称*/
int dj; /*单价*/
int sl; /*数量*/
long je; /*金额*/
}PRO;
PRO sell[MAX];
void ReadDat();
void WriteDat();
void SortDat()
{int i,j;
         PRO t;
for(i=0;i<MAX;i++)
for(j=i+1;j<MAX;j++)
   if(strcmp(sell[i].mc,sell[j].mc)<0)
    {
        t=sell[i];
                 sell[i]=sell[j];
                                 sell[j]=t;
           }
     else   if(strcmp(sell[i].mc,sell[j].mc)==0)
                if(sell[i].je>sell[j].je)
                    {
                      t=sell[i];
                                  sell[i]=sell[j];
                                                  sell[j]=t;
                       }
}
void main()
{
memset(sell,0,sizeof(sell));
ReadDat();
SortDat();
WriteDat();
}
void ReadDat()
{
FILE *fp;
char str[80],ch[11];
int i;
fp=fopen(\ IN.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].sl=atoi(ch);
sell[i].je=(long)sell[i].dj*sell[i].sl;
}
fclose(fp);
}
void WriteDat()
{
FILE *fp;
int i;
fp=fopen(\ OUT7.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].sl,sell[i].je);
}
fclose(fp);
}
　
　
　
088题编写函数jsValue，它的功能是：求Fibonacci数列中大于t的最小的一个数，结果由函数返回。其中Fibonacci数列F(n)的定义为：
F(0)=0,F(1)=1
F(n)=F(n-1)+F(n-2)
最后调用函数writeDat()读取10个数据t，分别得出结果且把结果输出到文件out.dat中。
例如：当t=1000时，函数值为：1597。
部分源程序已给出。
请勿改动主函数main()和写函数writeDat()的内容。 #include <stdio.h>
int jsValue(int t)
{
}
main()
{
int n;
n=1000;
printf(\ n=%d,f=%d\\n\ ,n,jsValue(n));
writeDat();
}
writeDat()
{
FILE *in,*out;
int i,n,s;
in=fopen(\ in.dat\ ,\ r\ );
out=fopen(\ out.dat\ ,\ w\ );
for(i=0;i<10;i++){
fscanf(in,\ %d\ ,&n);
s=jsValue(n);
printf(\ out\ ,\ %d\\n\ ,s);
}
fclose(in);
fclose(out);
}
________________________________________
int jsvalue(int t)
{ int f1=0,f2=1,fn;
fn=f1+f2;
while(fn<=t)
{f1=f2;
   f2=fn;
     fn=f1+f2;
}
return fn;
}
　
　
089题已知在文件IN.DAT中存有100个产品销售记录，每个产品销售记录由产品代码dm(字符型4位)，产品名称mc(字符型10位)，单价dj(整型)，数量sl(整型)，金额je(长整型)四部分组成。其中：金额=单价*数量计算得出。函数ReadDat()是读取这100个销售记录并存入结构数组sell中。请编制函数SortDat()，其功能要求：按产品代码从小到大进行排列，若产品代码相等，则按金额从小到大进行排列，最终排列结果仍存入结构数组sell中，最后调用函数WriteDat()把结果输出到文件OUT9.DAT中。
部分源程序已给出。
　　请勿改动主函数main()、读数据函数ReadDat()和输出数据函数WriteDat()的内容。 #include<stdio.h>
#include<mem.h>
#include<string.h>
#include<conio.h>
#include<stdlib.h>
#define MAX 100
typedef struct{
char dm[5]; /*产品代码*/
char mc[11]; /*产品名称*/
int dj; /*单价*/
int sl; /*数量*/
long je; /*金额*/
}PRO;
PRO sell[MAX];
void ReadDat();
void WriteDat();
void SortDat()
{int i,j;
        PRO t;
for(i=0;i<MAX;i++)
for(j=i+1;j<MAX;j++)
if(strcmp(sell[i].dm,sell[j].dm)>0)
{
    t=sell[i];
            sell[i]=sell[j];
                           sell[j]=t;
     }
   else   if(strcmp(sell[i].dm,sell[j].dm)==0)
             if(sell[i].je>sell[j].je)
              {
               t=sell[i];
                       sell[i]=sell[j];
                                      sell[j]=t;
                    }
　
}
void main()
{
memset(sell,0,sizeof(sell));
ReadDat();
SortDat();
WriteDat();
}
void ReadDat()
{
FILE *fp;
char str[80],ch[11];
int i;
fp=fopen(\ IN.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].sl=atoi(ch);
sell[i].je=(long)sell[i].dj*sell[i].sl;
}
fclose(fp);
}
void WriteDat()
{
FILE *fp;
int i;
fp=fopen(\ OUT9.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].sl,sell[i].je);
}
fclose(fp);
}
　
　
　
090题函数ReadDat()实现从文件in.dat中读取20行数据存放到字符串数组xx中(第行字符串长度均小于80)。请编制函数jsSort()，其函数的功能是：以行为单位对字符串变量的下标为奇数的字符按其ASCII值从大到小的顺序进行排序，排序后的结果仍按行重新存入字符串数组xx中，最后调用函数WriteDat()把结果xx输出到文件out.dat中。
　　例如：位置　　　0　1　2　3　4　5　6　7　
　　　　　源字符串　a b c d e f g h
     则处理后字符串 a h c f e d g b
　　部分源程序已给出。
　　请勿改动主函数main()、读数据函数ReadDat()和输出数据函数WriteDat()的内容。
#include<stdio.h>
#include<string.h>
#include<conio.h>
char xx[20][80];
void jsSort()
{ int i,j,k,strl;
　char ch;
　for(i=0;i<20;i++)
　{
　　strl=strlen(xx[i]);
　　for(j=1;j<strl;j=j+2)
　　　for(k=j+2;k<strl;k=k+2)
　　　　if(xx[i][j]<xx[i][k])
　　　　{
　　　　　ch=xx[i][j];
　　　　　xx[i][j]=xx[i][k];
　　　　　xx[i][k]=ch;
　　　　}
　}
}
void main()
{
readDat();
jsSort();
writeDat();
}
readDat()
{
FILE *in;
int i=0;
char *p;

in=fopen(\ in.dat\ ,\ r\ );
while(i<20&&fgets(xx[i],80,in)!=NULL){
p=strchr(xx[i],'\\n');
if(p)*p=0;
i++;
}
fclose(in);
}
writeDat()
{
FILE *out;
int i;
out=fopen(\ out.dat\ ,\ w\ );
clrscr();
for(i=0;i<20;i++){
printf(\ %s\\n\ ,xx[i]);
fprintf(out,\ %s\\n\ ,xx[i]);
}
fclose(out);
}
　
void jsSort()
{
int i,j,k,strl;
char ch;
for(i=0;i<20;i++)
{
strl=strlen(xx[i]);
for(j=1;j<strl;j=j+2)
for(k=j+2;k<strl;k=k+2)
if(xx[i][j]<xx[i][k])
{
ch=xx[i][j];
xx[i][j]=xx[i][k];
xx[i][k]=ch;
}
}
}

　
　
　
091题函数ReadDat()实现从文件ENG.IN中读取一篇英文文章，存入到字符串数组xx中；请编制函数encryptChar()，按给定的替代关系对数组xx中的所有字符进行替代，仍存入数组xx的对应的位置上，最后调用函数WriteDat()把结果xx输出到文件PS1.DAT中。
　　替代关系：f(p)=p*11 mod 256 (p是数组中某一个字符的ASCII值，f(p)是计算后新字符的ASCII值)，如果计算后f(p)值小于等于32或大于130，则该字符不变，否则将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()
{
}
void main()
{
clrscr();
if(ReadDat()){
printf(\ 数据文件ENG.IN不能打开！\\n\\007\ );
return;
}
encryptChar();
WriteDat();
}
int ReadDat(void)
{
FILE *fp;
int i=0;
unsigned char *p;
if((fp=fopen(\ eng.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(\ ps1.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,j,t;
for(i=0;i<maxline;i++)
{
for(j=0;j<strlen(xx[i]);j++)
{
t=xx[i][j]*11%256;
if(t<=32 ||t>130) continue;
xx[i][j]=t;
}
}
}
　
　
　
092题在文件in.dat中有200组数据，每组有3个数，每个数均是三位数。函数ReadDat()读取这200组数据存放到结构数组aa中，请编制函数jsSort()，其函数的功能是：要求在200组数据中找出条件为每组中的第二个数大于第一个数加第三个数的之和，其中满足条件的个数作为函数jsSort() 的返回值，同时把满足条件的数据存入结构数组bb中，再对bb中的数据按照每组数据的第二个数加第三个之和的大小进行降序排列(第二个数加第三个数的和均不相等)，排序后的结果仍重新存入结构数组bb中，最后调用函数WriteDat()把结果bb输出到文件out.dat中。
部分源程序已给出。
　　请勿改动主函数main()、读数据函数ReadDat()和输出数据函数WriteDat()的内容。
#include<stdio.h>
#include<string.h>
#include<conio.h>
typedef struct{
int x1,x2,x3;
}data;
data aa[200],bb[200];
int jsSort()
{int i,j,k=0;
DATA swap;
for(i=0;i<200;i++)
if(aa[i].x2>(aa[i].x1+aa[i].x3))
   bb[k++]=aa[i];
for(i=0;i<k-1;i++)
for(j=i+1;j<k;j++)
   if((bb[i].x2+bb[i].x3)<(bb[j].x2+bb[j].x3))
   {
      swap=bb[i];
               bb[i]=bb[j];
                         bb[j]=swap;
       }
return k;
　
}
void main()
{
int count;
readDat();
count=jsSort(); /*返回满足条件的个数*/
writeDat(count);
}
readDat()
{
FILE *in;
int i;

in=fopen(\ in.dat\ ,\ r\ );
for(i=0; i<200; i++)
fscanf(in,\ %d%d%d\ ,&aa[i].x1,&aa[i].x2,&aa[i].x3);
fclose(in);
}
writeDat(int count)
{
FILE *out;
int i;
out=fopen(\ out.dat\ ,\ w\ );
clrscr();
for(i=0; i<10; i++){
printf(\ %d,%d,%d 第二个数+第三个数=%d\\n\ ,bb[i].x1,bb[i].x2,bb[i].x3,bb[i].x2+bb[i].x3);
fprintf(out,\ %d%d%d\\n\ ,bb[i].x1,bb[i].x2,bb[i].x3);
}
fclose(out);
}
　
　
　
093题　函数ReadDat()实现从文件ENG.IN中读取一篇英文文章，存入到字符串数组xx中；请编制函数encryptChar()，按给定的替代关系对数组xx中的所有字符进行替代，仍存入数组xx的对应的位置上，最后调用函数WriteDat()把结果xx输出到文件PS3.DAT中。
　　替代关系：f(p)=p*17mod 256 (p是数组中某一个字符的ASCII值，f(p)是计算后新字符的ASCII值)，如果计算后f(p)值小于等于32或其ASCII值是奇数，则该字符不变，否则将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()
{
}
void main()
{
clrscr();
if(ReadDat()){
printf(\ 数据文件ENG.IN不能打开！\\n\\007\ );
return;
}
encryptChar();
WriteDat();
}
int ReadDat(void)
{
FILE *fp;
int i=0;
unsigned char *p;
if((fp=fopen(\ eng.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(\ ps3.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,j,t;
for(i=0;i<maxline;i++)
{
for(j=0;j<strlen(xx[i]);j++)
{
t=xx[i][j]*17%256;
if(t<=32 || t%2==1) continue;
xx[i][j]=t;
}
}
}
　
　
　
094题在文件中有200个正整数，且每个数均在1000至9999之间。函数ReadDat()读取这200个数存放到数组aa中。请编制函数jsSort()，其函数的功能是：要求按每个数的后三位的大小进行降序排列，然后取出满足此条件的前10个数依次存入数组b中，如果后三位的数值相等，则按原先的数值进行升序排列。最后调用函数WriteDat()把结果bb输出到文件out.dat中。
例：处理前 9012 5099 6012 7025 8088
    处理后 5099 8088 7025 6012 9012
部分源程序已给出。
　　请勿改动主函数main()、读数据函数ReadDat()和输出数据函数WriteDat()的内容。
#include<stdio.h>
#include<string.h>
#include<conio.h>
int aa[200],bb[10];
void jsSort()
{   int i,j,n,s;
     n=200；
   for(i=0;i<n-1;i++)
    for(j=i+1;j<n;j++)
       {if(aa[i]%1000<aa[j]%1000)
           {s=aa[i];
                 aa[i]=aa[j];
                            aa[j]=s;
          }
         else if(aa[i]%1000==aa[j]%1000)
               if(aa[i]>aa[j])
               {s=aa[i];
                     aa[i]=aa[j];
                                aa[j]=s;
                 }
   for(n=0;n<10;n++)
       bb[n]=aa[n];
}
void main()
{
readDat();
jsSort();
writeDat();
}
readDat()
{
FILE *in;
int i;

in=fopen(\ in.dat\ ,\ r\ );
for(i=0; i<200; i++) fscanf(in,\ %d\ ,&aa[i]);
fclose(in);
}
writeDat()
{
FILE *out;
int i;
out=fopen(\ out.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);
}
　
　
　
095题　　函数ReadDat()实现从文件ENG.IN中读取一篇英文文章，存入到字符串数组xx中；请编制函数encryptChar()，按给定的替代关系对数组xx中的所有字符进行替代，仍存入数组xx的对应的位置上，最后调用函数WriteDat()把结果xx输出到文件PS5.DAT中。
　　替代关系：f(p)=p*11mod 256 (p是数组中某一个字符的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()
{
}
void main()
{
clrscr();
if(ReadDat()){
printf(\ 数据文件ENG.IN不能打开！\\n\\007\ );
return;
}
encryptChar();
WriteDat();
}
int ReadDat(void)
{
FILE *fp;
int i=0;
unsigned char *p;
if((fp=fopen(\ eng.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(\ ps5.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,j,t;
for(i=0;i<maxline;i++)
{
for(j=0;j<strlen(xx[i]);j++)
{
t=xx[i][j]*11%256;
if(t<=32 ||（ t>='a' && t<='z'）) continue;
xx[i][j]=t;
}
}
}
　
　
096题　　函数ReadDat()实现从文件in.dat中读取20行数据存放到字符串数组xx中(第行字符串长度均小于80)。请编制函数jsSort()，其函数的功能是：以行为单位对字符串按给定的条件进行排序，排序后的结果仍按行重新存入字符串数组xx中，最后调用函数WriteDat()把结果xx输出到文件out.dat中。
　　条件：从字符串中间一分为二，左边部分按字符的ASCII值升序排序，右边部分按字符的ASCII值降序排序。如果原字符串长度为奇数，则最中间的字符不参加排序，字符仍放在原位置上。
　　例如：位置　　　0　1　2　3　4　5　6　7　8
　　　　　源字符串　h g f e a b c d
                    8 7 6 5 9 1 2 3 4
     则处理后字符串 e f g h d c b a
                    5 6 7 8 9 4 3 2 1
　　部分源程序已给出。
　　请勿改动主函数main()、读数据函数ReadDat()和输出数据函数WriteDat()的内容。
#include<stdio.h>
#include<string.h>
#include<conio.h>
char xx[20][80];
void jsSort()
{
}
void main()
{
readDat();
jsSort();
writeDat();
}
readDat()
{
FILE *in;
int i=0;
char *p;

in=fopen(\ in.dat\ ,\ r\ );
while(i<20&&fgets(xx[i],80,in)!=NULL){
p=strchr(xx[i],'\\n');
if(p)*p=0;
i++;
}
fclose(in);
}
writeDat()
{
FILE *out;
int i;
clrscr();
out=fopen(\ out.dat\ ,\ w\ );
for(i=0;i<20;i++){
printf(\ %s\\n\ ,xx[i]);
fprintf(out,\ %s\\n\ ,xx[i]);
}
fclose(out);
}
　
/*注解*/
void jsSort()
{
int i,j,k,strl;
char ch;
for(i=0;i<20;i++)
{
strl=strlen(xx[i]);
   for(j=0;j<strl/2;j++)
        for(k=j+1;k<strl/2;k++)
           if(xx[i][j]>xx[i][k])
             {
              ch=xx[i][j];
              xx[i][j]=xx[i][k];
              xx[i][k]=ch;
                           }
for(j=(strl+1)/2;j<strl;j++)
   for(k=j+1;k<strl;k++)
      if(xx[i][j]<xx[i][k])
          {
              ch=xx[i][j];
             xx[i][j]=xx[i][k];
              xx[i][k]=ch;
             }
    }
}
　
　
　
097题　函数ReadDat()实现从文件ENG.IN中读取一篇英文文章，存入到字符串数组xx中；请编制函数encryptChar()，按给定的替代关系对数组xx中的所有字符进行替代，仍存入数组xx的对应的位置上，最后调用函数WriteDat()把结果xx输出到文件PS7.DAT中。
　　替代关系：f(p)=p*11mod 256 (p是数组中某一个字符的ASCII值，f(p)是计算后新字符的ASCII值)，如果原字符是大写字母或计算后f(p)值小于等于32，则该字符不变，否则将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()
{
}
void main()
{
clrscr();
if(ReadDat()){
printf(\ 数据文件ENG.IN不能打开！\\n\\007\ );
return;
}
encryptChar();
WriteDat();
}
int ReadDat(void)
{
FILE *fp;
int i=0;
unsigned char *p;
if((fp=fopen(\ eng.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(\ ps7.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,j,t;
for(i=0;i<maxline;i++)
{
for(j=0;j<strlen(xx[i]);j++)
{
t=xx[i][j]*11%256;
if(t<=32 || （xx[i][j]>='A' && xx[i][j]<='Z'）) continue;
xx[i][j]=t;
}
}
}
　
　
　
098题　　函数ReadDat()实现从文件in.dat中读取20行数据存放到字符串数组xx中(第行字符串长度均小于80)。请编制函数jsSort()，其函数的功能是：以行为单位对字符串按给定的条件进行排序，排序后的结果仍按行重新存入字符串数组xx中，最后调用函数WriteDat()把结果xx输出到文件out.dat中。
　　条件：从字符串中间一分为二，右边部分按字符的ASCII值降序排序，排序后左边部分与右边部分进行交换。如果原字符串长度为奇数，则最中间的字符不参加排序，字符仍放在原位置上。
　　例如：位置　　　0 1 2 3 4 5 6 7 8
　　　　　源字符串　h g f e a b c d
                    8 7 6 5 9 1 2 3 4
     则处理后字符串 d c b a h g f e
                    4 3 2 1 9 8 7 6 5
　　部分源程序已给出。
　　请勿改动主函数main()、读数据函数ReadDat()和输出数据函数WriteDat()的内容。
#include<stdio.h>
#include<string.h>
#include<conio.h>
char xx[20][80];
void jsSort()
{
}
void main()
{
readDat();
jsSort();
writeDat();
}
readDat()
{
FILE *in;
int i=0;
char *p;

in=fopen(\ in.dat\ ,\ r\ );
while(i<20&&fgets(xx[i],80,in)!=NULL){
p=strchr(xx[i],'\\n');
if(p)*p=0;
i++;
}
fclose(in);
}
writeDat()
{
FILE *out;
int i;
clrscr();
out=fopen(\ out.dat\ ,\ w\ );
for(i=0;i<20;i++){
printf(\ %s\\n\ ,xx[i]);
fprintf(out,\ %s\\n\ ,xx[i]);
}
fclose(out);
}
　
/*注解*/
void jsSort()
{
int i,j,k,strl;
char ch;
for(i=0;i<20;i++)
{
strl=strlen(xx[i]);
for(j=(strl+1)/2;j<strl;j++)
for(k=j+1;k<strl;k++)
if(xx[i][j]<xx[i][k])
{
ch=xx[i][j];
xx[i][j]=xx[i][k];
xx[i][k]=ch;
}
for(j=0;j<strl/2;j++)
{
ch=xx[i][j];
xx[i][j]=xx[i][(strl+1)/2+j];
xx[i][(strl+1)/2+j]=ch;
}
}
}
　
　
　
099题函数ReadDat()实现从文件ENG.IN中读取一篇英文文章，存入到字符串数组xx中；请编制函数encryptChar()，按给定的替代关系对数组xx中的所有字符进行替代，仍存入数组xx的对应的位置上，最后调用函数WriteDat()把结果xx输出到文件PS9.DAT中。
　　替代关系：f(p)=p*11mod 256 (p是数组中某一个字符的ASCII值，f(p)是计算后新字符的ASCII值)，如果原字符是数字字符0至9或计算后f(p)值小于等于32，则该字符不变，否则将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()
{
}
void main()
{
clrscr();
if(ReadDat()){
printf(\ 数据文件ENG.IN不能打开！\\n\\007\ );
return;
}
encryptChar();
WriteDat();
}
int ReadDat(void)
{
FILE *fp;
int i=0;
unsigned char *p;
if((fp=fopen(\ eng.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(\ ps9.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,j,t;
for(i=0;i<maxline;i++)
{
for(j=0;j<strlen(xx[i]);j++)
{
t=xx[i][j]*11%256;
if(t<=32 ||（ xx[i][j]>='0' && xx[i][j]<='9'）) continue;
xx[i][j]=t;
}
}
}
　
　
　
100题函数ReadDat()实现从文件in.dat中读取20行数据存放到字符串数组xx中(第行字符串长度均小于80)。请编制函数jsSort()，其函数的功能是：以行为单位对字符串按给定的条件进行排序，排序后的结果仍按行重新存入字符串数组xx中，最后调用函数WriteDat()把结果xx输出到文件out.dat中。
　　条件：从字符串中间一分为二，右边部分按字符的ASCII值升序排序，排序后左边部分与右边部分进行交换。如果原字符串长度为奇数，则最中间的字符不参加排序，字符仍放在原位置上。
　　例如：位置　　　0 1 2 3 4 5 6 7 8
　　　　　源字符串　d c b a h g f e
                    8 7 6 5 9 1 2 3 4
     则处理后字符串 e f g h d c b a
                    5 6 7 8 9 4 3 2 1
　　部分源程序已给出。
　　请勿改动主函数main()、读数据函数ReadDat()和输出数据函数WriteDat()的内容。
#include<stdio.h>
#include<string.h>
#include<conio.h>
char xx[20][80];
void jsSort()
{
}
void main()
{
readDat();
jsSort();
writeDat();
}
readDat()
{
FILE *in;
int i=0;
char *p;