必背1：fwrite()函数的使用格式、fread()函数的功能和使用格式、fseek()函数的功能和使用格式、feof()的返回值、fgetc()读完了文件指针所指向的字符后，自动向后移动一个Byte（字符）、 fputc(字符地址,文件指针)格式、putchar(ch)，ch不能是指针、strcpy()函数的使用格式、rand()产生的随机数的范围、strcmp()函数的返回值、strlen()计算结束标识符与否、(指针类型*)malloc()的格式、free()函数用于释放动态内存空间，头文件stdlib、
必背2：求次方用幂函数pow(x,y)、浮点型求绝对值用fabs() 、平方根函数sqrt()中的参数确保是double型，使用时需引用math.h、
必背3：转义字符'\0''\n'别搞反了
必背3：toupper(‘a’)函数功能和返回值，将字符a转换成大写字母A，并返回其ASCII码值，如果不是字母或者本身就是大写字母，则返回本身的ASCII码值。
必背3：tolower('A‘)，将字符A转换成小写字母，并返回其ASCII码值，如果不是小写字母或者本身就是小写字母，则返回本身的ASCII码值。
必背3：isdigit()函数——判断字符是否为数字，是返回非0。
必背4：isalpha()函数——判断字符是否为字母，是返回非0。
必背3：关系运算符的符号，特别是用的比较少的大于等于。
必背2：强制类型转换的一般形式：
(类型说明符)(表达式)
需转换的表达式如果不是单个变量，则要用括号将其括起来，且优先级比“/”运算高。
必背2：
一维数组的实参形式：a、&a
形参形式：*p、*(p+i)、b[]
引用实参内容：p[i]、b[i]
结构体数组的实参形式：a、&a
形参形式：*p、p[]
二维数组的实参形式：a
形参形式：b[][N]、b[N][N]、(*b)[N]
改变实参的内容：a[i][j]是一种通过地址操作元素
行指针的定义：数据类型 *p[N]
必背3：结构体变量的引用
（1）结构体变量名.成员名
（2）结构体指针变量名->成员名
（3）(*指针变量名).成员名
必背4：函数指针的和指针函数的区别以及定义格式区别，指针函数说明函数返回的是一个指针（地址），定义格式：
数据类型 *函数名(参数表)
等价于
(数据类型*)函数名(参数表)
函数指针的定义格式：
数据类型(*指针变量名)(形参列表)
“数据类型”指函数的返回类型，“形参列表”指函数指针变量所指向的函数的形参列表
必背4：逻辑运算符“!” > 算术运算符（+-*/）> 关系运算符 > 逻辑运算符（&&、||） > 赋值运算符
++、*
必背5：break在for循环中跳出后执行什么。
必背6：for循环的表达式2不要使用函数，会得不到结果
必背5：函数指针的定义格式
数据类型(*指针变量名)(形参列表)
“数据类型”指函数的返回类型，“形参列表”指函数指针变量所指向的函数的形参列表
必背6：system函数表示执行系统命令，system("CLS");表示清屏，使用时需调用头文件stdlib.h。
必背7：素数概念，大于1的自然数，且只能被1和自身所整除的数。例如，3只能被1和3整除。
必背8：算数平均值就是平均值。
总结1：将字符数组给另一个字符数组要用strcpy函数。
总结2：将结构体数组中的元素赋值给另一个结构数组时，还可以用类似于数组的方式a[i]=b[j]，即便每一个元素是由char数组、int、float等数据类型组成。
总结2：求若干数的平均值有两种方法：（1）先求和，再除以个数；（2）每个数都除以个数然后再相加。
总结3：求最大公约的方法有3种，辗转相除法、相减法、穷举法。
总结4：在没有string.h头文件的情况下，可采用while循环去计算数字符串的长度。
总结4：每个变量使用前一定要初始化，不然其值是一个不确定的数。
总结5：指针变量指向字符时，*指针变量的值是其ASCII码值。通过ASCII码值-'0'将字符类型的数转换成数值类型。
总结6：sum+=*s-'0' 机器执行步骤为，先将*s-'0'计算出来，然后计算sum*s，再将结果赋值给sum。
总结7：*与++的优先级在同级别，又因为一元运算的结合方向是从右到左，先p++，然后取内容。
总结6：函数中可以有多个return，但无论是哪条命令触发了return都会导致函数结束。
总结7：不能在定义变量的中间行中插入赋初值或赋值的语句，会报错
总结8：尽管单目运算符的优先级比双目运算符的优先级高，但是很有可能程序结果正确，但扣分，因此该用括号，避免负数的负号造成扣分。
总结9：当不同数据类型在一块进行乘除运算时，结果为精度更高的类型
总结10：函数有返回值的，先将return函数写出来，避免忘记
总结11：当嵌套循环中循环变量j的起始值与循环变量i有关时，注意i的终止循环值有无越界问题
程序填空题
/*程序通过定义学生结构体变量，存储了学生的学号、姓名和三门课的成绩。所有学生数据均以二进制方
式输出到文件中。函数fun的功能是重写形参filename所指文件中最后一个学生的数据，即用新的学生数
据覆盖该学生原来的数据，其他学生的数据不变。*/
#include <stdio.h>
#define N 5
typedef struct student {
long sno;
char name[10];
float score[3];
} STU;
void fun(char *filename, STU n)
{ FILE *fp;
/**********found**********/
fp = fopen(__1__, "rb+"); //当打开文件的文件名（字符串）是由指针变量指向时，不应该
/**********found**********/ //加双引号。
fseek(__2__, -(long)sizeof(STU), SEEK_END); //fp
/**********found**********/
fwrite(&n, sizeof(STU), 1, __3__); //fp
fclose(fp);
}
void main()
{ STU t[N]={ {10001,"MaChao", 91, 92, 77}, {10002,"CaoKai", 75, 60, 88},
{10003,"LiSi", 85, 70, 78}, {10004,"FangFang", 90, 82, 87},
{10005,"ZhangSan", 95, 80, 88}};
STU n={10006,"ZhaoSi", 55, 70, 68}, ss[N];
int i,j; FILE *fp;
fp = fopen("student.dat", "wb");
fwrite(t, sizeof(STU), N, fp);
fclose(fp);
fp = fopen("student.dat", "rb");
fread(ss, sizeof(STU), N, fp);
fclose(fp);
printf("\nThe original data :\n\n");
for (j=0; j<N; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",ss[j].sno, ss[j].name);
for (i=0; i<3; i++) printf("%6.2f ", ss[j].score[i]);
printf("\n");
}
fun("student.dat", n); //函数的实参是字符串，形参是指向字符串的指针变量
printf("\nThe data after modifing :\n\n");
fp = fopen("student.dat", "rb");
fread(ss, sizeof(STU), N, fp);
fclose(fp);
for (j=0; j<N; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",ss[j].sno, ss[j].name);
for (i=0; i<3; i++) printf("%6.2f ", ss[j].score[i]);
printf("\n");
}
}总结：当打开文件的文件名（字符串）是由指针变量指向时，不应该加双引号。
/*函数fun的功能是：计算形参x所指数组中N各数的平均值（规定所有数均为正数），作为函数值返回，
并将大于平均值的数放在形参y所指数组中，在主函数中输出。
例如，有10个正数：46、30、32、40、6、17、45、15、48、26，其平均值为35.500000.
主函数中输出：46 32 40 45 48。
*/
#include <stdlib.h>
#include <stdio.h>
#define N 10
double fun(double x[],double *y)
{ int i,j; double av;
/**********found**********/
av=__1__; //0.0 浮点型赋初值要带小数点
/**********found**********/
for(i=0; i<N; i++)
av=av+__2__; //x[i]/N
for(i=j=0; i<N; i++)
/**********found**********/
if(x[i]>av) y[__3__]= x[i]; //j++ 仅仅填j并不够，因为后续没有j+1的语句
y[j]=-1; //搭配main函数遍历输出的循环结束标识
return av;
}
void main()
{ int i; double x[N],y[N];
for(i=0; i<N; i++){ x[i]=rand()%50; printf("%4.0f ",x[i]);}
printf("\n");
printf("\nThe average is: %f\n",fun(x,y));
for(i=0; y[i]>=0; i++) printf("%5.1f ",y[i]);
printf("\n");
}总结：浮点型赋初值要带小数点，0也不例外。
求若干数的平均值有两种方法：（1）先求和，再除以个数；（2）每个数都除以个数然后再相加。
/*函数fun的功能是：计算x所指数组中N个数的平均值（规定所有数均为正数），平均值通过形参返回给
主函数，将小于平均值且最接近平均值的数作为函数返回值返回，并再主函数中输出。
例如，有10个正数：46、30、32、40、6、17、45、15、48、26，平均值为30.500000。
主函数中输出m=30。
*/
#include <stdlib.h>
#include <stdio.h>
#define N 10
double fun(double x[],double *av)
{ int i,j; double d,s;
s=0;
for(i=0; i<N; i++) s = s +x[i];
/**********found**********/
__1__=s/N; //*av
d=32767;
for(i=0; i<N; i++)
if(x[i]<*av && *av - x[i]<=d){ //将数与平均值之差求出来进行比较是否小于上一次差值，
/**********found**********/ //小于则更新差值d
d=*av-x[i];
j=__2__; //i
}
/**********found**********/
return __3__; //x[j]
}
void main()
{ int i; double x[N],av,m;
for(i=0; i<N; i++){ x[i]=rand()%50; printf("%4.0f ",x[i]);}
printf("\n");
m=fun(x,&av);
printf("\nThe average is: %f\n",av);
printf("m=%5.1f ",m);
printf("\n");
}【解析】rand()产生的是0~32767之间的随机数，那么rand()%5产生的数的平均值av肯定是小于32767的，事实上d的初值给50就可以。
/*函数fun的功能是将a和b所指的两个字符串分别转换成面值相同的整数，并进行相加作为函数值返回，规
定字符串中只有9个以下数字字符。
例如，主函数中输入字符串“32486”和“12345”，在主函数中输出的函数值为44831。
*/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define N 9
long ctod( char *s )
{ long d=0;
while(*s)
if(isdigit( *s)) {
/**********found**********/
d=d*10+*s-__1__; //'0' *s的值是ASCII码
/**********found**********/
__2__; //s++
}
return d;
}
long fun( char *a, char *b )
{
/**********found**********/
return __3__; //ctod(a)+ctod(b)
}
void main()
{ char s1[N],s2[N];
do
{ printf("Input string s1 : "); gets(s1); }
while( strlen(s1)>N );
do
{ printf("Input string s2 : "); gets(s2); }
while( strlen(s2)>N );
printf("The result is: %ld\n", fun(s1,s2) );
}【解析】考点在于如何将字符类型的数转换成数值类型。s指向的字符-字符'0'=对应的数值。d*10是为了保证前一个数和后一个数之间的关系是10倍，每次循环进这条语句时，上次结果的d都会乘上10倍再加入个位数。
必背：isdigit()函数——判断字符是否为数字，是返回非0。
总结：指针变量指向字符时，*指针变量的值是其ASCII码值。
/*函数fun的功能是：把形参s所指字符串中最右边的n个字符复制到形参t所指字符数组中，形成一个新
串。若s所指字符串的长度小于n，则将整个字符串复制到形参t所指字符数组中。
例如，形参s所指的字符串为：abcdefgh，n的值为5，程序执行后t所指字符数组中的字符串应为：
defgh。
*/
#include <stdio.h>
#include <string.h>
#define N 80
void fun(char *s, int n, char *t)
{ int len,i,j=0;
len=strlen(s);
/**********found**********/
if(n>=len) strcpy(__1__); //t,s
else {
/**********found**********/
for(i=len-n; i<=len-1; i++) t[j++]= __2__ ; //s[i]
/**********found**********/
t[j]= __3__ ; //'\0'
}
}
void main()
{ char s[N],t[N]; int n;
printf("Enter a string: ");gets(s);
printf( "Enter n:"); scanf("%d",&n);
fun(s,n,t);
printf("The string t : "); puts(t);
}/*此程序中，通过定义学生结构体变量，存储学生的学号、姓名和3门课的成绩。函数fun的功能是：将形
参a中的数据进行修改，把修改后的数据作为函数值返回主函数进行输出。
例如，若传给形参a的数据学号、姓名和三门课的成绩依次是：10001、"ZhangSan"、95、80、88，修改
后的数据应为：10002、"LiSi"、96、81、89。
*/
#include <stdio.h>
#include <string.h>
struct student {
long sno;
char name[10];
float score[3];
};
/**********found**********/
__1__ fun(struct student a) //struct student
{ int i;
a.sno = 10002;
/**********found**********/
strcpy(__2__, "LiSi"); //a.name
/**********found**********/
for (i=0; i<3; i++) __3__+= 1; //a.score[i]
return a;
}
void main()
{ struct student s={10001,"ZhangSan", 95, 80, 88}, t;
int i;
printf("\n\nThe original data :\n");
printf("\nNo: %ld Name: %s\nScores: ",s.sno, s.name);
for (i=0; i<3; i++) printf("%6.2f ", s.score[i]);
printf("\n");
t = fun(s);
printf("\nThe data after modified :\n");
printf("\nNo: %ld Name: %s\nScores: ",t.sno, t.name);
for (i=0; i<3; i++) printf("%6.2f ", t.score[i]);
printf("\n");
}总结：结构体自动填充选项不一定是结构体的顺序，要仔细看
/*函数fun的功能是：调用随机函数产生20个互不相同的整数放在形参a所指数组中（此数组在主函数中
已置零）。
*/
#include <stdlib.h>
#include <stdio.h>
#define N 20
void fun( int *a)
{ int i, x, n=0;
x=rand()%20;
/**********found**********/
while (n<__1__) //N
{ for(i=0; i<n; i++ )
/**********found**********/
if( x==a[i] )
__2__; //break
/**********found**********/
if( i==__3__) //n
{ a[n]=x; n++; }
x=rand()%20;
}
}
void main()
{ int x[N]={0} ,i;
fun( x );
printf("The result : \n");
for( i=0; i<N; i++ )
{ printf("%4d",x[i]);
if((i+1)%5==0)printf("\n");
}
printf("\n\n");
}【解析】x变量用来生成随机数，n是判断数组中存进去了多少个不同的数，当n不满足20时，就要继续生成随机数。 通过for循环遍历整个数组判断是否有同随机数相等的，如果有就不能写进数组，如果没有，下一步就是将这个数写进数组。因此当没有时，for应该循环完，i就等于n，就能根据n值判断是否执行写操作命令。当数组中存在和随机数相同的数，就不能让i=n。
2次未做对
/*在此程序中，函数fun的功能是建立一个N*N的矩阵。矩阵元素的构成规律是：最外层元素的值全部为1；
从外向内第2层元素的值全部为2；第3层元素的值全部为3，……依此类推。例如，若N=5，生成的矩阵为：
1 1 1 1 1
1 2 2 2 1
1 2 3 2 1
1 2 2 2 1
1 1 1 1 1
*/
/*根据规律，1、2阶矩阵，元素只有1；3、4阶矩阵元素有1、2；5、6阶矩阵元素有1、2、3
*/
#include <stdio.h>
#define N 7
/******foud*******/
void fun(int (*a)__1__) //int (*a)[N] 表示：定义指向长度为N的一维数组的指针a
{ int i,j,k,m;
if(N%2==0) m=N/2; //判断矩阵阶数的奇偶性，求元素最大值m
else m=N/2+1;
for(i=0; i<m; i++){
/******found******/
for(j=__2__; j<N-i; j++) //j并不表示矩阵的第几列，而是元素列下标
a[i][j]=a[N-i-1][j]=i+1; //第一行元素要用a[0]表示。同理，矩阵的第一个元素
for(k=i+1; k<N-i; k++) //要用a[0][0]表示，但是从外到内的第2层开始的元素
/******found******/ //地址是a[1][1]，所以j应该等于i
a[k][i]=a[k][N-i-1]=__3__; //=i+1
}
}
void main()
{ int x[N][N]={0},i,j;
fun(x); //将二维数组x的地址传给fun函数的形参
printf("\nThe result is:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%3d",x[i][j]);
printf("\n");
}
}/*函数fun的功能是：判定形参a所指的N×N（规定N为奇数）的矩阵是否是“幻方”，若是，函数返回值为
1；若不是，函数返回值为0。“幻方”的判定条件是：矩阵每行、每列、主对角线及反对角线上元素之和
都相等。
例如，以下3×3的矩阵就是一个“幻方”：
4 9 2
3 5 7
8 1 6
*/
#include <stdio.h>
#define N 3
int fun(int (*a)[N])
{ int i,j,m1,m2,row,colum;
m1=m2=0;
for(i=0; i<N; i++)
{ j=N-i-1; m1+=a[i][i]; m2+=a[i][j]; }
if(m1!=m2) return 0;
for(i=0; i<N; i++) {
/**********found**********/
row=colum= __1__; //0
for(j=0; j<N; j++)
{ row+=a[i][j]; colum+=a[j][i]; }
/**********found**********/
if( (row!=colum) __2__ (row!=m1) ) return 0; //||
}
/**********found**********/
return __3__; //1
}
void main()
{ int x[N][N],i,j;
printf("Enter number for array:\n");
for(i=0; i<N; i++)
for(j=0; j<N; j++) scanf("%d",&x[i][j]);
printf("Array:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++) printf("%3d",x[i][j]);
printf("\n");
}
if(fun(x)) printf("The Array is a magic square.\n");
else printf("The Array isn't a magic square.\n");
}
总结：函数中可以有多个return，但无论是哪条命令触发了return都会导致函数结束。
/*函数fun的功能是：用函数指针指向要调用的函数，并进行调用。规定在【2】处使f指向函数f1，在
【3】处使f指向函数f2。当调用正确时，程序输出：
x1=5.000000, x2=3.000000, x1*x1+x1*x2=40.000000。
*/
#include <stdio.h>
double f1(double x)
{ return x*x; }
double f2(double x, double y)
{ return x*y; }
double fun(double a, double b)
{
/**********found**********/
__1__ (*f)(); //double
double r1, r2;
/**********found**********/
f = __2__ ; //f1
r1 = f(a);
/**********found**********/
f = __3__ ; //f2
r2 = (*f)(a, b);
return r1 + r2;
}
void main()
{ double x1=5, x2=3, r;
r = fun(x1, x2);
printf("\nx1=%f, x2=%f, x1*x1+x1*x2=%f\n",x1, x2, r);
}#include <stdio.h>
#define M 3
#define N 5
void fun(int (*a)[N],int k)
{ int i,j,p,temp;
/**********found**********/
for(p=1; p<= __1__; p++) //k
for(i=0; i<M; i++)
{ temp=a[i][0];
/**********found**********/
for(j=0; j< __2__ ; j++) a[i][j]=a[i][j+1]; //N-1 填入N虽然能得到正确答案，
/**********found**********/ //但在最后执行一列时，j+1会越
a[i][N-1]= __3__; //界
}
}
void main( )
{ int x[M][N]={ {1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5} },i,j;
printf("The array before moving:\n\n");
for(i=0; i<M; i++)
{ for(j=0; j<N; j++) printf("%3d",x[i][j]);
printf("\n");
}
fun(x,2);
printf("The array after moving:\n\n");
for(i=0; i<M; i++)
{ for(j=0; j<N; j++) printf("%3d",x[i][j]);
printf("\n");
}
}
/*函数fun的功能是：在3×4的矩阵中找出行上最大、列上最小的那个元素，若没有符合条件的元素则输出
相应信息
*/
#include <stdio.h>
#define M 3
#define N 4
void fun(int (*a)[N])
{ int i=0,j,find=0,rmax,c,k;
while( (i<M) && (!find))
{ rmax=a[i][0]; c=0;
for(j=1; j<N; j++)
if(rmax<a[i][j]) {
/**********found**********/
rmax=a[i][j]; c= __1__ ; } //j
find=1; k=0; //find是判断位，找到某一行的最大值，默认它是这列的最小值，然后进行比较
while(k<M && find) {
/**********found**********/
if (k!=i && a[k][c]<=rmax) find= __2__ ; //0 找到了比这一行更小的值，说明这个
k++; //值不符合要求
}
if(find) printf("find: a[%d][%d]=%d\n",i,c,a[i][c]);
/**********found**********/
__3__ ; //i++
}
if(!find) printf("not found!\n");
}
void main()
{ int x[M][N],i,j;
printf("Enter number for array:\n");
for(i=0; i<M; i++)
for(j=0; j<N; j++) scanf("%d",&x[i][j]);
printf("The array:\n");
for(i=0; i<M; i++)
{ for(j=0; j<N; j++) printf("%3d",x[i][j]);
printf("\n\n");
}
fun(x);
}/*函数fun的功能是：判断形参s所指字符串是否是“回文”（PALINDROME）,若是，函数返回值为1；不是，
函数返回值为0。回文是正读和反读都一样的字符串（不区分大小写字母）。
例如，LEVEL和Level是回文，而LEVLEV不是“回文”。
*/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int fun(char *s)
{ char *lp,*rp;
/**********found**********/
lp= __1__ ; //s
rp=s+strlen(s)-1; //s是个地址，并不是数组下标0，当加上数组元素个时，会溢出，因此需要-1
while((toupper(*lp)==toupper(*rp)) && (lp<rp) ) {
/**********found**********/
lp++; rp __2__ ; } //--
/**********found**********/
if(lp<rp) __3__ ; //0
else return 1;
}
void main()
{ char s[81];
printf("Enter a string: "); scanf("%s",s);
if(fun(s)) printf("\n\"%s\" is a Palindrome.\n\n",s);
else printf("\n\"%s\" isn't a Palindrome.\n\n",s);
}必背：toupper()函数功能和返回值。
/*函数fun的功能是：将形参s所指字符串中的数字字符转换成对应的数值，计算出这些数值的累加和作为
函数值返回。
例如，形参s所指的字符串为abs5def126jkm8，程序执行后多输出结果为22。
*/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int fun(char *s)
{ int sum=0;
while(*s) {
/**********found**********/
if( isdigit(*s) ) sum+= *s- __1__ ; //'0'
/**********found**********/
__2__; //s++
}
/**********found**********/
return __3__ ; //sum
}
void main()
{ char s[81]; int n;
printf("\nEnter a string:\n\n"); gets(s);
n=fun(s);
printf("\nThe result is: %d\n\n",n);
}总结：sum+=*s-'0' 机器执行步骤为，先将*s-'0'计算出来，然后计算sum*s，再将结果赋值给sum。
/*函数fun的功能是：找出形参s所指字符串中出现频率最高的字母（不区分大小写），并统计出其出现
的次数。
例如，形参s所指的字符串为：abcAbsmaxless，程序执行后的输出结果为：
letter'a':3times
letter's':3times
*/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
void fun(char *s)
{ int k[26]={0},n,i,max=0; char ch;
while(*s)
{ if( isalpha(*s) ) {
/**********found**********/
ch=tolower(__1__);
n=ch-'a';
/**********found**********/
k[n]+= __2__ ;
}
s++;
/**********found**********/
if(max<k[n]) max= __3__ ;
}
printf("\nAfter count :\n");
for(i=0; i<26;i++)
if (k[i]==max) printf("\nletter \'%c\' : %d times\n",i+'a',k[i]);
}
void main()
{ char s[81];
printf("\nEnter a string:\n\n"); gets(s);
fun(s);
}必背：isalpha()的功能
#include <stdio.h>
#include <string.h>
#define N 5
#define M 8
void fun(char (*ss)[M])
{ char *ps[N],*tp; int i,j,k; //char *ps[N]定义的是一个行指针
for(i=0; i<N; i++) ps[i]=ss[i];
for(i=0; i<N-1; i++) {
/**********found**********/
k= __1__; //i
for(j=i+1; j<N; j++)
/**********found**********/
if(strlen(ps[k]) < strlen(__2__) ) k=j; //ps[j]
/**********found**********/
tp=ps[i]; ps[i]=ps[k]; ps[k] = __3__ ; //tp 因为ps是行指针（地址），右操作数也应
} //该是地址
printf("\nThe string after sorting by length:\n\n");
for(i=0; i<N; i++) puts(ps[i]);
}
void main()
{ char ch[N][M]={"red","green","blue","yellow","black"};
int i;
printf("\nThe original string\n\n");
for(i=0;i<N;i++)puts(ch[i]); printf("\n");
fun(ch);
}必背：行指针的定义格式
/*函数fun的功能是：计算下式前n项的和，并作为函数值返回。
1×3 3×5 5×7 n-1(2×n-1)×(2×n+1)
S=——— - ——— + ——— +(-1) ———————————————
2 2 2 2
2 4 6 (2×n)
例如，当形参n的值为10时，函数返回：-0.204491。
*/
#include <stdio.h>
double fun(int n)
{ int i, k; double s, t;
s=0;
/**********found**********/
k= __1__; //1
for(i=1; i<=n; i++) {
/**********found**********/
t= __2__; //2*i
s=s+k*(2*i-1)*(2*i+1)/(t*t);
/**********found**********/
k=k*__3__; //(-1)
}
return s;
}
void main()
{ int n=-1;
while(n<0)
{ printf("Please input(n>0): "); scanf("%d",&n); }
printf("\nThe result is: %f\n",fun(n));
}总结：尽管单目运算符的优先级比双目运算符的优先级高，但是很有可能程序结果正确，但扣分，因此该用括号，避免负数的负号造成扣分。
/*函数fun的功能是将带头结点的单向链表逆置，即若原链表中从头至尾结点数据域依次为2,4,6,8,10，
逆置后，从头至尾结点数据域依次为10,8,6,4,2。
*/
#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct node {
int data;
struct node *next;
} NODE;
void fun(NODE *h)
{ NODE *p, *q, *r;
/**********found**********/
p = h->__1__; //next
/**********found**********/
if (p==__2__) return;
q = p->next;
p->next = NULL;
while (q)
{ r = q->next; q->next = p;
/**********found**********/
p = q;
q = __3__; //r
}
h->next = p;
}
NODE *creatlist(int a[])
{ NODE *h,*p,*q; int i;
h = (NODE *)malloc(sizeof(NODE));
h->next = NULL;
for(i=0; i<N; i++)
{ q=(NODE *)malloc(sizeof(NODE));
q->data=a[i];
q->next = NULL;
if (h->next == NULL) h->next = p = q;
else { p->next = q; p = q; }
}
return h;
}
void outlist(NODE *h)
{ NODE *p;
p = h->next;
if (p==NULL) printf("The list is NULL!\n");
else
{ printf("\nHead ");
do
{ printf("->%d", p->data); p=p->next; }
while(p!=NULL);
printf("->End\n");
}
}
void main()
{ NODE *head;
int a[N]={2,4,6,8,10};
head=creatlist(a);
printf("\nThe original list:\n");
outlist(head);
fun(head);
printf("\nThe list after inverting :\n");
outlist(head);
}总结：哪怕输出结果正确，也要仔细查看题目部分的输出信息是否同程序信息一致
/*函数fun的功能是：将形参s所指字符串中下标为奇数的字符取出，并按ASCII码大小递增排序，将排序
后的字符存入形参p所指字符数组中，形成一个新串。
例如，形参s所指的字符为：baaawrskjghzlicda，执行后p所指字符数组中的字符串应为：aachjlsw。
*/
#include <stdio.h>
void fun(char *s, char *p)
{ int i, j, n, x, t;
n=0;
for(i=0; s[i]!='\0'; i++) n++;
for(i=1; i<n-2; i=i+2) {
/**********found**********/
__1__; //t=i 假设s[i]就是最小的值，并将下标赋值给t
/**********found**********/
for(j=__2__ ; j<n; j=j+2) //i或者t+2 循环变量从i开始和从i+2开始都一样
if(s[t]>s[j]) t=j;
if(t!=i)
{ x=s[i]; s[i]=s[t]; s[t]=x; }
}
for(i=1,j=0; i<n; i=i+2, j++) p[j]=s[i];
/**********found**********/
p[j]=__3__; //0
}
void main()
{ char s[80]="baawrskjghzlicda", p[50];
printf("\nThe original string is : %s\n",s);
fun(s,p);
printf("\nThe result is : %s\n",p);
}/*函数fun的功能是将形参给定的字符串、整数、浮点数写到文本文件中，再用字符方式从此文本文件中逐
个读入并显示在终端屏幕上。
*/
#include <stdio.h>
void fun(char *s, int a, double f)
{
/**********found**********/
__1__ fp; //FILE*
char ch;
fp = fopen("file1.txt", "w");
fprintf(fp, "%s %d %f\n", s, a, f);
fclose(fp);
fp = fopen("file1.txt", "r");
printf("\nThe result :\n\n");
ch = fgetc(fp);
/**********found**********/
while (!feof(__2__)) //fp
{
/**********found**********/
putchar(__3__); //ch
ch = fgetc(fp);
}
putchar('\n');
fclose(fp);
}
void main()
{ char a[10]="Hello!"; int b=12345;
double c= 98.76;
fun(a,b,c);
}必背：feof()的返回值；fgetc()读完了文件指针所指向的字符后，自动向后移动一个Byte（字符）；putchar(ch)，ch不能是指针。
/*函数fun的功能是将参数给定的字符串、整数、浮点数写到文本文件中，再用字符串方式从此文本文件中
逐个读入，并调用库函数atoi和atof将字符串转换成相应的整数、浮点数，然后将其显示在屏幕上。
*/
#include <stdio.h>
#include <stdlib.h>
void fun(char *s, int a, double f)
{
/**********found**********/
__1__ fp; //FILE*
char str[100], str1[100], str2[100];
int a1; double f1;
fp = fopen("file1.txt", "w");
fprintf(fp, "%s %d %f\n", s, a, f);
/**********found**********/
__2__ ; //fclose(fp)
fp = fopen("file1.txt", "r");
/**********found**********/
fscanf(__3__,"%s%s%s", str, str1, str2); //fp
fclose(fp);
a1 = atoi(str1);
f1 = atof(str2);
printf("\nThe result :\n\n%s %d %f\n", str, a1, f1);
}
void main()
{ char a[10]="Hello!"; int b=12345;
double c= 98.76;
fun(a,b,c);
}【解析】 atoi()是将字符串转化为整型，atof()可以将字符串转换成浮点型
/*函数fun的功能是：将形参n中，各位上为偶数的数取出，并按原来从高位到低位的顺序组成一个新数，
作为函数值返回。
例如，从主函数输入一个整数27638496，则函数返回值为26846。
*/
#include <stdio.h>
unsigned long fun(unsigned long n)
{ unsigned long x=0, s, i; int t;
s=n;
/**********found**********/
i=__1__; //1
/**********found**********/
while(__2__) //s或s>0
{ t=s%10;
if(t%2==0){
/**********found**********/
x=x+t*i; i=__3__; //i*10
}
s=s/10;
}
return x;
}
void main()
{ unsigned long n=-1;
while(n>99999999||n<0)
{ printf("Please input(0<n<100000000): "); scanf("%ld",&n); }
printf("\nThe result is: %ld\n",fun(n));
}【解析】s!=0会扣分
/*此程序中，通过定义学生结构体数组，存储若干名学生的学号、姓名和三门课的成绩。函数fun的功能是
：将存放学生数据的结构体数组，按姓名的字典序（从小到大）排序。
*/
#include <stdio.h>
#include <string.h>
struct student {
long sno;
char name[10];
float score[3];
};
void fun(struct student a[], int n)
{
/**********found**********/
__1__ t; //struct student
int i, j;
/**********found**********/
for (i=0; i<__2__; i++) //n-1
for (j=i+1; j<n; j++)
/**********found**********/
if (strcmp(__3__) > 0) //a[i].name,a[j].name
{ t = a[i]; a[i] = a[j]; a[j] = t; }
}
void main()
{ struct student s[4]={{10001,"ZhangSan", 95, 80, 88},{10002,"LiSi", 85, 70, 78},
{10003,"CaoKai", 75, 60, 88}, {10004,"FangFang", 90, 82, 87}};
int i, j;
printf("\n\nThe original data :\n\n");
for (j=0; j<4; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",s[j].sno, s[j].name);
for (i=0; i<3; i++) printf("%6.2f ", s[j].score[i]);
printf("\n");
}
fun(s, 4);
printf("\n\nThe data after sorting :\n\n");
for (j=0; j<4; j++)
{ printf("\nNo: %ld Name: %-8s Scores: ",s[j].sno, s[j].name);
for (i=0; i<3; i++) printf("%6.2f ", s[j].score[i]);
printf("\n");
}
}总结：当嵌套循环中循环变量j的起始值与循环变量i有关时，注意i的终止循环值有无越界问题
/*甲乙丙丁4人同时开始放鞭炮，甲每隔t1s放一次，乙每隔t2s放一次，丙每隔t3s放一次，丁每隔t4s放
一次，每人各放n次。函数fun的功能是根据形参炸响，只算一次响声，第一次响声是在第0s。
例如，若t1=7，t2=5，t3=6，t4=4，n=10，则总共可听到28次鞭炮声。
*/
/*题干有问题，根据视频解析，甲乙丙丁在第0s同时放第一次炮，各自间隔一段时间再放。由于间隔时间
各不相同，很有可能会在某个时间，有人同时放炮，那么，就计算这次炮声只为1次。
只能从第0s开始，每秒计算，看有无人在放炮，直到最后一个人放了n次。例如，在甲间隔时间最长，放炮
的时间最久。
*/
#include <stdio.h>
/**********found**********/
#define OK(i, t, n) ((___1___%t==0) && (i/t<n)) //i 对间隔时间t求余，判断是否
int fun(int t1, int t2, int t3, int t4, int n) //应该放炮，同时将次数减1
{ int count, t , maxt=t1;
if (maxt < t2) maxt = t2;
if (maxt < t3) maxt = t3;
if (maxt < t4) maxt = t4;
count=1; /* 给count赋初值 */
/**********found**********/
for(t=1; t< maxt*(n-1); ___2___) //t++ 由于第0s就放了第一次，那么最后的次数就应该
{ //减1
if(OK(t, t1, n) || OK(t, t2, n)|| OK(t, t3, n) || OK(t, t4, n) )
count++;
}
/**********found**********/
return ___3___; //count
}
void main()
{ int t1=7, t2=5, t3=6, t4=4, n=10, r;
r = fun(t1, t2, t3, t4, n);
printf("The sound : %d\n", r);
}/*函数fun的功能是：求出形参ss所指字符串数组中最长字符串的长度，将其余字符串右边用字符*补齐，
使其与最长的字符串等长。ss所指字符串数组中共有M个字符串，且串长小于N。
*/
#include <stdio.h>
#include <string.h>
#define M 5
#define N 20
void fun(char (*ss)[N])
{ int i, j, n, len=0;
for(i=0; i<M; i++)
{ n=strlen(ss[i]);
if(i==0) len=n;
if(len<n)len=n;
}
for(i=0; i<M; i++) {
/**********found**********/
n=strlen(__1__); //ss[i]
for(j=0; j<len-n; j++)
/**********found**********/
ss[i][n+__2__]='*'; //j
/**********found**********/
ss[i][n+j+__3__]='\0'; //0
}
}
void main()
{ char ss[M][N]={"shanghai","guangzhou","beijing","tianjing","cchongqing"};
int i;
printf("The original strings are :\n");
for(i=0; i<M; i++) printf("%s\n",ss[i]);
printf("\n");
fun(ss);
printf("The result is :\n");
for(i=0; i<M; i++) printf("%s\n",ss[i]);
}/*此程序功能是：调用函数fun将指定源文件中的内容复制到指定的目标文件中，复制成功时函数返回1，
失败时返回0。在复制的过程中，把复制的内容输出到屏幕。主函数源文件名放在变量sfname中，目标文
件名放在变量tfname中。
*/
#include <stdio.h>
#include <stdlib.h>
int fun(char *source, char *target)
{ FILE *fs,*ft; char ch;
/**********found**********/
if((fs=fopen(source, __1__))==NULL) //"r" 源文件的打开方式应该是读
return 0;
if((ft=fopen(target, "w"))==NULL)
return 0;
printf("\nThe data in file :\n");
ch=fgetc(fs);
/**********found**********/
while(!feof(__2__)) //fs
{ putchar( ch ); //输出屏幕
/**********found**********/
fputc(ch,__3__); //ft 写入目标文件
ch=fgetc(fs);
}
fclose(fs); fclose(ft);
printf("\n\n");
return 1;
}
void main()
{ char sfname[20] ="myfile1",tfname[20]="myfile2";
FILE *myf; int i; char c;
myf=fopen(sfname,"w");
printf("\nThe original data :\n");
for(i=1; i<30; i++){ c='A'+rand()%25;fprintf(myf,"%c",c); printf("%c",c); }
fclose(myf);printf("\n\n");
if (fun(sfname, tfname)) printf("Succeed!");
else printf("Fail!");
}/*此程序中，已建立了一个带头结点的单向链表，在main函数中将多次调用fun函数，每调用一次，输出链
表尾部结点中的数据，并释放该结点，使链表缩短。
*/
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{ int data;
struct list *next;
} SLIST;
void fun( SLIST *p)
{ SLIST *t, *s;
t=p->next; s=p;
while(t->next != NULL)
{ s=t;
/**********found**********/
t=t->___1___; //next
}
/**********found**********/
printf(" %d ",___2___); //t->data
s->next=NULL;
/**********found**********/
free(___3___); //t
}
SLIST *creatlist(int *a)
{ SLIST *h,*p,*q; int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{ q=(SLIST *)malloc(sizeof(SLIST));
q->data=a[i]; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{ SLIST *p;
p=h->next;
if (p==NULL) printf("\nThe list is NULL!\n");
else
{ printf("\nHead");
do { printf("->%d",p->data); p=p->next; } while(p!=NULL);
printf("->End\n");
}
}
void main()
{ SLIST *head;
int a[N]={11,12,15,18,19,22,25,29};
head=creatlist(a);
printf("\nOutput from head:\n"); outlist(head);
printf("\nOutput from tail: \n");
while (head->next != NULL){
fun(head);
printf("\n\n");
printf("\nOutput from head again :\n"); outlist(head);
}
}必背：free()函数用于释放动态内存空间，头文件stdlib
/*函数fun的功能是：有N×N矩阵，根据给定的m(m<=N)值，将每行元素中的值均向右移动m个位置，左位置
为0。
例如，N=3，m=2，有下列矩阵：
1 2 3
4 5 6
7 8 9
程序执行结果为：
0 0 1
0 0 4
0 0 7
*/
#include <stdio.h>
#define N 4
void fun(int (*t)[N], int m)
{ int i, j;
/**********found**********/
for(i=0; i<N; ___1___ ) //i++
{ for(j=N-1-m; j>=0; j--)
/**********found**********/
t[i][j+___2___]=t[i][j]; //m
/**********found**********/
for(j=0; j<___3___; j++) //m
t[i][j]=0;
}
}
void main()
{ int t[][N]={21,12,13,24,25,16,47,38,29,11,32,54,42,21,33,10}, i, j, m;
printf("\nThe original array:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++)
printf("%2d ",t[i][j]);
printf("\n");
}
printf("Input m (m<=%d): ",N);scanf("%d",&m);
fun(t,m);
printf("\nThe result is:\n");
for(i=0; i<N; i++)
{ for(j=0; j<N; j++)
printf("%2d ",t[i][j]);
printf("\n");
}
}/*函数fun的功能是：根据所给的年、月、日，计算出该日是这一年的第几天，并作为函数值返回。其中函
数isleap用来判别某一年是否为闰年。
例如，若输入：2008 5 1，则程序输出：2008年5月1日是该年的第122天。
*/
#include <stdio.h>
int isleap(int year)
{ int leap;
leap= (year%4==0 && year%100!=0 || year%400==0); //
/**********found**********/
return __(1)__; //leap
}
int fun(int year, int month, int day)
{ int table[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
int days=0 , i;
for(i=1; i<month; i++) //计算从一月至上个月月底的天数
days=days + table[i];
/**********found**********/
days=days+__(2)__ ; //day 计算这个月的天数
if( isleap(year) && month>2 ) //闰年的二月份有29天
/**********found**********/
days=days+__(3)__; //1
return days;
}
void main()
{ int year, month, day, days ;
printf("请输入年、月、日：");
scanf("%d%d%d",&year, &month, &day);
days = fun(year, month, day);
printf("%d年%d月%d日是该年的第%d天\n",year, month, day, days);
}总结：判断闰年的方法
/*函数fun的功能是：求出s1和s2两个字符串的最大公共子串的长度并返回
所谓两个字符串的公共子串是指同时在两个字符串中出现的连续的一个字串。本题要求输出这两个字符串最
长公共字串的长度。
例如：s1="qwertyuiop"，s2="asdrtyukl"，则“rtyu”为这两个字符串的最长公共子串，因此返回值为
4。
*/
#include <stdio.h>
#include <string.h>
int fun(char s1[], char s2[])
{
int n, m, mx = 0;
int i, j, k;
int left_n, left_m, left_num;
n = strlen(s1);
/**********found**********/
m = ____(1)____; //strlen(s2)
for (i = 0;i < n;i++)
{
for (j = 0; j < m;j++)
{
left_n = n - i;
left_m = m - i;
/**********found**********/
left_num = left_n > left_m ? ____(2)____; //left_m:left_n
for (k = 0;k < left_num;k++)
{
if (s1[i + k] != s2[j + k])
break;
}
/**********found**********/
mx = k > mx ? ____(3)____; //k:mx
}
}
return mx;
}
main()
{
char s1[100] = "qwertyuiop";
char s2[100] = "asdrtyukl";
int max;
max = fun(s1, s2);
printf("max=%d\n", max);
}程序修改题
/*在此程序中，函数Creatlink的功能是：创建带头结点的单向链表，并为各结点数据域赋0到m-1的值。
*/
#include <stdio.h>
#include <stdlib.h>
typedef struct aa
{ int data;
struct aa *next;
} NODE;
NODE *Creatlink(int n, int m)
{ NODE *h=NULL, *p, *s;
int i;
/**********found***********/
p=(NODE )malloc(sizeof(NODE)); //NODE* malloc返回的是指针，最后强制类型转换的指针
h=p; //标识符“*”别忘。p在定义时也是用的NODE *。p指向NODE
p->next=NULL; //结构体类型的内存首地址，同时也让h指向这个区域。并且
for(i=1; i<=n; i++) //让这个结点的指针域赋值为NULL
{ s=(NODE *)malloc(sizeof(NODE)); //每次循环创建一个新的结点
s->data=rand()%m; s->next=p->next; //将新结点的next域赋值为NULL
p->next=s; p=p->next; //让p的nect域指向新结点，同时让指针p指向新结
} //点
/**********found***********/
return p; //return h;
}
void outlink(NODE *h)
{ NODE *p;
p=h->next;
printf("\n\nTHE LIST :\n\n HEAD ");
while(p)
{ printf("->%d ",p->data);
p=p->next;
}
printf("\n");
}
void main()
{ NODE *head;
head=Creatlink(8,22);
outlink(head);
}总结：两个指针变量指向同一个地址时，通过一个指针变量修改地址的内容，也会使得另一个指针变量指向的内容产生变化，但是当指针变量指向的是NULL时，则并不会，因为它们并不是指向同一个公共区域。
【解析】Creatlink函数先创建了头结点和指向它首地址的指针p，并让指针变量h也指向这个结点，且头结点next域赋值为NULL。
在for循环中，每循环一次创建一个新的结点，并将数据域和next域进行更改。s指向新的结点，s的data域随机产生数据，并将新结点的next域指向为NULL。
然后将新结点的首地址（data域）给p所指向的头结点的next域，最后让p的值等于新结点的首地址，实际上p指向的是新结点的data域，二者是等价的。
新的循环开始后，s会被初始化为下一个新结点， next域同样会被赋予NULL。
新的结点将会被插在上一个结点后面（尾插法），同样p将指向末尾的结点。整个过程中只有h没动过。
/*函数fun的功能是：根据整型形参n，计算如下公式的值。
1 1 1
A1=1, A2=-----， A3=-----，…， An=---------
1+A1 1+A2 1+A(n-1)、
例如，若n=10，则应输出0.617977。
*/
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
/*************found**************/
int fun(int n) //float fun(int n) 虽然用double程序也能运行出正确结果，但是会扣分,因
{ float A=1;int i; //为A的定义就是float
/*************found**************/
for(i=2;i<n;i++) //for(i=2;i<=n;i++) 如果i=1，当n=2时，不会计算A2的值
A=1.0/(1+A);
return A;
}
void main()
{ int n;
system("CLS");
printf("\nPlease enter n: ");
scanf("%d",&n);
printf("A%d=%lf\n",n,fun(n));
}/*函数fun的功能是：统计字符串中各元音字母（即A、E、I、O、U）的个数。注意：字母不分大小写。
例如，输入“THIs is a boot”，则应输出是1 0 2 2 0。
*/
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
/*************found**************/
fun(char *s, int num[5]) //void fun(char *s, int num[5])
{ int k, i=5;
for(k=0;k<i;k++)
/*************found**************/
num[i]=0; //num[k]=0 未初始化的变量要初始化，不然其值不确定
for(;*s;s++)
{ i=-1;
/*************found**************/
switch(s) //switch(*s)
{ case 'a': case'A':{i=0;break;}
case 'e': case 'E':{i=1;break;}
case 'i': case 'I':{i=2;break;}
case 'o': case 'O':{i=3;break;}
case 'u': case 'U':{i=4;break;}
}
if(i>=0)
num[i]++;
}
}
void main()
{ char s1[81]; int num1[5], i;
system("CLS");
printf("\nPlease enter a string: ");
gets(s1);
fun(s1, num1);
for(i=0;i<5;i++) printf("%d ",num1[i]);
printf("\n");
}
总结：每个变量使用前一定要初始化，不然其值是一个不确定的数。
/*在此程序中，函数fun的功能是：将十进制正整数m转换成k(2≤k≤9)进制数，并按位输出。例如，若输入
8和2，则应该输出1000（即十进制数8转换成二进制表示是1000）。
*/
/*十进制转k进制的方法就是“除k取余”
*/
#include <stdio.h>
#include <conio.h>
/*********foud**********/ //“found”提示在下1~2行有错误
void fun(int m,int k); //定义函数fun时，不应有“;”
{ int aa[20],i;
for(i=0;m;i++) //将十进制数“m”作为循环终止判断，当m=0表示已经被除尽
{
/*********foud**********/
aa[i]=m/k; //用aa数组存储十进制数m除以进制k后的余数，aa[i]=m%k
m/=k; //将商赋值给m，再次循环，直至m为0
}
for(;i;i--) //由于aa数组最后一个元素是k进制的最高位，输出屏幕时应从aa中第i-1标号处递减
/*********foud**********/ //输出
printf("%d",aa[i]); //printf("%d",aa[i-1];
}
void main()
{
int b,n;
printf("\nPlease enter a number and a base:\n");
scanf("%d%d",&n,&b);
fun(n,b);
printf("\n");
}/*在此程序中，建立一个带头结点的单向链表，并用随机函数为各结点赋值。函数fun的功能是将单向链表
结点（不包括头结点）数据域为偶数的值累加起来，并且作为函数值返回。
*/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
typedef struct aa
{ int data;
struct aa *next;
} NODE;
int fun (NODE *h)
{ int sum=0;
NODE *p;
p=h->next;
/*************found**************/
while(p->next) //while(p!=NULL)
{ if(p->data%2==0)
sum+=p->data;
/*************found**************/
p=h->next; //p=p->next
}
return sum;
}
NODE *creatlink(int n)
{
NODE *h,*p,*s;
int i;
h=p=(NODE*)malloc(sizeof(NODE));
for(i=1;i<n;i++)
{
s=(NODE*)malloc(sizeof(NODE));
s->data=rand()%16;
s->next=p->next;
p->next=s;
p=p->next;
}
p->next=NULL;
return h;
}
void outlink(NODE *h)
{ NODE *p;
p=h->next;
printf("\n\n The LIST :\n\n HEAD");
while(p)
{ printf("->%d",p->data);
p=p->next;}
printf("\n");
}
void main()
{ NODE *head; int sum;
system("CLS");
head=creatlink(10);
outlink(head);
sum=fun(head);
printf("\nSUM=%d",sum);
}【解析】这题有点奇怪，仿照outlink函数用p去遍历所有结点，居然提示扣分，非得是p != NULL。
/*函数fun的功能是：根据形参m=值（2≤m≤9），在m行m列的二维数组中存放如下所示规律的数据，由main
函数输出。
例如，若输入2 若输入4
则输出： 则输出：
1 2 1 2 3 4
2 4 2 4 6 8
3 6 9 12
4 8 12 16
*/
#include <conio.h>
#include <stdio.h>
#define M 10
int a[M][M] = {0} ;
/**************found**************/
void fun(int **a, int m) //void fun(int a[][M], int m)
{ int j, k ;
for (j = 0 ; j < m ; j++ )
for (k = 0 ; k < m ; k++ )
/**************found**************/
a[j][k] = k * j ; //a[j][k]=(k+1)*(j+1)
}
void main ( )
{ int i, j, n ;
printf ( " Enter n : " ) ; scanf ("%d", &n ) ;
fun ( a, n ) ;
for ( i = 0 ; i < n ; i++)
{ for (j = 0 ; j < n ; j++)
printf ( "%4d", a[i][j] ) ;
printf ( "\n" ) ;
}
}
【解析】为什么形参不能用全局变量a，不是说在局部变量的范围内，全局变量会被屏蔽吗？虽然用*aa也能得出正确的结果，但是对应的实参a是个二维数组的全局变量，用变量a没有问题，问题在于二维数组指针的形参形式错了，用*a[][M]也能得到正确结果，可是会扣分。
/*函数fun的功能是：给定n个实数，输出平均值，并统计平均值以上（含平均值）的实数个数。例如，
n=8时，输入193.199、195.673、195.757、196.051、196.092、196.596、196.579、196.763、
所得平均值为195.838745，在平均值以上的实数个数应为5。
*/
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
int fun(float x[], int n)
/************found************/
int j, c=0; float xa=0.0; //{ int j, c=0; float xa=0.0;
for (j=0; j<n; j++)
xa += x[j]/n;
printf("ave =%f\n",xa);
for (j=0; j<n; j++)
/************found************/
if (x[j] => xa) //if(x[j] >= xa)
c++;
return c;
}
void main ()
{float x[100] = {193.199, 195.673, 195.757, 196.051, 196.092, 196.596, 196.579,
196.763};
system("cls");
printf("%d\n", fun (x, 8));
}
【解析】尽管将if表达式用<=去表达程序正确，但会扣分。
必背：关系运算符的符号，特别是用的比较少的大于等于。
/*函数fun的功能使：比较两个字符串，将长的字符串的首地址作为函数值返回。
*/
#include <conio.h>
#include <stdio.h>
/*************found**************/
double fun(char *s,char *t) //char *fun(char *s,char *t)
{
int s1=0,t1=0;
char *ss,*tt;
ss=s;
tt=t;
while(*ss)
{
s1++;
/*************found**************/
(*ss)++; //ss++;
}
while(*tt)
{
t1++;
/*************found**************/
(*tt)++; //tt++;
}
if(t1>s1)
return t;
else
return s;
}
void main()
{
char a[80],b[80];
printf("\nEnter a string : ");
gets(a);
printf("\nEnter a string again: ");
gets(b);
printf("\nThe longer is :\n\n%s\n", fun(a,b));
}必背：函数指针的和指针函数的区别以及定义格式。
/*函数fun的功能是：在字符串的最前端加入n个*号，形成新串，并覆盖远串。
字符串的长度最长允许为79。
*/
#include <stdio.h>
#include <string.h>
void fun ( char s[], int n )
{
char a[80] , *p;
int i;
/**********found***********/
s=p; //p=s;
for(i=0; i<n; i++) a[i]='*';
do
{ a[i]=*p;
i++;
}
/**********found***********/
while(*p++) //while(*p++);
a[i]=0;
strcpy(s,a);
}
void main()
{ int n; char s[80];
printf("\nEnter a string : "); gets(s);
printf("\nThe string \"%s\"\n",s);
printf("\nEnter n ( number of * ) : "); scanf("%d",&n);
fun(s,n);
printf("\nThe string after insert : \"%s\" \n" ,s);
}必背：do{…}while; 需要带上分号。
总结：*与++的优先级在同级别，又因为一元运算的结合方向是从右到左，先p++，然后取内容。
/*函数fun的功能是：计算s所指字符串中含有t所指字符串的数目，并作为函数值返回。
*/
/*考察字符串匹配，需要在字符串a查找是否包含字符字串b，然后将a中包含字串b的个数统计，并返回。
*/
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <stdio.h>
#define N 80
int fun(char *s,char *t)
{ int n;
char *p, *r;
n=0;
/*************found**************/
*r=t; //r=t;
while ( *s )
{
p = s;
while ( *r )
{
if ( *r == *p )
{
r++;
p++;
}
else
break;
if ( *r == '\0' )
n++;
}
/*************found**************/
____1___; //r=t
s++;
}
return n;
}
void main()
{char a[N],b[N]; int m;
printf("\nPlease enter string a: ");
gets(a);
printf("\nPlease enter substring b: ");
gets(b);
m=fun(a,b);
printf("\nThe result is :m=%d\n",m);
}/*函数fun的功能是：用下面的公式求Π的近似值，直到最后一项的绝对值小于指定的数（参数num）为止。
Π 1 1 1
—≈1 - — + — - — + …
4 3 5 7
例如，程序运行后，输入0.0001，则程序输出3.1414。
*/
#include <math.h>
#include <stdio.h>
float fun ( float num )
{ int s ;
float n, t, pi ;
t = 1 ; pi = 0 ; n = 1 ; s = 1 ;
/**************found**************/
while(t >= num) //while(fabs(t) >= num)
{
pi = pi + t ;
n = n + 2 ;
s = -s ;
/**************found**************/
t = s % n ; //
}
pi = pi * 4 ;
return pi ;
}
void main( )
{ float n1, n2 ;
printf("Enter a float number: ") ;
scanf("%f", &n1) ;
n2 = fun(n1) ;
printf("%6.4f\n", n2) ;
}必背：浮点型求绝对值用函数fabs()
/*函数fun的功能是：对N名学生的学习成绩，按从高到低的顺序找出前m(m≤10)名学生来，并将这些学生
的数据存放在一个动态分配的连续存储区中，此存储区的首地址作为函数值返回。
*/
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <stdio.h>
#include <malloc.h>
#define N 10
typedef struct ss
{ char num[10];
int s;
} STU;
STU *fun(STU a[], int m)
{ STU b[N],*t;
int i, j,k;
/*************found**************/
*t=calloc(m,sizeof(STU)); //t=(STU*)calloc(m,sizeof(STU));
for(i=0;i<N;i++) b[i]=a[i];
for(k=0;k<m;k++)
{ for (i=j=0;i<N;i++)
if(b[i].s>b[j].s) j=i;
/*************found**************/
t[k].num=b[j].num; //strcpy(t[k].num,b[j].num);
t[k].s=b[j].s;
b[j].s=0;
}
return t;
}
void outresult(STU a[],FILE *pf)
{ int i;
for(i=0;i<N;i++)
fprintf(pf, "No=%s Mark=%d\n ",
a[i].num, a[i].s);
fprintf(pf, "\n\n ");
}
void main()
{ STU a[N]={{ "A01 ",81},{ "A02 ",89},{ "A03 ",66},{ "A04 ",87},{ "A05 ",77},
{ "A06 ",90},{ "A07 ",79},{ "A08 ",61},{ "A09 ",80},{ "A10 ",71}};
STU *pOrder;
int i, m;
system("CLS");
printf("*****THE RESULT*****\n");
outresult(a,stdout);
printf("\nGive the number of the students who have better score: ");
scanf("%d",&m);
while(m>10)
{ printf("\nGive the number of the students who have better score: ");
scanf("%d",&m);
}
pOrder=fun(a,m);
printf("***** THE RESULT*****\n");
printf("The top :\n");
for(i=0;i<m;i++)
printf("%s %d\n",pOrder[i].num, pOrder[i].s);
free(pOrder);
}必背：将指针指向一个动态分配区域的格式，最后指针类型进行强制转换
/*函数fun的功能是：计算并输出下列级数的前N项和S ，直到S 的值大于q为止，q的值通过形参传入。
N N+1
2 3 4 N+1
S = — + — + — + … + ———
N 1 2 3 N
例如，若q的值为50.0，则函数值应为49.394948。
*/
#include <conio.h>
#include <stdio.h>
double fun(double q)
{
int n;
double s,t;
n=2;
s=2.0;
while (s <= q)
{
t=s;
/********found*********/
s=s+ (n+1)/n; //s=s+(double)(n+1)/n;
n++;
}
printf("n=%d\n",n);
/********found********/
return s; //return t;
}
void main ( )
{
printf("%f\n",fun(50));
}【解析】不改变执行顺序的括号很有可能会扣分，要注意。
总结：当不同数据类型在一块进行乘除运算时，结果为精度更高的类型
/*此程序中，函数fun的功能是：求两个非零正整数的最大公约数，并作为函数值返回。
例如，若num1和num2分别为49和21，则输出的最大公约数为7；若num1和num2分别为27和81，则输出的最
大公约数为27。
*/
#include <stdio.h>
int fun(int a,int b)
{ int r,t;
if(a<b) {
/************found************/
t=a; b=a; a=t; //t=a; a=b; b=t;
}
r=a%b;
while(r!=0)
{ a=b; b=r; r=a%b; }
/************found************/
return (a); //return (b) r=0后，循环结束，最大公约数的位置在b
}
void main()
{ int num1, num2,a;
printf("Input num1 num2: "); scanf("%d%d",&num1,&num2);
printf("num1= %d num2= %d\n\n",num1,num2);
a=fun(num1,num2);
printf("The maximun common divisor is %d\n\n",a);
}总结：求最大公约的方法有3种，辗转相除法、相减法、穷举法。
/*函数fun的功能是：为一个偶数寻找两个素数，这两个素数之和等于该偶数，并将这两个素数通过形参指
针传回主函数。
*/
#include <stdio.h>
#include <math.h>
void fun(int a, int *b, int *c)
{ int i,j,d,y;
for (i=3;i<=a/2;i=i+2) //i的步长为2，保证每次i的值为奇数，因为素数不可能为偶数
{ //i代表着两个素数中较小的那个数，所以取值不能超过a/2
/*************found**************/
y=0; //y=1; 用y来判定i是不是素数，根据后面的程序，i一开始就应为认为是素数
for (j=2;j<=sqrt((double)i );j++)
if (i%j==0) y=0; //如果i不是素数，y就为0
if (y==1) //i是素数，y就为1
{
/*************found**************/
d=i-a; //d=a-i; 通过a-素数i，求出另一个数，判断是否是素数
for (j=2;j<=sqrt((double)d );j++)
if (d%j==0) y=0;
if (y==1)
{*b=i; *c=d;}
}
}
}
void main()
{ int a,b,c;
do
{ printf("\nInput a: ");
scanf("%d",&a);}
while(a%2);
fun(a,&b,&c);
printf("\n\n%d=%d+%d\n",a,b,c);
}/*此程序种，主函数将a、b、c三个结点链成一个单向链表，并给各结点的数据域赋值，，函数fun()的作
用是：累加链表结点数据域中的数据作为函数值返回。
*/
#include <stdio.h>
typedef struct list
{ int data;
struct list *next;
} LIST;
int fun(LIST *h)
{ LIST *p;
/**********found**********/
int t; //int t=0;
p=h;
/**********found**********/
while( *p ) //while( p )
{
/**********found**********/
t=t+*p.data; //t=t+(*p).data;
p=(*p).next;
}
return t;
}
void main()
{ LIST a, b, c, *h;
a.data=34; b.data=51; c.data=87; c.next='\0';
h=&a; a.next=&b; b.next=&c;
printf("总和 = %d\n",fun( h ));
}/*函数fun的功能是：根据形参n计算并返回阶乘n!。为避免每次阶乘都要从1开始乘起，程序中使用了静态
结构体变量old保存上次计算的阶乘。每次计算时，要比较新的参数n与上次计算的阶数n，以便决定计算方
法。
*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#pragma warning (disable:4996)
struct Ord
{
int n;
long ordor;
};
long fun(int n)
{
static struct Ord old={0,1};
int i;
if(n==old.n)
/**********************found***********************/
return (___1___); //old.ordor
if(n>old.n)
for(i=old.n+1;i<=n;i++)
old.ordor*=i;
else
for(i=old.n;i>n;i--)
old.ordor/=i;
/**********************found***********************/
old.n=___2___; //n
/**********************found***********************/
return (___3___); //old.ordor
}
main( )
{
int i,n;
for(i=0;i<5;i++)
{
n=rand()%10;
printf("%d %ld\n",n,fun(n));
}
}程序设计题
/*函数fun的功能是：统计一行字符串中单词的个数，作为函数值返回。字符串在主函数中输入，规定所有
单词由小写字母组成，单词之间有若干个空格隔开，一行的开始没有空格。
*/
/*通过计算空格数不行，因为单词之间可以有若干个空格
*/
#include<string.h>
#include<stdio.h>
#define N 80
int fun(char *s)
{ /*
int i, count = 0; //count用来统计个数
for(i = 0;s[i] != '\0'; i++) //通过i来遍历整个数组
{
if(s[i] !=' ' && (s[i+1] ==' ' || s[i+1] == '\0')) //通过判断指针前后的
{ //字符去统计空格，并且
count++; //避免重复空格和'\0'
} //的干扰
}
return count;
*/
}
void main()
{
FILE *wf;
char line[N];
int num=0;
printf("Enter a string:\n ");
gets(line);
num=fun(line);
printf("The number of word is:%d\n\n ",num);
/******************************/
wf=fopen("out.dat","w");
fprintf(wf,"%d",fun("a big car"));
fclose(wf);
/*****************************/
}/*已知5学生的记录由学号和学习成绩构成，N名学生的数据已存入a结构体数组中。请编写函数fun，该函
数的功能是，找出成绩最低的学生记录，通过形参返回主函数（规定只有一个最低分）。
*/
#include<stdio.h>
#include<string.h>
#include<conio.h>
#include<stdlib.h>
#define N 10
typedef struct ss
{ char num[10];
int s;
} STU;
void fun(STU a[], STU *s)
{/*
int i=0;
(*s).s = a[i].s;
strcpy((*s).num, a[i].num); //将字符数组给另一个字符数组要用strcpy函数
for(i=1; i+1<N; i++)
{ if((*s).s > a[i].s)
{ (*s).s = a[i].s;
strcpy((*s).num, a[i].num);
}
}
*/
}
void main()
{
FILE *wf;
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;
system("CLS");
printf("*****The original data*****\n");
for(i=0;i<N;i++)
printf("No=%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);
/******************************/
wf=fopen("out.dat","w");
fprintf(wf,"%s, %d",m.num,m.s);
fclose(wf);
/*****************************/
}总结：将字符数组给另一个字符数组要用strcpy函数，用“=”会报错中断。
/*此程序中，学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中，请编写
函数fun，其功能是：把低于平均分的学生数据放入b所指的数组中，低于平均分的学生人数通过形参n
传回，平均分通过函数值返回。
*/
#include <stdio.h>
#define N 8
typedef struct
{ char num[10];
double s;
} STREC;
double fun( STREC *a, STREC *b, int *n )
{/*
double ave=0,sum=0.0;
int i,count=0;
for(i=0; i<N; i++)
sum+=a[i].s;
ave=sum/N;
for(i=0; i<N; i++)
if(a[i].s<ave)
{
b[count++]=a[i];
}
*n=count;
return ave;
*/
}
void main()
{ STREC s[N]={{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},
{"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87}};
STREC h[N],t;FILE *out ;
int i,j,n; double ave;
ave=fun( s,h,&n );
printf("The %d student data which is lower 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.dat","w") ;
fprintf(out, "%d\n%7.3f\n", n, ave);
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(h[i].s>h[j].s) {t=h[i] ;h[i]=h[j]; h[j]=t;}
for(i=0;i<n; i++)
fprintf(out,"%4.1f\n",h[i].s);
fclose(out);
}总结：将结构体数组中的元素赋值给另一个结构数组时，还可以用类似于数组的方式a[i]=b[j]，即便每一个元素是由char数组、int、float等数据类型组成。
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 5
void fun(int a[][N], int m)
{/*
int i,j;
for(i=0; i<N; i++)
{ for(j=i; j<N; j++)
{
a[i][j]=a[i][j]*m;
}
}
*/
}
void main()
{
int a[N][N],m, i, j;
FILE *out;
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");
}
m=rand()%4;
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");
}
/******************************/
out=fopen("out.dat","w");
for(i=0;i<N;i++)
for(j=0;j<N;j++)
a[i][j]=i*j;
fun(a,8);
for(i=0;i<N;i++)
{ for(j=0;j<N;j++)
fprintf(out,"%4d",a[i][j]);
fprintf(out,"\n");
}
fclose(out);
/******************************/
}
【解析】考点在于遍历矩阵上三角的编程。
/*此程序中，定义了N×N的二维数组，并在主函数中赋值。请编写函数fun，函数的功能是：求出数组周边
元素的平均值并作为函数值返回给主函数中的s。例如，若a数组中的值为：
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
则返回主程序后s的值应为3.375。
*/
/*规律：如果矩阵行下标为0或N-1，以及列下标是0或N-1，对应的元素就是周边元素。
*/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define N 5
double fun (int w[][N])
{/*
int i,j,count = 0; //定义循环变量和统计周边元素个数的count
double sum=0;
for(i=0; i<N; i++) //首先还是矩阵所有元素遍历的循环语句
{ for(j=0; j<N; j++)
{
if(i==0 || i== N-1 || j==0 || j==N-1) //遍历过程中，只要满足四个条件其一，就将
{ //元素进行求和
sum+=w[i][j];
count++;
}
}
}
return sum/count;
*/
}
void main()
{
FILE *wf;
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;
system("CLS");
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); //题目中sum写错了
/******************************/
wf=fopen("out.dat","w");
fprintf (wf,"%lf",s);
fclose(wf);
/*****************************/
}
【解析】考点在于对矩阵周边一圈元素的遍历 。
/*编一个函数float fun(double h),该函数的功能是：使变量h中的值保留两位小数，并对第三位进行四
舍五入（规定h中的值为正数）。
例如，若h值为1234.567，则函数返回1234.570000；若h值为1234.564，则函数返回1234。560000。
*/
/*用判断语句进行某位小数是该进还是该舍的判断很复杂，可以通过+5然后判断是否有进位来进行。
但是+0.005会有浮点数精度不够的问题，即便精度够，操作也复杂
先将3位小数转换为整数，然后+5，第二位数会有进位或者没有进位两种可能，最后除以10，并只保留整数
位就能达到应该显示的2位数，之后再除以100。
*/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
float fun (float h )
{/*
int temp = ((int)(h*1000)+5)/10; //先把3位小数变成整数，强制转换int后，第3位以后的
//都舍弃了，再+5,再除以10，将第3位小数放回小数点
//后，由于该数现在是int，第3位不会保留
return (float)temp/100; //转换为浮点型后除以100，保留了第1、2位小数
*/
}
void main()
{
FILE *wf;
float a;
system("CLS");
printf("Enter a: ");
scanf ("%f",&a);
printf("The original data is : ");
printf("%f\n\n", a);
printf("The result : %f\n", fun(a));
/******************************/
wf=fopen("out.dat","w");
fprintf(wf,"%f",fun(8.32533));
fclose(wf);
/*****************************/
}
【解析】考点在于如何进行小数的四舍五入。
/*编写函数int fun(int lim,int aa[MAX]),其功能是求出小于或等于lim的所有素数并放在aa数组中，
并返回所求出的素数的个数。
*/
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
int fun(int lim, int aa[MAX])
{/*
int i,j,count=0;
for(i=2; i<=lim; i++)
{ for(j=2; j<=i; j++)
{ if(i%j == 0)
{ if(j == i)
{ aa[count]=i; //可以把++放进去
count++;
}
else break;
}
}
}
return count;
*/
}
void main()
{
FILE *wf;
int limit,i,sum;
int aa[MAX];
system("CLS");
printf("输入一个整数:");
scanf("%d",&limit);
sum=fun(limit,aa);
for(i=0;i<sum;i++)
{
if(i%10==0&&i!=0) /*每行输出10个数*/
printf("\n ");
printf("%5d ",aa[i]);
}
/******************************/
wf=fopen("out.dat","w");
sum=fun(15,aa);
for(i=0;i<sum;i++)
{
if(i%10==0&&i!=0) /*每行输出10个数*/
fprintf(wf,"\n");
fprintf(wf,"%5d ",aa[i]);
}
fclose(wf);
/*****************************/
}必背：素数的概念和判断。
/*函数fun的功能是：找出一个大于给定整数m且紧随m的素数，并作为函数值返回。
*/
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
int fun( int m)
{ int i,k;
for (i=m+1; ;i++)
{ for (k=2;k<i;k++)
/*************found**************/
if (i%k!=0) //if(i%k==0)
break;
/*************found**************/
if (k<i) //if(k==i)
return(i);
}
}
void main()
{ int n;
system("CLS");
printf("\nPlease enter n: ");
scanf("%d",&n);
printf ("%d\n",fun(n));
}必背：break在for循环中跳出后执行什么。
2次未做出
/*在此程序中，编写一个函数，其功能是：从传入的num个字符中找出最长的一个字符串，并通过形参指针
max传回该串地址（用****最为结束输入的标识）。
*/
/*
*/
#include<conio.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
char *fun(char (*a)[81], int num, char *max) //数据类型 *函数名(形参1,形参2,…) 是指针
{ /* //函数
int i;
max = a[0]; //假设第一个字符串目前是最长的
for(i = 1;i<num;i++) //“****”所在位置为a[num]
{
if(strlen(max)<strlen(a[i]))
{
max = a[i];
}
}
return max;
*/
}
void main()
{
FILE *wf; //定义了一个文件指针，用于最后校验fun函数正确性
char ss[10][81],*ps=NULL; //定义一个二维字符数组ss
char s[3][81]={"abcd","deg","diegns"},*p=NULL; //定义一个二维字符数组s，包含3个字符
int i=0,n; //串，用于main函数中最后一段代码单独
system("CLS"); //校验所写fun函数
printf("输入若干个字符串：");
gets(ss[i]);
puts(ss[i]);
while(!strcmp(ss[i], "****")==0) /*用4个星号作为结束输入的标志*///"****"并不是跟在最
{ //后一个字符串后面的，
i++; //而是单独作为一个字符
gets(ss[i]); //串放在二维数组的一个
puts(ss[i]); //一维数组中
}
n=i;
ps=fun(ss,n,ps);
printf("\nmax=%s\n",ps);
/******************************/ //这一段
wf=fopen("out.dat","w");
p=fun(s,3,p);
fprintf(wf,"%s",p);
fclose(wf);
/*****************************/
}/*在此程序中，编写一个函数，用来删除字符串中的所有空格。
例如，输入asd af aa z67，则输出为asdafaaz67。
*/
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
#include <stdlib.h>
void fun (char *str)
{/*
int i,j;
for(i=0; i<=strlen(str); i++)
{ if(str[i]==' ')
{
for(j=i; j<=strlen(str); j++) str[j]=str[j+1];
}
}
*/
}
void main()
{
char str[81];
char Msg[]="Input a string:";
int n;
FILE *out;
printf(Msg);
gets(str);
puts(str);
fun(str);
printf("*** str: %s\n",str);
/******************************/
out=fopen("out.dat","w");
fun(Msg);
fprintf(out,"%s",Msg);
fclose(out);
/******************************/
}总结：时刻注意“=”和“==”别搞错
/*编写函数fun，该函数的功能是：判断字符串是否为回文，若是，则函数返回1，主函数中输出“YES”，
否则返回0，主函数中输出“N0”。回文是指顺读和倒读都一样的字符串。
例如，字符串LEVEL是回文，而字符串123312就不是回文。
*/
#include <stdio.h>
#define N 80
int fun(char *str)
{
/*
int i,j=0;
int flag=1;
while(str[j])
j++;
j--;
for (i=0; i<j; i++,j--)
{
if(str[i] != str[j])
{
flag=0;
break;
}
}
return flag;
*/
}
void main()
{
char s[N];
FILE *out;
char *test[]={"1234321","123421","123321","abcdCBA"};
int i;
printf("Enter a string : ");
gets(s);
printf("\n\n");
puts(s);
if(fun(s))
printf("YES\n");
else
printf("NO\n");
/************************************/
out=fopen("out.dat","w");
for(i=0;i<4;i++)
if(fun(test[i]))
fprintf(out,"YES\n");
else
fprintf(out,"NO\n");
fclose(out);
/************************************/
}总结：在没有string.h头文件的情况下，可采用while循环去计算数字符串的长度。
/*在此程序中，m个人的成绩存放在score数组中，请编写函数fun，它的功能是：将低于平均分的人数作
为函数值返回，将低于平均分的分数放在below所指的数组中。
例如，当score数组中的数据位10、20、30、40、50、60、70、80、90时，函数返回的人数应该是4，
below中的数据应为10、20、30、40。
*/
#include <conio.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int fun(int score[],int m, int below[])
{
/*
int i,count=0; double av=0.0;
for(i=0; i<m; i++)
av=av+(double)score[i]/m;
for(i=0; i<m; i++)
if(score[i]<av)
below[count++]=score[i];
return count; //因为count从0开始，既有下标属性又有计数属性，应结合mian函数的调用思
//考
*/
}
void main()
{
FILE *wf;
int i, n, below[9];
int score[9]={10,20,30,40,50,60,70,80,90};
system("CLS");
n=fun(score, 9, below);
printf("\nBelow the average score are: ");
for(i=0;i<n;i++)
printf("%d ",below[i]);
/******************************/
wf=fopen("out.dat","w");
for(i=0;i<n;i++)
fprintf(wf,"%d ",below[i]);
fclose(wf);
/*****************************/
}总结：强制类型转换的优先级比“/”运算高。
/*编写一个函数int fun(int *s, int t, int *k)，用来求出数组的最大元素在数组中的下标并存放在
k所指向的存储单元中。
例如，输入如下整数：
876 675 896 101 301 401 980 431 451 777
则输出结果为6,980。
*/
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
int fun(int *s,int t,int *k)
{
/*
int i,j,max=s[0];
for(i=1; i<t; i++)
{
if(max<s[i])
{
max=s[i];
j=i;
}
}
*k=j;
*/
}
void main()
{
FILE *wf;
int a[10]={ 876,675,896,101,301,401,980,431,451,777},k;
system("CLS");
fun(a, 10, &k);
printf("%d, %d\n ", k, a[k]);
/******************************/
wf=fopen("out.dat","w");
fprintf (wf,"%d, %d", k, a[k]);
fclose(wf);
/*****************************/
}/*编写函数fun，它的功能是计算下列级数和，和值由函数值返回。
2 3 n
x x x
S=1+x+---+---+...---
2! 3! n!
例如，当n=10，x=0.3时，函数值为1.349859。
*/
#include<conio.h>
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
double fun(double x, int n)
{/*
double S=1,sum;
int i,j;
for(i=1; i<=n; i++)
{
sum=1;
for(j=1; j<=i; j++ )
sum*=x/j;
S+=sum;
}
return S;
*/
}
void main()
{
FILE *wf;
system("CLS");
printf("%f ",fun(0.3,10));
/******************************/
wf=fopen("out.dat","w");
fprintf(wf,"%f",fun(0.3,10));
fclose(wf);
/*****************************/
}必背：次方的表达式
/*编写函数fun，其功能是：统计s所指字符串中的数字字符个数，并作为函数值返回。
例如，s所指字符串中的内容是：2def35adh25 3kjsdf7/kj8655x，
函数fun返回值为：11
*/
#include <stdio.h>
void NONO();
int fun(char *s)
{/*
int i,leng,count=0;
char *p=s;
leng=count;
while(*p)
{
leng++;
p++;
}
for(i=0; i<=leng; i++)
if(s[i]>='0' && s[i]<='9')
count++;
return count;
*/
}
void main()
{ char *s="2def35adh25 3kjsdf 7/kj8655x";
printf("%s\n",s);
printf("%d\n",fun(s));
NONO();
}
void NONO()
{/* 本函数用于打开文件，输入数据，调用函数，输出数据，关闭文件。 */
FILE *fp, *wf ;
int i;
char s[256];
fp = fopen("in.dat","r") ;
wf = fopen("out.dat","w") ;
for(i = 0 ; i < 10 ; i++) {
fgets(s, 255, fp);
fprintf(wf, "%d\n", fun(s));
}
fclose(fp) ;
fclose(wf) ;
}总结：不能在定义变量的中间行中插入赋初值或赋值的语句，会报错
/*编写函数fun，该函数的功能是：删除一维数组中所有相同的数，使之只剩一个。数组中的数已按由小到
大的顺序排列，函数返回删除后数组中数据的个数。
例如，若一维数组中的数据是：
2 2 2 3 4 4 5 6 6 6 6 7 7 8 9 9 10 10 10
删除后，数组中的内容应该是：
2 3 4 5 6 7 8 9 10
*/
#include <stdio.h>
#define N 80
int fun(int a[], int n)
{/*
int i, count=0;
for(i=1; a[count]<=a[n-1]; i++)
if(a[i]>a[count])
a[++count]=a[i];
return count;
*/
}
void main()
{
FILE *wf;
int a[N]={ 2,2,2,3,4,4,5,6,6,6,6,7,7,8,9,9,10,10,10,10}, i, n=20;
printf("The original data :\n");
for(i=0; i<n; i++)
printf("%3d",a[i]);
n=fun(a,n);
printf("\n\nThe data after deleted :\n");
for(i=0; i<n; i++)
printf("%3d",a[i]);
printf("\n\n");
/******************************/
wf=fopen("out.dat","w");
for(i=0; i<n; i++)
fprintf(wf,"%3d",a[i]);
fclose(wf);
/*****************************/
}总结：函数有返回值的，先将return函数写出来，避免忘记
/*此程序中，规定输入的字符串中只包含字母和*号。编写函数fun，其功能是：除了字符串前导和尾部的
*号外，将串中其它的*号全部删除。形参h已指向字符串中第一个字母，形参p指向字符串的中最后一个字
母。在编写函数时，不得使用C语言提供的字符串函数。
例如，若字符串中的内容为****A*BC*DEF*G*******，删除后，字符串中的内容应当是
****ABCDEFG********。
*/
/*根据头尾指针，将字符串分为三段，采用循环变量将各段写入
*/
#include <stdio.h>
void fun( char *a, char *h,char *p )
{/*
char *k=a;
int i=0;
while(k<h)
{
a[i++]=*k;
k++;
}
while(k<=p)
{
if(*k!='*')
a[i++]=*k;
k++;
}
while(*k!=0)
{
a[i++]=*k;
k++;
}
a[i]='\0';
*/
}
void main()
{ char s[81],*t, *f;
void NONO ( );
printf("Enter a string:\n");gets(s);
t=f=s;
while(*t)t++;
t--;
while(*t=='*')t--;
while(*f=='*')f++;
fun( s , f,t );
printf("The string after deleted:\n");puts(s);
NONO();
}
void NONO()
{/* 本函数用于打开文件，输入数据，调用函数，输出数据，关闭文件。 */
FILE *in, *out ;
int i ; char s[81], *t, *f ;
in = fopen("in.dat","r") ;
out = fopen("out.dat","w") ;
for(i = 0 ; i < 10 ; i++) {
fscanf(in, "%s", s) ;
t=f=s;
while(*t)t++;
t--;
while(*t=='*')t--;
while(*f=='*')f++;
fun(s, f, t);
fprintf(out, "%s\n", s) ;
}
fclose(in) ;
fclose(out) ;
}【解析】题目表述和答案判定有歧义，直接背
/*此程序中，规定输入的字符串中只包含字母和*号。请编写函数fun，其功能是：使字符串中尾部的*号不
多于n个，若多于n个，则删除多余的*号；若少于或等于n个，则不做任何操作，字符串中间和前面的*号不
删除。
例如，字符串中的内容为“****A*BC*DEF*G*******”，若n的值为4，删除后，字符串中的内容应为
“****A*BC*DEF*G*****”；若n的值为7，则字符串中的内容仍为“****A*BC*DEF*G*******”。
*/
#include <stdio.h>
void fun( char *a,int n )
{/*
int count=0;
char *p=a;
while(*p)
p++;
p--;
while(*p=='*')
p--;
p++;
for(; *p=='*' && count<=n; p++)
count++;
if(count>n)
{
p--;
*p='\0';
}
*/
}
void main()
{ char s[81]; int n;
void NONO ( );
printf("Enter a string:\n");gets(s);
printf("Enter n : ");scanf("%d",&n);
fun( s,n );
printf("The string after deleted:\n");puts(s);
NONO();
}
void NONO()
{/* 本函数用于打开文件，输入数据，调用函数，输出数据，关闭文件。 */
FILE *in, *out ;
int i, n ; char s[81] ;
in = fopen("in.dat","r") ;
out = fopen("out.dat","w") ;
for(i = 0 ; i < 10 ; i++) {
fscanf(in, "%s", s) ;
fscanf(in, "%d", &n) ;
fun(s,n) ;
fprintf(out, "%s\n", s) ;
}
fclose(in) ;
fclose(out) ;
}【解析】*(p--)='\0';结果正确但会扣分，尽量不用这种形式。
/*函数fun功能是：求出1~1000之间能被7或11整除，但不能同时被7和11整数的所有整数，并将其放在a所
指的数组中，通过n返回这些数的个数。
*/
#include <stdio.h>
void fun (int *a, int *n)
{/*
int i;
*n=0;
for(i=1; i<=1000; i++)
if((i%7==0 || i%11==0) && !(i%7==0 && i%11==0))
{
a[*n]=i;
(*n)++;
}
*/
}
void main( )
{ int aa[1000], n, k ;
void NONO ( );
fun ( aa, &n ) ;
for ( k = 0 ; k < n ; k++ )
if((k + 1) % 10 == 0) printf("\n") ;
else printf("%5d", aa[k]) ;
NONO( );
}
void NONO ( )
{/* 本函数用于打开文件，输入测试数据，调用fun函数，输出数据，关闭文件。*/
int aa[1000], n, k ;
FILE *fp ;
fp = fopen("out.dat","w") ;
fun ( aa, &n ) ;
for ( k = 0 ; k < n ; k++ )
if((k + 1) % 10 == 0) fprintf(fp, "\n") ;
else fprintf(fp, "%5d", aa[k]) ;
fclose(fp) ;
}/*编写函数fun，其功能是：将所有大于1小于整数m的非素数存入xx所指数组中，非素数的个数通过k返回
。
例如，若输入17，则应输出：4 6 8 9 10 12 14 15 16。
*/
#include <stdio.h>
void fun( int m, int *k, int xx[] )
{/*
int i,j;
*k=0;
for(i=4; i<m; i++)
{
for(j=2; j<i; j++)
{
if(i%j==0) break
}
if(j!=i) {xx[*k]=i; (*k)++;} //通过这条语句判断是否执行了break
}
*/
}
void main()
{
int m, n, zz[100];
void NONO ( );
printf( "\nPlease enter an integer number between 10 and 100: " );
scanf( "%d", &n );
fun( n, &m, zz );
printf( "\n\nThere are %d non-prime numbers less than %d:", m, n );
for( n = 0; n < m; n++ )
printf( "\n %4d", zz[n] );
NONO();
}
void NONO()
{
/* 请在此函数内打开文件，输入测试数据，调用 fun 函数，
输出数据，关闭文件。 */
int m, n, zz[100];
FILE *rf, *wf ;
rf = fopen("in.dat","r") ;
wf = fopen("out.dat","w") ;
fscanf( rf, "%d", &n );
fun( n, &m, zz );
fprintf(wf, "%d\n%d\n", m, n );
for( n = 0; n < m; n++ )
fprintf(wf, "%d\n", zz[n] );
fclose(rf) ;
fclose(wf) ;
}/*编写函数fun，w是一个大于10的无符号整数，若w是n(n≥2)的无符号整数，则函数求出w的后n-1位的数
作为函数值返回。
例如，w值位5923，则函数返回923；若值为923，则函数返回23。
*/
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
unsigned fun(unsigned w)
{/*
unsigned t=w;
int i,n=0,s=1;
while(t)
{
t/=10;
n++;
}
for(i=1; i<n; i++)
s*=10;
return w%s;
*/
}
void main()
{
FILE *wf;
unsigned x;
system("CLS");
printf("Enter a unsigned integer number: ");
scanf ("%u",&x);
printf("The original data is:%u\n",x);
if(x<10)
printf("Data error! ");
else
printf ("The result :%u\n", fun(x));
/******************************/
wf=fopen("out.dat","w");
fprintf(wf,"%u",fun(5923));
fclose(wf);
/*****************************/
}/*编写函数fun，其功能是：计算并输出3~n之间所有素数的平方根之和。
例如，若主函数从键盘给n输入100后，则输出为sum=148.874270。
注意：n的值要大于2但不大于100。
*/
#include <stdio.h>
#include <math.h>
double fun(int n)
{/*
int i,j;
double sum=0;
for(i=3; i<=n; i++)
{
for(j=2; j<i; j++)
{
if(i%j==0)
{
break;
}
}
if(j==i)
sum+=sqrt((double)i);
}
return sum;
*/
}
void main()
{int n;
double sum;
FILE *out;
printf("Input N=");
scanf("%d",&n);
sum=fun(n);
printf("\n\nsum=%f\n\n",sum);
/******************************/
out=fopen("out.dat","w");
fprintf(out,"%f\n",fun(180));
fclose(out);
/******************************/
}必背：平方根函数sqrt()
/*此程序中，学生的记录由学号成绩组成，N名学生的数据已放入主函数中的结构体数组s中，请编写函数
fun，其功能是：函数返回该学号的学生数据，指定的学号在主函数中输入。若没找到指定学号，在结构
变量中给学号置空串，给成绩置-1，作为函数值返回。（用于字符串比较的函数时strcmp）。
*/
#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;
STREC h;
for(i=0; i<N; i++)
{
if(strcmp(b,a[i].num)==0)
return a[i];
}
strcpy(h.num,""); h.s=-1; return h;
*/
}
void main()
{ STREC s[N]={{"GA005",85},{"GA003",76},{"GA002",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;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("out.dat","w") ;
h=fun(s,"GA013");
fprintf(out,"%s %4d\n",h.num,h.s);
fclose(out);
}/*编写函数fun，其功能是计算：
s=sqrt(ln(1)+ln(2)+ln(3)+……+ln(m))
s作为函数值返回
在C语言中可调用log(n)函数求ln(n)。log函数的引用说明为doulbe log(double x)。
例如，若m的值为20，则fun函数值为6.506583。
*/
#include <math.h>
#include <stdio.h>
double fun( int m )
{/*
double s=0.0;
int i;
for(i=1; i<=m; i++)
s+=log((double)i);
return sqrt(s);
*/
}
void main()
{
void NONO ( );
printf("%f\n", fun(20));
NONO();
}
void NONO ( )
{/* 本函数用于打开文件，输入数据，调用函数，输出数据，关闭文件。 */
FILE *fp, *wf ;
int i, n ;
double s ;
fp = fopen("in.dat","r") ;
wf = fopen("out.dat","w") ;
for(i = 0 ; i < 10 ; i++) {
fscanf(fp, "%d", &n) ;
s = fun(n) ;
fprintf(wf, "%f\n", s) ;
}
fclose(fp) ;
fclose(wf) ;
}/*结构体struct mpow两个成员的意义是：a为幂的底，t为幂的指数。
请编写函数fun，其功能是：计算出x所指数组中n个幂数之和并返回。
例如，当结构体数组用如此数据12,0,9,2,23,1,7,2初始化时，程序的输出结果应该是：
sum=154.000000
*/
#include <stdio.h>
#pragma warning (disable:4996)
#define N 5
struct mpow
{
double a;
int t;
};
double fun(struct mpow *x,int n)
{/*
int i,j;
double sum=0.0;
for(i=0; i<n; i++)
{
double power=1.0;
for(j=0; j<x[i].t; j++)
{
power*=x[i].a;
}
sum+=power;
}
return sum;
*/
}
void main()
{
void NONO();
struct mpow x[N]={ 12,0,9,2,23,1,7,2 };
double sum;
sum=fun(x,4);
printf("sum=%lf\n",sum);
NONO();
}
void NONO ()
{/* 请在此函数内打开文件，输入测试数据，调用 fun 函数，输出数据，关闭文件。 */
FILE *in, *out ;
struct mpow x[N];
int i,j ;
double sum;
in = fopen("in.dat","r") ;
out = fopen("out.dat","w") ;
for(i = 0 ; i < 10 ; i++) {
for(j=0 ; j < 4; j++) fscanf(in, "%lf,%d,", &x[j].a,&x[j].t) ;
sum=fun(x,4);
fprintf(out, "sum=%lf\n",sum);
}
fclose(in) ;
fclose(out) ;
}/*编写函数fun，其功能是：在一个含有11个四位数的数组中，统计出这些数的奇数、偶数个数，然后计算
出个数多的那些数的算术平均值并由函数返回，个数通过yy传回。
例如，若11个数据为：1101,1202,1303,1404,1505,2611,2712,2813,2914,3202,4222
则输出：yy=6,pjz=2609.33
*/
#include <stdio.h>
#pragma warning (disable:4996)
#define N 11
double fun( int xx[], int *yy )
{/*
int jj[N]={0},oo[N]={0};
int i,j=0,o=0;
double avg=0.0;
for(i=0; i<N; i++)
if(xx[i]%2==0)
oo[o++]=xx[i];
else
jj[j++]=xx[i];
if(j>o)
{
for(i=0; i<j; i++)
avg+=jj[i];
*yy=j;
return avg/j;
}
else
{
for(i=0; i<o;i++)
avg+=oo[i];
*yy=o;
return avg/o;
}
*/
}
main()
{
int yy, xx[N]={1101,1202,1303,1404,1505,2611,2712,2813,2914,3202,4222};
double pjz ;
void NONO();
pjz = fun( xx, &yy );
printf("yy=%d, pjz=%.2lf\n", yy, pjz);
NONO();
}
void NONO()
{
/* 请在此函数内打开文件，输入测试数据，调用 fun 函数，
输出数据，关闭文件。 */
int i, j, xx[N], yy;
double pjz;
FILE *rf, *wf ;
rf = fopen("in.dat","r") ;
wf = fopen("out.dat","w") ;
for(i=0; i<10; i++) {
for(j=0; j<N; j++) fscanf(rf, "%d ", &xx[j]);
pjz = fun( xx, &yy );
fprintf(wf, "%d, %.2lf\n", yy, pjz);
}
fclose(rf) ;
fclose(wf) ;
}必背：算数平均值就是平均值
/*编写函数fun，其功能是：找出用1、2、3、4四个数字，能组成多少个互不相同且无重复数字的三位数，
然后把这些三位数按从小到大的顺序依次存入相应的数组xxx中，符合条件的个数由函数值返回。
*/
/*可以在100~999之间进行遍历，取出个十百位上的数字进行比较判断，同时也完成了排序
*/
#include <stdio.h>
#define max 100
int fun(int xxx[])
{/*
int i,a,b,c,count=0;
for(i=0; i<max; i++)
xxx[i]=0;
for(i=100; i<=999; i++)
{
a=i/100; b=i%100/10; c=i%10;
if(a <1 || a>4)
continue;
if(b <1 || b>4)
continue;
if(c <1 || c>4)
continue;
if(a!=b && b!=c && a!=c)
xxx[count++]=i;
}
return count;
*/
}
int main()
{
int xx[max],cnt;
void NONO(int xx[], int cnt);
cnt = fun(xx);
printf("符合条件的个数=%d\n", cnt);
NONO(xx, cnt);
return 0;
}
void NONO(int xx[], int cnt)
{
int i;
FILE *fp;
fp = fopen("out.dat", "w");
fprintf(fp, "%d\n", cnt);
for(i=0;i<cnt;i++)
fprintf(fp, "%d\n", xx[i]);
fclose(fp);
}/*根据哥德巴赫猜想，任意一个大偶数都可以分解为两个素数之和。但许多偶数分解为两个素数之和并不
是唯一的。
请编写函数fun，其功能是：求1000（不包括1000）以内的所有恰好能分解成10组两个素数之和（5+109
和109+5被认为是同一组）的偶数，并一次存入数组a种并在屏幕上打印出来，打印时每个数单独一行，
符合条件的个数通过函数值返回。
例如，114=5+109=7+107=11+103=13+101=17+97=31+83=41+73=43+71=47+67=53+61
114恰好可以分解为10组素数之和，因此114是我们要找的偶数。
而1163+113=7+109=13+103=19+97=37+79=43+73
120=7+113=11+109=13+107=17+103=19+101=23+97=31+89=37+83=41+79=47+73=53+67=59+61
116可以分解为6组素数之和，120可以分解为12组素数之和，因此116和120都不是我们要找的偶数。
函数prime用来判断一个数n是否为素数，是则返回1，否则返回0。
*/
#include<stdio.h>
#include<math.h>
#pragma warning(disable:4996)
int prime(int n)
{ int k,flag=1;
for (k=2; k<=(int)sqrt((double)n); k++)
if (n%k == 0)
flag=0;
return flag;
}
int fun(int m, int a[])
{
int k, s, count, i=0;
for(k=6; k<=m; k+=2)
{ count = 0;
/* 请在此处填写代码 */
for(s=2; s<=k/2 && prime(s); s+=2)
if(prime(k-s))
count++;
if (count == 10) {
printf("%d\n", k);
a[i++] = k;
}
}
return i;
}
main( )
{ int count, a[100];
void NONO(int count, int a[]);
count = fun(999, a);
NONO(count, a);
}
void NONO(int count, int a[])
{
FILE *fp;
int i;
fp = fopen("out.dat","w") ;
for(i=0; i<count; i++)
fprintf(fp, "%d\n", a[i]);
fclose(fp);
}必背：for循环的表达式2不要使用函数，会得不到结果。
总结：素数的判断要从2开始，因为1不是素数。
/*编写函数fun，其功能是：从一个整数数组中，统计出有重复数字数的个数存于m中，m值由函数值返回。
例如，2430,3001,1798,199,498,277,229,851,369,1146
其中如：3001中有重复的数字0
输出：Total Num=5
*/
#include <stdio.h>
#include <string.h>
void NONO();
int fun(int a[], int n)
{/*
int i,j,k,s,m,sum=0,flag=0,b[10];
for(i=0; i<n; i++)
{
j=0;
while(a[i])
{
b[j++]=a[i]%10;
a[i]/=10;
}
for(k=0; k<j-1; k++)
{
s=b[k];
for(m=k+1; m<j; m++)
if(s==b[m])
flag=1;
}
if(flag==1)
{
sum++;
flag=0;
}
}
return sum;
*/
}
void main()
{
int a[10]={2430,3001,1798,199,498,277,229,851,369,1146};
int m;
m = fun(a, 10);
printf("符合条件的数共有：%d\n",m);
NONO();
getch();
}
void NONO()
{
FILE *fp=fopen("in.dat", "r");
FILE *fw=fopen("out.dat", "w");
int a[5000];
int cnt=0, m;
while(!feof(fp)) fscanf(fp, "%d", &a[cnt++]);
m = fun(a, cnt);
fprintf(fw,"%d\n", m);
fclose(fp); fclose(fw);
}/*编写函数fun，其功能是：将具有n个元素的形参数组x中的偶数依原顺序输出到字符数组str中，每个数
字后面加一个小数点，并生成一个结果字符串str由函数返回。
例如，当数组x内容为1,4,19,82,61,2，输出结果是4.82.2.
*/
#include <stdio.h>
#include <string.h>
/* 函数int_to_str的功能是将参数n中的整数转换成字符串，存入s指内存中 */
void int_to_str(int n,char *s)
{
sprintf(s,"%d",n);
}
char *fun(int x[], int n)
{
static char str[200],s[10];
int i;
*str = 0;
/* 请在这里填入你编写的代码*/
/*
for(i=0; i<n; i++)
if(x[i]%2==0)
{
int_to_str(x[i],s);
strcat(str,s);
strcat(str,".");
}
*/
return str;
}
int main()
{
void NONO();
int x[] = {1,4,19,82,61,2};
printf("str=%s\n", fun(x, 6));
NONO();
return 0;
}
void NONO()
{
int i;
int x[10][20] = {{11,5,6,8,9,18,54},{1,4,19,82,61,2},
{87,78,54,32},{9,1,2,3,4,67,8,12},
{91,12,33,55,66},{9,7,8,5,6,4,3,2,1,12},
{12,13,14,15,11,16,17,18},{21,23,22,24,25,26,27,28,29},
{33,32,31,41,42,43,51,42,53,54,66},{71,72,81,82,91,92}};
int y[10] ={7,6,4,8,5,10,8,9,11,6};
FILE *fp;
fp = fopen("out.dat","w") ;
for(i = 0; i< 10; i++)
fprintf(fp, "str=%s\n", fun(x[i], y[i]));
fclose(fp);
}/*主函数的功能是：输入一个实数啊，根据迭代公式x1=(x0+a/x0)/2，计算并输出其平方根。
要求误差不超过1e-6（即0.000001）。
*/
#include <stdio.h>
main( )
{
double a,x0,x1;
printf("输入一个实数, 本程序计算并输出其平方根\n");
do
/**********************found***********************/
____(1)____; //scanf("%lf",&a)
while(a<=0);
x1=a/2.0;
do
{
/**********************found***********************/
____(2)____; //x0=x1
x1=(x0+a/x0)/2.0;
/**********************found***********************/
}while((x1-x0)>1e-6 ____(3)____ ); //|| (x0-x1)>1e-6
printf("%f 的平方根是 %f\n",a,x1);
}/此程序中，编写函数fun，其功能是：根据以下公式求Π的值（要求精度0.0005，即某项小于0.0005时停
止迭代）。
Π 1 1×2 1×2×3 1×2×3×4 1×2×…×n
— = 1 + — + ——— + ————— + ——————— + ————————————
2 3 3×5 3×5×7 3×5×7×9 3×5×…×(2n+1)
程序运行后，若输入精度0.0005，则程序应输出为3.140578。
#include <stdio.h>
#include <math.h>
double fun ( double eps)
{
/*
double s=0.0,s1=1.0; //官方答案
int n=1;
while(s1>=0.0005)
{
s=s+s1;
s1=s1*n/(2*n+1);
n++;
}
return 2*s;
*/
/*
double t=1.0,s=0.0;
int i;
for(i=1; t>=eps; i++) //使用循环时犯了一个错误，上一个单项满足精度进入循环后，直接求
{ //了下一个单项然后直接加进总和中。没有考虑此时的单项可能已经不
s=s+t; //满足精度了。所以将其调换了位置并更改了初始值。
t=t*(double)i/(double)(2*i+1);
}
return s*2;
*/
}
void main( )
{ double x;void NONO ();
printf("Input eps:") ;
scanf("%lf",&x); printf("\neps = %lf, PI=%lf\n", x, fun(x));
NONO();
}
void NONO ()
{/* 本函数用于打开文件，输入数据，调用函数，输出数据，关闭文件。 */
FILE *fp, *wf ;
int i ;
double x ;
fp = fopen("in.dat","r") ;
wf = fopen("out.dat","w") ;
for(i = 0 ; i < 10 ; i++) {
fscanf(fp, "%lf", &x) ;
fprintf(wf, "%lf\n", fun(x)) ;
}
fclose(fp) ;
fclose(wf) ;
}
硬背题
/*函数fun的功能是：用递归算法计算斐波拉契数列中第n项的值。从第1项起，斐波拉契数列为：1、1、
2、3、5、8、13、21、……
例如，若给n输入7，则该项的斐波拉契数值为13。
*/
#include <stdio.h>
long fun(int g)
{
/**********found**********/
switch(g); //switch(g)
{ case 0: return 0;
/**********found**********/
case 1 ;case 2 : return 1 ; //case 1: case 2 : return 1;
}
return( fun(g-1)+fun(g-2) );
}
void main()
{ long fib; int n;
printf("Input n: "); scanf("%d",&n); printf("n = %d\n",n);
fib=fun(n);
printf("fib = %d\n\n",fib);
}按我自己的想法，其实只需要在“case 1”后面加个“:”就行，执行一个空语句，但会扣分。
2139
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
