扬大C语言上机题.docx
《扬大C语言上机题.docx》由会员分享，可在线阅读，更多相关《扬大C语言上机题.docx（20页珍藏版）》请在冰豆网上搜索。
扬大C语言上机题
设n。
是一个给定的正整数。
对于i=0,1,2,6……，定义：
若nI是偶数，则nI+1=nI/2;若nI是奇数，则nI+1=3nI+1；若nI是1，则序列结束。
编写一个voidhailstones（intn），其功能是显示有n产生的所需要的序列。
按每行6个数输出该数列中的所有数。
编写main函数，在main函数中定义一个整型变量n，。
#include
voidhailstones（intn）
{intj,i=1;
printf（"Hailstonesgeneratedby%d\n",n）;
while（n>1）
{for（j=0;j<6;j++）
{printf（"%d\t",n）;
if（n==1）break;
if（n%2==0）n/=2;
elsen=3*n+1;
i++;}
printf（"\n"）;
}
printf（"Numberofhailstonesgenerated:
%d",i）;
}
main（）
{intn;
scanf（"%d",&n）;
hailstones（n）;
getch（）;
}
编写程序，找出满足条件的整数m
在（11,999）之间
m，m2，m3均为回文数。
设计函数intvalue（longm）判断m是否为回文数。
若是，返回值为1，否则为0.编写main函数，求出（11,999）内满足的数。
voidmain（）
{longintm,i,j;
for（m=11;m<=999;m++）
{i=m*m;
j=m*m*m;
if（value（m）==1&&value（i）==1&&value（j）==1）
printf（"%ld\n",m）;}
getch（）;
}
intvalue（longm）
{longa=0,k;
k=m;
while（m）
{a=a*10+m%10;
m=m/10;}
if（a==k）
return1;
else
return0;
getch（）;
}
如果一个数及该数的反序数都是素数，则称该数为可逆素数。
例如17是素数，17的反序数71也是素数，因此17便是一个可逆素数。
编程要求：
（1）编写函数以下程序中，函数intf（intm,intn,inta[]），其功能是在[m,n]区间内查找所有可逆素数并将这些素数依次保存到a指向的数组中，函数返回a数组中可逆素数的数目。
（2）编写main函数，声明一个足够大的一维数组，并从键盘上输入2个正整数m和n（m
#include
#include
intp（intn）
{inti,j=sqrt（n）;
for（i=2;i<=j;i++）
if（n%i==0）return0;
return1;
}
intconvert（intn）
{intm=0;
while（n>0）
{m=m*10+n%10;
n=n/10;
}
returnm;
}
intf（intm,intn,inta[]）
{inti,j=0;
for（i=m;i<=n;i++）
if（p（i）&&p（convert（i）））a[j++]=i;
returnj;
}
main（）
{inti,n,a[50];
n=f（50,150,a）;
for（i=0;iprintf（"%d,",a[i]）;
printf（"%d",a[n-1]）;
getch（）;
}
整数145有一个奇怪的特性：
145=1!
+4!
+5!
。
编程要求:
（1）编写函数intfacsum（longx），其功能是判断长整型数x是否具有上述特性，如具有上述特性则返回值1，否则返回值0。
（2）编写main（），在1~2000000内寻找具有此特性的数，并将满足该特性的数输出。
longfac（intx）
{longinty=1;
for（;x>0;x--）y*=x;
returny;
}
intfacsum（longx）
{longsum=0;
longy;y=x;
while（y）
{sum+=fac（y%10）;y/=10;}
if（sum==x）return1;
elsereturn0;}
main（）
{longi;
for（i=1;i<=200000;i++）
if（facsum（i））
printf（"%12ld",i）;
getch（）;
}
1.请编写函数intprimecount（inta[],intm,intn），其功能是：
找出[m,n]内的所有质数并依次将它们存储到a指向的一维数组中，函数返回[m,n]内质数的个数。
编写main函数，声明一个长度为100的一维数组a，从键盘上输入m和n，用a、m、n作为实在参数调用函数primecount，将结果数组输出到屏幕，并输出[m,n]内质数的个数。
2.编写函数intdelnum（chars[]），其功能是：
将s指向的字符串中的数字字符删除，函数返回被删除的数字字符的个数。
编写main函数，声明一个长度为80的字符型数组item并用下列测试数据初始化，用item作为实在参数调用函数delnum，输出结果字符串及被删除的数字字符的个数。
测试数据为：
my2009xy3com+
输出结果为：
myxycom+，5。
3.请编写函数intpalindrome（long*a,longm,longn），其功能是找出[m,n]内的所有回文数（回文数：
顺读倒读其值都相同的数，例如12321），函数返回[m,n]内回文数的个数。
编写main函数，声明一个长度为1000的长整型数组a，从键盘输入长整型数m和n，用a、m、n作为实在参数调用函数palindrome，将结果数组输出至屏幕，并输出符合条件数的个数。
例如，若m=100n=500，则输出结果为：
101111121131141
151161171181191
202212222232242
252262272282292
303313323333343
353363373383393
404414424434444
454464474484494
count=40
4．请按下列要求编写程序：
（1）编写voidchange（inta[],intn），其功能是对a指向的长度为n的数组作如下调整：
将所有的偶数调整到数组的前端；所有奇数调整到数组的后端。
（2）设计main函数，声明一个长度为12的整型数组a，并用如下数据初始化：
1,2,3,6,8,5,7,11,90,31,9,10，用a和12作为实在参数调用change函数，以便以分析数据的格式输出a数组变化前后的各元素的值。
5．请设计程序，将一字符串做压缩处理。
编程要求如下：
（1）编写一个函数intcompress（chars[]），将s中连续出现的多个相同字符压缩为一个字符，统计被删除的字符个数，返回被删除的字符个数；
（2）编写函数main，从键盘读入一行字符数据存入一个字符型数组中，调用compress函数对该字符数组中存储的字符做压缩处理，输出压缩后的字符串。
测试数据：
@@@@@@Iwwillllsuccesful&&&&&&andyoutoo##########
运行结果：
@Iwilsucesful&andyouto!
#
30
/*1
#include
#include
intprime（intn）
{
inti;
for（i=2;i<=n/2;i++）
if（n%i==0）
return0;
return1;
}
intprimecount（inta[],intm,intn）
{
intk=0,i;
for（i=m;i<=n;i++）
if（prime（i））
a[k++]=i;
returnk;
}
voidmain（）
{
inta[100],x,y,i,count;
scanf（"%d%d",&x,&y）;
count=primecount（a,x,y）;
for（i=0;i（i%5==0）?
printf（"\n%5d",a[i]）:
printf（"%5d",a[i]）;
printf（"\ncount=%d",count）;
getch（）;
}
*/
/*2
#include
#include
intdelnum（chars[80]）
{
inti,j,n;
n=strlen（s）;
for（i=0,j=0;s[i]!
='\0';i++）
if（!
（s[i]>='0'&&s[i]<='9'））
{s[j]=s[i];j++;}
s[j]='\0';
returnn-strlen（s）;
}
voidmain（）
{
charitem[80]="my2009xy3com+";
intn;
printf（"%s\n",item）;
n=delnum（item）;
printf（"%s\n",item）;
printf（"%d\n",n）;
getch（）;
}
*/
/*3
#include
#include
voidmain（）
{
longinta[1000],m,n;
inti,count;
scanf（"%ld%ld",&m,&n）;
count=palindrome（a,m,n）;
for（i=0;i（i%5==0）?
printf（"\n%5d",a[i]）:
printf（"%5d",a[i]）;
printf（"\ncount=%d\n",count）;
getch（）;
}
intpalindrome（long*a,longm,longn）
{
longx,y,i,k=0;
for（i=m;i<=n;i++）
{
y=0;
x=i;
while（x）
{
y=y*10+x%10;
x/=10;
}
if（y==i）
a[k++]=i;
}
returnk;
}
*/
/*4
#include"stdio.h"
voidchange（inta[],intn）
{inti=0,j=n-1,m;
while（i{
while（a[i]%2）i++;
while（a[j]%2==0）j--;
if（im=a[i],a[i]=a[j],a[j]=m;
i++;
j--;
}
}
main（）
{inti,n=12,a[12]={1,2,3,6,8,5,7,11,90,31,9,10};
for（i=0;iprintf（"%3d",a[i]）;
change（a,n）;
printf（"\n"）;
for（i=0;iprintf（"%3d",a[i]）;
getch（）;
}
*/
/*5
（1）
#include"stdio.h"
#include"conio.h"
intcompress（chars[]）
{inti,j,h=0;
for（i=0;s[i];）
if（s[i]==s[i+1]）
{for（j=i;s[j];j++）
s[j]=s[j+1];
s[j]='\0';
h++;
}
elsei++;
returnh;
}
main（）
{chars[80]="@@@@@@Iwwillllsuccesful&&&&&&andyoutoo##########";
inti,m;
m=compress（s）;
printf（"%s",s）;
printf（"\n"）;
printf（"%d",m）;
getch（）;
}
（2）
*/
#include"stdio.h"
#include"string.h"
intcompress（chars[]）
{char*p=s,*q;
inth=0;
while（*p）
{q=p+1;
while（*q==*p）q++,h++;
strcpy（p+1,q）;
p++;
}
returnh;
}
main（）
{chars[80]="@@@@@@Iwwillllsuccesful&&&&&&andyoutoo##########";
inti,m;
m=compress（s）;
printf（"%s",s）;
printf（"\n"）;
printf（"%d",m）;
getch（）;
}
1.请编写函数inttwinborn（inta[][2],intm,intn），其功能是找出[m,n]中的所有孪生质数对（相差为2的两个质数称为孪生质数），并依次将每对孪生质数写到a指向的二维数组的每一行中。
编写main函数，声明一个100×2的二维数组a，并从键盘上输入m和n的值，用a、m、n作为实在参数调用函数twinborn，将结果数组以行为单位输出至屏幕。
例如，测试数据和运行结果如下：
inputtwonumbers:
10100
11,13
17,19
29,31
41,43
59,61
71,73
2．请按下列要求编写程序：
（1）编写函数voidfun（charx[]），其功能是在x指向的字符串中的所有数字字符之前分别插入1个字符'$'；
（2）编写main函数，定义一个字符数组a，用测试数据中的数据初始化字符数组a，用a作为实在参数调用函数fun，输出结果字符串。
测试数据：
a1b34cdef5
运行结果：
a$1b$3$4cdef$5
3．要求40名学生对学生食堂的饭菜质量按照从1到10（1意味着非常不好，10表示非常好）进行打分，分别统计出打各分数的人数。
请按下列要求编写程序：
（1）编写voidcont（inta[],intn,intb[]），其功能是对a指向的长度为n的整型数组中存储的分值作统计，统计结果依次存入b所指向的数组中；
（2）设计main函数，声明一个长度为40的整型数组并用下列测试数据初始化，声明一个长度为11的数组b，用a、40和b作为实在参数调用cont函数，输出统计结果至屏幕。
注意：
b[1]中存放打分值1的人数，b[2]中存放打分值2的人数，依次类推。
测试数据：
1,2,6,4,8,9,10,2,3,4,2,3,4,5,4,6,7,8,6,9,1,6,7,8,7,6,9,10,8,6,7,6,8,9,5,4,3,9,8,7
4.请编写函数inttwinborn（inta[][2],intm,intn），其功能是找出[m,n]中的所有孪生质数对（相差为2的两个质数称为孪生质数），并依次将每对孪生质数写到a指向的二维数组的每一行中。
编写main函数，声明一个100×2的二维数组a，并从键盘上输入m和n的值，用a、m、n作为实在参数调用函数twinborn，将结果数组以行为单位输出至屏幕。
例如，测试数据和运行结果如下：
inputtwonumbers:
10100
11,13
17,19
29,31
41,43
59,61
71,73
5.编程要求：
（1）请编写函数intfun（inta[][3]），其功能是：
找出符合下列命题的所有3位数：
“若一个三位数是37的倍数，则将这个三位数的三个数字循环移位得到另两个三位数也是37的倍数”。
例如，148是37的倍数，481和814也都是37的倍数。
将满足条件的三位数及其循环移位后得到的另2个三位数依次写到形参a指向的二维数组中，函数返回三位数的组数（注意：
尽量做到已经输出过的数，下次就不再输出。
例如：
148，481，841三个数算作一组）。
（2）编写main函数，声明一个300×3的二维数组a，用a作为实在参数调用函数fun，输出所有满足上述条件的三位数。
输出时，每组数据占一行。
/*1#include"stdio.h"
intprime（inti）
{intk;
for（k=2;kif（!
（i%k））
return0;
return1;
}
inttwinborn（inta[][2],intm,intn）
{intk=0,i;
for（i=m;i<=n-2;i+=2）
if（prime（i）&&prime（i+2））
a[k][0]=i,a[k][1]=i+2,k++;
returnk;
}
main（）
{inta[100][2],m,n,i;
printf（"inputtwonumbers:
"）;
scanf（"%d%d",&m,&n）;
if（!
（m%2））
m+=1;
if（m==1）
m+=2;
m=twinborn（a,m,n）;
for（i=0;iprintf（"%5d,%5d\n",a[i][0],a[i][1]）;
getch（）;
}*/
/*2
#include"stdio.h"
#include"conio.h"
voidfun（charx[]）
{inti,j;
for（i=0;x[i];）
if（x[i]>='1'&&x[i]<='9'）
{for（j=i;x[j]!
=0;j++）;j=j-1;
{while（j>=i）
{x[j+1]=x[j];j--;}
x[i]='$';i=i+2;
}
}
elsei++;
}
main（）
{charc[20]="a1b34cdef5";
puts（c）;
fun（c）;
printf（"%s",c）;
getch（）;
}
*/
/*3
#include"stdio.h"
voidcont（inta[],intn,intb[]）
{
inti;
for（i=0;i<40;i++）
b[a[i]]++;
}
main（）
{inta[40]={1,2,6,4,8,9,10,2,3,4,2,3,4,5,4,6,7,8,6,9,1,6,7,8,7,6,9,10,8,6,
7,6,8,9,5,4,3,9,8,7},b[11]={0},i,n=40;
cont（a,n,b）;
for（i=1;i<=10;i++）
printf（"%3d:
%3d\n",i,b[i]）;
getch（）;
}
*/
/*5
（1）
#include
#include
intfun（inta[][3]）
{
intn,y,k,m,q,b,c,i=0,x;
for（n=100;n<1000;n++）
{
if（n%37==0）
{k=n/100;
m=n/10%10;
q=n%10;
if（k*m*q!
=0&&（（k==m）+（m==q）+（q==k）<3））
{b=100*m+10*q+k;
c=100*q+10*k+m;
if（b%37==0&&c%37==0）
{
a[i][0]=n;
a[i][1]=b;
a[i][2]=c;
i++;
}
}
}
}
returni;
}
main（）
{
inta[300][3],i,n;
n=fun（a）;
for（i=0;iprintf（"%5d%5d%5d\n",a[i][0],a[i][1],a[i][2]）;
getch（）;
}*/
/*
（2）*/
#include
#include
intfun1（intn,intm,inta[][3]）
{
inti;
for（i=0;iif（n==a[i][0]||n==a[i][1]||n==a[i][2]）
return0;
return1;
}
intfun（inta[][3]）
{
intn,y,k,m,q,b,c,i=0,x;
for（n=100;n<1000;n++）
{
if（n%37==0）
{k=n/100;
m=n/10%10;
q=n%10;
if（k*m*q!
=0&&（k==m）+（m==q）+（q==k）<3&&fun1（n,i,a））
/*第1个条件去掉2位数，第2个条件去掉重复数字，第3个条件去掉前面出现过的3位数*/
{b=100*m+10*q+k;
c=100*q+10*k+m;
if（b%37==0&&c%37==0）
{
a[i][0]=n;
a[i][1]=b;
a[i][2]=c;
i++;
}
}
}
}
returni;
}
main（）
{
inta[300][3],i,n;
n=fun（a）;
for（i=0;iprintf（"%5d%5d%5d\n",a[i][0],a[i][1],a[i][2]）;
getch（）;
}
4．任何各位数字不全相同的3位正整数经以下变换后均能变为495，称495为3位整数的黑洞数。
变换步骤：
对于任意一个各位数字不全相同的3位正整数，将组成该正整数的3个数字重新组合分别生成一个最大数和最小数，用最大数减去最小数得到一个新的3位数（不足3位时前面补0）；再对新的3位数重复上述操作，最多重复7次。
编写程序，接收从键盘输入的一个3位正整数，判断各位数字是否不全相同，若不全相同，则实施上述变换，输出每步变换后得到的3位整数。
5．求1~100以内的“完备数”。
一个数如果恰好等于除它本身之外的各个因子之和，则称该数为“完备数”。
例如：
6是完备数。
因为6的因子为1，2，3，且6=1+2+3。
6．打印如下图形：
*
***
*****
*******
*****
***
*
4.
#include
voidmain（）
{intmin,max,count=0,n=0,m=123,a,b,c,t;
while（n!
=m）
{
n=m;
printf（"%4d",n）;
count++;
a=n/100;
b=n/10%10;
c=n%10;
if（aif（aif（bmax=a*100+b*10+c;
min=c*100+b*10+a;
m=max-min;
}
printf（"%4d",count-1）;
getch（）;
}
5.
（1）作者：
崔鑫鑫
voidmain（）
{
intn,i,a;
for（n=1;n<
升级会员 