计算机三级考试数据库上机练习题

2012年3月计算机三级数据库技术上机练习题
1.调用函数rwdata()，从IN.dat文件中读取10组数据(m和k值)，并嵌套调用primenum函数分别得出array[]数组。请编写函数primenum(int m，int k，int array[])，该函数的功能是：将紧靠m的k个素数存入数组array并在屏幕上显示。最后把结果输出到文件OUT.dat中。
例如，若输入3 9，则应输出5 7 11 13 17 19 23 29 31。
注意：部分程序已经给出。请勿改动主函数main()和输出数据函数rwdata()的内容。
【答案】
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++;
}
}
1.函数RData()实现从文件IN.dat中读取一篇英文文章，存入到字符串数组str中;请编写encryptChar()函数，其功能是：按给定的替代关系对数组str中的所有字符进行替代，仍存入数组str对应的位置上，最后调用函数WData()，把结果str输出到文件OUT.dat中。
替代关系：f(p)=p*11 mod 256(p是数组中某一个字符的ASCII值，f(p)是计算后新字符的ASCII值)，如果计算后f(p)值小于1等于32或大于130，则该字符不变，否则将f(p)所对应的字符进行替代。
原始数据文件存放的格式是：每行的宽度均小于80个字符。
【答案】
void encryptChar()
{ int i;
char *pf;
for (i=0; i<="" p="">
{ pf = str[i];
while (*pf != 0)
{ if (*pf*11%6<=130 && *pf*11%6>32)
*pf = *pf*11%6;
pf++;
}
}
}
1.编写函数findStr()，其功能是：统计一个长度为2的子字符串在另一个字符串中出现的次数。例如，假定输入的字符串为"asd asasdfg asd as zx67 asd mklo"，子字符串为"as"，函数返回值是6。
函数ReadWrite()实现从文件IN.dat中读取两个字符串，并调用函数findStr()，最后，把结果输出到文件OUT.dat中。
【答案】
int findStr(char *str, char *substr)
{ int n;
char *p, *r;
n = 0;
while (*str)
{ p = str;
r = substr;
while (*r)
if (*r == *p)
{ r++;
p++;
}
else
{ break;
}
if (*r == '\0')
n++;
str++;
}
return n;
}
1.已知数据文件IN.dat中存有300个四位数，并已调用读函数Rdata()把这些数存入数组a中，请编写函数primeNum()，其功能是：求出所有这些四位数中素数的个数count，再把所有满足此条件的四位数依次存入数组b中，然后对数组b的四位数按从小到大的顺序进行排序。最后调用写函数Wdata()，把结果输出到OUT.dat文件中。
　

　例如，5591是素数，则该数满足条件存入数组b中，且个数count=count+1。9812是非素数，则该数不满足条件，不存入数组b中，count值也不加1。
【答案】
void primeNum()
{ int j, i, value;
for (i=0; i<300; i++)
if (isP(a[i]))
{ b[count] = a[i];
count++;
}
for (i=0; i<="">
for (j=i+1; j<="">
if (b[i] > b[j])
{ value = b[i];
b[i] = b[j];
b[j] = value;
}
}
1.函数Rdata()实现从文件IN.dat中读取一篇英文文章存入到字符串数组string中，请编写ConvertCharD()函数，其功能是：以行为单位把字符串中的所有小写字母改写成该字母的上一个字母，如果是字母a，则改写成字母z。大写字母仍为大写字母，小写字母仍为小写字母，其他字符不变，最后把已处理的字符串仍按行重新存入字符串数组string中。最后调用函数Wdata()，把结果string输出到文件OUT.dat中。
例如，原文：Adb.Bcdza
abck.LLhj
结果：Aca.Bbcyz
zabj.LLgi
原始数据文件存放的格式是：每行的宽度均小于80个字符。
【答案】
void ConvertCharD(void)
{ int i;
char *pf;
for (i=0; i<="">
{ pf = string[i];
while (*pf)
{ if (*pf == 'a')
*pf = 'z';
else if (*pf>='b' && *pf<='z')
*pf -= 1;
pf++;
}
}
}
1.下列程序的功能是：寻找并输出11~999之间的数m，它满足m、m2和m3均为回文数。所谓回文数是指各位数字左右对称的整数，例如121、676、94249等。满足上述条件的数如m=11，m2=121，m3=1331皆为回文数。请编写函数int palindromevalue(long n)实现功能：如果是回文数，则函数返回1，反之则返回0。最后，把结果输出到文件OUT.dat中。
【答案】
int palindromevalue(long n)
{ int i, strl, half;
char temp[20];
ltoa(n, temp, 10);
strl = strlen(temp);
half = strl/2;
for (i=0; i<="">
if (temp[i] != temp[--strl])
break;
if (i >= half)
return 1;
else
return 0;
}
1.已知数据文件IN.dat中存有200个四位数，并已调用读函数rdata()把这些数存入数组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] 00/100;
bb[2] = a[i] 0/10;
bb[3] = a[i] ;
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<="">
for (j=i+1; j<="">
if (b[i] < b[j])
{ k = b[i];
b[i] = b[j];
b[j] = k;
}
}
　1.下列程序的功能是：把str字符串中的所有字母改写成该字母的下一个字母，字母z改写成字母a。要求大写字母仍为大写字母，小写字母仍为小写字母，其他字符不做改变。
请编写函数CharChange(char*str)实现程序要求，最后调用函数RWData()从IN.dat文件中读取50组数据，分别得出结果，并把结果输出到文件OUT.dat中。
例如，str字符串中原有的内容为：Mn.123Zxy，则调用该函数后，结果为：No.123Ayz。
【答案】
void CharChange(char *str)
{ while (*str)
{ if (*str=='z' || *str=='Z')
*str -= 25;
else if (isalpha(*str))
*str += 1;
str++;
}
}
1.已知a1 <= a2、a2 <= a3、a3 <= a4、a[i]%2 == 0这4个条件同时成立，则a[i]就是要求下列程序的功能是：在三位整数(100~999)中寻找符合条件的整数并依次从小到大存入数组中;该整数既是完全平方数，又有两个数字相同，例如144、676等。请编写函数SearchVal()实现此功能，满足该条件的整数的个数通过所编写的函数返回。最后调用函数WData()，把结果输出到文件OUT.dat中。
注意：部分源程序已给出。请勿改动主函数main()和写函数WData()的内容。
【答案】
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 ;
c = i*i ;
if (a==b || b==c || c==a)
bb[cnt++] = i*i;
}
return cnt;
}
1.已知在文件IN.dat中存有若干个(<200)四位数字的正整数，函数RData()读取这若干个正整数并存入数组original中。请编写函数CalValue()，其功能要求是：①求出这个文件中共有多少个正整数totNum;②求这些数右移1位后，产生的新数是偶数的数的个数toteven，以及满足此条件的这些数(右移前的值)的算术平均值totavg。最后调用函数WData()把所求的结果输出到OUT.dat文件中。
【答案】
void CalValue(void)
{ int i, data;
for (i=0; i<="">
{ if (!original[i])
break;
if (original[i] > 0)
totNum++;
data = original[i]>>1;
if (data%2 == 0)
{ toteven++;
totavg += original[i];
}
}
totavg /= toteven;
}
1.已知在文件IN.dat中存有100个产品销售记录，每个产品销售记录由产品代码code(字符型4位)、产品名称name(字符型10位)、单价uprice(整型)、数量amount(整型)、金额sum(长整型)5部分组成。其中：金额=单价×数量。函数RData()读取

这100个销售记录并存入结构数组sell中。请编写函数SortDat()，其功能要求：按金额从大到小进行排列，若金额相同，则按产品代码从大到小进行排列，最终排列结果仍存入结构数组sell中。最后调用函数WData()，把结果输出到OUT.dat文件中。
【答案】
void SortDat()
{ int i, j;
PRO temp;
for (i=0; i<99; i++)
for (j=i+1; j<100; j++)
if (sell[i].sum < sell[j].sum)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
else if (sell[i].sum == sell[j].sum)
{ if (strcmp(sell[i].code, sell[j].code) < 0)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
}
}
　1.下列程序的功能是：选出100以上、1000之内所有个位数字与十位数字之和被10除所得余数恰好是百位数字的素数(如293)，计算并输出上述这些素数的个数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 0/10;
data = i ;
if (hun == (ten+data) )
{ half = i/2;
for (j=2; j<="">
if (i%j == 0)
break;
if (j >= half)
{ count++;
sum += i;
}
}
}
}
1.已知在文件IN.dat中存有100个产品销售记录，每个产品销售记录由产品代码code(字符型4位)、产品名称name(字符型10位)、单价uprice(整型)、数量amount(整型)、金额sum(长整型)5部分组成。其中：金额=单价×数量。函数RData()是读取这100个销售记录并存入结构数组sell中。请编写函数SortDat()，其功能是：按产品代码从小到大进行排列，若产品代码相同，则按金额从小到大进行排列，最终排列结果仍存入结构数组sell中。最后调用函数WData()，把结果输出到OUT.dat文件中。
【答案】
void SortDat()
{ int i, j;
PRO temp;
for (i=0; i<="" p="">
for (j=i+1; j<="">
if (strcmp(sell[i].code, sell[j].code) > 0)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
else if (strcmp(sell[i].code, sell[j].code) == 0)
{ if (sell[i].sum > sell[j].sum)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
}
}
1.已知在文件IN.dat中存有100个产品销售记录，每个产品销售记录由产品代码code(字符型4位)、产品名称name(字符型10位)、单价uprice(整型)、数量amount(整型)、金额sum(长整型)5部分组成。其中：金额=单价×数量。函数RData()是读取这100个销售记录并存入结构数组sell中。请编写函数SortDat()，其功能要求：按产品名称从大

到小进行排列，若产品名称相等，则按金额从大到小进行排列，最终排列结果仍存入结构数组sell中。最后调用函数WData()，把结果输出到文件OUT.dat中。
【答案】
void SortDat()
{ int i, j;
PRO temp;
for (i=0; i<99; i++)
for (j=i+1; j<100; j++)
if (strcmp(sell[i].name, sell[j].name) < 0)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
else if (strcmp(sell[i].name, sell[j].name) == 0)
{ if (sell[i].sum < sell[j].sum)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
}
}
1.已知在文件IN.dat中存有100个产品销售记录，每个产品销售记录由产品代码code(字符型4位)、产品名称name(字符型10位)、单价uprice(整型)、数量amount(整型)、金额sum(长整型)5部分组成。其中：金额=单价×数量。函数RData()读取这100个销售记录并存入结构数组sell中。请编写函数SortDat()，其功能是：按金额从大到小进行排列，若金额相等，则按产品代码从小到大进行排列，最终排列结果仍存入结构数组sell中。最后调用函数WData()，把结果输出到OUT.dat文件中。
【答案】
void SortDat()
{ int i, j;
PRO temp;
for (i=0; i<="" p="">
for (j=i+1; j<="">
if (sell[i].sum < sell[j].sum)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
else if (sell[i].sum == sell[j].sum)
{ if (strcmp(sell[i].code, sell[j].code) > 0)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
}
}
1.已知数据文件IN.dat中存有300个四位数，并已调用读函数RData()把这些数存入数组a中，请编写函数diffVal()，其功能是：求出千位上的数减百位上的数减十位上的数减个位上的数大于0的个数count，再求出所有满足此条件的四位数的平均值ave1，以及不满足此条件的四位数的平均值ave2。最后调用写函数WData()，把结果输出到OUT.dat文件中。
例如，9123，9-1-2-3>0，则该数满足条件，计算平均值ave1，且个数count=count+1。9812，9-8-1-2<0，则该数不满足条件，计算平均值ave2。
【答案】
void diffVal()
{ int i, thou, hun, ten, data, n = 0;
for (i=0; i<300; i++)
{ thou = a[i]/1000;
hun = a[i] 00/100;
ten = a[i] 0/10;
data = a[i] ;
if (thou-hun-ten-data > 0)
{ count++;
ave1 += a[i];
}
else
{ n++;
ave2 += a[i];
}
}
ave1 /= count;
ave2 /= n;
}
1.函数Rdata()实现从文件IN.dat中读取一篇英文文章，存入到字符串数组string中。请编写encryptChar()函数，其功能是：按给定的替代关系对数组string中的所有字符进行替代后，仍存入数组string的对应位

置上。最后调用函数Wdata()，把结果string输出到OUT.dat文件中。
替代关系：f(p)=p*11 mod 256(p是数组中某一个字符的ASCII值，f(p)是计算后新字符的ASCII值)，如果计算后f(p)值小于等于32或f(p)对应的字符是大写字母，则该字符不变，否则将f(p)所对应的字符进行替代。
原始数据文件存放的格式是：每行的宽度均小于80个字符。
【答案】
void encryptChar()
{ int i;
char *pf;
for (i=0; i<="" p="">
{ pf = string[i];
while (*pf != 0)
{ if ((*pf*11%6>='A' && *pf*11%6<='Z') || *pf*11%6<=32)
{ pf++;
continue;
}
*pf = *pf*11%6;
pf++;
}
}
}
2.在文件IN.dat中有200个正整数，且每个数均在1000~9999之间。函数RData()读取这200个数存放到数组original中。请编写函数numAscend()，其功能是：要求按每个数的后3位的大小进行升序排列，然后取出满足此条件的前10个数依次存入数组result中，如果后3位的数值相等，则按原先的数值进行降序排列。最后调用函数WData()，把结果result输出到文件OUT.dat中。
例如，处理前：6012 5099 9012 7025 8088
处理后：9012 6012 7025 8088 5099
【答案】
void numascend()
{ int i, j, data;
for (i=0; i<199; i++)
for (j=i+1; j<200; j++)
{ if (original[i] 00 > original[j] 00)
{ data = original[i];
original[i] = original[j];
original[j] = data;
}
else if (original[i] 00 == original[j] 00)
{ 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];
}
3.已知文件IN.dat中存有100个产品销售记录，每个产品销售记录由产品代码code(字符型4位)、产品名称name(字符型10位)、单价uprice(整型)、数量amount(整型)、金额sum(长整型)5部分组成。其中：金额=单价×数量。函数RData()读取这100个销售记录并存入结构数组sell中。请编写函数DescSort()，其功能要求：按产品代码从大到小进行排列，若产品代码相同，则按金额从大到小进行排列，最终排列结果仍存入结构数组sell中，最后调用函数WData()，把结果输出到文件OUT.dat中。
【答案】
void DescSort()
{ int i, j;
PRO temp;
for (i=0; i<99; i++)
for (j=i+1; j<100; j++)
if (strcmp(sell[i].code, sell[j].code) < 0)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
else if (strcmp(sell[i].code, sell[j].code) == 0)
{ if (sell[i].sum < sell[j].sum)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
}
}
2.函数RData()实现从文件IN.dat中读取一篇英文文章存

入到字符串数组str中，请编写函数DescSort()，其功能是：以行为单位对字符按从大到小的顺序进行排序，排序后的结果仍按行重新存入字符串数组str中，最后调用函数WData()，把结果str输出到文件OUT.dat中。原始数据文件存放的格式是：每行的宽度均小于80个字符(含标点符号和空格)。
例如，原文：dAeBfC.
CcbbAA
结果：fedCBA.
cbbCAA
【答案】
void DescSort(void)
{ int i, j, k, strl;
char ch;
for (i=0; i<="" p="">
{ strl = strlen(str[i]);
for (j=0; j<="">
for (k=j+1; k<="">
if (str[i][j] < str[i][k])
{ ch = str[i][j];
str[i][j] = str[i][k];
str[i][k] = ch;
}
}
}
　3.函数RData()实现从文件IN.dat中读取一篇英文文章存入字符串数组original中，请编写StrCharMove()函数，其功能是：以行为单位把字符串中所有字符的ASCII值右移4位，然后把右移后的字符ASCII值再加上原字符的ASCII值，得到新的字符仍存入原字符串对应的位置上。最后把已处理的字符串仍按行重新存入字符串数组original中。最后调用函数WData()，把结果original输出到文件OUT.dat中。
原始数据文件存放的格式是：每行的宽度均小于80个字符(含标点符号和空格)。
【答案】
void StrCharMove(void)
{ int i, j, strl;
for (i=0; i<="" p="">
{ strl = strlen(original[i]);
for (j=0; j<="">
original[i][j] += original[i][j]>>4;
}
}
2.请编写函数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<="" p="">
if (i%3==0 && i%7==0)
xy += i;
xy = sqrt((double)xy);
return xy;
}
　3.已知在文件IN.dat中存有N个(N<200)实数，函数RData()读取这N个实数并存入数组original中。请编写函数CalValue()，要求实现的功能有：①求出这N个实数的平均值(aver);②分别求出这N个实数的整数部分之和(sumint)以及小数部分之和(sumdec)，最后调用函数WData()把所求的结果输出到文件OUT.dat中。
【答案】
void CalValue(void)
{ int i;
double x, sum = 0;
for (i=0; i<="" p="">
{ sumint = sumint+(int)original[i];
x = original[i]-(int)original[i];
sumdec = sumdec+x;
sum = sum+original[i];
}
aver = sum/MAXNUM;
}
2.下列程序的功能是：把s字符串中的所有字符左移一个位置，字

符串中的第一个字符移到最后。请编写函数change(char*s)实现程序要求，最后调用函数readwriteDAT()从IN.dat文件中读取50组数据，分别得出结果，且把结果输出到OUT.dat文件中。
例如，s字符串中原有内容为：Mn.123xyZ，调用该函数后结果为：n.123xyZM。
【答案】
void change(char*s)
{ int i, strl;
char ch;
strl = strlen(s);
ch = *s;
for (i=0; i<="">
*(s+i) = *(s+i+1);
*(s+strl-1) = ch;
}
　3.下列程序的功能是：找出所有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;
}
}
　2.下列程序的功能是：把s字符串中的所有字符左移一个位置，字符串中的第一个字符移到最后。请编写函数change(char*s)实现程序要求，最后调用函数readwriteDAT()从IN.dat文件中读取50组数据，分别得出结果，且把结果输出到OUT.dat文件中。
例如，s字符串中原有内容为：Mn.123xyZ，调用该函数后结果为：n.123xyZM。
【答案】
void change(char*s)
{ int i, strl;
char ch;
strl = strlen(s);
ch = *s;
for (i=0; i<="">
*(s+i) = *(s+i+1);
*(s+strl-1) = ch;
}
3.下列程序的功能是：找出所有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;
}
}
2.请编写函数countValue()，它的功能是：求出1~1000之内能被7或11整除但不能同时被7或11整除的所有整数，将它们放在数组a中，并通过n返回这些数的个数。主函数最后调用函数Wdata()把计算结果输出到OUT.dat中。
【答案】
void countValue(int *a, int *n)
{ int i;
*n = 0;
for (i=1; i<=1000; i++)
if (i%7==0 && i )
{ *a = i;
*n = *n+1;
a++;
}
else if (i%7 && i ==0)
{ *a = i;
*n = *n+1;
a++;
}
}
3.已知数据文件IN.dat中存有300个四位数，并已调用读函数Rdata()把这些数存入数组a中，请编写函数primeCal()，其功能是：求出这些四位数中素数的个数count，再求出所有满足此条件的四位数的平均值Ave1以及不满足此条件的四位

数的平均值Ave2。最后调用写函数Wdata()，把结果count、Ave1、Ave2输出到OUT.dat文件中。
例如，5591是素数，则该数满足条件计算平均值Ave1，且个数count=count+1。9812是非素数，则该数不满足条件计算平均值Ave2。
【答案】
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);
}
2.请补充程序，使得程序能实现以下功能：
从文件IN.dat中读取200个整数至数组number中，求出奇数的个数cnt1和偶数的个数cnt2以及数组number下标为偶数的元素值的算术平均值ave(保留2位小数)。把结果cnt1、cnt2、ave输出到OUT.dat中。
【答案】
for (i=0, j=0, cnt1=0, cnt2=0; i<="">
{ if (number[i]%2)
cnt1++;
else
cnt2++;
if (i%2 == 0)
j += number[i];
}
ave = (float)j/(N/2);
3..函数Rdata()实现从文件IN.dat中读取一篇英文文章，存入到字符串数组string中，请编写函数CharRight()，其功能是：以行为单位把字符串中的最后一个字符的ASCII值右移4位后加倒数第二个字符的ASCII值，得到最后一个新的字符;倒数第二个字符的ASCII值右移4位后加倒数第三个字符的ASCII值，得到倒数第二个新的字符;依此类推，一直处理到第二个字符;第一个字符的ASCII值加原最后一个字符的ASCII值，得到第一个新的字符。得到的新字符分别存放在原字符串对应的位置上，最后已处理的字符串仍按行重新存入字符串数组string中。最后调用函数Wdata()，把结果string输出到文件OUT.dat中。
原始数据文件存放的格式是：每行的宽度均小于80个字符(含标点符号和空格)。
【答案】
void CharRight(void)
{ int i, j, strl;
char ch;
for (i=0; i<="">
{ strl = strlen(string[i]);
ch = string[i][strl-1];
for (j=strl-1; j>0; j--)
{ string[i][j] >>= 4;
string[i][j] += string[i][j-1];
}
string[i][0] += ch;
}
}
2.函数RData()实现从文件IN.dat中读取一篇英文文章存入字符串数组StrResult中;请编写Strmove()函数，其功能是：以行为单位，依次把字符串中所有小写字母"o"左边的字符串内容移到该字符串的右边存放，然后把小写字母"o"删除，余下的字符串内容移到已处理字符串的左边存放，之后把已处理的字符串仍按行重新存入字符串数组StrResult中。最后main()函数调用函数WData()，把结果StrResult输出到文件OUT.dat中。原始数据文件存放的格式是：每行的宽度均小于80个字符，含标点符号和空格。
例如，原文：n any field.Yu can create an index
you have the corlrectrecord.

结果：n any field.Yu can create an index
rd.yu have the crlrectrec
【答案】
void Strmove(void)
{ int i, j, k;
char buf[80];
for (i=0; i<="">
{ j = strlen(StrResult[i])-1;
while (StrResult[i][j]!='o' && j>=0)
j--;
if (j < 0)
continue;
StrResult[i][j] = 0;
strcpy(buf, &StrResult[i][j+1]);
k = j = 0;
while (StrResult[i][j])
{ while (StrResult[i][j]!='o' && StrResult[i][j])
j++;
if (!StrResult[i][j])
{ strcat(buf, &StrResult[i][k]);
break;
}
StrResult[i][j] = 0;
strcat(buf, &StrResult[i][k]);
j++;
k = j;
}
strcpy(StrResult[i], buf);
}
}
3.函数RData()实现从文件IN.dat中读取一篇英文文章并存入到字符串数组StrResult中，请编写函数StrRes()，其功能是：以行为单位对行中以空格或标点符号为分隔的所有单词进行倒排。最后把已处理的字符串(应不含标点符号)仍按行重新存入字符串数组StrResult中，最后调用函数WData()，把结果StrResult输出到文件OUT.dat中。原始数据文件存放的格式是：每行的宽度均小于80个字符，含标点符号和空格。
例如，原文：You He Me
I am a student.
结果：Me He You
student a am I
【答案】
char StrRes(void)
{ int i, j, k, strl, l;
for (i=0; i<="">
for (j=0; j<(int)strlen(StrResult[i]); j++)
if (!isalpha(StrResult[i][j]) && StrResult[i][j]!=' ')
StrResult[i][j] = ' ';
for (l=0; l<="">
{ char ch[80] = {0};
char pp[80] = {0};
strl = strlen(StrResult[l]);
i = strl-1;
k = 0;
while(1)
{ while (isalpha(StrResult[l][i]) && i >= 0)
{ for (j=k; j>=0; j--)
pp[j+1] = pp[j];
pp[0] = StrResult[l][i];
k++;
i--;
}
strcat(ch, pp);
strcpy(pp, "");
k = 0;
if (i < 0)
break;
while (!isalpha(StrResult[l][i]) && i >= 0)
{ for (j=k; j>=0; j--)
pp[j+1] = pp[j];
pp[0] = StrResult[l][i];
k++;
i--;
}
strcat(ch, pp);
strcpy(pp, "");
k = 0;
if (i < 0)
break;
}
strcpy(StrResult[l], ch);
}
}
2.已知在文件IN.dat中存有100个产品销售记录，每个产品销售记录由产品代码code(字符型4位)、产品名称name(字符型10位)、单价uprice(整型)、数量amount(整型)、金额sum(长整型)5部分组成。其中，金额=单价×数量。函数RData()读取这100个销售记录并存入结构数组sell中。请编写AscendSort()函数，其功能是：按产品名称从小到大进行排列，若产品名称相等，则按金额从小到大进行排列，最终排列结果仍存入结构数组sell中。最后调用函数WData()，把结果输出到文件OUT.dat中。
【答案】
　

　void AscendSort()
{ int i, j;
PRO temp;
for (i=0; i<99; i++)
for (j=i+1; j<100; j++)
if (strcmp(sell[i].name, sell[j].name) > 0)
{ temp = sell[i];
sell [i] = sell[j];
sell[j] = temp;
}
else if (strcmp(sell[i].name, sell[j].name) == 0)
{ if (sell[i].sum > sell[j].sum)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
}
}
　3.已知数据文件IN.dat中存有200个四位数，并已调用读函数RData()把这些数存入数组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<="">
{ a1 = a[i]/1000;
a2 = a[i] 00/100;
a3 = a[i] 0/10;
a4 = a[i] ;
if ((a1 <= a2) && (a2 <= a3) && (a3 <= a4) && (a[i]%2 == 0))
{ b[count] = a[i];
count++;
}
}
for (i=0; i<="">
for (j=i+1; j<="">
if (b[i] > b[j])
{ k = b[i];
b[i] = b[j];
b[j] = k;
}
}
2.已知数据文件IN.dat中存有300个四位数，并已调用读函数RData()把这些数存入数组a中，请编写函数jsValue()，其功能是：求出千位数上的数减百位数上的数减十位数上的数减个位数上的数大于0的数的个数count，再把所有满足此条件的四位数依次存入数组b中，然后对数组b的四位数按从小到大的顺序进行排序。最后调用写函数WData()，把结果输出到OUT.dat文件中。
例如，9123，9-1-2-3>0，则该数满足条件存入数组b中，且个数count=count+1。9812，9-8-1-2<0，则该数不满足条件，忽略。
程序中已定义数组a[300]，b[300];已定义变量count。
【答案】
void jsValue()
{ int i, thou, hun, ten, data, j;
for (i=0; i<300; i++)
{ thou = a[i]/1000;
hun = a[i] 00/100;
ten = a[i] 0/10;
data = a[i] ;
if (thou-hun-ten-data > 0)
{ b[count] = a[i];
count++;
}
}
for (i=0; i<="">
for (j=i+1; j<="">
if (b[i] > b[j])
{ data = b[i];
b[i] = b[j];
b[j] = data;
}
}
3.函数Rdata()实现从文件IN.dat中读取一篇英文文章存入到字符串数组string中，请编写函数CharLeft()，其功能是：以行为单位把字符串中所有字符的ASCII值左移4位，如果左移后，

其字符的ASCII值小于等于32或大于100，则原字符保持不变，否则就把左移后的字符ASCII值再加上原字符ASCII值，得到新的字符仍存入原字符串对应的位置上。最后把已处理的字符串仍按行重新存入字符串数组string中，最后调用函数Wdata()，把结果string输出到文件OUT.dat中。
原始数据文件存放的格式是：每行的宽度均小于80个字符(含标点符号和空格)。
【答案】
void CharLeft(void)
{ int i, j, str;
char ch;
for (i=0; i<="">
{ str = strlen(string[i]);
for (j=0; j<="">
{ ch = string[i][j]<<4;
if (ch>32 && ch<=100)
string[i][j] += ch;
}
}
}
2.已知数据文件IN.dat中存有200个四位数，并已调用读函数RData()把这些数存入数组a中，请编写函数spellVal()，其功能是：把千位数字和十位数字重新组成一个新的二位数ab(新二位数的十位数字是原四位数的千位数字，新二位数的个位数字是原四位数的十位数字)，以及把个位数字和百位数字组成另一个新的二位数cd(新二位数的十位数字是原四位数的个位数字，新二位数的个位数字是原四位数的百位数字)，如果新组成的两个二位数ab-cd≥0且ab-cd≤10且两个数均是奇数，同时两个新数的十位数字均不为0，则将满足此条件的四位数按从大到小的顺序存入数组b中，并要计算满足上述条件的四位数的个数count。最后main()函数调用写函数WData()，把结果count以及数组b中符合条件的四位数输出到OUT.dat文件中。
【答案】
void spellVal()
{ int i, thou, hun, ten, data, j;
int ab, cd;
for (i=0; i<200; i++)
{ thou = a[i]/1000;
hun = a[i] 00/100;
ten = a[i] 0/10;
data = a[i] ;
if (thou==0 || data==0)
continue;
ab = 10*thou+ten;
cd = 10*data+hun;
if ((ab-cd)>=0 && (ab-cd)<=10 && ab%2==1 && cd%2==1)
{ b[cnt] = a[i];
cnt++;
}
}
for (i=0; i<="">
for (j=i+1; j<="">
if (b[i] < b[j])
{ data = b[i];
b[i] = b[j];
b[j] = data;
}
}
　3.已知数据文件IN.dat中存有200个四位数，并已调用读函数RData()把这些数存入数组a中，请编写函数seVal()，其功能是：依次从数组a中取出一个四位数，如果该四位数连续小于该四位数以后的5个数且该数是偶数(该四位数以后不满4个数，则不统计)，则统计出满足此条件的个数count并把这些四位数按从小到大的顺序存入数组b中。最后调用写函数WData()，把结果count以及数组b中符合条件的四位数输出到OUT.dat文件中。
注意：部分程序已经给出。程序中已定义数组a[200]、b[200]，已定义变量count。请勿改动数据文件
【答案】
void seVal()
{ int i, j

, flag = 0;
for (i=0; i<="">
{ for (j=i+1; j<=i+5; j++)
if (a[i] < a[j])
{ flag = 1;
}
else
{ flag = 0;
break;
}
if (flag==1 && a[i]%2==0)
{ b[count] = a[i];
count++;
}
}
for (i=0; i<="">
for (j=i+1; j<="">
if (b[i] > b[j])
{ flag = b[i];
b[i] = b[j];
b[j] = flag;
}
}
　2.请补充完整RData()函数，实现从文件IN.DET中读取1000个十进制整数到数组evennum中，请编写函数Compute()分别计算出evennum中奇数的个数odd，偶数的个数even，奇数的平均值ave1，偶数的平均值ave2以及所有偶数的方差totfc的值。最后调用函数WData()，把结果输出到OUT.dat文件中。
计算方差的公式如下：
其中：N为偶数的个数，evennum[i]为偶数，ave2为偶数的平均值。
原始数据文件存放的格式是：每行存放10个数(每个数均大于0且小于等于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<="">
totfc += (result[i]-ave2)*(result[i]-ave2)/even;
}
33.下列程序的功能是：将一个正整数序列{K1，K2，…，K9}重新排列成一个新的序列。新序列中，比K1小的数都在K1的前面(左面)，比K1大的数都在K1的后面(右面)，要求编写函数NumSort()实现此功能。最后调用Wdata()函数将新序列输出到OUT.dat文件中。
说明：在程序中已给出了10个序列，每个序列有9个正整数，并存入数组a[10][9]中，分别求出这10个新序列。
例如：序列{6，8，9，1，2，5，4，7，3}
经重排后成为{3，4，5，2，1，6，8，9，7}
【答案】
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] < value)
{ num = a[i][j];
for (k=j; k>0; k--)
a[i][k] = a[i][k-1];
a[i][0] = num;
}
}
}
　2.函数RData()实现从文件IN.dat中读取一篇英文文章，存入字符串数组str中，请编写函数encryptChar()，其功能是：按给定的替代关系对数组str中的所有字符进行替代后，仍存入数组str的对应位置上。最后调用函数WData()，把结果str输出到OUT.dat文件中。
替代关系：f(p)=p*11mod 256(p是数组中某一个字符的ASCII值，f(p)是计算后新字符的ASCII值)，如果计算后f(p)值小于等于32或f(p)对应的字符是数字0~9，则该字符不变，否则将f(p)所对应的字符进行替代。
原始数据文件存放的格式是：每行

的宽度均小于80个字符。
【答案】
void encryptChar()
{ int i;
char *pf;
for (i=0; i<="">
{ pf = str[i];
while (*pf != 0)
{ if ((*pf*11%6>='0' && *pf*11%6<='9') || *pf*11%6<=32)
{ pf++;
continue;
}
*pf = *pf*11%6;
pf++;
}
}
}
3.函数RData()实现从文件IN.dat中读取一篇英文文章，存入字符串数组str中，请编写函数encryptChar()，其功能是：按给定的替代关系对数组str中的所有字符进行替代后，仍存入数组str的对应位置上。最后调用函数WData()，把结果str输出到OUT.dat文件中。
替代关系：f(p)=p*11mod 256(p是数组中某一个字符的ASCII值，f(p)是计算后新字符的ASCII值)，如果计算后f(p)值小于等于32或f(p)对应的字符是数字0~9，则该字符不变，否则将f(p)所对应的字符进行替代。
原始数据文件存放的格式是：每行的宽度均小于80个字符。
【答案】
void encryptChar()
{ int i;
char *pf;
for (i=0; i<="">
{ pf = str[i];
while (*pf != 0)
{ if ((*pf*11%6>='0' && *pf*11%6<='9') || *pf*11%6<=32)
{ pf++;
continue;
}
*pf = *pf*11%6;
pf++;
}
}
}
2.已知在文件IN.dat中存有若干个(少于200个)四位数字的正整数，函数RData()读取若干个正整数并存入数组original中。请编写函数CalValue()，其功能要求是：①求出这个文件中共有多少个正整数totNum;②求这些数中的各位数字之和是偶数的数的个数totCnt，以及满足此条件的这些数的算术平均值totave。最后调用函数WData()把所求的结果输出到OUT.dat文件中。
【答案】
void CalValue(void)
{ int i, thou, hun, ten, data;
int ab;
long sum = 0;
for (i=0; i<="" p="">
{ if (original[i] > 0)
totNum++;
thou = original[i]/1000;
hun = original[i] 00/100;
ten = original[i] 0/10;
data = original[i] ;
ab = thou+hun+ten+data;
if (ab%2 == 0)
{ totCnt++;
sum = sum+original[i];
}
}
totave = (double)sum/totCnt;
}
3.下列程序的功能是：计算出自然数SIX和NINE、它们满足的条件是SIX+SIX+SIX=NINE+NINE的个数cnt以及满足此条件所有的SIX与NINE的和sum，请编写函数countValue()实现程序的要求。最后调用函数WData()，把结果cnt和sum，输出到OUT.dat文件中。
其中的S、I、X、N、E各代表一个十进制数。
【答案】
void countValue()
{ int S, I, X, N, E;
int SIX, NINE;
for (S=1; S<10; S++)
for (I=0; I<10; I++)
for (X=0; X<10; X++)
for (N=1; N<10; N++)
for (E=0; E<10; E++)
{ SIX = S*100+I*10+X;
NINE = N*1000+I*100+N*10+E;
if (SIX*3 == NINE*2)
{ cnt++;
sum += SIX+

NINE;
}
}
}
2.函数RData()实现从文件IN.dat中读取20行数据存放到字符串数组str中(每行字符串长度均小于80)。请编写函数oddSort()，其功能是：以行为单位对字符串变量的下标为奇数的字符按其ASCII值从小到大的顺序进行排序，排序后的结果仍按行重新存入字符串数组str中。最后调用函数WData()，把结果str输出到OUT.dat文件中。
例如，位置 0 1 2 3 4 5 6 7
源字符串 h g f e d c b a
则处理后字符串 h a f c d e b g
【答案】
void oddSort()
{ int i, j, k, strl;
char ch;
for (i=0; i<20; i++)
{ strl = strlen(str[i]);
for (j=1; j
for (k=j+2; k
if (str[i][j] > str[i][k])
{ ch = str[i][j];
str[i][j] = str[i][k];
str[i][k] = ch;
}
}
}
3.已知数据文件IN.dat中存有200个四位数，并已调用读函数RData()把这些数存入数组a中，请编写函数evenVal()，其功能是：依次从数组a中取出一个四位数，如果该四位数连续大于该四位数以前的5个数且该数是偶数(该四位数以前不满5个数，则不统计)，则统计出满足此条件的个数count并把这些四位数按从大到小的顺序存入数组b中。最后调用写函数WData()，把结果count以及数组b中符合条件的四位数输出到OUT.dat文件中。
【答案】
void evenVal()
{ int i, j, flag = 0;
for (i=5; i<="">
{ for (j=i-5; j<="">
if (a[i] > a[j])
{ flag = 1;
}
else
{ flag = 0;
break;
}
if (flag==1 && a[i]%2==0)
{ b[count] = a[i];
count++;
}
}
for (i=0; i<="">
for (j=i+1; j<="">
if (b[i] < b[j])
{ flag = b[i];
b[i] = b[j];
b[j] = flag;
}
}
2.函数Rdata()实现从文件IN.dat中读取一篇英文文章，存入字符串数组str中。请编写函数encryptChar()，其功能是：按给定的替代关系对数组str中的所有字符进行替代后，仍存入数组str的对应位置上。最后调用函数Wdata()，把结果str输出到OUT.dat文件中。
替代关系：f(p)=p*11mod 256(p是数组中某一个字符的ASCII值，f(p)是计算后新字符的ASCII值)，如果计算后f(p)值小于等于32或f(p)对应的字符是小写字母，则该字符不变，否则将f(p)所对应的字符进行替代。
原始数据文件存放的格式是：每行的宽度均小于80个字符。
【答案】
void encryptChar()
{ int i;
char *pf;
for (i=0; i<="" p="">
{ pf = str[i];
while (*pf != 0)
{ if ((*pf*11%6>='a' && *pf*11%6<='z') || *pf*11%6<=32)
{ pf++;
continue;
}
*pf = *pf*11%6;
pf++;
}
}
}
3.已知数据文件IN.dat中存有300个四位数，并已调用读函数RData()把这些数存入

数组a中，请编写函数spellVal()，其功能是：求出千位上的数加个位上的数等于百位上的数加十位上的数的个数count，再把所有满足此条件的四位数依次存入数组b中，然后对数组b的四位数按从小到大的顺序进行排序。最后调用写函数WData()，把结果输出到OUT.dat文件中。
例如，6712，6+2=7+1，则该数满足条件存入数组b中，且个数count=count+1。8129，8+9!=1+2，则该数不满足条件，不存入数组b中，count变量也不加1。
【答案】
void spellVal()
{ int i, thou, hun, ten, data, j;
for (i=0; i<300; i++)
{ thou = a[i]/1000;
hun = a[i] 00/100;
ten = a[i] 0/10;
data = a[i] ;
if (thou+data == hun+ten)
{ b[count] = a[i];
count++;
}
}
for (i=0; i<="" p="">
for (j=i+1; j<="">
if (b[i] > b[j])
{ data = b[i];
b[i] = b[j];
b[j] = data;
}
}
2.已知数据文件IN.dat中存有200个四位数，并已调用读函数Rdata()把这些数存入数组a中，请编写函数spellNum()，其功能是：把千位数字和十位数字重新组成一个新的二位数(新二位数的十位数字是原四位数的千位数字，新二位数的个位数字是原四位数的十位数字)，以及把个位数字和百位数字组成另一个新的二位数(新二位数的十位数字是原四位数的个位数字，新二位数的个位数字是原四位数的百位数字)，如果新组成的两个二位数均是素数且新数的十位数字均不为0，则将满足此条件的四位数按从大到小的顺序存入数组b中，并要计算满足上述条件的四位数的个数count。最后main()函数调用写函数Wdata()，把结果count以及数组b中符合条件的四位数输出到OUT.dat文件中。
【答案】
void spellNum()
{ int i, thou, hun, ten, data, j;
int ab, cd;
for (i=0; i<200; i++)
{ thou = a[i]/1000;
hun = a[i] 00/100;
ten = a[i] 0/10;
data = a[i] ;
if (thou==0 || data==0)
continue;
ab = 10*thou+ten;
cd = 10*data+hun;
if (isprime(ab) && isprime(cd))
{ b[count] = a[i];
count++;
}
}
for (i=0; i
for (j=i+1; j
if (b[i] < b[j])
{ data = b[i];
b[i] = b[j];
b[j] = data;
}
}
3.设有n个人围坐一圈并按顺时针方向从1到n编号，从第s个人开始进行1到m的报数，报数到第m个人，此人出圈，再从他的下一个人重新开始1到m的报数，如此进行下去直到所有的人都出圈为止。现要求按出圈次序，每10人一组，给出这n个人的顺序表。请编写函数Josegh()实现此功能，并调用函数WriteDat()，把结果p输出到OUT.dat文件中。
设n=100，s=1，m=10。
①将1到n个人的序号存入一维数组p中;②若第i个人报数后出

圈，则将p[i]置于数组的倒数第i个位置上，而原来第i+1个至倒数第i个元素依次向前移动一个位置;③重复第②步直至圈中只剩下p[1]为止。
【答案】
void Josegh(void)
{ int i, j, s1, w;
s1 = s;
for (i=1; i<=n; i++)
p[i-1] = i;
for (i=n; i>=2; i--)
{ s1 = (s1+m-1)%i;
if (s1 == 0)
s1 = i;
w = p[s1-1];
for (j=s1; j<=i-1; j++)
p[j-1] = p[j];
p[i-1] = w;
}
}
2.已知数据文件IN.dat中存有300个四位数，并已调用读函数Rdata()把这些数存入数组a中，请编写函数diffNum()，其功能是：求出千位数上的数减百位数上的数减十位数上的数减个位数上的数大于0的个数count，再把所有满足此条件的四位数依次存入数组b中，然后对数组b的四位数按从小到大的顺序进行排序。最后调用写函数Wdata()，把结果输出到OUT.dat文件中。
例如，9123，9-1-2-3>0，则该数满足条件存入数组b中，满足条件count加1。9812，9-8-1-2<0，则该数不满足条件，count不变。
【答案】
void diffNum()
{ int i, thou, hun, ten, data, j;
for (i=0; i<300; i++)
{ thou = a[i]/1000;
hun = a[i] 00/100;
ten = a[i] 0/10;
data = a[i] ;
if (thou-hun-ten-data > 0)
{ b[count] = a[i];
count++;
}
}
for (i=0; i<="" p="">
for (j=i+1; j<="">
if (b[i] > b[j])
{ data = b[i];
b[i] = b[j];
b[j] = data;
}
}
　3.已知数据文件IN.dat中存有200个四位数，并已调用读函数Rdata()把这些数存入数组a中，请编写函数spellNum()，其功能是：把千位数字和十位数字重新组成一个新的二位数ab(新二位数的十位数字是原四位数的千位数字，新二位数的个位数字是原四位数的十位数字)，以及把个位数字和百位数字组成另一个新的二位数cd(新二位数的十位数字是原四位数的个位数字，新二位数的个位数字是原四位数的百位数字)，如果ab
【答案】
void spellNum()
{ int i, thou, hun, ten, data, j;
int ab, cd;

for (i=0; i<200; i++)
{ thou = a[i]/1000;
hun = a[i] 00/100;
ten = a[i] 0/10;
data = a[i] ;
if (thou==0 || data==0)
continue;
ab = 10*thou+ten;
cd = 10*data+hun;
if (ab
{ b[count] = a[i];
count++;
}
}
for (i=0; i<="" p="">
for (j=i+1; j<="">
if (b[i] < b[j])
{ data = b[i];
b[i] = b[j];
b[j] = data;
}
}
1.在文件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<="" p="">
for (j=i+1; j<="">
if (bb[i].x2+bb[i].x3 < bb[j].x2+bb[j].x3)
{ ch = bb[i];
bb[i] = bb[j];
bb[j] = ch;
}
return cnt;
}
2.已知数据文件IN.dat中存有200个四位数，并已调用读函数rData()把这些数存入数组a中，请编写函数CalVal()，其功能是：把一个四位数的千位数字上的值加上十位数字上的值恰好等于百位数字上的值加上个位数字上的值，并且原四位数是偶数，则统计出满足此条件的四位数的个数count，并把这些四位数按从小到大的顺序存入数组b中。最后调用写函数wData()，把结果count以及数组b中符合条件的四位数输出到OUT.dat文件中。
【答案】
void CalVal()
{ int i, thou, hun, ten, data, j;
for (i=0; i<="" p="">
{ thou = a[i]/1000;
hun = a[i] 00/100;
ten = a[i] 0/10;
data = a[i] ;
if ((thou+ten==hun+data) && a[i]%2!=1)
{ b[count] = a[i];
count++;
}
}
for (i=0; i<="" p="">
for (j=i+1; j<="">
if (b[i] > b[j])
{ data = b[i];
b[i] = b[j];
b[j] = data;
}
}
3.已知在文件IN.dat中存有100个产品销售记录，每个产品销售记录由产品代码code(字符型4位)、产品名称name(字符型10位)、单价uprice(整型)、数量amount(整型)、金额sum(长整型)5部分组成。其中：金额=单价×数量。函数ReadDat()是读取这100个销售记录并存入结构数组sell中。请编写函数SortDat()，其功能要求：按金额从小到大进行排列，若金额

相同，则按产品代码从大到小进行排列，最终排列结果仍存入结构数组sell中。最后调用函数WriteDat()，把结果输出到OUT.dat文件中。
注
【答案】
void SortDat()
{ int i, j;
PRO temp;
for (i=0; i<99; i++)
for (j=i+1; j<100; j++)
if (sell[i].sum > sell[j].sum)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
else if (sell[i].sum == sell[j].sum)
{ if (strcmp(sell[i].code, sell[j].code) < 0)
{ temp = sell[i];
sell[i] = sell[j];
sell[j] = temp;
}
}
}
1.已知在文件IN.dat中存有若干个(不多于200个)四位数字的正整数，函数ReadDat()读取这若干个正整数并存入数组number中。请编写函数CalValue()，其功能要求是：①求出文件中所有的正整数个数totNum;②求这些数中的各位数字之和是奇数的个数totCnt，以及满足此条件的这些数的算术平均值totave。最后调用函数writeDat()把所求的结果输出到OUT.dat文件中。
【答案】
void CalValue(void)
{ int i, thou, hun, ten, data;
for (i=0; i<="" p="">
{ if (!number[i])
break;
if (number[i] > 0)
totNum++;
thou = number[i]/1000;
hun = number[i] 00/100;
ten = number[i] 0/10;
data = number[i] ;
if ((thou+hun+ten+data)%2)
{ totCnt++;
totave += number[i];
}
}
totave /= totCnt;
}
2.下列程序的功能是：计算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<="">
if (i%j == 0)
break;
if (j >= half)
{ yy[count] = i;
count++;
}
}
for (i=0, j=1; i<="" p="">
{ sum += j*yy[i];
j = j*-1;
}
}
3.下列程序的功能是：选出5000以下符合条件的自然数。条件是：千位数字与百位数字之和等于十位数字与个位数字之和，且千位数字与百位数字之和等于个位数字与千位数字之差的10倍。计算并输出这些四位自然数的个数count以及这些数的和sum。请编写函数calValue()实现程序的要求，最后调用函数writeDat()，把结果count和sum输出到OUT.dat文件中。
【答案】
void calValue()
{ int i, thou, hun, ten, data;
for (i=5000; i>=1000; i--)
{ thou = i/1000;
hun = i 00/100;
ten = i 0/10;
data = i ;
if (thou+hun==ten+data && thou+hun==(data-thou)*10)

{ count++;
sum += i;
}
}
}
　1.已知数据文件IN.dat中存有200个四位数，并已调用读函数readDat()把这些数存入数组a中，请编写函数primecount()，其功能是：如果四位数各个位上的数字均是奇数，则统计出满足此条件的个数count并把这些四位数按从大到小的顺序存入数组b中。最后main()函数调用写函数writeDat()，把结果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] 00/100;
ten = a[i] 0/10;
data = a[i] ;
if (thou%2!=0 && hun%2!=0 && ten%2!=0 && data%2!=0)
{ b[count] = a[i];
count++;
}
}
for (i=0; i<="" p="">
for (j=i+1; j<="">
if (b[i] < b[j])
{ data = b[i];
b[i] = b[j];
b[j] = data;
}
}
2.函数RData()实现从文件IN.dat中读取一篇英文文章，存入到字符串数组original中;请编写函数encryptChar()，其功能是：按给定的替代关系对数组original中的所有字符进行替代后，仍存入数组original的对应的位置上。最后调用函数WData()，把结果original输出到OUT.dat文件中。
替代关系：f(p)=p*11 mod 256(p是数组中某一个字符的ASCII值，f(p)是计算后新字符的ASCII值)，如果原字符的ASCII值是偶数或计算后f(p)值小于等于32，则该字符不变，否则将f(p)所对应的字符进行替代。
原始数据文件存放的格式是：每行的宽度均小于80个字符。
【答案】
void encryptChar()
{ int i;
char *pf;
for (i=0; i<="" p="">
{ pf = original[i];
while (*pf != 0)
{ if (*pf%2 && *pf*11%6>32)
*pf = *pf*11%6;
pf++;
}
}
}
3.已知数据文件IN.dat中存有200个四位数，并已调用读函数readDat()把这些数存入数组a中，请编写函数diffVal()，其功能是：把一个四位数的千位数字上的值，减去百位数字上的值，再减去十位数字上的值，最后减去个位数字上的值，如果得出的值大于等于0且原四位数是奇数，则统计出满足此条件的个数count并把这些四位数按从小到大的顺序存入数组b中。最后调用写函数writeDat()，把结果count以及数组b中符合条件的四位数输出到OUT.dat文件中。
【答案】
void diffVal()
{ int i, thou, hun, ten, data, j;
for (i=0; i<="" p="">
{ thou = a[i]/1000;
hun = a[i] 00/100;
ten = a[i] 0/10;
data = a[i] ;
if ((thou-hun-ten-data>=0) && a[i]%2==1)
{ b[count] = a[i];
count++;
}
}
for (i=0; i<="" p="">
for (j=i+1; j<="">
if (b[i] > b[j])
{ data = b[i];
b[i] = b[j];
b[j] = data;
}