广工C语言编程题目

C语言编程题目

1.025 编写一个C程序，用函数printf(char *s)输出

以下3行信息：

******************** * Very Good! * ******************** 注意：

（1）要求精确到每个字符、空格、字母及其大小写。

（2）可多次调用printf(char *s)，每次仅一个字符串参数。 **********/ void print1() {

printf("********************\n"); }

void print2() {

printf("* Very Good! *\n"); }

void main() { print1(); print2();

print1(); }

1.055 编写一个程序，输入a、b、c三个值，输出其中最大值。

要求不改变下列给定的程序框架内容，填入合适语句，使其成

为满足题目要求的正确程序。 **********/

int max_a(int a,int b,int c) {int max=a; if(max<b) max=b; if(max<c) max=c; return max;}

int max_b(int a,int b,int c) {int max=b; if(max<a) max=a;

1

if(max<c)

max=c;

return max;}

int max_c(int a,int b,int c) {int max=c; if(max<a) max=a; if(max<b) max=b; return max;} void main() {int a,b,c,max;

scanf("%d,%d,%d",&a,&b,&c); //max=a>b?a:b; //max=max>c?max:c; //max=a;

//if(max<b) max=b; //if(max<c) max=c;

printf("max(%d,%d,%d)=%d\n",a,b,c,max_a(a,b,c));

printf("max(%d,%d,%d)=%d\n",a,b,c,max_b(a,b,c));

printf("max(%d,%d,%d)=%d\n",a,b,c,max_c(a,b,c)); }

6.022 n是系统给定的外部变量，编写程序求1到n间的

自然数之和。请定义局部变量s存放求和的结果，并用

下列语句输出结果

printf("1+2+...+n=%d\n",s); **********/

void main() {int s;

/* 请添加相关说明和语句 */ int i;

for(i=1;i<=n;i++)

s+=i;

printf("1+2+...+n=%d\n",s); /* 注意：不要修改此输出语句 */

}

6.026 n和s是系统给定的外部整型变量（不需要自行定义），

编写程序求1到n之间的奇数之和，并将结

果存放到s。 **********/ void main() {int i;

for(i=1;i<=n;i++) if(i%2!=0) s+=i;

}

6.040 m,n和s是系统定义的外部整型变量（不需要自行定义），

编写程序，根据m的值求满足1+2+...+n>=m的最小n，并将

1+2+...+n的结果存放到s。例如，若m=50，则n=10，s=55。 **********/ void main() {int i;

for(i=1;s<m;i++) { s+=i; n=i; }

}

/**********

6.051 n和s是系统给定的外部整型变量（不需要自行定义）， 编写程序求1-1/2+1/3-1/4+...1/n，并将结果存放到s。 **********/ void main() {

//int sign=1;

//float deno=2.0,term; //s=1.0;

//while(deno<=n) //{

//sign=-sign; //term=sign/deno; //s=s+term; //deno=deno+1; //}

//printf("%f\n",s); int i=1,flag=1; s=0.0;

while(i<=n)

2

{

s+=1.0/i++*flag; flag*=-1; }

printf("s=%f\n",s); }

int min(int x, int y, int z)

/* 返回3个整数x,y和z中最小的数 */ { int t;

t=x<y?x:y; return(t<z?t:z);

}

/* 8.020 编写函数，求用1元、5元和10元三种纸币支付n元钱

共有多少种支付方法？

例如，16元可有6种支付方法： 方法 1 2 3 4 5 6 10元 0 0 0 0 1 1 5元 0 1 2 3 0 1 1元 16 11 6 1 6 1 */

int change(int n) { int i,j,k;

int sum=0;

printf("\t1元\t5元\t10元\n"); for(i=0;i<=n;i++)

for(j=0;j<=n/5;j++)

for(k=0;k<=n/10;k++) if(n==(i+5*j+10*k)) { sum=sum+1;

printf("%-d",sum); printf("\t%-d\t%-d\t%-d\n",i,j,k); } printf("\n"); return(sum);

}

/* 8.030 先编写一个判断素数的函数。再编写一个函数将一个

偶数表示为两个素数之和，并返回其中较小的素数。

注：素数指只能被1和自身整除的正整数。规定0，1不是素数。 */

int prime(int n)

/* 判断素数，如果是素数返回1，不是素数则返回0 */ { int t; if(n==1) return 0;

for(t=2;t<=(n/2);t++) if(n%t==0) return 0; return 1;

}

int f(int i)

/* 将偶数i表示为两个素数之和，返回其中较小的素数*/

{ int n;

for( n=3; n<=i; n++)

if(prime(i-n) && prime(n)) return n; }

/* 8.050 编写函数，将字符串中ASCII码最小的字符放在第一

个字符位置，其余字符依次往后移。 */

void func(char *str)

/* 将字符串str中ASCII码最小的字符放在

7 8 9 7 4 1 */

void invert(char a[N][N]) { int i, j,b[20][20]; for(i=0;i<N;i++) for(j=0;j<N;j++) b[i][j]=a[N-1-j][N-1-i]; for(i=0;i<N;i++) for(j=0;j<N;j++) a[i][j]=b[i][j];

return; }

/* 8.064 编写函数将一个NxN的二维数组“水平”翻转。

例如：翻转前的数组 翻转后的数组 1 2 3 7 8 9 4 5 6 ---> 4 5 6 7 8 9 1 2 3 */

void invertH(char a[N][N]) { int i,j;

char k;

for (i=0;i*2<N;i++) for (j=0;j<N;j++) {

第一个 */ k=a[i][j];

/* 字符位置，其余字符依次往后移。 a[i][j]=a[N-i-1][j]; */

{ int i,j,min;

for(min=0,i=1;str[i]!='\0';i++) {

if(str[min]>str[i]) min=i; }

j=str[min];

for(i=min-1;i>=0;i--) str[i+1]=str[i];

str[0]=j; }

/* 8.060 编写函数将一个nxn的二维数组按“次对角线”翻转。

例如：翻转前的数组 翻转后的数组 1 2 3 9 6 3 4 5 6 ---> 8 5 2

3

a[N-i-1][j]=k; } }

/* 8.067 编写函数将一个NxN的二维数组的周边元素“顺时针”轮转1位。 例如：轮转前的数组 轮转后的数组 1 2 3 4 1 2 4 5 6 ---> 7 5 3 7 8 9 8 9 6 */

void turningClockwise(char a[N][N]) { int i,j,row=0,column=0; int tmp,t;

int flag=1;

printf("原来的数组：\n"); for(i=0;i<N;i++){ for(j=0;j<N;j++)

printf("%5d",a[i][j]); printf("\n"); }

tmp = a[0][0]; a[0][0] = a[1][0]; column = 1;

while(!(row==0&&column==0)){ t = a[row][column]; a[row][column] = tmp; tmp = t; if(flag==1){ if(column!=N-1) column ++; else{ flag++; row++;

}

}else if(flag==2){ if(row!=N-1) row++; else{

flag++; column--; }

}else if(flag==3){ if(column!=0) column --; else{ flag++;; row--;

}

}else if(flag==4){ if(row!=0) row--;

} }

printf("\n顺时针旋转后的数组：\n"); for(i=0;i<N;i++){ for(j=0;j<N;j++) printf("%5d",a[i][j]); printf("\n");

} }

/* 8.072 编写函数将一个NxN的二维数组a

4

的元素按行向右轮转1位。

例如：轮转前的数组 轮转后的数组 1 2 3 3 1 2 4 5 6 ---> 6 4 5 7 8 9 9 7 8 */

void turningRight(char a[N][N]) { int row, col=N-3, tmp;

printf("原来的数组：\n"); for(row=0; row<N; row++) { for(col=0; col<N; col++) printf("%5d",a[row][col]); printf("\n"); }

for (row=0; row<N; row++) { tmp = a[row][N-1];

for (col=N-1; col; col--) {

a[row][col] = a[row][col-1]; }

a[row][col] = tmp; }

printf("右移一位后的的数组：\n"); for(row=0; row<N; row++) { for(col=0; col<N; col++) printf("%5d",a[row][col]); printf("\n"); }

printf("\n"); }

void func(char s[], char t[], int n)

/* 数组s的前n个元素存放给定的字符序列，

数组t的前n个元素存放s的逆序列。 注意：数组的下标从0开始。 */ { int i;

for(i=0;i<n;i++) t[i]=s[n-i-1]; t[i]='\0'; }

void func(char *s, char *t)

/* s是给定字符串的起始地址， t是求得s的逆串的起始地址

*/

{ int i,n=strlen(s); for(i=0;i<n;i++) *(t+i)=*(s+n-i-1); }

void func(char *s1, char *s2, int n) { int i,j;

char t;

for(i=0;i<n;i++) *(s2+i)=*(s1+i); for(j=1;j<n-2;j++) for(i=1;i<=n-2-j;i++) { if(*(s2+i)<*(s2+i+1)) { t=*(s2+i); *(s2+i)=*(s2+i+1); *(s2+i+1)=t;

} } }

对字符串除首尾字符外，将其余字符按ASCII码将序排列 void func(char *s1, char *s2) { int i,j,n; char t;

n=strlen(s1); for(i=0;i<n;i++) *(s2+i)=*(s1+i); for(j=1;j<n-2;j++) for(i=1;i<=n-2-j;i++) { if(*(s2+i)<*(s2+i+1)) { t=*(s2+i);

*(s2+i)=*(s2+i+1); *(s2+i+1)=t; } } }

char *match(char *s, char c)

/* 返回字符在串s中首次出现的位置指针 */

{while(*s != '\0') if(*s == c) return(s); else s++;

return(NULL);

5

}

int month_day(int year, int yearday, int *pmonth, int *pday) /* year是年，

yearday是天数，

若year和yearday合理，

则*pmonth和*pday是计算得出的月和日，函数返回1；

否则，函数返回0。 */

{int

i,z=0,d1[12]={31,28,31,30,31,30,31,31,30,31,30,31},d2[12]={31,29,31,30,31,30,31,31,30,31,30,31};

*pmonth=1;

if(year%4==0&&year%100!=0||year%400==0) {if(1<=year&&1<=yearday&&yearday<=366) {z=1;

if((yearday-31)>0) {yearday=yearday-31; for(i=1;i<=11;i++) if(yearday/d2[i]==0) {

*pmonth=*pmonth+1; break; }

else

{*pmonth=*pmonth+1; if(yearday-d2[i]>0) yearday=yearday-d2[i]; else break; }

}

*pday=yearday; } } else

{ if(1<=year&&1<=yearday&&yearday<=365)

{z=1;

if((yearday-31)>0) {yearday=yearday-31;

for(i=1;i<=11;i++)

if(yearday/d1[i]==0&&yearday!=0) {

*pmonth=*pmonth+1; break; } else {

*pmonth=*pmonth+1; if(yearday-d1[i]!=0) yearday=yearday-d1[i]; else break; } }

*pday=yearday; } } return(z); }

long func(char *s)

/* s是一个数字字符串的地址，函数返回值为由s含有的数字字符转换得到的数（包含正负数情况） */

{ int i,j,k=0,a=1; long n=0;

for(j=0;*(s+j)!='\0';j++) {}

for(i=j-1;i>=0;i--) {

if(*(s+i)>='0'&&*(s+i)<='9') {

n=n+(*(s+i)-'0')*a; a=a*10; } }

if(*s=='-') n=n*(-1); return n;

}

int findmax(int s[], int n)

/* 返回s中n(>0)个整数的最大值。

6

注意：要求在函数中采用指针（而不是下标）来处理数组元素。 */

{ int i,max; max=*s; for(i=0;i<n;i++) if(*(s+i)>max) max=*(s+i); return max; }

int min3adj(int *s, int n) /* 数组s含n(>=3)个整数，

返回在s中相邻三个数的和中的最小值。 */

{int i,j;

int sum[20]={0};int min = 0; for(i=0;i<n-2;i++) {

for(j=0;j<3;j++ ) {

sum[i] += s[i+j]; } }

sum[i+1]='\0'; min = sum[0]; for(i=0;i<n-2;i++) {

if(sum[i]<min) {

min = sum[i]; } }

return min; }

/* 11.023 数组s存储了n个人的信息。写一函数，求这n个人中年龄最大（即出生日期最小）者的姓名。

*/

char *oldest(student s[], int n) { int i;

struct student *p;

p=&s[0];

for(i=1;i<n;i++)

{ if(s[i].birth.year<(*p).birth.year)

{ p=&s[i]; continue; }

if(s[i].birth.year==(*p).birth.year) { if(s[i].birth.month<(*p).birth.month) { p=&s[i]; continue;}

if(s[i].birth.month==(*p).birth.month) { if(s[i].birth.day<(*p).birth.day) p=&s[i]; } } }

return(p->name); }

/* 11.033 链表L存储了多个人的信息。写一函数，求这些人中年龄最大 （即出生日期最小）者的名字。 结构体类型定义如下：

struct date{int year; int month; int day;}; //日期结构体类型

struct studentNode //链表结点的结构体类型

{ char name[10]; //人名 struct date birth; //出生日期 struct studentNode *next }; */

char *oldest(struct studentNode *L) /* 若L是空表，则返回空指针null 否则返回表中年龄最大者的名字 */ {int j;

char *p;

struct studentNode *head1,*head; head=L;

p=(*head).name; if(head->next!=0) {

for(j=1;;j++) {

head1=head->next;

if((*head).birth.year<(*head1).birth.year) { head->next=head1->next; p=(*head).name; } else

7

{ if((*head).birth.year==(*head1).birth.year) {

if((*head).birth.month<(*head1).birth.month) { head->next=head1->next; p=(*head).name; } else {

if((*head).birth.month==(*head1).birth.month)

{

if((*head).birth.day<(*head1).birth.day) { head->next=head1->next; p=(*head).name; }

else

{ head=head1; p=(*head).name; } }

else

{ head=head1; p=(*head).name;} } } else

{ head=head1;

p=(*head).name;} }

if(head1->next==0) break; } } else

{ p=(*head).name; } return(p);

}

/* 11.063 结构体类型定义如下： struct course

{ int cID; //课程号，取值0~99 char name[10]; //课程名 float credit; //学分，取值0~5 int semester; //学期，取值1~8 };

结构体数组c存储了n门课程的信息。写一函数，求学期s的总学分。

*/

float creditSum(struct course c[], int n, int s) { int i;

float sum=0; for(i=0;i<n;i++) if(c[i].semester==s) sum=sum+c[i].credit; return sum;

}

/* 11.073 课程链表结点的结构体类型定义如下：

struct courseNode //课程链表结点的结构体类型

{ int cID; //课程号，取值0~99 char name[10]; //课程名

float credit; //学分，取值0~5 int semester; //学期，取值1~8 struct courseNode *next;

};

结构体链表Lc存储了各学期多门课程的信息。写一函数， 求学期s的总学分。 */

float creditSum(struct courseNode *Lc, int s) /* 若Lc是空表，则返回0; 否则返回学期s的总学分 */

{ float sum=0; if(Lc==NULL) return 0.0; else

{while(Lc!=NULL) {if(s==(*Lc).semester)

sum=sum+(*Lc).credit; Lc=(*Lc).next; }

return sum; }

}

/* 11.133 日期和结构体类型定义如下： struct date{int year; int month; int day;}; //日期结构体类型

8

struct student //结构体类型 { char name[10]; //人名 struct date birth; //出生日期 };

结构体数组s存储了n个人的名字和出生日期。写一函数，由数组s中n个人 的信息及其顺序构造相应的链表。链表的结点的结构体类型定义如下：

struct studentNode //结构体类型 { char name[10]; //人名 struct date birth; //出生日期 struct studentNode *next }; */

struct studentNode *CreateLinkList(struct student s[], int n)

{ int i,j=0;

struct studentNode *head; struct studentNode *p1,*p2; if(n==0) return NULL; while(j<n)

{p1=(struct studentNode *)malloc(sizeof(struct studentNode)); if(j==0) head=p1; else (*p2).next=p1; p2=p1;

for(i=0;i<10;i++)

(*p1).name[i]=s[j].name[i]; (*p1).birth.year=s[j].birth.year; (*p1).birth.month=s[j].birth.month; (*p1).birth.day=s[j].birth.day; j++;

}

(*p2).next=NULL;

return(head); }

/* 11.173 课程链表结点的结构体类型定义如下：

struct courseNode //课程链表结点的结构体类型

{ int cID; //课程号，取值0~99 char name[10]; //课程名

float credit; //学分，取值0~5 int semester; //学期，取值1~8

struct courseNode *next;

};

结构体链表Lc存储了多门课程的信息。写一函数，将课程号

为c的课程的学分修改为t。 */ struct

courseNode

*creditChange(struct

courseNode *Lc, int c, float t)

/* 若课程c不存在，则修改不成功，返回 {

struct courseNode *p1,*p2,*head,*t; p1=p2=*Lc;

while(c!=p1->cID&&p1->next!=NULL) {

p2=p1;p1=p1->next;} if(c==p1->cID) { t=p1; null;

否则修改该课程的学分为t，返回指向该 课程结点的指针。 */

{ struct courseNode *p1; p1=Lc;

while(p1!=NULL)

{ if(p1->cID==c)

{ p1->credit=t;break; } } else p1=p1->next; }

return p1; }

/*11.183 课程链表结点的结构体类型定义 如下：*/

// struct courseNode //课程链表结点的 结构体类型

// { int cID; //课程号，取值0~99 // char name[10]; //课程名

//float credit; //学分，取值0~5 //int semester; //学期，取值1~8 //struct courseNode *next;

//};

//结构体链表Lc存储了多门课程的信息。写 一函数，将课程号为c的课程结点删除。

/*要求实现下列函数：*/

struct courseNode *deleteCourse(struct courseNode **Lc, int c)

/* 若在链表Lc中课程c不存在，则删除不 成功，返回null;

否则从链表Lc中删除该课程结点，并返 回指向该课程结点的指针。 */

9

if(p1==*Lc) *Lc=p1->next; else

p2->next=p1->next; return(t); } else

return(NULL);

本文来源：https://www.bwwdw.com/article/prji.html