1. 简单程序设计
编程写程序，在屏幕上输出信息：Happy New Year!
/* 输出图形*/
#include<stdio.h>
void main()
{
printf("Happy New Year!\n");
}
2. 简单计算
由键盘任意输入2个数，分别计算它们的和、差、积、商。
/*简单计算*/
#include<stdio.h>
void main()
{
float a,b;
float h,c,j,s;
scanf("%f%f", &a,&b);
h=a+b;
c=a-b;
j=a*b;
s=a/b;
printf("和=%f,差=%f,积=%f,商=%f\n",h,c,j,s);
}
3. 计算梯形的面积
已知梯形的上底、下底和高，计算梯形的面积。
/*计算梯形的面积*/
#include<stdio.h>
void main()
{
float supline,dowline,high;
double area;
scanf("%f",&supline);
scanf("%f",&dowline);
scanf("%f",&high);
area = ((supline+dowline)*high)/2.0;
printf("%f \n",area);
}
4. 输出字符对应的ASCII码
任意输入一个字符，输出此字符对应的ASCII码。
/*输出字符对应的ASCII码*/
#include<stdio.h>
void main()
{
char c;
scanf("%c",&c);
printf("%d\n",c);
}
5. 数据类型长度测试
编写程序，测试所使用的计算机系统字符型、短整型、整形、长整型、单精度实型、双精度实型所占有的字节数量。
/*数据类型长度测试*/
#include<stdio.h>
void main()
{
printf("size of char=%d\n",sizeof(char));
printf("size of short=%d\n",sizeof(short));
printf("size of int=%d\n",sizeof(int));
printf("size of long int=%d\n",sizeof(long int));
printf("size of float=%d\n",sizeof(float));
printf("size of double=%d\n",sizeof(double));
}
6. 成绩判断
输入一个学生的数学成绩，如果它低于60，输出“Fail”，否则，输出“Pass”。不要改变与输入输出有关的语句。
/*成绩判断*/
#include<stdio.h>
void main()
{
float mark;
scanf("%f",&mark);
if(mark<60)
printf("Fail\n");
else
printf("Pass\n");
}
7. 字符转换
输入一个字符，如果它是大写字母，输出相应的小写字母；如果它是小写字母，输出相应的大写字母；否则，原样输出。不要改变与输入输出有关的语句。
/*字符转换*/
#include<stdio.h>
void main()
{
char ch;
ch=getchar("%c");
if(ch>='A'&&ch<='Z')
{
ch=ch+32;
printf("%c\n",ch);}
else if(ch>='a'&&ch<='z')
{
ch=ch-32;
printf("%c\n",ch);}
else
printf("%c\n",ch);
}
8. 利用海伦公式求三角形面积
三角形三个边长
/*计算三角形面积*/
#include "math.h"
#include "stdio.h"
void main()
{
double a,b,c,s,area;
printf("请输入3条边长:");
scanf("%lf%lf%lf",&a,&b,&c);
if(a+b>c&&b+c>a&&a+c>b)
{
s=1.0/2*(a+b+c);
area=sqrt(s*(s-a)*(s-b)*(s-c));
printf("三角形的面积是:%f\n",area);
scanf("%lf\n",area);
}
else
printf("这3个数无法组成三角形!\n");
}
9. 判断是否能构成一个三角形
从键盘输三个数，判断是否能将它们作为三角形的三条边构成一个三角形。若能，输出“Yes”，否则，输出“No”。
/*判断是否能构成一个三角形*/
#include<stdio.h>
void main()
{
float a,b,c;
printf("请输入3条边长:");
scanf("%f%f%f",&a,&b,&c);
if(a>0&&b>0&&c>0&&a+b>c&&a+c>b&& b+c>a)
printf("Yes\n");
else
printf("No\n");
}
10. 按从大到小排序三个数
从键盘输入三个数，将它们按从大到小进行排序，然后输出。
/*按从大到小排序三个数*/
#include<stdio.h>
main()
{
int a,b,c,d,e,f;
printf("请输入三个整数n1,n2,n3:");
scanf("%d%d%d",&a, &b, &c);
printf("排序前：%d, %d, %d\n", a, b, c);
if(a>b)
{
{
d=c;
e=a;
f=b;
}
{
if(c<b)
{
d=a;
e=b;
f=c;
}
else
{
d=a;
e=c;
f=b;
}
}
}
else
{
if(b<c)
{
d=c;
e=b;
f=a;
}
else
{
if(a>c)
{
d=b;
e=a;
f=c;
}
else
{
d=b;
e=c;
f=a;
}
}
}
printf("排序后：%d, %d, %d\n", d, e, f);
}
11. 数据统计
任意输入n个整数，分别统计奇数的和、奇数的个数、偶数的和、偶数的个数。
/*数据统计*/
#include <stdio.h>
void main()
{
int i,n,m,jishuhe=0,oushuhe=0,jishuge=0,oushuge=0;
scanf("%d",&n);
for(i=0; i<n; i++)
{
scanf("%d",&m);
if(m%2!=0)
{
jishuhe=jishuhe+m;
jishuge++;
}
else
{
oushuhe=oushuhe+m;
oushuge++;
}
}
printf("%d\n%d\n%d\n%d\n",jishuhe,jishuge,oushuhe,oushuge);
}
12. 爱因斯坦阶梯问题
设有一阶梯，每步跨2阶，最后剩1阶；每步跨3阶，最后剩2阶；每步跨5阶，最后剩4阶；每步跨6阶，最后剩5阶；每步跨7阶，正好到阶梯顶。问满足条件的最少阶梯数是多少。
/*爱因斯坦阶梯问题*/
#include <stdio.h>
void main()
{
int x;
x=7;
while(!((x%3==2)&&(x%5==4)&&(x%6==5)))
x+=7;
printf("%d\n",x);
}
13. 猴子吃桃问题
一天一只猴子摘下一堆桃子，吃了一半，觉得不过瘾，又多吃了一个，第2天接着吃了前一天剩下的一半，再多吃了一个，以后每天如此，直到第n天，只剩下1个桃子，问猴子一共摘了多少桃子？
/*猴子吃桃问题*/
#include<stdio.h>
void main()
{
int n;
int x=1,i;
scanf("%d",&n);
for(i=1; i<n; i++)
{
x=2*(x+1);
}
printf("%d\n",x);
}
14. 求两个数的最大公约数和最小公倍数
用辗转相除法（即欧几里得算法）求两个正整数的最大公约数和最小公倍数。
/* 求两个数的最大公约数和最小公倍数*/
#include<stdio.h>
void main()
{
int a,b,rem,temp;
int Div,Multi;
int a1,b1;
scanf("%d%d",&a,&b);
a1=a;
b1=b;
if(a<b)
{
temp=a;
a=b;
b=temp;
}
while(rem)
{
rem = a%b;
a=b;
b=rem;
}
Div=a;
Multi = a1*b1/Div;
printf("%d\n%d\n",Div,Multi);
}
15. 求sin(x)的近似值 利用公式求sin(x)的近似值（精度为10e-6）。
sin(x)=x-x3/3!+x5/5!-x7/7!+....(-1)nx(2n+1)/(2n+1)!+...
/*求sin(x)的近似值*/
#include<stdio.h>
#include<math.h>
void main()
{
float a,b=1;
float i,sinx,x;
scanf("%f",&x);
a=x;
sinx=0;
for(i=1; fabs(a/b)>=1e-6; i++)
{
sinx+=a/b;
a=-a*x*x;
b=b*2*i*(2*i+1);
}
printf("%f\n",sinx);
}
16. 图形输出
输入一个字符及行数n，用该字符在屏幕上输出如下图形：
*
***
*****
*******
*********
输入： 一个字符及要输出的行数n。
输出： 用该字符在屏幕上构成的要求图形。
/*图形输出*/
#include<stdio.h>
void main()
{
int n,i,j;
char ch;
ch=getchar();
scanf("%d",&n);
for(i=0; i<n; i++)
{
for(j=0; j<(n-1-i); j++)
printf(" ");
for(j=0; j<(2*i+1); j++)
printf("%c",ch);
printf("\n");
}
}
17. 字符串连接
由键盘任意输入两串字符，不用库函数strcat，连接将两串字符。
输入： 两串字符
输出： 连接将两串字符
输入样例： abc
def
输出样例： abcdef
/*字符串连接1*/
#include<stdio.h>
#include<string.h>
void main()
{
int i,j,k;
char str[20]= {"\0"},str1[10],str2[10];
gets(str1);
gets(str2);
j=strlen(str1),k=strlen(str2);
for(i=0; i<j+k; i++)
{
if(i<j)
str[i]=str1[i];
else
str[i]=str2[i-j];
}
puts(str);
}
/*字符串连接2*/
#include<stdio.h>
#include<string.h>
void main()
{
char str1[100],str2[50];
int i,j;
gets(str1);
gets(str2);
for(i=0;str1[i]!='\0';i++);
for(j=0;str2[j]!='\0';j++)
{
str1[i]=str2[j];
i++;
}
str1[i] = '\0';
puts(str1);
}
18. 简单加密程序
由键盘任意输入一串字符，对其进行加密，加密原则为：如果为字母，将其循环右移2个字母，其他字符保持不变。
输入： 一串字符
输出： 加密后的字符串
输入样例： abl2CDxyz
输出样例： cdl2EFzab
提示： 1. 可用gets()和puts()输入输出字符串。
2. 利用ASCII码运算进行加密。
3. 循环右移的含义是：将a-z，A－Z各看成一个环进行移动，即y右移2个字母后为a,z右移2个字母后为b；Y右移2个字母后为A，Z右移2个字母后为B。
/*简单加密程序*/
#include<stdio.h>
void main()
{
char a[80];
int i;
gets(a);
for(i=0; a[i]!=0; i++)
{
if((a[i]>='A'&& a[i]<='X')||(a[i]>='a'&&a[i]<='x'))
a[i]=a[i]+2;
else if ((a[i]>='y'&&a[i]<='z')||(a[i]>='Y'&&a[i]<='Z'))
a[i]=a[i]-24;
}
puts(a);
}
19. 矩阵对角线元素求和
输入一个5×5的数组，分别求其主对角线和辅对角线上元素之和。
输入： 5×5的数组
输出： 主对角线和辅对角线上元素之和
输入样例： 1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
输出样例： 65 65
提示： 主对角线为从矩阵的左上角至右下角的连线，在数组中即指行列下标相同的元素，辅对角线为从矩阵的右上角至左下角的连线，这些元素的下标之间也可用相应的表达式表达。
/*矩阵对角线元素求和*/
#include<stdio.h>
#include<string.h>
void main()
{
int i,j;
int a[6][6];
int sum1=0,sum2=0;
for(i=0; i<5; i++)
for(j=0; j<5; j++)
scanf("%d",&a[i][j]);
for(i=0; i<5; i++)
{
sum1=sum1+a[i][i];
sum2=sum2+a[i][4-i];
}
printf("%d %d\n",sum1,sum2);
}
20. 数据顺序调整
由键盘任意输入10个数，将最大数调到最前面，最小数调到最后面。
输入： 任意10个数
输出： 数据调整后的10个数。
输入样例： 0 1 2 3 4 5 6 7 8 9
输出样例： 9 1 2 3 4 5 6 7 8 0
提示： ① 定义四个变量d1、d2、x1、x2，分别存放最大数、最小数及它们的位置；
② 在循环开始前，将第一个元素作为参考，将其值分别存入d1、x1，将其下标分别存入d2、x2；
③ 在循环中将其它元素逐一与d1比较，若比d1大，将其存入d1，并将其下标存入d2；否则将其与x1比较，若比x1小，将其存入x1，并将其下标存入x2；
④ 结束循环后，将d2所示位置的数与第一个数交换，将x2所示位置的数与最后一个数交换，然后输出数组所有元素即可。
/* 数据顺序调整*/
#include<stdio.h>
#include<string.h>
int main ()
{
int i,a[10],temp1,temp2;
for(i=0; i<10; i++)
scanf("%d",&a[i]);
int d1=a[0],x1=a[0],x2=0,d2=0;
for(i=0; i<10; i++)
{
if(a[i]>d1){
d1=a[i];
d2=i;
}else if(a[i]<x1)
{
x1=a[i];
x2=i;
}
}
temp1=a[0];
a[0]=a[d2];
a[d2]=temp1;
temp2=a[9];
a[9]=a[x2];
a[x2]=temp2;
for(i=0; i<10; i++)
printf("%d ",a[i]);
return 0;
}
21. 字符个数统计
由键盘输入任意一串字符串，将其存入一个字符数组，统计其中的大写字母、小写字母、数字以及其他字符的个数。
输入： 任意一串字符串
输出： 大写字母、小写字母、数字以及其他字符的个数。
输入样例： abcdefg123456ABCDEFG
输出样例： 7 7 6
/*字符统计*/
#include<stdio.h>
#include<string.h>
void main()
{
char str[100];
int iA=0,ia=0,io=0,iqt=0;
int i;
gets(str);
for(i=0; str[i]; i++)
{
if(str[i]>='A'&&str[i]<='Z')
iA++;
else if(str[i]>='a'&&str[i]<='z')
ia++;
else if(str[i]>='0'&&str[i]<='9')
io++;
else
iqt++;
}
printf("%d %d %d %d\n",iA,ia,io,iqt);
}
22. 学生成绩计算
已知10个学生的5门课程的成绩，将其存入一个二维数组，求每一个学生的总成绩和每一个学生的平均成绩。
输入： 10个学生的5门课程的成绩
输出： 每一个学生的总成绩和每一个学生的平均成绩
输入样例： 90.5 80 70 89 84.6
91.5 81 71 88 84.7
92.5 82 72 87 84.8
93.5 83 73 86 84.9
94.5 84 74 85 84.0
95.5 85 75 84 84.1
96.5 86 76 83 84.2
97.5 87 77 82 84.3
98.5 88 78 81 84.4
99.5 89 79 80 84.5
输出样例： 414.100006 82.820000
416.200012 83.240005
418.299988 83.659996
420.399994 84.080002
421.500000 84.300003
423.600006 84.720001
425.700012 85.139999
427.799988 85.559998
429.899994 85.979996
432.000000 86.400002
/*学生成绩计算*/
#include"stdio.h"
void main()
{
int i,j;
float score[10][5];
float sum[10], aver[10];
for(i=0; i<10; i++)
for(j=0; j<5; j++)
scanf("%f",&score[i][j]);
for(i=0; i<10; i++)
{
sum[i]=0;
for(j=0; j<5; j++)
{
sum[i]=sum[i]+score[i][j];
}
aver[i]=sum[i]/5;
}
for(i=0; i<10; i++)
printf("%f %f\n",sum[i],aver[i]);
}
23. 姓名排序
由键盘任意输入10个学生的姓名（以拼音形式），将它们按照ASCⅡ码的顺序从小到大排序。
输入： 10个学生的姓名（以拼音形式）。
输出： 按照ASCⅡ码的顺序从小到大排序。
输入样例： zhang
ziang
zaang
zbang
zcang
zdang
zeang
zfang
zgang
zhang
输出样例： zaang
zbang
zcang
zdang
zeang
zfang
zgang
zhang
zhang
ziang
/*姓名排序*/
#include<stdio.h>
#include<string.h>
void main()
{
char name[10][10];
int i,j;
char temp[20];
for(i=0; i<10; i++)
gets(name[i]);
for(j=0; j<10; j++)
{
for(i=0; i<9-j; i++)
if(strcmp(name[i],name[i+1])>0)
{
strcpy(temp,name[i]);
strcpy(name[i],name[i+1]);
strcpy(name[i+1],temp);
}
}
for(i=0; i<10; i++)
puts(name[i]);
}
24. 输出杨辉三角形
编程实现n阶(n<10)杨辉三角形的输出，n=6时，杨辉三角形如下所示：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
输入： 杨辉三角形的阶数n。
输出： n阶杨辉三角形。
输入样例： 6
输出样例： 1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
提示： ① 杨辉三角形的特点：第一列和对角线上的元素值均为1，即a[i][0]=a[i][i]=1;其余位置元素的值=上一行本列元素值+上一行前一列元素值，如第三行第二列2就是第二行第一列+第二行第二列，计算公式为a[i][j]=a[i-1][j-1]+ a[i-1][j]。
② 应先对第一列和对角线元素赋值，然后再为其它元素赋值。
/*输出杨辉三角形*/
#include<stdio.h>
#include<string.h>
void main()
{
int i,j,n;
int a[100][100];
scanf("%d",&n);
for(i=0; i<n; i++)
{
a[i][i]=1;
a[i][0]=1;
}
for(i=0; i<n; i++)
for(j=1; j<i; j++)
a[i][j]=a[i-1][j-1]+a[i-1][j];
for(i=0; i<n; i++)
{
for(j=0; j<=i; j++)
printf("%d ",a[i][j]);
printf("\n");
}
}
25. 用指针实现排序
用指针实现：由键盘输入10个整数，将他们按由小到大的顺序排列。
输入： 键盘输入的10个整数。
输出： 按由小到大的顺序排列。
输入样例： 1 5 4 3 2 9 23 11 5 7
输出样例： 1 2 3 4 5 5 7 9 11 23
/*用指针实现排序*/
#include<stdio.h>
void main(void)
{
int a[10],*p;
int i,j=0,temp;
p=a;
for(i=0; i<10; i++ )
{
scanf("%d",p+i);
}
p=&a[j];
for(i=1; i<=9; i++)
for(j=0; j<10-i; j++)
if(*(p+j)>*(p+j+1))
{
temp=*(p+j);
*(p+j)=*(p+j+1);
*(p+j+1) =temp;
}
for(i=0; i<9; i++)
printf("%d ",a[i]);
printf("%d\n",a[9]);
}
26. 用指针实现字符串排序
用指针实现：将10个字符串（设其长度小于20）从小到大排序。
输入： 10个字符串。
输出： 排序后的10个字符串。
输入样例： ijk
jkl
def
ghi
def
cde
hij
def
efg
fgh
输出样例： cde
def
def
def
efg
fgh
ghi
hij
ijk
jkl
提示： ① 定义二维字符数组和指向该数组的指针数组；
② 用循环使指针数组的元素指向二维字符数组各行首；
③ 用循环为指针数组元素赋字符串为值；
④ 用strcmp函数比较两个指针数组元素的值、用strcpy函数交换两个指针数组元素的值。
/*用指针实现字符串排序*/
#include<stdio.h>
#include<string.h>
void main()
{
char a[10][20],*p[10],b[20];
int i,j;
for(i=0; i<10; i++)
{
p[i]=a[i];
}
for(i=0; i<10; i++)
{
gets(p[i]);
}
for(i=0; i<9; i++)
{
for(j=i+1; j<10; j++)
{
if(strcmp(p[i],p[j])>0)
{
strcpy(b,p[i]);
strcpy(p[i],p[j]);
strcpy(p[j],b);
}
}
}
for(i=0; i<10; i++)
{
puts(a[i]);
}
}
27. 数据倒置
用指针实现：将具有10个元素的一维数组中的数据倒置。
输入： 10个元素。
输出： 倒置数据。
输入样例： 0 1 2 3 4 5 6 7 8 9
输出样例： 9 8 7 6 5 4 3 2 1 0
提示： 数据倒置是指将数组前后元素的值交换后再输出。
/*数据倒置*/
#include <stdio.h>
void main()
{
int a[10],b,*p,*q;
int i;
for(i=0; i<10; i++ )
{
scanf("%d",a+i);
}
p=a;
q=a+9;
for(p=a,q=a+9; p<q; p++,q--)
{
b=*p;
*p=*q;
*q=b;
}
for(i=0; i<10; i++ )
{
printf("%d ",*(a+i));
}
}
28. 用指针实现数据位置调整
用指针实现：由键盘输入10个整数，将最大的调到最后，最小的调到最前。
输入： 10个整数。
输出： 最大的调到最后，最小的调到最前。
输入样例： 5 8 7 6 9 4 3 2 1 0
输出样例： 0 8 7 6 5 4 3 2 1 9
/*用指针实现数据位置调整*/
#include <stdio.h>
void main()
{
int a[10],*p1,*p2,temp;
int *b1,*b2;
int i;
//p1=a;
//p2=a;
for(i=0; i<10; i++ )
{
scanf("%d",&a[i]);
}
b1=a;
p1=a+1;
for(i=1; i<10; i++)
{
if(*p1>*b1)
b1=p1;
p1++;
}
temp=*b1;
*b1=a[9];
a[9]=temp;
b2=a;
p2=a+1;
for(i=0; i<10; i++)
{
if(*p2<*b2)
b2=p2;
p2++;
}
temp=*b2;
*b2=a[0];
a[0]=temp;
for(i=0; i<10; i++)
{
printf("%d ",*(a+i));
}
}
29. 用指针实现查找二维数组中最大数及其位置
用指针实现：找出二维数组（设3行4列）中的最大数及其位置。
输入： 二维数组（设3行4列）。
输出： 最大数及其位置。
输入样例： 1 2 5 4
6 8 7 2
0 2 4 5
输出样例： 1 1 8
/*用指针实现查找二维数组中最大数及其位置*/
#include<stdio.h>
void main()
{
int a[3][4],i,j;
int iMaxRow,iMaxCol;
for(i=0; i<3; i++)
{
for(j=0; j<4; j++)
{
scanf("%d",a[i]+j);
}
}
iMaxRow=0;
iMaxCol=0;
for(i=0; i<3; i++)
{
for(j=0; j<4; j++)
{
if(*(*(a+i)+j)>a[iMaxRow][iMaxCol])
{
iMaxRow=i;
iMaxCol=j;
}
}
}
printf("%d %d %d\n",iMaxRow,iMaxCol,a[iMaxRow][iMaxCol] );
}
30. 用指针实现子字符串提取
用指针实现：由键盘输入一串字符，从下标为m的字符开始，取出n个字符（m和n由键盘输入），形成一个新的字符串。
输入： 键盘输入一串字符。
输出： 从下标为m的字符开始，取出n个字符（m和n由键盘输入），形成一个新的字符串。
输入样例： 0123456
5 2
输出样例： 56
提示： ① 定义二个字符数组zfsour[100]、zfdest[100]，zfsour存放原串，zfdest存放新串；
② 定义二个指针变量*pzfsour、*pzfdest； zfsour字符数组的首地址；
③ 从键盘输入取字符的开始位置m（即下标值）和要取的字符个数n；
④ 让指针变量pzfsour指向zfsour+m处，让pzfdest指向zfdest字符数组的首地址；
⑤ 通过n次循环，逐次赋值、移动指针，即将原串中的n个字符存到新串字符数组中。
/*用指针实现子字符串提取*/
#include<stdio.h>
#include<string.h>
void main(void)
{
char szstrsour[80],szstrdest[80],*pszsour,*pszdest;
int i,m,n;
gets(szstrsour);
scanf("%d %d",&m,&n);
pszsour=szstrsour+m;
pszdest=szstrdest;
for(i=0; i<n; i++)
{
*pszdest=*pszsour;
pszdest++;
pszsour++;
}
*pszdest='\0';
puts(szstrdest);
}
31. 整数交换函数设计
设计一个函数，将任意2个整数交换，并在主函数中调用此函数。
输入： 任意2个整数
输出： 交换后的2个整数
输入样例： 1 2
输出样例： 2 1
/* 整数交换函数设计*/
#include <stdio.h>
void swap(int*,int*);
void main()
{
int a,b;
scanf("%d%d",&a,&b);
swap(&a,&b);
printf("%d %d\n",a,b);
}
void swap(int*p1,int*p2)
{
int temp;
temp=*p1;
*p1=*p2;
*p2=temp;
}
32. 数字字符个数统计函数设计
设计一个函数，统计任意一串字符中数字字符的个数，并在主函数中调用此函数。
输入： 任意一串字符
输出： 字符串中数字字符的个数
输入样例： abs1234ajbkc
输出样例： 4
/* 数字字符个数统计函数设计*/
#include <stdio.h>
int count(char*);
void main()
{
char a[100];
gets(a);
printf("%d\n",count(a));
}
int count(char *p)
{
int b=0;
while(*p!='\0')
{
if(*p>='0'&&*p<='9')
b++;
p++;
}
return b;
}
33. 排序函数设计
设计一个函数，对任意n个整数排序(从大到小)，并在主函数中输入数据个数n和n个整数，调用此函数实现排序。
输入： n个整数
输出： 排序后的n个整数
输入样例： 10<----数据个数
0 1 2 3 4 5 6 7 8 9<----数据
输出样例： 9 8 7 6 5 4 3 2 1 0
/*排序函数设计*/
#include<stdio.h>
void paixu(int a[],int num);
void main(void)
{
int i,n,m[100];
scanf("%d",&n);
for(i=0; i<n; i++)
scanf("%d",&m[i]);
paixu(m,n);
for(i=0; i<n; i++)
printf("%d ",m[i]);
}
void paixu(int a[],int num)
{
int i,j,k,temp;
for(i=0; i<num-1; i++)
{
k=i;
for(j=i+1; j<num; j++)
if(a[k]<a[j])
k=j;
if(k!=j)
{
temp=a[k];
a[k]=a[i];
a[i]=temp;
}
}
}
34. 矩阵转置函数设计
设计一个函数，将任意n×n的矩阵转置，并在主函数中调用此函数将一个4*4的矩阵转置。
输入： n×n的矩阵
输出： 转置后的n×n的矩阵
输入样例： 3
1 2 3
4 5 6
7 8 9
输出样例： 1 4 7
2 5 8
3 6 9
/* 矩阵转置函数设计*/
#include<stdio.h>
void zhuan(int a[][100],int );
int main(void)
{
int i, j;
int m[100][100];
int n;
scanf("%d", &n);
for(i=0; i<n; i++)
{
for(j=0; j<n; j++)
scanf("%d",&m[i][j]);
}
zhuan(m,n);
for(i=0; i<n; i++)
{
for(j=0; j<n - 1; j++)
printf("%d ",m[i][j]);
printf("%d\n", m[i][j]);
}
return 0;
}
void zhuan(int a[][100],int n)
{
int i,j,temp;
for(i=0; i<n; i++)
{
for(j=0; j<i; j++)
{
temp = a[i][j];
a[i][j] = a[j][i];
a[j][i] = temp;
}
}
}
35. 求素数函数设计
设计一个函数，用以判断一个整数是否为素数，如果是，则返回1；如果不是，则返回0；并利用此函数，找出m-n之间的所有素数，并统计其个数，m、n由键盘输入。
输入： 数据范围m-n。
输出： m-n之间的所有素数及个数。
输入样例： 100 200
输出样例： 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
21
/*求素数函数设计*/
#include<stdio.h>
#include<math.h>
int P(int );
void main(void)
{
int m,num=0;
int i,j;
scanf("%d %d",&i,&j);
for (m=i; m<=j; m=m+1)
{
if(P(m))
{
printf("%d ",m);
num++;
}
}
printf("\n%d\n",num);
}
int P(int n)
{
int found;
int i;
double k;
k=sqrt((double)n);
found = 1;
i = 2;
while(i<=k && found)
{
if( n%i ==0)
found = 0;
i++;
}
return found;
}
36. 进制转换函数设计
设计一个函数，将任意一个八进制数据字符串转换为十进制数据，并在主函数中调用此函数。
输入： 一个八进制数
输出： 十进制数
输入样例： 77
输出样例： 63
/*进制转换函数设计*/
#include<stdio.h>
int conver(char *);
void main(void)
{
char str[10];
gets(str);
printf("%d\n",conver(str));
}
int conver(char *p)
{
int num=0;
for(; *p!='\0'; p++)
num=num*8+*p-'0';
return num;
}
37. 求最大公约数函数设计
设计一个函数，找出任意2个整数的最大公约数，并在主函数中调用此函数。
输入： 2个整数
输出： 最大公约数
输入样例： 8 4
输出样例： 4
提示： 求最大公约数可用辗转相除法： rem=m%n; m=n;n=rem;若rem=0,m是最大公约数，程序结束；否则从新执行以上语句。
/*求最大公约数函数设计*/
#include<stdio.h>
int comdivi(int,int);
void main(void)
{
int a,b,com;
scanf("%d%d",&a,&b);
com=comdivi(a,b);
printf("%d\n",com);
}
int comdivi(int m,int n)
{
int q;
if(n>m)
{
int z;
z=m;
m=n;
n=z;
}
do
{
q=m%n;
m=n;
n=q;
}
while(q!=0);
return m;
}
38. 对称数组判断
设计一个函数，判断二维数组是否为对称数组（对称矩阵），如果是，则返回1；如果不是，则返回0，并在主函数中调用此函数，判断一个4*4的数组是否为对称数组。
输入： 二维数组
输出： 是否为对称数组
输入样例： 1 2 3 4
2 5 6 7
3 6 8 9
4 7 9 0
输出样例： Yes
/*对称数组判断*/
#include<stdio.h>
#include<math.h>
int array(int*,int);
void main(void)
{
int i,j;
int a[4][4];
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
scanf("%d",&a[i][j]);
}
if(array((int*)a,4))
printf("No\n");
else
printf("Yes\n");
}
int array(int*p,int n)
{
int found;
int i,j;
found=1;
for(i=0;i<n;i++)
{
for(j=0;j<i;j++)
{
if(*(p+i*n+j)!=*(p+j*n+j))
{
found=0;break;
}
}
}
return found;
}
39. 结构体的定义与引用
定义一个职工结构体数据类型，并定义职工结构体变量。
输入： 从键盘输入一个职工的信息。（4个数据，每个占一行，工资有两位小数）
输出： 输出职工信息。（4个数据，每个占一行）
输入样例： zhangping
610103196802262001
21
2183.55
输出样例： zhangping
610103196802262001
21
2183.55
/*结构体的定义与引用*/
#include<stdio.h>
struct employee
{
char name[20];
char id[20];
int gl;
float salary;
};
int main()
{
struct employee em;
scanf("%s",em.name);
scanf("%s",em.id);
scanf("%d",&em.gl);
scanf("%g",&em.salary);
printf("%s\n%s\n%d\n%g\n",em.name,em.id,em.gl,em.salary);
return 0;
}
40. 结构体数组的定义与引用
定义一个职工结构体数组，从键盘输入5位职工的信息，打印出最高的工资。
输入： 从键盘输入5位职工的信息（4个数据，每个占一行，工资有两位小数）。
输出： 打印出最高的工资。
输入样例： liuxin
91736527976271265
11
1234.23
liyixin
91736527976271265
11
5234.24
liuxin
91736527943271265
11
1244.25
liuxin
91736527976271265
11
1284.26
liuxin
91736527976271265
11
1232.27
输出样例： 5234.24
/* 结构体数组的定义与引用*/
#include<stdio.h>
#define N 5
struct a
{
char name[8];
int id;
int NO;
float salary;
} a[N];
void main()
{
int i;
int j=0;
float max=0;
for(i=0; i<N; i++)
{
scanf("%s%d%d%g",a[i].name,&a[i].id,&a[i].NO,&a[i].salary);
}
for(i=0; i<N; i++)
{
if(max<a[i].salary)
{
max=a[i].salary;
j=i;
}
}
printf("%g\n",a[j].salary);
}
41. 电话薄管理程序设计
编写手机电话薄管理程序，用结构体实现下列功能：
（1) 手机电话薄含有姓名、宅电、手机3项内容，建立含有上述信息的电话簿。
（2）输入姓名，查找此人的号码。
（3）插入某人的号码。
（4）输入姓名，删除某人的号码。
（5）将以上功能分别用子函数实现，编写主函数，可以根据用户的需要，调用相应的子函数。
建议用结构体完成。
1、程序主函数如下所示，请认真理解，不要更改代码。
int main(void) /* 主函数 */
{
int k;
do
{
printf(" 0: exit\n"); /* 打印菜单项 */
printf(" 1: creat\n");
printf(" 2: search\n");
提示： printf(" 3: insert\n");
printf(" 4: delete\n");
printf(" 5: output\n");
printf("please select:");
scanf("%d",&k); /* 输入选择项 */
switch(k)
{
case 0:
exit(0); /* 退出函数 */
case 1:
creat( );
break;
case 2:
search( );
break;
case 3:
insert( );
break;
case 4:
delete( );
break;
case 5:
output( );
break; /* 调用子函数 */
default:
exit(0);
}
}
while(1);
return 0;
}
2、根据主函数，设计相应函数完成指定功能。
3、creat时，可用while(1)循环连续创建，当输入'*'时，则结束。
/*3. 电话薄管理程序设计*/
/*1) 手机电话薄含有姓名、宅电、手机3项内容，建立含有上述信息的电话簿*/
/*（2）输入姓名，查找此人的号码。*/
/*（3）插入某人的号码。*/
/*（4）输入姓名，删除某人的号码。*/
/*（5）将以上功能分别用子函数实现，编写主函数，*/
/*可以根据用户的需要，调用相应的子函数。*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int N;
struct phone
{
char name[20];
char num1[20];
char num2[20];
} book[100];
void creat();
void search();
void insert();
void delete();
void output();
int main(void) /* 主函数 */
{
int k;
do
{
printf(" 0: exit\n"); /* 打印菜单项 */
printf(" 1: creat\n");
printf(" 2: search\n");
printf(" 3: insert\n");
printf(" 4: delete\n");
printf(" 5: output\n");
printf("please select:");
scanf("%d",&k); /* 输入选择项 */
switch(k)
{
case 0:
exit(0); /* 退出函数 */
case 1:
creat( );
break;
case 2:
search( );
break;
case 3:
insert( );
break;
case 4:
delete( );
break;
case 5:
output( );
break; /* 调用子函数 */
default:
exit(0);
}
}
while(1);
return 0;
}
void creat(void)
{
char appella[20];
getchar();
while(1) /* 输入结构数组 */
{
gets(appella);
if(*appella=='*')
break; /* 输入*，则结束 */
strcpy(book[N].name, appella);
gets(book[N].num1);
gets(book[N].num2);
N++;
}
}
void search(void) /*查找子函数 */
{
char appella[20];
int i=0;
getchar();
gets(appella);
while(i<N && strcmp(book[i].name,appella)!=0)
{
i++;
}
if(i<N)
printf("%s %s %s\n",
book[i].name,book[i].num1,book[i].num2);
else
printf("not found");
}
void insert(void) /* 插入子函数 */
{
getchar();
gets(book[N].name);
gets(book[N].num1);
gets(book[N].num2);
N++; /* 长度加1 */
}
void delete(void) /*删除子函数 */
{
char appella[20];
int i=0,j;
getchar();
gets(appella);
while(i<N && strcmp(book[i].name,appella)!=0)
{
i++;
}
if(i<N)
{
for(j=i+1; j<N; j++)
{
book[j-1] = book[j];
}
N--; /* 长度减1 */
}
else
printf("not found");
}
void output(void) /* 输出子函数 */
{
int i;
for(i=0; i<N; i++)
printf("%s %s %s\n",
book[i].name,book[i].num1,book[i].num2);
}
42. 正负数判断
从键盘输入任意十六进制整数a，判断其最高为是0或1，如果为0，输出此函数是正数的信息；如果为1，输出此函数是负数的信息。
输入： 整数a。
输出： 输出此函数是负数的信息。
输入样例： 0XFFA7 或 0X59
输出样例： is negative number 或 is positive number
/*正负数判断*/
#include<stdio.h>
void main(void)
{
short num,a;
int m;
m= 0x8000;
scanf("%x",&num);
a = (m& num)?1:0;
if(a==0)
printf("is positive number\n");
else
printf("is negative number\n");
}
43. 偶数位清零
从键盘任意输入整数a，将其偶数位清零，其他位保留。
输入： 整数a。
输出： 偶数位清零，其他位保留后的数。
输入样例： 0XFFFF
输出样例： 5555<--十六进制
/*偶数位清零*/
#include<stdio.h>
void main(void)
{
unsigned short a,b,mask;
mask = 0x5555;
scanf("%x",&a);
b = a&mask;
printf("%x\n",b);
}
44. 文本文件中字符个数统计
统计一个文本文件中字符的个数。
输入： 文本文件名称(包含全路径)
输出： 文本文件中字符的个数。
输入样例： E:\\DATA\\70\\f1.txt
输出样例： 16
/*文本文件中字符统计*/
#include<stdio.h>
#include<stdlib.h>
void main(void)
{
char ch, filename[200];
int count = 0;
FILE *fp; /* 定义文件指针 */
scanf("%s", filename);//输入文本文件名
if((fp=fopen(filename,"r"))==NULL)
{
printf("File open error!\n");
exit(1);
}
while((ch=fgetc(fp))!=EOF)
{
count++;
}
printf("%d\n",count);
if(fclose(fp))
{
printf("File close error!\n");
exit(1);
}
}
45. 二进制文件操作
已知一个文本文件中存放了10个整型数据，将它们以二进制数据的形式存入另一个文件。
输入： 存放了10个整型数据的文本文件名。
输出： 二进制数据文件。
输入样例： E:\\DATA\\72\\f0.txt
E:\\DATA\\72\\result.dat
输出样例： 23 45 67 78 45 32 12 56 99 56
/*二进制文件操作*/
#include<stdio.h>
#include<stdlib.h>
int main(vaoid)
{
int a[10], i = 0;
char filename1[80], filename2[80];
FILE *fp1,*fp2;
/* 定义文件指针 */
scanf("%s", filename1);//输入要打开的文本文件名
scanf("%s", filename2);//输入要创建的二进制文件名
if((fp1 = fopen(filename1, "rb")) == NULL)
{
printf("Input file open error!\n");
exit(1);
}
if((fp2 = fopen(filename2, "wb")) == NULL)
{
printf("Result file open error!\n");
exit(1);
}
for(i=0; i<10; i++)
{
fscanf(fp1,"%d",&a[i]);
fwrite(&a[i],sizeof(int),1,fp2);
}
if( fclose(fp1))
{
printf("Result file close error!\n");
exit(1);
}
if( fclose(fp2))
{
printf("Result file close error!\n");
exit(1);
}
if((fp1 = fopen(filename2, "rb")) == NULL)
{
printf("Result file open error!\n");
exit(1);
}
for(i = 0; i < 10; i++)
{
fread(&a[i], sizeof(int), 1, fp1); /* 读出数据 */
}
if( fclose(fp1))
{
printf("Result file close error!\n");
exit(1);
}
for(i = 0; i < 9; i++)
printf("%d ", a[i]);
printf("%d\n", a[i]);
return 0;
}
46. 文件内容比较
设2个文本文件中的字符数量相等，比较2个文本文件中的内容是否一致，如果不同输出首次不同的字符的位置。
输入： 2个文本文件全路径名。
输出： 比较2个文本文件中的内容是否一致，如果不同输出首次不同的字符的位置。
输入样例： E:\\DATA\\73\\f01.txt
E:\\DATA\\73\\f02.txt
输出样例：
4
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int i =1, flag = 0;
char filename1[80], filename2[80];
char a,b;
FILE *p1;
FILE *p2;
scanf("%s", filename1);
scanf("%s", filename2);
if((p1=fopen(filename1,"r"))==NULL)
{
printf("Input file1 open error!\n");
exit(1);
}
if((p2=fopen(filename2,"r"))==NULL)
{
printf("Input file2 open error!\n");
exit(1);
}
for(;!flag&&feof(p1)==0;i++)
{
fscanf(p1,"%c",&a);
fscanf(p2,"%c",&b);
if(a!=b)
{
flag=1;
printf("%d\n",i);
}
}
if(flag==0)
printf("is equal\n");
fclose(p1);
fclose(p2);
return 0;
}
47. 除不尽的自然数
一个自然数被8除余1，所得的商被8除也余1，再将第二次的商被8除后余7，最后得到的商为a。又知这个自然数被17除余4，所得的商被17除余15，最后得到一个商是a的2倍。求这个自然数。
输入： 无
输出： 满足条件的自然数。
输入样例： 无
输出样例： 1993
提示： 根据题意，可设最后的商为i(i从0开始取值)，用逆推法可以列出关系式：(((i*8+7)*8)+1)*8+1=((2*i*17)+15)*17+4再用试探法求出商i的值。
#include<stdio.h>
int main()
{
int i;
for(i=0;; i++) /*试探商的值*/
if(((i*8+7)*8+1)*8+1==(34*i+15)*17+4)
{
/*逆推判断所取得的当前i值是否满足关系式*/
/*若满足则输出结果*/
printf("%d\n",(34*i+15)*17+4);
break; /*退出循环*/
}
return 0;
}
48. 4位反序数
设N是一个四位数，它的9倍恰好是其反序数，求N。反序数就是将整数的数字倒过来形成的整数。例如：1234的反序数是4321。
输入： 无
输出： 4位反序数
输入样例： 无
输出样例： 1089
提示： 可设整数N的千、百、十、个位为i、j、k、l，其取值均为0~9，则满足关系式：(i*10^3+j*10^2+10*k+l)*9=(l*10^3+k*10^2+10*j+i)的i、j、k、l即构成N。
#include<stdio.h>
int main()
{
int i;
for(i=1002; i<1111; i++) /*穷举四位数可能的值*/
if(i%10*1000+i/10%10*100+i/100%10*10+i/1000==i*9)
/*判断反序数是否是原整数的9倍*/
printf("%d\n",i);
/*若是则输出*/
return 0;
}
49.求车速
一辆以固定速度行驶的汽车，司机在上午10点看到里程表上的读数是一个对称数(即这个数从左向右读和从右向左读是完全一样的)，为95859。两小时后里程表上出现了一个新的对称数。问该车的速度是多少？新的对称数是多少？
输入： 无
输出： 满足条件的对称数和车速
输入样例： 无
输出样例： 95959
50.00
提示： 根据题意，设所求对称数为i，其初值为95859，对其依次递增取值，将i值的每一位分解后与其对称位置上的数进行比较，若每个对称位置上的数皆相等，则可判定i即为所求的对称数。
#include<stdio.h>
int main()
{
int t,a[5]; /*数组a存放分解的数字位*/
long int k,i;
for(i=95860;; i++) /*以95860为初值，循环试探*/
{
for(t=0,k=100000; k>=10; t++) /*从高到低分解所取i值的每位数*/
{
/* 字，依次存放于a[0]~a[5]中*/
a[t]=(i%k)/(k/10);
k/=10;
}
if((a[0]==a[4])&&(a[1]==a[3]))
{
printf("%d%d%d%d%d\n",
a[0],a[1],a[2],a[3],a[4]);
printf("%.2f\n",(i-95859)/2.0);
break;
}
}
return 0;
}
50. 阿姆斯特朗数
如果一个正整数等于其各个数字的立方和，则称该数为阿姆斯特朗数(亦称为自恋性数)。如 407=4^3+0^3+7^3就是一个阿姆斯特朗数。试编程求1000以内的所有阿姆斯特朗数。
输入： 无
输出： 阿姆斯特朗数
输入样例： 无
输出样例： 153 370 371 407
提示： 输出时printf()的格式串用"%5d"。
#include<stdio.h>
int main()
{
int i,t,k,a[3];
//printf("There are follwing Armstrong number smaller than 1000:\n");
for(i=2; i<1000; i++) /*穷举要判定的数i的取值范围2~1000*/
{
for(t=0,k=1000; k>=10; t++) /*截取整数i的各位(从高向低位)*/
{
a[t]=(i%k)/(k/10); /*分别赋于a[0]~a[2}*/
k/=10;
}
if(a[0]*a[0]*a[0]+a[1]*a[1]*a[1]+a[2]*a[2]*a[2]==i)
/*判断i是否为阿姆斯特朗数*/
printf("%5d",i); /*若满足条件，则输出*/
}
printf("\n");
return 0;
}
51.完全数
如果一个数恰好等于它的因子之和，则称该数为“完全数”，求1000以内的完全数。
输入： 无
输出： 完全数
输入样例： 无
输出样例： 6 28 496
提示： 1、根据完全数的定义，先计算所选取的整数a(a的取值1~1000)的因子，将各因子累加于m，若m等于a，则可确认a为完全数。
2、输出用printf("%4d ",a)。
#include<stdio.h>
int main()
{
int a,i,m;
//printf("There are following perfect numbers smaller than 1000:\n");
for(a=1; a<1000; a++) /*循环控制选取1~1000中的各数进行判断*/
{
for(m=0,i=1; i<=a/2; i++) /*计算a的因子，并将各因子之和m=a，则a是完全数输出*/
if(!(a%i))m+=i;
if(m==a)
printf("%4d ",a);
}
printf("\n");
return 0;
}
52. 亲密数
如果整数A的全部因子（包括1，不包括A本身）之和等于B；且整数B的全部因子（包括1，不包括B本身）之和等于A，则将整数A和B称为亲密数。求3000以内的全部亲密数。
输入： 无
输出： 亲密数
输入样例： 无
输出样例： 220<->284
1184<->1210
2620<->2924
/*亲密数*/
#include<stdio.h>
void main()
{
int a,i,b,n;
for(a=1; a<3000; a++)
{
for(b=0,i=1; i<=a/2; i++)
if(!(a%i))b+=i;
for(n=0,i=1; i<=b/2; i++)
if(!(b%i))n+=i;
if(n==a&&a<b)
printf("%d<->%d\n",a,b);
}
}
53. 自守数
自守数是指一个数的平方的尾数等于该数自身的自然数。例如：25^2=625、 76^2=5776、9376^2=87909376，请求出200000以内的自守数。
输入： 无
输出： 自守数
输入样例： 无
输出样例： 0 1 5 6 25 76 376 625 9376 90625 109376
提示： 若采用“求出一个数的平方后再截取最后相应位数”的方法显然是不可取的，因为计算机无法表示过大的整数。
#include<stdio.h>
int main()
{
long mul,number,k,ll,kk;
//printf("It exists following automorphic nmbers small than 200000:\n");
for(number=0; number<200000; number++)
{
for(mul=number,k=1; (mul/=10)>0; k*=10);
/*由number的位数确定截取数字进行乘法时的系数k*/
kk=k*10; /*kk为截取部分积时的系数*/
mul=0; /*积的最后n位*/
ll=10; /*ll为截取乘数相应位时的系数*/
while(k>0)
{
mul=(mul+(number%(k*10))*(number%ll-number%(ll/10)))%kk;
/*(部分积+截取被乘数的后N位*截取乘数的第M位)，%kk再截取部分积*/
k/=10; /*k为截取被乘数时的系数*/
ll*=10;
}
if(number==mul) /*判断若为自守数则输出*/
printf(" %ld",number);
}
printf("\n");
return 0;
}
54. 回文数
打印所有不超过n(取n<256) 的平方具有对称性质的数(也称回文数)。
输入： 无
输出： 满足条件的整数
输入样例： 无
输出样例： 1 1 1
2 2 4
3 3 9
4 11 121
5 22 484
6 26 676
7 101 10201
8 111 12321
9 121 14641
10 202 40804
11 212 44944
提示： 1、对于要判断的数n，计算出其平方后(存于a)，将a的每一位进行分解，再按a的从低到高的顺序将其恢复成一个数k(如n=13，则a=169且k=961)，若a等于k则可判定n为回文数。
2、输出格式串用："%2d%10d%10d\n"。
#include<stdio.h>
int main(void)
{
int m[16],n,i,j,t,count=0;
long unsigned a,k;
//printf("No. number it's square(palindrome)\n");
for(n=1; n<256; n++) /*穷举n的取值范围*/
{
k=0;
t=1;
a=n*n; /*计算n的平方*/
for(i=0; a!=0; i++) /*从低到高分解数a的每一位存于数组m[0]~m[16]*/
{
m[i]=a%10;//这个是取得a的个位，整个循环合起来就可以取得各个位
a/=10;
}
j=0;
for(i--; j<i; j++,i--) //因为n的平方的各个位都存在数组中了，下面判断是不是对称
if(m[j]!=m[i])break;//只要有一位不是对称，那就说明不是对称，就可以退出了
//所有的位都对称就说明是对称了，这样就可以打印出结果了
if(j>=i)printf("%2d%10d%10d\n",++count,n,n*n);
}
return 0;
}
55. 具有abcd=(ab+cd)^2性质的四位数
3025这个数具有一种独特的性质：将它平分为二段，即30和25，使之相加后求平方，即(30+25)^2，恰好等于3025本身。请求出具有这样性质的全部四位数。
输入： 无
输出： 具有abcd=(ab+cd)^2性质的四位数
输入样例： 无
输出样例： 2025 3025 9801
#include<stdio.h>
int main()
{
int n,a,b;
//printf("There are following number with 4 digits satisfied condition\n");
for(n=1000; n<10000; n++) /*四位数N的取值范围1000~9999*/
{
a=n/100; /*截取N的前两位数存于a*/
b=n%100; /*截取N的后两位存于b*/
if((a+b)*(a+b)==n) /*判断N是否为符合题目所规定的性质的四位数*/
printf("%d ",n);
}
return 0;
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
