1、 编一个函数fun(char *s),函数的功能是把字符串中的内容逆置：
例如：字符串中原有的内容为：abcdefg，则调用该函数后，串中的内容为：gfedcba
试题程序：
#include <string.h>
#include <conio.h>
#include <stdio.h>
#define N 81
/*注：该题的算法是先分别找出字符串的两头，然后同时逐一往中间移动，每移动一次都进行两字符的位置对换，直到中间字符（s+i<s+n-1-i来控制）：由于s+i中一个地址，因此要注意把它的内容取出再进行换位：即先进行取内容运算* */
fun(char *s)
{ int i=0,t,n=strlen(s);
for(;s+i<s+n-1-i;i++)
{t=*(s+i);*(s+i)=*(s+n-1-i);*(s+n-1-i)=t;}
}
main()
{ char a[N];
clrscr();
printf("Enter a string:"); gets(a);
printf("The original string is:");puts(a);
fun(a);
printf("/n");
printf("The string after modified:");
puts(a);
}
2、 写程序，实现矩阵（3行3列）的转置（即行列互换）：
试题程序：
#include <stdio.h>
#include <conio.h>
/*这题的关键在于进行行列下标转换的算法，由矩阵的对称性我们不难看出在进行行列互换时a[j]在好是与a[j][i]互换，因而只要我位让程序走完矩阵的左上角即可（用for(i=0;i<2;i++)再套for(j=i+1;j<3;j++)来完成左上角的走动：*/
int fun(int array[3][3])
{ int i,j,t;
for(i=0;i<2;i++)
for(j=i+1;j<3;j++)
{t=array[i][j];array[i][j]=array[j][i];array[j][i]=t;}
}
main()
{ int i,j;
int array[3][3]={{100,200,300},{400,500,600},{700,800,900}};
clrscr();
for(i=0;i<3;i++)
{for(j=0;j<3;j++)
printf("%7d",array[i][j]);
printf("/n");}
fun(array);
printf("Converted array:/n");
for(i=0;i<3;i++)
{for(j=0;j<3;j++)
printf("%7d",array[i][j]);
printf("/n");
}}
3、 请编一个函数fun(int *a,int n,int *odd,int *even)，函数的功能是分别求出数组中所有奇数之和以及所有偶数之和：形参n给了数组中数据的个数：利用指针odd返回奇数之和，利用指针even返回偶娄这和：
例如：数组中的值依次为：1，8，2，3，11，6；则利用指针odd返回奇数之和24；利用指针even返回偶数之和8：
试题程序：
#include <stdio.h>
#include <conio.h>
#define N 20
/*注：该题的算法是：用for()循环一步一步地找元素，用if(!a[i]%2)来判断是否是奇数，%运算是求余运算，当对2求余为1时表示原数为奇数，否则为偶数：*/
fun(int *a,int n,int *odd,int *even)
{ int i; *even=0;*odd=0;
for(i=0;i<n;i++)
if(!(a[i]%2))
*even+=a[i]; else*odd+=a[i];
}
main()
{ int a[N]={1,9,2,3,11,6},i,n=6,odd,even;
clrscr();
printf("The original data is:/n");
for(i=0;i<n;i++) printf("%5d",*(a+i));
printf("/n/n");
fun(a,n,&odd,&even);
printf("The sum of odd numbers:%d/n",odd);
printf("The sum of even number:%d/n",even);
}
4、 要求程序的功能是：把20个随机数存入一个数组，然后输出该数组中的最小值：其中确定最小值的下标的操作在fun函数中实现，请给出该函数的定义：
试题程序：
#include <stdio.h>
#include <conio.h>
#define VSIZE 20
int vector[VSIZE];
/*注：该题的算法是用一个变量（j)来存储最小值元素的下标，在循环过程中让每个元素都与原最小值元素进行大小比较(if(list[i]<list[j])，如发现更小的则让j重新拥有最小值元素的下标（j=i)：*/
int fun(int list[],int size)
{ int i,j=0;
for(i=1;i<size;i++)
if(list[i]<list[j])
j=i;
return j;
}main()
{
int i;
clrscr();
for(i=0;i<VSIZE;i++)
{
vector[i]=rand();
printf("Vector[%d]=%6d/n",i,vector[i]);
}
i=fun(vector,VSIZE);
printf("/nMininum:vector[%d]=%6d/n",i,vector[i]);}
5、 请编一个函数float fun(double h)，函数的功能是对变量h中的值保留2位小数，并对第三位进行四舍五入（规定h中的值为正数）：
例如：h值为8.32433，则函数返回8.32；h值为8.32533，则函数返回8.33：
试题程序：
#include <stdio.h>
#include <conio.h>
/*注：h乘以1000后正好是原小数点后第三位做了新数的个位数，然后再进行加5运算时：如原小数点后第三位为4及以下则加5后还是不能进一位（即四舍），如是5及以上则加5后该位就要向前进一位数（即五入）：进行加5运算后除10再赋给一个整型变量此时就只有原小数点第二位及以前各位保留在整型变量中，最后再对整型变量除100，这样又出现了两位小数：该题中，进行四舍五入后一定要赋给一个整型变量才能将不用部分彻底变成0 ：*/
float fun(float h)
{ long t;
h=h*1000;
t=(h+5)/10;
return (float)t/100;
}
main(){
float a;clrscr();scanf("%f",&a);
printf("The result :%6.2f/n",fun(a));}
6、 编写函数fun，函数的功能是：从字符串中删除指定的字符：同一字母的大、小写按不同字符处理：若程序执行时，输入字符串为：turbo c and Borland c++从键盘上输入字符：n，则输出后变为：turbo c ad borlad c++如果输入的字符串不存在，则字符串照原样输出：
试题程序：
#include <stdio.h>
#include <conio.h>
/*注：该题的算法是让i控制一个一个字符往后走，在移动过程中如果s[i]不是要删的字符，则将其按顺序放到新串中（新串亦是用s来做，只是用k来控制新串的下标，由于要删除一些元素，因此新串的下标总是比原下标i要慢：因而可用此法即同一字符串变量的方法：*/
int fun(char s[],int c)
{int i,k=0;
for(i=0;s[i];i++)
if(s[i]!=c) s[k++]=s[i];
s[k]='/0';
}
main()
{ static char str[]="turbo c and borland c++";
char ch;
clrscr();
printf(" :%s/n",str);
printf(" :");
scanf("%c",&ch);
fun(str,ch);
printf("str[]=%s/n",str);
}
7、 请编写一个unsigned fun(unsigned w)，w是一个大于10的无符号整数，若w是n（n>=2）位的整数，函数求出w的后n-1位的数作为函数值返回：例如：w值为5923，则函数返回923；w值为923则函数返回23：
试题程序：
#include <conio.h>
#include <stdio.h>
/* 注：由于unsigned型整数在0-65535这间，只要它大于10000则对10000求余即得出后面4位，否则如果大于1000则对1000求余得出后3位数，这样一层一层往小的判断：由于return的作用除了返回值以外，还有当执行到return时就跳出该程序，所以可以连续的if()语句： */
unsigned fun( unsigned w )
{ if(w>=10000) return w%10000;
if(w>=1000) return w%1000;
if(w>=100) return w%100;
return w%10;
}
main()
{ unsigned x;
printf( "enter a unsigned integer number :" );
scanf( "%u",&x);
if(x<10) printf("data error!");
else printf ("the result :%u/n", fun(x));
}
8、 编写函数int fun(int lim,int aa[MAX])，该函数的功能是求出小于lim的所有素数并放在aa数组中，该函数返回所求出素数的个数：
试题程序：
#include <stdio.h>
#include <conio.h>
#define MAX 100
/*注：循环for(i=2;i<k;i++)用于判断k是否为素数，原理是当用2到k-1这间的数去对k求余，如余数为0（即被整除）则表示k不是一个素数：语句if(i>=k)用于判断在上一个for()循环中i能否走到k，如果能则表示在2到k-1的数都不能整除k，即k为素数*/
int fun( int lim, int aa[MAX])
{ int i,j=0,k;
for( k=2; k<lim; k++)
{ for( i=2; i<k; i++)
if( !(k%i)) break;
if( i>=k) aa[j++]=k;
}
return j;
}
main()
{ int limit,i,sum;
int aa[MAX];
printf("/n input a integer number:");
scanf(" %d",&limit);
sum=fun(limit,aa);
for(i=0; i<sum; i++)
{ if(i%10==0&&i!=0)
printf("/n");
printf("%5d", aa[i]);
}
}
9、 请编写函数fun，函数的功能是求出二维数组周边元素之和，作为函数值返回：二维
数组中的值在主函数中赋予：
例如：二维数组中的值为
则函数值为61：
试题程序：
#include <conio.h>
#include <stdio.h>
#define M 4
#define N 5
/*注：该题的第一个for()循环是计算矩阵的最上一行和最下一行的总和，第二个for()
是计算除两头元素以外的最左一列和最右一列的元素的和，最后sun就是周边元素的和：
*/
int fun(int a[M][N])
{int sum=0,i;
for(i=0;i<N;i++)
sum+=a[0][i]+a[M-1][i];
for(i=1;i<M-1;i++);
sum+=a[i][0]+a[i][N-1];
return sum ;
}
main()
{ int aa[M][N]={{1,3,5,7,9},
{2,9,9,9,4},
{6,9,9,9,8},
{1,3,5,7,0}};
int i,j,y;
clrscr();
printf("The original data is :/n");
for(i=0;i<M;i++)
{for(j=0;j<N;j++) printf("%6d",aa[i][j]);
printf("/n");
}
y=fun(aa);
printf("/nThe sum: %d/n",y);
printf("/n");
}
10、 请编写函数fun，对长度为7个字符的字符串，除首、尾字符外，将其余5个字符按
降序排列：例如，原来的字符串为CEAedca，排序后输出为CedcEAa：
试题程序：
#include <string.h>
#include <conio.h>
#include <stdio.h>
/*该题采用的排序法是选择法进行降序排序，算法是用外for()循环从字符串的前端往后
端走动，每走动一个字符都用内嵌的for(）循环在该字符后找出最小的字符与该字符进
行换位：直到外for()循环走到最后一个字符：此外，此题还要注意把首尾字符除开，即
在最外层for()循环中从1开始，只到num-2即可：*/
int fun(char *s,int num)
{ int i,j,t;
for(i=1;i<num-2;i++)
for(j=i+1;j<num-1;j++)
if(s[i]<s[j])
{ t=s[i];
s[i]=s[j];
s[j]=t;
}
}
main()
{ char s[10];
clrscr();
printf("输入7个字符的字符串:");
gets(s);
fun(s,7);
printf("/n%s",s);
}
11、 请编一函数void fun(int tt[M][N],int pp[N])，tt指向一个M行N列的二维数组，
求出二维数组每列中最小元素，并依次放入pp所指一维数组中，二维数组中的数已在主
函数中赋予：
试题程序：
#include "conio.h"
#include "stdio.h"
#define M 3
#define N 4
/*注：该题用for(i=0;i<N;i++)来控制一列一列地找，而内嵌循环for(j=0;j<M;
j++)用于控制同列内元素的比较：多重循环的嵌套总是最里层循环变化最快，即外层循
环改变一个值，内层循环就要循环完一次，对于多重循环一定要好好去体会和理解，在
多数题目中都要用到多重循环（一般为二重）：*/
void fun(int tt[M][N],int pp[N])
{ int i, j;
for(i=0;i<N;i++)
{ pp=tt[0][i];
for(j=0;j<M;j++)
if(tt[j][i]<pp[i]) pp[i]=tt[j][i];
}
}
main()
{ int t[M][N]={ {22,45,56,30},
{19,33,45,38},
{20,22,66,40}};
int p[N],i,j,k;
clrscr();
printf("the original data is:/n");
for(i=0;i<M;i++)
{for(j=0;j<N;j++)
printf("%6d",t[i][j]);
printf("/n");
}
fun(t,p);
printf("/nthe result is:/n");
for(k=0;k<N;k++)
printf("%4d",p[k]);
printf("/n");
}
12、 写一个函数，从传入的num个字符串中找出最长的一个字符串，并通过形参指针max
传回该串地址：（注意：用****作为结束输入的标志：）
试题程序：
#include "stdio.h"
#include "string.h"
#include "conio.h"
/* 函数strlen()用于求出字符串的长度，这个题中主要是*max=p;不能换成max=&p
；如果用maz=&p;则只改变了max的指向，它不能传回给实参：因此我们要改变max指
向地址中的内容，这才能使得实参ps有正确的值：*/
fun(char (*a)[81], int num,char **max)
{ char *p=a[0];int i;
for(i=1;i<num;i++)
if(strlen(a[i])>strlen(p))
p=a[i];
*max=p;
}
main()
{ char ss[10][81],*ps;
int n,i=0;
clrscr();
printf("enter string:/n");
gets(ss[i]);
puts(ss[i]);
while(!strcmp(ss[i],"****")==0)
{
i++;
gets(ss[i]);
puts(ss[i]);
}
n=i;
fun(ss,n,&ps);
printf("/nmax=%s/n",ps);
}
13、 请编一个函数fun，其中n所指存储单元中存放了数组中元素的个数：函数的功能是
：删除所有值为y的元素：数组元素中的值和y的值由主函数通过健盘读入：
试题程序：
#include <conio.h>
#include <stdio.h>
#define M 20
/*注：该题的算法是，用for()循环控制元素逐一判断数组元素是否等于y，若不等则赋
给新数bb，由于删除的关系j总是小于或等于i，故而可用bb作为新数组，与第6题相似：
还要注意*n=j；如果没有这个语句则不能传回新数组的个数，另外也不能换成n=&j
;这点是用指针时常犯的错误，切记！*/
void fun (int bb[], int *n,int y)
{ int i，j=0;
for( i=0; i<*n; i++)
if(bb[i]!=y) bb[j++]=bb[i];
*n=j;
}
main()
{ int aa[M],n,y,k;
printf("/nplease enter n:");
scanf("%d",&n);
printf("/nenter %d positive number:/n", n);
for( k=0; k<n; k++) scanf( "%d",&aa[k]);
printf("the original data is: /n");
for( k=0; k<n; k++) printf(" %5d", aa[k]);
printf(" /nenter a number to deleted:");
scanf("%d",&y);
fun(aa,&n,y);
printf("the data after deleted %d:/n", y);
for(k=0; k<n; k++) printf("%4d",aa[k]);
printf("/n");
}
4、 编写一个函数，该函数可以统计一个长度为2的字符串在另一个字符串中出现的次数
：例如，假定输入的字符串为：asd asasdfg asd as zx67 asd mklo，子字符串为：as
，则应输出6：
试题程序：
#include "stdio.h"
#include "string.h"
#include "conio.h"
/*注：由于小串中只有2个字符所以可用str[i]==sbustr[0]&&str[i+1]==subs
tr[1]来判断小串是否与长串当前位置（str[i]）相同（即出现一次）：因而只要让长串
当前位置逐一向后移即可（用for()循环来完成）：*/
int fun(char *str,char *substr)
{ int i,n=0,s=strlen(str);
for(i=0;i<s;i++)
if((str[i]==substr[0])&&(str[i+1]==substr[1]))
n++;
return n;
}
main()
{
char str[81],substr[3];
int n; clrscr();
printf("enter 1:");
gets(str);
printf("enter 2:");
gets(substr);
puts (str);
puts(substr);
n=fun(str,substr);
printf("n=%d/n",n);
}
5、 请编写一个函数int fun(int x)，它的功能是：判断整数x是否是同构数：若是同构
数，函数返回1；否则返回0：
所谓“同构数”是指这样的数，它出现在它的平方数的右边：
例如：输入整数5，5的平方数是25，5是25中右侧的数，所以5是同构数：
x的值由主函数从健盘读入，要求不大于100：
试题程序：
#include "conio.h"
#include "stdio.h"
/*注：由“同构数”的定义可得只要求出平方数或平方数的最后一位或平方数的最后两
位然后与x进行判断即可，分别求余后即得出平方数的右边：*/
int fun (int x)
{ int xx=x * x;
if(xx==x//xx%10==x//xx%100==x) return 1;
else return 0;
}
main()
{ int x,y;
clrscr();
printf("/n please enter a integer numbers: ");
scanf("%d",&x);
if(x>100){printf("data eror!/n");exit(0);}
y=fun(x);
if(y) printf("%d yes/n",x);
else printf ("%d no!/n",x);
}
16、 请编写函数fun，函数的功能是：在字符串中所有数字字符前加一个$字符：
例如，输入：A1B23CD45，则输出为：A$1B$2$3CD$4$5：
注意：部分源程序给出如下：
#include <stdio.h>
/*注：该题用while()循环来控制原字符串从头走到尾，在走动过程中判断是当前字符是
否是数字，若是则在新串中先连一个'$'然后再连原字符，否则直接连原字符：一定要
注意指针和下标的变化：最后要把新串拷贝到s所指的地址中，注意不能用s=a；若用了
，则实参数组还是原字符串：*/
void fun( char *s)
{char a[100];
int i=0;
while(*s)
if(*s>='0'&&*s<='9') {a[i++]='$';a[i++]=*s++;}
else a[i++]=*s++;
a='/0';
strcpy(s,a);
}
main()
{ char s[80];
printf("enter a string:");
scanf("%s", s);
fun(s);
printf("the result: %s/n", s);
}
17、 请编一个函数fun(char *s)，函数的功能是把字符串中所有的字符前移一个位置，串中的第一个字符移到最后：例如：原有的字符串为：Mn.123xyZ，则调用该函数后，串中的内容为：n.123xyZM：
试题程序：
#include "conio.h"
#include "stdio.h"
#define N 81
/* 注：该题要先将字符串的头元素存到某一变量（用c=*s)中，然后后面的字符依向前移（用for()循环），要记得在串的未尾加一个结束符：*/
fun(char *s)
{ char c=*s;
for(;*(s+1);s++)
*s=*(s+1);
*s=c;
*(s+1)='/0';
}
main()
{ char a[N];
clrscr();
printf("enter a string:");
gets(a);
printf("the original string is:");
puts(a);
fun(a);
printf("the string after modified:");
puts(a);
}
18、 请编写函数fun，函数的功能是：将所有大于1小于整数m的非素数存入xx所指数组中，非素数的个数通过k传回：例如，若输入：17，则应输出：9和4 6 8 9 10 12 14 15 16：
试题程序：
#include <conio.h>
#include <stdio.h>
/* 注：内嵌的for()循环用于判断是否是素数，在j<i的情况下，只要j对i求余，余数为0则表示i不是素数，则将i存入xx数组中：break;语句只是让它提前结束循环：不用亦可：*/
void fun( int m, int *k, int xx[] )
{ int i,j;
*k=0;
for( i=2; i<m; i++)
for( j=2; j<i; j++)
if( i%j==0)
{ xx[(*k)++]=i; break;}
}
main()
{ int m, n,zz[100];
printf("/n please enter an integer number between 10 and 100: "
);
scanf( "%d",&n);
fun(n,&m,zz);
printf("/n/n there are %d non-prime numbers less than %d: ", m,
n);
for(n=0; n<m; n++)
printf("/n %4d",zz[n]);
}
19、 请编一个函数fun(char *s)，函数的功能是把字符串中所有的字母改写成该字母的下一个字母，最后一个字母z改写成字母a：大写字母仍为大写字母，小写字母仍为小写字母，其他的字符不变：
例如：原有的字符串为：Mn.123zyZ，则调用该函数后，串中的内容为：No.123yzA：
试题程序：
#include "conio.h"
#include "string.h"
#include "stdio.h"
#include "ctype.h"
#define N 81
/* 该题的思路较为明显，用for()循环一个字符一个字符地走动，移动过程中判断是否在a到y之间，若是则加1（即下移一个字母），若是z则换成对应的a */
fun(char *s)
{ int i,n=strlen(s);
for(i=0;i<n;i++)
{ if((s[i]>='A'&&s[i]<'Z')//(s[i]>='a'&&s[i]&
lt;'z'))
s[i]=s[i]+1;
else if(s[i]=='z') s[i]='a';
else if(s[i]=='Z') s[i]='A';
}
}
main()
{ char a[N];
clrscr();
printf("enter a string:");gets(a);
printf("the original string is:");puts(a);
fun(a);
printf("the string after modified:");
puts(a);
}
20、 请编写函数fun，函数的功能是：将s所指字符串中、下标为奇数位置上的大写字母转换为字母序列中的下一个小写字母；若该位置上是小写字母，则不转换；若该位置上是大写字母Z，则仅转换成小写字母z：
例如，输入：ABCdxZZZ，则输出为：AcCdXzZz：
试题程序：
#include "stdio.h"
#define N 80
/* 该题的算法与上一题相似，注意同一个字母小写要比大写在ASCII值上大32：*/
void fun(char *s)
{
int i;
for(i=1;i<N;i=i+2)
if (s[i]>='A'&&s[i]<'Z')
s[i]+=32+1;
else if(s[i]=='Z') s[i]+=32;
}
main()
{
char s[N];
printf("/nenter a string:");scanf("%s",s);
fun(s);
printf("/nthe result:%s/n",s);
}
21、 程序定义了N*N的二维数组，并在主函数中赋值：请编写函数fun，函数的功能是：给数组周边元素置0值：
部分源程序给出如下：
试题程序：
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define N 5
/* 由于是赋值0，因而只要能表示出周边元素即好办，它与求和不同在于求和不能重复
对某个元素进行运算，而赋值则可重复赋值：所以这里只用了一个for()循环来找出所有
的周边元素：*/
fun(int w[][N])
{ int i ;
for(i=0;i<N;i++)
{ w[i][0]=0;
w[i][N-1]=0;
w[0][i]=0;
w[N-1][i]=0;}}
22、 请编写函数fun，它的功能是：求出ss所指字符串中、指定字符的个数，并返回此值：
例如：若输入字符串：123412132，输入字符为：1，则输出：3：
试题程序：
#include<conio.h>
#include<stdio.h>
#define M 81
/* 注：本题用while()循环来控制字符的移动，每移动一个字符都要进行判断（if(*ss==c)）是否为指定的字母，若是则个数加1：这里要注意如何让ss指针向下走动（ss++）：*/
int fun(char *ss,char c)
{int num=0;
while(*ss!='/0')
{if(*ss==c) num++;
ss++;}
return(num);}
main()
{char a[M],ch;clrscr();
printf("/nPlease enter a strint:");gets(a);
printf("/nPlease enter a char:");ch=getchar();
printf("/nThe number of the char is:%d/n",fun(a,ch));}
23、 程序定义了N*N的二维数组，并在主函数中赋值：请编写函数fun，函数的功能是：求出数组周边元素的平均值并作为函数值返回给主函数中的s：
试题程序：
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define N 5
/* 注意不能重复计算，它与题21不同，第一个for()循环求出第一列与最后一列的和，
第二个for()循环求出第一行与最后一行（已除去两头元素），要注意第二个for(）中起
始为1，最后为N-2：*/
double fun (int w[][N])
{ int i,t=0;
double s=0;
for(i=0;i<N;i++)
{s+=w[i][0]+w[i][N-1]; t+=2;}
for(i=1;i<N-1;i++)
{s+=w[0][i]+w[N-1][i]; t+=2;}
s=s/t;
return s;}
main()
{ int a[N][N]={0,1,2,7,9,1,9,7,4,5,2,3,8,3,1,4,5,6,8,2,5,9,1,4,1};
int i,j;
double s;
clrscr();
printf("***** The array *****/n");
for(i=0;i<N;i++)
{for(j=0;j<N;j++)
printf("%4d",a[i][j]);
printf("/n");
}
s=fun(a);
printf("***** The result *****/n");
printf("The sum is %lf/n",s);
}
24、 编写一个函数fun，它的功能是：实现两个字符串的连接（不使用库函数strcat）
例如，分别输入下面两个字符串：FirstSrting—、SecondString程序输出：FirstString—SecondString
试题程序：
#include<stdio.h>
#include<conio.h>
/* 注：第一个for()循环用于让i成为第一个字符串的结束符的下标，要注意在这个for()后要有一个分号否则出错：第二个for()的作用是将第二个字符串一个一个字符依次放到第一个字符串的未尾：此外，还要注意最后一定要有p1[i]='/0'；来给字符串加上结束符：*/
void fun(char p1[],char p2[])
{int i,j;
for(i=0;p1[i];i++);
for(j=0;p2[j];j++)
p1[i++]=p2[j];
p1[i]='/0';
}
main()
{ char s1[80],s2[80];
clrscr();
printf("Enter s1 and s2:/n");
scanf("%s%s",s1,s2);
printf("s1=%s/n",s1);
printf("s2=%s/n",s2);
printf("Invoke fun(s1,s2):/n");
fun(s1,s2);
printf("After invoking:/n");
printf("%s/n",s1);
}
25、 程序定义了N*N的二维数组，并在主函数中自动赋值：请编写函数fun(int a[][N]
)，函数的功能是：使数组第一列元素中的值与最后一列元素中的值对调、第二列元素的
值与倒数第二列中的值对调、……、其他依次类推：
例如：a数组中的值为
则返回主程序后a数组中的值应为
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
#define N 5
/* 本题的第一个for()循环用于控制行，而内嵌的for()用于在同一行中将列与列对调，
当i为0时a[m][i]为第m行的第一列元素，a[m][N-1-i]为第m行的最后一列的元素，正好
符合调换的要求：依次类推：*/
int fun(int a[][N])
{ int i ,m,t;
for(m=0;m<N;m++)
for(i=0;i<N/2;i++)
{t=a[m][i];
a[m][i]=a[m][N-1-i];
a[m][N-1-i]=t;
}
}
main()
{ int a[N][N],i,j;
clrscr();
printf("***** The array *****/n");
for(i=0;i<N;i++)
{for(j=0;j<N;j++)
{a[i][j]=rand()%30;printf("%4d",a[i][j]);}
printf("/n");
}
fun(a);
printf("***** The result *****/n");
for(i=0;i<N;i++)
{for(j=0;j<N;j++)
printf("%4d",a[i][j]);
printf("/n");
}
}
26、 请编写函数fun，函数的功能是：实现B=A+A’，即把矩阵A加上A的转置，存放在矩
阵B中：计算结果在main函数中输出：
例如：输入下面的矩阵： 其转置矩阵为：
程序输出：
注意：部分源程序给出如下：请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写的若干语句：
试题程序：
#include<conio.h>
#include<stdio.h>
/* 26题：本题没有先求出A的转置，而是直接利用转置的性质（即第一行作为转置后的第一列，第二行作为转置后的第二列，的行列互换的性质）：而且最后要求出两矩阵的相加后得出的新矩阵，由转置性质可知原a[j][i]转置后位置为a[i][j]，在表达式：b[i][j]=a[i][j]+a[j][i]第一个a为A的元素，第二个a为A'的元素：*/
void fun(int a[3][3],int b[3][3])
{int i,j;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
b[i][j]=a[i][j]+a[j][i];
}
main()
{int a[3][3]={{1,2,3},{4,5,6},{7,8,9}},t[3][3];
int i,j;
clrscr();
fun(a,t);
for(i=0;i<3;i++)
{for(j=0;j<3;j++)
printf("%7d",t[i][j]);
printf("/n");}}
27、 序定义了N*N的二维数组，并在主函数中自动赋值：请编写函数fun(int a[][N])，
函数的功能是：使数组第一行元素中的值与最后一行元素中的值对调、第二行元素的值与倒数第二行中的值对调、……、其他依次类推：
注意：部分源程序给出如下：
试题程序：
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
#define N 5
/* 27题：该题与25题相似，外层for()循环用于控制一列一列地移动，内嵌的forr()循
环用于控制在同一列内对应行元素的对调：a[i][m]为第m列第i行元素，而a[N-1-i][m]
为第m列倒数第i行的元素，正好需要对调：*/
fun(int a[][N])
{ int i,m,t;
for(m=0;m<N;m++)
for(i=0;i<N/2;i++)
{t=a[i][m];
a[i][m]=a[N-1-i][m];
a[N-1-i][m]=t;
}
}
main()
{ int a[N][N], i,j;
clrscr();
printf("***** The array *****/n");
for(i=0;i<N;i++)
{for(j=0;j<N;j++)
{a[i][j]=rand()%30; printf("%4d",a[i][j]);}
printf("/n");
}
fun(a);
printf("***** The result *****/n");
for(i=0;i<N;i++)
{for(j=0;j<N;j++)
printf("%4d",a[i][j]);
printf("/n");
}
}
28、 m个人的成绩存放在score数组中，请编写函数fun，它的功能是：将低于平均分的
人数作为函数值返回：
例如，当score 数组中的数据为：10、20、30、40、50、60、70、80、90、时，函数返
回的人数应该是4，below中的数据应为：10、20、30、40：
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <string.h>
#include <conio.h>
#include <stdio.h>
/* 28题：第一个for()循环用来计算score数组中分数的总和，然后用aver/=m求出平均
值，第二个循环用来找出小于平均分的元素，并放到数组below中，这里要注意j的递增
方式：*/
int fun(int score[],int m, int below[])
{ int i,j=0,aver=0;
for(i=0;i<m;i++)
aver+=score[i];
aver/=m;
for(i=0;i<m;i++)
if(score[i]<aver)
below[j++]=score[i];
return j;
}
main()
{ int i,n,below[9];
int score[9]={10,20,30,40,50,60,70,80,90};
clrscr();
n=fun(score,9,below);
printf("/nBelow the average score are :");
for(i=0;i<n;i++) printf("%4d",below[i]);
}
29、 程序定义了N*N的二维数组，并在主函数中自动赋值：请编写函数fun(int a[][N]
),函数的功能是：使数组左下半三角元素中的值全部置成0：
例如：a数组中的值为
，则返回主程序后a数组中的值应为
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define N 5
/* 29题：该题的关键是如何表示出左下半角的元素，当从上往下到第i行时只有左边的
i个元素要置为0（每行总是如此）：用外层for()来控制行而内嵌的for()来控制每行的
左边元素，故而在内嵌for()中j最大只能循环到i（即表示出第i行左边的i个元素）：*
/
int fun(int a[][N])
{int i,j;
for(i=0;i<N;i++)
for(j=0;j<=i;j++)
a[i][j]=0;
}
main()
{int a[N][N],i,j;
clrscr();
printf("*** The array ****/n");
for(i=0;i<N;i++)
{for(j=0;j<N;j++)
{a[i][j]=rand()%10;printf("%4d",a[i][j]);}
printf("/n");
}
fun(a);
printf("The result/n");
for(i=0;i<N;i++)
{for(j=0;j<N;j++)
printf("%4d",a[i][j]);
printf("/n");
}
}
30、 请编写函数fun，经的功能是：求出1到1000之内能被7或11整除、但不能同时补7和
11整除的所有整数并将它们放在a所指的数组中，通过n返回这些数的个数：
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <conio.h>
#include <stdio.h>
/* 30题：该题关键就是如何表示能被7或11整除，但不能同时被7和11整除：用（i%7==
0)//(i%11==0)来表示能被7或11整除，用 !((i%7==0)&&(i%11==0))来表示不能
同时被7和11整除：
void fun(int *a,int *n)
{ int i,m=0;
for(i=1;i<1000;i++)
if(((i%7==0)//(i%11==0))&&!((i%7==0)&&(i%11==0)))
{a[m]=i;m+=1;}
*n=m;
}
main()
{ int aa[1000],n,k;
clrscr();
fun(aa,&n);
for(k=0;k<n;k++)
if((k+1)%10==0) printf("/n");
else printf("%d,",aa[k]);
}
31、程序定义了N*N的二维数组，并在主函数中自动赋值：请编写函数fun(int a[][N])
,函数的功能是：使数组右上半三角元素中的值全部置成0：
例如：a数组中的值为
，则返回主程序后a数组中的值应为
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define N 5
/* 31题：该题的关键亦是在如何表示右上半角，当从上往下到第i行时要从第i列（所
以内嵌for()的j从i开始循环）开始替换直到最后一列，本题用外层for()来控制行，而
用内嵌的for()来控制在每一行内右边元素置0：
int fun(int a[][N])
{ int i,j;
for(i=0;i<N;i++)
for(j=i;j<N;j++)
a[i][j]=0;
}
main()
{ int a[N][N],i,j;
clrscr();
printf("***** The array *****/n");
for(i=0;i<N;i++)
{for(j=0;j<N;j++)
{a[i][j]=rand()%20; printf("%4d",a[i][j]);}
printf("/n");
}
fun(a);
printf("THE RESULT/n");
for(i=0;i<N;i++)
{for(j=0;j<N;j++) printf("%4d",a[i][j]);
printf("/n");
}
}
32、 编写函数void fun(int x,int pp[],int *n)，它的功能是：求出能整除x且不是偶
数的各整数，并放在pp所指的数组中，这些除数的个数通过形参n返回：
例如，若x 中的值为：30，则有4个数符合要求，它们是
1，3，5，15：
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <conio.h>
#include <stdio.h>
/* 32题：由于要求的数不能是偶数故编程时从1开始循环而步长为2这样正好保正i永远
的奇数：这里也要注意存放结果的数组pp的下标变化方式：*/
void fun(int x, int pp[], int *n)
{ int i,j=0;
for( i=1;i<=x; i=i+2)
if( x%i==0)
pp[j++]=i;
*n=j;
}
main()
{ int x, aa[1000], n, i;
printf("/n please enter an integer number:/n"); scanf("%d
",&x);
fun(x,aa,&n);
for(i=0;i<n;i++)
printf("%d ", aa[i]);
printf("/n");
}
33、 序定义了N*N的二维数组，并在主函数中自动赋值：请编写函数fun(int a[][N],i
nt n)，函数的功能是：使数组右上半三角元素中的值乘以m：例如：若m的值为2，a数组
中的值为
，则返回主程序后a数组中的值应为
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define N 5
/* 33题：该题的关键也是在如何表示右上半角（可以与31题相同），本题采用的是在一
行内从最后一列的元素开始往前乘，只有j>=i时才改变（原理与31题相同）：*/
int fun( int a[][N], int m)
{ int i,j;
for(i=0; i<N; i++)
for(j=N-1; j>=i; j--)
a[i][j]*=m;
}
main()
{ int a[N][N],m,i,j;
printf("**** the array ****/n");
for( i=0; i<N;i++)
{ for( j=0; j<N; j++)
{a[i][j]=rand()%20; printf("%4d", a[i][j]); }
printf("/n");
}
do m=rand()%10; while( m>=3);
printf("m=%4d/n", m);
fun( a,m);
printf(" the result /n");
for(i=0; i<N; i++)
{for(j=0; j<N; j++) printf("%4d", a[i][j]);
printf("/n");
}
}34、 编写一个函数void fun(char *tt,int pp[])，统计在tt字符串中’a’到’z’26
个字母各自出现的次数，并依次放在pp所指数组中：
例如，当输入字符串：abcdefgabcdeabc后，程序的输出结果应该是：
3 3 3 2 2 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include<conio.h>
#include<stdio.h>
/* 34题：本题采用的是字母的ASCII码值与数组pp下标的对应转换关系分别求出对应字
母的个数：第一个for()是给pp赋初值0，第二个for()用于控制在字符串内从头到尾移动
：由于字母'a'的ASCII码值为97而它的个数要放在pp[0]中，而'a'-97的值正好为0
，其它的依此类推：*/
void fun(char *tt,int pp[])
{ int i;
for(i=0;i<26;i++)
pp[i]=0;
for(;*tt;tt++)
if(*tt<='z'&&*tt>='a')
pp[*tt-97]++;
}
main()
{ char aa[1000];
int bb[26],k;
clrscr();
printf("/nPlease enter a char string:");scanf("%s",aa)
;
fun(aa,bb);
for(k=0;k<26;k++) printf("%d",bb[k]);
printf("/n");
}
35、序定义了N*N的二维数组，并在主函数中自动赋值：请编写函数fun(int a[][N],in
t n)，函数的功能是：使数组左下半三角元素中的值乘以n：例如：若n的值为2，a数组
中的值为
，则返回主程序后a数组中的值应为
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define N 5
/* 35题：本题与29题相似，只要能表示出左下半角的元素即可：*/
int fun( int a[][N], int n)
{ int i,j;
for(i=0; i<N; i++)
for(j=0; j<=i; j++)
a[i][j]*=n;
}
main()
{ int a[N][N],n,i,j;
printf("**** the array ****/n");
for( i=0; i<N; i++)
{for( j=0; j<N; j++)
{a[i][j]=rand()%10; printf("%4d", a[i][j]); }
printf("/n");
}
do n=rand()%10 ; while(n>=3);
printf("n=%4d /n", n);
fun( a,n);
printf( "**** the result ****/n");
for(i=0;i<N; i++)
{for(j=0; j<N; j++) printf("%4d", a[i][j]);
printf("/n");
}
}
36、数fun的功能是：将两个两位数的整数a、b合并形成一个整数放在c中：合并的方式
是：将a的十位和个位数依次放在c数的千位和十位上，b数的十位和个位数依次放在c数
的个位和百位上：
例如：当a=45，b=12：调用该函数后，c=4251
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <conio.h>
#include <stdio.h>
/* 36题：本题的关键在于如何表示出个、十、百、千位数：对于一个两位的整数，用1
0对它求余得到个位数上的数，将它除10得到十位数上的数：*/
void fun(int a, int b, long *c)
{ int i,j,k,n;
i=a%10; j=a/10; k=b%10; n=b/10;
*c=j*1000+k*100+i*10+n;
}
main()
{ int a,b; long c;
printf(" input a, b: ");
scanf("%d%d", &a,&b);
fun(a,b,&c);
printf(" the result is :%ld/n", c);
}
37、请编写一个函数void fun(int m,int k,int xx[])，该函数的功能是：将大于整数
m且紧靠m的k个素数存入xx所指的数组中：
例如，若输入17，5，则应输出：19，23，29，31，37：
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <conio.h>
#include <stdio.h>
/* 37题：本题中的for()循环用来判断一个数是否为素数，由于个数只能是k个所以用d
o-while循环来控制：*/
void fun(int m, int k, int xx[])
{ int i,j=0,p=m+1;
do
{for( i=2; i<p; i++)
if(p%i==0) break;
if(i>=p) xx[j++]=p;
p++;
} while(j<k);
}
main()
{ int m,n,zz[1000];
printf("/n please enter two integers: ");
scanf("%d%d",&m,&n);
fun( m,n,zz);
for(m=0; m<n; m++)
printf("%d ", zz[m]);
printf("/n");
}
38、已知学生的记录由学号和学习成绩构成，N名学生的数据已存入a结构体数组中：请
编写函数fun，函数的功能是：找出成绩最低的学生记录，通过形参返回主函数（规定只
有一个最低分）：已给出函数的首部，请完成该函数：
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <stdio.h>
#include <string.h>
#include <conio.h>
#define N 10
typedef struct ss
{ char num[10]; int s;} STU;
/* 38题：这个题目中有一结构组数，要找的是数组元素中整型成员的值最小的元素：要
注意本题中的赋值方式（分两部分，对于字符型成员只能用strcpy()函数，而不能用等
号“=”进行赋（即不能用(*s).num=a[k].num），这与字符串的赋值相同（切记）：*/
fun( STU a[], STU *s)
{ int k,i;
(*s).s=a[0].s;
for( i=0;i<N; i++)
if (a[i].s<(*s).s)
{(*s).s=a[i].s; k=i; }
strcpy ( (*s).num, a[k].num);
}
main()
{ STU a[N]={ {"A01",81},{"A02",89},{"A03",66}
,{"A04",87},{"A05",77},
{"A06",90},{"A07",79},{"A08",61},{"
;A09",80},{"A10",71} }, m;
int i;
printf("**** the original data ****/n");
for(i=0;i<N; i++) printf("N0=%s Mark=%d/n", a[i].num,a[i].s
);
fun( a,&m);
printf("**** the result****/n");
printf(" the lowest: %s ,%d/n", m.num,m.s);
}
39、请编写一个函数void fun(char a[],int k,int n)，其功能是：删除字符串中指定
下标开始的n 个字符：其中，a指向字符串，k中存放指定的下标：
例如，字符串内容为：Hellollo World!，k中值为：5，n中的值为：3，则调用该函数的
结果为：Hello World!：
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <stdio.h>
#define N 80
/* 39题：本题要删除从下标k开始的后n个字符：所以所用的算法是将下标为k+n及以后
的所有字符依次往前移n个字符，这样就把要删除的字符覆盖了（即删除了）：记得最后
要在新串尾加一个结束符'/0'：*/
void fun( char *a, int k, int n)
{ int m=strlen(a),i;
for(i=k+n; i<m; i++) a[k++]=a[i];
a[k]='/0';
}
main()
{ char s[N]="Hellollo World!";
int k,n;
printf("/n the original string: %s/n", s);
printf(" enter index---------------k: "); scanf("%d"
, &k);
printf(" enter number to delete----n: "); scanf("%d"
, &n);
fun(s,k,n);
printf("/n the string after deleted: %s/n", s);
}
40、已知学生的记录由学号和学习成绩构成，N名学生的数据已存入a结构体数组中：请
编写函数fun，函数的功能是：找出成绩最高的学生记录，通过形参返回主函数（规定只
有一个最高分）：已给出函数的首部，请完成该函数：
注意：部分源程序给出如下：
请勿改动主函数main和其它函数中的任何去何内容，仅在函数fun的花括号中填入你编写
的若干语句：
试题程序：
#include <stdio.h>
#include <string.h>
#include <conio.h>
#define N 10
typedef struct ss
{ char num[10]; int s;} STU;
/* 40题：本题与38题相似，只是采用的赋值方式不同：采用的是结构体元素对结构体元
素赋值：*/
fun( STU a[], STU *s)
{ int i;
*s=a[0];
for( i=1;i<N; i++)
if (a[i].s>(*s).s)
*s=a[i];
}
main()
{ STU a[N]={ {"A01",81},{"A02",89},{"A03",66}
,{"A04",87},{"A05",77},
{"A06",90},{"A07",79},{"A08",61},{"
;A09",80},{"A10",71} }, m;
int i;
printf("**** the original data ****/n");
for(i=0;i<N; i++) printf("N0=%s Mark=%d/n", a[i].num,a[i].s
);
fun( a,&m);
printf("**** the result****/n");
printf(" the top : %s ,%d/n", m.num,m.s);
}
/* 41题：在本题中要注意使k所指的存储单元的值变为最大值元素的下标（不能用k=&a
mp;i)，另外由于用t返回数组元素个数最后要让其所指的存储单元的值增加1：*/
void fun( int *s, int *t, int *k)
{ int i,p=s[0];
for(i=0; i<*t; i++)
if( s>p ) { p=s[i]; *k=i;}
s[*t]=p; (*t)++;
}
42题：本题要求删除下标为奇数、同时ASCII值也为奇数的字符反过来想就是要将不
标为偶数或ASCII值为偶数的字符留下并放到t数组中：在看类似题型时要注意题中是否
用了“同时”两个字：本题采用的就是后一种思编程方式：*/
void fun( char *s, char t[])
{ int i,j=0,n=strlen(s);
for(i=0;i<n;i++)
if(i%2==0//s[i]%2==0)
t[j++]=s[i];
t[j]='/0';
}
43题：本题采用了双重循环的方式，其中内层循环用于算出每一加项的分母：用这种
方式较好理解但程序比较长，其中还要注意每次都要给p重新赋0.0：此外，亦可用一个
循环将其做出：*/
float fun (int n)
{ int i,j;
float s,p;
s=0.0;p=0.0;
for (i=1;i<=n;i++)
{ for(j=1;j<=i;j++)
p=p+j;
s=s+1.0/p;
p=0.0;
}
return s;
}
44题：本题与42题相似，它要删除下标为奇数、同时ASCII值偶数的字符，即要留下
下标为 偶数或者ASCII值为奇数的字符，注意在if()判断中一定要用逻辑或（//）将两
关系运算连接起来：*/
void fun( char *s, char t[])
{ int i,j=0,n=strlen(s);
for(i=0;i<n;i++)
if(i%2==0//s[i]%2!=0)
t[j++]=s[i];
t[j]='/0';
}45题：由算式可看出n要从0开始，所以循环中i从0开始，在循环中用k来表示每项的
符号，所以每次循环k都要转换正负号：*/
void fun(float *sn,int n)
{ int i;
float k=-1.;
*sn=0;
for(i=0;i<=n;i++)
{k=-k;
*sn=*sn+k/(2*i+1);
}
}
46题：本题要删除下标为偶数、同时ASCII值奇数的字符，也就是要留下下标为奇数
或者ASCII值为偶数的字符：在if()判断中采用的是i%2而不是i%2==1由于在C语言中当i
为奇数时i%2的值为1（即为逻辑真，它与i%2==1的效果是一样的：在一点要注意，它在
笔试考中也常出现：*/
void fun( char *s, char t[])
{ int i,j=0,n=strlen(s);
for(i=0;i<n++)
if(i%2//!(s[i]%2))
t[j++]=s[i];
t[j]='/0';
}
47题：在公式中的m!表示m的阶乘（即从m一直乘到1），本题分别用三个循环求出m!
，1/n!，/1(m-n)!并已将其合在一起：要注意它的结合方式：*/
float fun( int m, int n)
{ int i;
double t=1;
for(i=1; i<=m; i++) t*=i;
for(i=1; i<=n; i++) t/=i;
for(i=1; i<=m-n; i++) t/=i;
return (t);
}
48题：本题要求删除下标为偶数、同时ASCII值偶数的字符，即要留下下标为奇数或
ASCII值为奇数的字符：*/
void fun( char *s, char t[])
{ int i,j=0,n=strlen(s);
for(i=0; i<n; i++)
if(i%2//s[i]%2) t[j++]=s[i];
t[j]='/0';
}
49题：这是一道典型的迭代算法题：迭代算法就是x0和x1反复求值反复交换值直到两
值小于其个被认为0的数时，在浮点型中由于存在精确度的问题，所以认为一个很小的数
（如：1e-006即0.000001）与0相当：故本题的fabs(x0-x1)>1e-006不用fabs(x0-x1
)==0.0，若是用后面的表达式将会出现永无成立的时候：*/
float fun()
{ float x0,x1=0;
do { x0=x1;
x1=cos(x0);
}while( fabs(x0-x1)>1e-006);
return x1;
}
50题：本题要删除的是ASCII值为偶数的字符即要将ASCII值为奇数的留下：注意if(
)中表示奇数的方式：采用的是s[i]%2而不是s[i]%2==1由于在C语言中当s[i]为奇数时s
[i]%2的值为1（即为逻辑真，它与s[i]%2==1的效果是一样的：在一点要注意，它在笔试
考中也常出现：*/
void fun( char *s, char t[])
{ int i,j=0,n=strlen(s);
for(i=0; i<n; i++)
if(s[i]%2) t[j++]=s[i];
t[j]='/0';
}
51题：由于要求求出能同时被3和7整除的数，由3和7的最小公倍数为21，可得，i一
定是21的倍数，所以题中直接用21来作为循环的初值和步长，这样既能保证能同时衩3和
7整除，同时也保证了所有数都被统计完：*/
double fun(int n)
{int sum,i;sum=0;
for(i=21;i<n;i=i+21)
sum=sum+i;
return (sqrt(sum));
}
52题：本题与50题的区别只有if()的判断，它要表求出s的ASCII值为偶数：*/
void fun(char *s,char t[])
{int n,i,k=0;
for(i=0;s[i];i++)
if(s[i]%2==0)
{t[k]=s[i];k=k+1;}
t[k]=0;
}
53题：Fibonacci数列是这么一个数列0，1，1，2，3，5，8，13……从它的第三项
开始每一项的值都是其紧接着的前两项的和：本也是采用函数的嵌套调用来完成，但若
用嵌套调用方式会较难理解：它要求求出比t大的最小一个数：在本题的编程中采用的是
while(f2<=t)当它的条件这假时，即得到了第一个比t大的数：*/
int fun (int t)
{int f1=0,f2=1,temp;
while(f2<=t)
{temp=f2;
f2=f1+f2;
f1=temp;
}
return f2;
}
54题：本题采用while()循环来控制：要注意不管下标是否符合条件，都要让下标增
加1（即后移一个字符）用i++完成：*/
void fun(char *s,char t[])
{int i=0,j=0;
while(*(s+i)!='/0')
if(i%2==0) i++;
else t[j++]=s[i++];
t[j]='/0';
}
55题：要注意在s=s+1.0/(j*(j+1));中不能将1.0换成1，若为1由于都是整型运算完
后只用整数部分，这时就会出错：另外若用乘号“*”则必须用括号将其括起：*/
double fun(int n)
{float s=0;int j;
for(j=1;j<=n;j++)
s=s+1.0/(j*(j+1));
return s;
}
56题：本题要求删除下标为奇数的字符即留下下标为偶数的字符：题中for()的i从0
开始，而每次都增加2，这就保证了下标永远是偶数：*/
void fun(char *s,char t[])
{
int i,n,k=0;n=strlen(s);
for(i=0;i<n;i=i+2)
t[k++]=s;
t[k]='/0';
}
57题：所谓因子即能整除n的数：由于1和n除外所以for()循环从1到n-1进行循环，
在循环过程中用if()判断能否整除n若能则加到s中：*/
int fun(int n)
{ int i,s=0;
for(i=2;i<n;i++)
if(n%i==0)
s=s+i;
return s;
}
58题：本题要求除了下标为奇数、同时ASCII值也为奇数的字符之外，其余的所有字
符都删除，即留下下标为奇数同时ASCII值为奇数的字符：本题在用for()循环时初值从
1开始且每次都加2故而得到的i（即下标）都是奇数，进而只要对字符本身进行判断：*
/
void fun(char *s,char t[])
{int i,n,k=0;n=strlen(s);
for(i=1;i<n;i=i+2)
if(s[i]%2==1)
t[k++]=s[i];
t[k]='/0';
}
59题：本题较简单：主要就是函数的应用：*/
double fun(int m)
{double i,r=0.;
for(i=1;i<=m;i++)
r+=log(i);
return (sqrt(r));
}
60题：要题要将除了下标为偶数、同时ASCII值也为偶数的字符之外，其余的所有字
符都删除，即留下下标为偶数同时ASCII值为偶数的字符：与58题同：*/
void fun(char *s,char t[])
{ int i,k=0;
for(i=0;i<strlen(s);i=i+2)
if(s[i]%2==0)
{t[k]=s[i];k++;}
t[k]='/0';
}
61题：从第二项开始以后的每一项都是它前一项的x/i倍（从第0项开始数当求到第一
项时i为1（即项值为x，当求到第二项时i为2即（项值为x*x/2），当求到第三项时i为3（
即项值为x*x*x/(2*3)）,……，这里用t来代表第i项的值：*/
double fun( double x, int n)
{ int i;
double t=1.,s=0.;
for(i=1;i<=n;i++)
{s+=t;t*=x/i;}
return s;
}
62题：内层循环用于在同一行内将所有元素相加：*/
fun (int a[][N] ,int b[])
{int i,j,p,sum=0;
for (i=0;i<M;i++)
{for(j=0;j<N;j++)
sum=sum+a[i][j];
b[i]=sum;
sum=0;
}
}
63题：第一个while()循环用来找出第一个不是*号的字符，注意在while的括号后有
一分号，由于在while()循环结束时b已指向第二个不是*号的字符，因此在下一个循环之
前要让b后退一个字符（b--;），第二个循环是让后面的字符往前移，这种移动方法不用
在最后赋'/0'，这是因为在while()循环中先移动后判断，即当它循环到串尾时先将串
结束符'/0'前移后才停止循环：*/
void fun( char *a)
{ char *b=a;
while(*b++=='*');b--;
while((*a++=*b++)!='/0');
}
64题：本题采用的是判断当前字符是否为数字，若不是则留下到新（与原串共用一个
数组）的字符串中，下标的改变方法要注意：记得最后要加上串结束符'/0'：*/
void fun( char *s)
{int i=0,j=0;
while(*(s+i)!='/0')
if(*(s+i)>='0'&&*(s+i)<='9') i++;
else *(s+j++)=*(s+i++);
*(s+j)='/0';
}
65题：本题中的第一个for()循环用来使指指变量指向串尾，注意在for()的后面直接
跟一个分号，为了使下一个for()循环能得以正确执行，最后要让a向回退一个字符（即
不能让它指向'/0'），第二个for()循环是让a指向倒数第一个不是*号的字符，这时只
要在a的后一个字符加上串结束符'/0'即可（用*++a='/0'来完成）：*/
void fun( char *a)
{for(;*a;a++);a--;
for(;*a=='*';a--);
*++a='/0';
}
66题：较简单：*/
fun (int a[][M])
{ int i,j,max=a[0][0];
for (i=0;i<2;i++)
for (j=0;j<M;j++)
if(a[i][j]>max)
max=a[i][j];
return max;
}
67题：本题采用的算法是：先让*p（包括*p）前面不是*号的字符按顺序留在新串中（
新串与原串共用一个数组变量）用for()循环来完成，最后用while()循环再把*p（不含
*p）以后的所有字符也按顺序留下：在注意下标的变化方式：*/
void fun( char *a, char *p)
{int i,j=0;
for(i=0;a+i<=p;i++)
if(*(a+i)!='*')
a[j++]=*(a+i);
while((a[j++]=*p++)!='/0');
}
69题答案
第一个for使字符串移到前面连续*的末尾，第二个for删除其他的*
int i,j=0;
for(i=0;a ='*';i++);
j=i;
for(;a ;i++)
if(a!='*')
a[j++]=a[i];
a[j]='/0';
71题答案
第一个for将字符串移动到前面联系的*后面，第二个for将中间的*去掉，第三个for将后
面的*联入
int i;
for(i=0;a[i]=='*';i++);
for(;h<p;h++)
if(*h!='*')
a[i++]=*h;
for(;*p;p++)
a[i++]=*p;
a[i]='/0';
73
int i;
n=n-e;
a[n]='/0';
for(i=0;h<=n;i++)
a[i]=a[h++];
74题
int i=1;
double t=1,s=1,pi;
while(fab(t)>=eps)
{t*=i/(2*i+1.0);
i=i+1;
s=s+t;}
pi=2*s;
return pi;
77题答案
int i,j;
for(i=0;a[i]=='*';i++);
if(i>n)
j=i-n;
i=0;
while(a[i++]=a[j++];
a[i]='/0';
79题答案
int i;
char *b;
b=a;
for(;*b;b++);b--;
while(*b=='*')
b--;
for(i=0;i<n&&*b;i++)
b++;
*(b+1)='/0';
80
#include <stdio.h>
float fun(float *a, int n)
{ float ave=0;
int i;
for(i=0;i<n;i++)
ave+=a/n;
return ave;
}
main()
{ float score[30]={90.5,72,80,61.5,55},aver;
aver=fun(score,5);
printf("/nAverage score is :%5.2f/n",aver);
}
81
#include <stdio.h>
#include <conio.h>
void fun(char *a)
{ int i,j,k,l=0;
char *p,*t;
for(i=0;*(a+i)=='*';i++)
p[i]=*(a+i);
for(j=0;j<i;j++)
for(k=0;a[k];k++)
a[k]=a[k+1];
t=a;
while (*t)
{ if(*t=='*'&&*(t+1)=='*')
{ for(j=0;*(t+j)=='*';j++)
{ p[i++]=*(t+j);
l++;
}
for(;l;l--)
for(k=0;t[k];k++)
t[k]=t[k+1];
}
t++;
}
p[i]='/0';
printf("%s",p);
t--;
while(*t=='*') t--;
for(j=0;p[j];j++)
t[j]=p[j];
}
main()
{ char s[81],*p;
int n=0;
printf("Enter a sring :/n"); gets(s);
fun(s);
printf("The string after moneing :/n");
puts(s);
}
82
#include <stdio.h>
#include <conio.h>
void fun(int a,int b , long *c)
{ int ag,as,bg,bs;
ag=a%10; as=a/10%10;
bg=b%10; bs=b/10%10;
*c=as+ag*10+bs*100+bg*1000;
}
main()
{ int a,b;
long c;
clrscr();
printf("Input a,b:");
scanf("%d%d",&a,&b);
fun(a,b,&c);
printf("The result is :%ld/n",c);
}
83
#include <stdio.h>
#define N 8
typedef struct
{ char num[10];
double s[N];
double ave;
}STREC;
void fun(STREC *s)
{ int i;
double sum=0;
for(i=0;i<N;i++)
sum+=s->s[i];
s->ave=sum/N;
}
main()
{ STREC s={"GA005",85.5,76,69.5,85,91,72,64.5,87.5};
int i;
fun(&s);
printf("The %s's strdent data:/n",s.num);
for(i=0;i<N;i++)
printf("%4.1f/n",s.s[i]);
printf("/nave=%7.3f/n",s.ave);
}
84
#include <conio.h>
#include <stdio.h>
void fun (int a, int b ,long *c)
{ int d,e,f,g;
d=a/10;e=a%10;f=b/10;g=b%10;
*c=1000*e+100*d+10*g+f;
}
main ()
{ int a,b; long c;
clrscr ();
printf ("Input a, b:");
scanf ("%d%d", &a, &b);
fun (a, b, &c);
printf ("The result is: %ld/n", c);
}
85
#include <stdio.h>
#define N 12
typedef struct
{ char num [10];
double s;
}STREC;
double fun ( STREC *a, STREC *b, int *n )
{ int i,j;double sum=0,t;
for(i=0;i<N;i++)
sum+=a[i].s;
t=sum/N;
for(i=0,j=0;i<N;i++)
if(a[i].s>t)
b[j++]=a[i];
*n=j;
return t;
}
main ()
{ STREC s[N]={{"GA05",85}, {"GA03",76}, {"GA02&qu
ot;,69}, {"GA04",85},
{"GA01",91}, {"GA07",72}, {"GA08",64}
, {"GA06",87},
{"GA09",60}, {"GA11",79}, {"GA12",73}
, {"GA10",90}};
STREC h [N]; FILE *out ;
int i,n; double ave;
ave=fun ( s, h, &n );
printf ( "The %d student data which is higher than %7.3f:/n", n
, ave);
for ( i=0; i<n; i++ )
printf ("%s %4.1f/n", h[i]. num, h[i]. s);
printf ("/n");
out=fopen("out 12.dat","w");
fprintf(out,"%d/n%7.3f/n",n,ave);
for(i=0;i<n;i++)
fprintf(out,"%s %4.1f/n",h[i].num,h[i].s);
fclose(out);
}
86
#include <conio.h>
#include <stdio.h>
void fun (int a, int b, long *c )
{ int d,e,f,g;
d=a/10;e=a%10;f=b/10;g=b%10;
*c=e*1000+g*100+d*10+f;
}
main ()
{ int a, b; long c;
clrscr ();
printf (" Input a, b;");
scanf ("%d%d", &a, &b);
fun (a, b, &c);
printf ("The result is : %ld/n", c);
}
87
#include <stdio.h>
#define N 8
typedef struct
{ char num[10];
double s;
} STREC;
double fun (STREC *a, STREC *b, int *n)
{int i,j;double s=0,t;
for(i=0;i<N;i++)s+=a[i].s;
t=s/N;
for(i=0,j=0;i<N;i++)
if(a[i].s<t) b[j++]=a[i];
*n=j;
return t;
}
main ()
{ STREC s[N]={{"GA05",85}, {"GA03",76}, {"GA02&q
uot;,69}, {"GA04",85},
{"GA01",91}, {"GA07",72}, {"GA08",64
}, {"GA06", 87}};
STREC h[N]; FILE *out;
int i, n; double ave;
ave=fun ( s, h, &n );
printf ("The %d student data which is lower than %7.3f:/n&qu
ot;, n, ave );
for (i=0; i<n; i++)
printf ("%s %4.1f/n", h[i]. num, h[i]. s);
printf ("/n");
out=fopen ("out13.dat","w");
fprintf (out, "%d/n%7.3f/n", n, ave);
for (i=0; i<n; i++)
fprintf (out, "%s %4.1f/n", h[i]. num, h[i]. s );
fclose (out );
}
88
#include <conio.h>
#include <stdio.h>
void fun (int a, int b, long *c)
{int d,e,f,g;
d=a/10;e=a%10;
f=b/10;
g=b%10;
*c=e*1000+f*100+d*10+g;
}
main ()
{ int a, b; long c;
clrscr ();
printf ("Input a, b:");
scanf ("%d%d", &a, &b);
fun ( a, b, &c );
printf ("The result is: %ld/n", c);
}
89
#include <stdio.h>
#define N 16
typedef struct
{ char num[10];
int s;
} STREC;
int fun ( STREC *a, STREC *b )
{ int i,j,p;
p=a[0].s;
for(i=0;i<N;i++)
if(a[i].s<p) p=a[i].s;
for(i=0,j=0;i<N;i++)
if(a[i].s==p) b[j++]=a[i];
return j;
}
main ()
{
STREC s[N]= {{"GA05",85}, {"GA03",76}, {"GA02"
;,69}, {"GA04",85},
{"GA01",91}, {"GA07",72}, {"GA08",64}
, {"GA06", 87},
{"GA015",85}, {"GA013",91}, {"GA012",
64}, {"GA014",91},
{"GA011",91}, {"GA017",64}, {"GA018",
64}, {"GA016",72}};
STREC h[N];
int i, n; FILE *out;
n=fun ( s, h );
printf ("The %d lowest score :/n", n);
for (i=0; i<n; i++)
printf ("%s %4d/n", h[i]. num, h[i]. s);
printf ("/n");
out=fopen ("out14.dat", "w");
fprintf (out, "%d/n", n);
for (i=0; i<n; i++)
fprintf (out, "%s %4d/n", h[i]. num, h[i]. s);
fclose (out );
}
90
#include <stdio.h>
#define N 16
typedef struct
{ char num[10];
int s;
} STREC;
int fun ( STREC *a, STREC *b )
{int i,j,p=a[0].s;
for(i=0;i<N;i++)
if(a[i].s>p)
p=a[i].s;
for(i=0,j=0;i<N;i++)
if(a[i].s==p) b[j++]=a[i];
return j;
}
main ()
{ STREC s[N]= {{"GA05",85}, {"GA03",76}, {"GA02&q
uot;,69}, {"GA04",85},
{"GA01",91}, {"GA07",72}, {"GA08",64}
, {"GA06", 87},
{"GA015",85}, {"GA013",91}, {"GA012",
64}, {"GA014",91},
{"GA011",77}, {"GA017",64}, {"GA018",
64}, {"GA016",72}};
STREC h[N];
int i, n; FILE *out;
n=fun ( s, h );
printf ("The %d highest score :/n", n);
for (i=0; i<n; i++)
printf ("%s %4d/n", h[i]. num, h[i]. s);
printf ("/n");
out=fopen ("out15.dat", "w");
fprintf (out, "%d/n", n);
for (i=0; i<n; i++)
fprintf (out, "%s %4d/n", h[i]. num, h[i]. s);
fclose (out );
}
91
#include <conio.h>
#include <stdio.h>
void fun (int a, int b, long *c)
{ int d,e,f,g;
d=a/10;e=a%10;f=b/10;g=b%10;
*c=1000*g+100*e+10*f+d;
}
main ()
{ int a, b; long c;
clrscr ();
printf ("Input a, b:");
scanf ("%d%d", &a, &b);
fun ( a, b, &c );
printf ("The result is: %ld/n", c);
}
92
#include <stdio.h>
#define N 16
typedef struct
{ char num[10];
int s;
} STREC;
int fun ( STREC a[ ] )
{int i,j,t,p;STREC k;
for(i=0;i<N;i++)
{p=a[i].s;
for(j=i;j<N;j++)
if(a[j].s>p) {p=a[j].s;t=j;}
k=a[i];a[i]=a[t]; a[t]=k;
}
}
main ()
{ STREC s[N]= {{"GA005",85}, {"GA003",76}, {"GA00
2",69}, {"GA004",85},
{"GA001",91}, {"GA007",72}, {"GA008",64}, {&
quot;GA006", 87},
{"GA015",85}, {"GA013",91}, {"GA012",64}, {&
quot;GA014",91},
{"GA011",66}, {"GA017",64}, {"GA018",64}, {&
quot;GA016",72}};
int i; FILE *out;
fun ( s );
printf ("The data after sorted :/n");
for (i=0; i<N; i++)
{ if ( (i)%4==0 ) printf ("/n");
printf ("%s %4d/t", s[i].num, s[i].s);
}
printf ("/n");
out=fopen ("out16.dat", "w");
for (i=0; i<N; i++)
{ if ( (i)%4==0 && i ) fprintf (out, "/n" );
fprintf (out, "%s %4d", s[i].num, s[i].s);
}
fprintf ( out, "/n" );
fclose (out );
}
93
#include <conio.h>
#include <stdio.h>
void fun (int a, int b, long *c)
{ int d,e, f,g;
d=a/10;e=a%10;f=b/10;g=b%10;
*c=1000*g+100*d+10*f+e;
}
main ()
{ int a, b; long c;
clrscr ();
printf ("Input a, b:");
scanf ("%d%d", &a, &b);
fun ( a, b, &c );
printf ("The result is: %ld/n", c);
}
94
#include <stdio.h>
#include <string.h>
#define N 16
typedef struct
{ char num[10];
int s;
} STREC;
STREC fun ( STREC *a, char *b )
{int i,j;
for(i=0;i<N;i++)
if(strcmp(a[i].num,b)==0)
return a[i];
*a[N].num='/0';a[N].s=-1;
return a[N];
}
main ()
{ STREC s[N]= {{"GA005",85}, {"GA003",76}, {"GA00
2",69}, {"GA004",85},
{"GA001",91}, {"GA007",72}, {"GA008",
64}, {"GA006", 87},
{"GA015",85}, {"GA013",91}, {"GA012",
64}, {"GA014",91},
{"GA011",77}, {"GA017",64}, {"GA018",
64}, {"GA016",72}};
STREC h;
char m[10];
int i, n; FILE *out;
printf ( "The original data :/n" );
for (i=0; i<N; i++)
{ if ( i%4==0 ) printf ("/n");
printf ("%s %3d", s[i]. num, s[i]. s);
}
printf ("/n/nEnter the number : "); gets ( m );
h=fun ( s, m );
printf ( " The data : " );
printf ( "/n%s %4d/n", h . num, h . s );
printf ( "/n" );
out=fopen ("out17.dat", "w");
h=fun ( s, "GA013" );
fprintf (out, "%s %4d/n", h . num, h . s);
fclose (out );
}
95
#include <conio.h>
#include <stdio.h>
void fun (int a, int b, long *c)
{int d,e,f,g;
d=a/10;e=a%10;
f=b/10;g=b%10;
*c=1000*f+100*e+g*10+d;
}
main ()
{ int a, b; long c;
clrscr ();
printf ("Input a, b:");
scanf ("%d%d", &a, &b);
fun ( a, b, &c );
printf ("The result is: %ld/n", c);
}
96
#include <stdio.h>
#define N 16
typedef struct
{ char num[10];
int s;
} STREC;
int fun ( STREC *a, STREC *b, int l, int h )
{int i,j;
for(i=0,j=0;i<N;i++)
if(a[i].s>=l&&a[i].s<=h)
b[j++]=a[i];
return j;
}
main ()
{ STREC s[N]= {{"GA005",85}, {"GA003",76}, {"GA00
2",69}, {"GA004",85},
{"GA001",96}, {"GA007",72}, {"GA008",
64}, {"GA006", 87},
{"GA015",85}, {"GA013",94}, {"GA012",
64}, {"GA014",91},
{"GA011",90}, {"GA017",64}, {"GA018",
64}, {"GA016",72}};
STREC h[N]; FILE *out;
int i, n, low, heigh, t;
printf ( "Enter 2 integer number low & heigh : " );
scanf ("%d%d", &low, &heigh );
if ( heigh < low ) { t=heigh; heigh=low; low=t; }
n=fun (s, h, low , heigh );
printf ( "The student 's data between %d----%d : /n", low,
heigh );
for (i=0; i<n; i++)
printf ("%s %4d/n", h[i]. num, h[i]. s);
printf ( "/n" );
out=fopen ("out18.dat", "w");
fprintf ( out, "%d/n", n );
n=fun ( s, h, 80, 98 );
for (i=0; i<n; i++)
fprintf (out, "%s %4d/n", h[i]. num, h[i]. s);
fprintf ( out, "/n" );
fclose ( out );
}
97
#include <conio.h>
#include <stdio.h>
void fun (int a, int b, long *c)
{int d,e,f,g;
d=a/10;e=a%10;f=b/10;g=b%10;
*c=1000*f+100*d+10*g+e;
}
main () /*主函数*/
{ int a, b; long c;
clrscr ();
printf ("Input a, b:");
scanf ("%d%d", &a, &b);
fun ( a, b, &c );
printf ("The result is: %ld/n", c);
}
98
#include <stdio.h>
#include <stdlib.h>
#define N 8
struct slist
{ double s;
struct slist *next;
};
typedef struct slist STREC;
double fun ( STREC *h )
{double sum,ave;STREC *q;
sum=(*h).s;q=h->next;
while(q)
{sum+=(*q).s;
q=q->next;}
ave=sum/N;
return ave;
}
STREC * creat ( double *s )
{ STREC *h, *p, *q; int i=0;
h=p=( STREC* ) malloc (sizeof (STREC ) ); p->s=0;
while ( i<N )
{ q=( STREC* ) malloc (sizeof ( STREC ) );
q->s=s[i]; i++; p->next=q; p=q;
}
p->next=0;
return h;
}
outlist ( STREC *h )
{ STREC *p;
p=h->next; printf ( " head " );
do
{ printf ( "->%4.1f", p->s ); p=p->next; }
while ( p!=0 );
printf ( "/n/n" );
}
main ()
{ double s[N]={85, 76, 69, 85, 91, 72, 64, 87}, ave;
STREC *h;
h=creat ( s ); outlist (h);
ave=fun ( h );
printf ( "ave= %6.3f/n", ave );
}
99
#include <conio.h>
#include <stdio.h>
void fun (int a, int b, long *c)
{int d,e,f,g;
d=a/10;e=a%10;f=b/10;g=b%10;
*c=1000*d+100*f+10*e+g;
}
main ()
{ int a, b; long c;
clrscr ();
printf ("Input a, b:"); scanf ("%d%d", &a,
&b);
fun ( a, b, &c );
printf ("The result is: %ld/n", c);
}
100、#include <stdio.h>
#include<string.h>
#include<conio.h>
void Myswap(char *s)
{char *sp,*st,ch;
sp=s;
st=s+strlen(s)-1;
while (sp<=st)
{ch=*sp;*sp=*st;*st=ch;sp++;st--;}
}
void fun (char *a,char *b,char *c)
{
char s1[100],s2[100],*sa,*sb;
strcpy(s1,a);
strcpy(s2,b);
Myswap(s1);Myswap(s2);
sa=s1; sb=s2;
while(*sa//*sb)
{if (*sa){*c=*sa;c++;sa++;}
if (*sb){*c=*sb;c++;sb++;}
}*c=0;
}
main()
{char s1[100],s2[100],t[200];
clrscr();
printf("/nEnter s1 string:");scanf("%s",s1);
printf("/nEnter s2 string:");scanf("%s",s2);
fun(s1,s2,t);
printf("/nThe result is :%s/n",t);
}