[ZZULI]1092~1113（函数专题）

ran迩

已于 2023-03-26 22:49:15 修改

阅读量800

点赞数 2

分类专栏：机试文章标签：蓝桥杯算法

于 2023-03-23 23:00:01 首次发布

本文链接：https://blog.csdn.net/m0_53216637/article/details/129740383

版权

机试专栏收录该内容

29 篇文章 2 订阅

订阅专栏

1092: 素数表(函数专题）

题目描述
输入两个正整数m和n，输出m和n之间的所有素数。
要求程序定义一个prime()函数和一个main()函数，prime()函数判断一个整数n是否是素数，其余功能在main()函数中实现。
int prime(int n)
{
//判断n是否为素数，若n为素数，本函数返回1，否则返回0
}
对于C/C++代码的提交，本题要求必须通过定义prime函数和main函数实现，否则，提交编译错误，要提交完整的程序。
输入
输入两个正整数m和n，m<=n，且都在int范围内。
输出
输出占一行。输出m和n之间的所有素数，每个数后有一个空格。测试数据保证m到n之间一定有素数。
样例输入
2 6
样例输出
2 3 5

#include<stdio.h>
#include<math.h>
int prime(int n){
	int flag=0;
	for(int i=2;i<=sqrt(n);i++){    
		if(n%i==0)
			flag=1;
	}
	if(flag==0)    // 是素数 
		return 1;
	else
		return 0; 
}
int main(){
	int m,n;
	scanf("%d%d",&m,&n);
	for(int i=m;i<=n;i++){
		if(i>=2){
			int a=prime(i);
			if(a==1)
				printf("%d ",i);
		}
	}
	return 0;
}

prime()里，如果 i<=sqrt(n) 换成 i<n，会导致时间超限。
main()里，如果m=1，不设置 i>=2 的话，会导致输出 1 ，而 1 不是素数，故需要设置条件 i>=2 。

1093: 验证哥德巴赫猜想（函数专题）

题目描述
哥德巴赫猜想大家都知道一点吧。我们现在不是想证明这个结论，而是对于任给的一个不小于6的偶数，来寻找和等于该偶数的所有素数对。做好了这件实事,就能说明这个猜想是成立的。
要求程序定义一个prime()函数和一个main()函数，prime()函数判断一个整数n是否是素数，其余功能在main()函数中实现。
int prime(int n)
{
//判断n是否为素数，若n为素数，本函数返回1，否则返回0
}
对于C/C++代码的提交，本题要求必须通过定义prime函数和main函数实现，否则，提交编译错误，要提交完整的程序。
输入
一个偶数M (M是6到1000000之间的一个偶数).
输出
输出和等于该偶数的所有素数对a和b，按a递增的顺序输出，(a,b)和(b,a)被视为同一个素数对。
样例输入
40
样例输出
3 37
11 29
17 23

#include<stdio.h>
#include<math.h>
int prime(int n){
	int flag=0;
	for(int i=2;i<=sqrt(n);i++){
		if(n%i==0)
			flag=1;
	}
	if(flag==0)    //是素数 
		return 1;
	else 
		return 0;
}
int main(){
	int M;
	scanf("%d",&M);
	for(int i=3;i<=M/2;i=i+2){   
		if(prime(i)&&prime(M-i))
			printf("%d %d\n",i,M-i);
	}
	return 0;
}

关于main()中 int i=3，而不是 i=2，理由如下：M是偶数，如果素数对第一个数是2，那么第二个数应该是M-2，还是偶数，偶数不可能是素数。所以从 i=3开始。（写 i=2 会报错，如果写成：int i=2 ; i<=M/2 ; i=i+1 是正确的。）

1094: 统计元音（函数专题）

题目描述
输入一个字符串，统计其中元音字母的个数。要求使用函数vowel()用来判断是否为元音,其余功能在main()函数中实现。
int vowel(char ch)
{
//如果ch是元音，返回1，否则返回0
}
本题如果是C/C++代码提交，只需要提交vowel函数的定义部分，提交其它内容，编译出错。
输入
输入一个字符串，长度不超过1000，以回车符结束。
输出
输出一个整数，表示元音字母个数。输出单独占一行。
样例输入
Hello world!
样例输出
3

#include<stdio.h>
int vowel(char ch){
	if(ch=='A'||ch=='a'||ch=='E'||ch=='e'||ch=='I'||ch=='i'||ch=='O'||ch=='o'||ch=='U'||ch=='u')
		return 1;
	else
		return 0;
}
int main(){
	char c;
	int n=0;
	while(scanf("%c",&c),c!='\n'){
		n+=vowel(c);
	}
	printf("%d",n);
	return 0;
}

1095: 时间间隔（函数专题）

题目描述
从键盘输入两个时间点(24小时制），输出两个时间点之间的时间间隔，时间间隔用“小时:分钟:秒”表示。要求程序定义如下两个函数，并在main()中调用这两个函数实现相应的功能,其中main函数系统已经实现，你只需要完成下面这两个函数的定义。

//把时分秒转换成秒并返回, 三个参数分别为用于表示一个时间点的时、分、秒

int HmsToS(int h, int m, int s);

//将时间段转换为对应的“小时:分钟:秒” 格式输出 ,形参s表示一个时间段的长度，单位是秒

void PrintTime(int s);

输入
输入数据有多组。每组输入包括两行。第一行为时间点1，第二行为时间点2，时间点均以“HH:MM:SS”的格式输入。测试数据保证时间点1早于时间点2。
输出
对应每组数据，有一行输出，以“HH:MM:SS”的格式输出时间间隔。注意不足两位要补占位符0。格式参看输入输出。
样例输入
12:01:12
13:09:43
12:40:12
13:09:43
样例输出
01:08:31
00:29:31
提示
注意：要输出01:08:31中的占位符0，printf中的格式控制符用"%02d"

#include<stdio.h>
int HmsToS(int h, int m, int s){   //求某个时间的秒数
	return s+m*60+h*3600;
}
void PrintTime(int s){      //把以s为单位的时间间隔转换成以 H：M：S的格式
	int h1,m1,s1;
	h1=s/3600;
	m1=(s-3600*h1)/60;
	s1=s-3600*h1-60*m1;
	printf("%02d:%02d:%02d\n",h1,m1,s1);
}
int main(){
	int h1,m1,s1;
	int h2,m2,s2;
	int t1,t2;
	while(scanf("%d:%d:%d",&h1,&m1,&s1)!=EOF,scanf("%d:%d:%d",&h2,&m2,&s2)!=EOF){
		t1=HmsToS(h1,m1,s1);     //输入的第1个时间的秒数
		t2=HmsToS(h2,m2,s2);     //输入的第2个时间的秒数
		PrintTime(t2-t1);
	}
	return 0;
}

1096: 水仙花数（函数专题）

题目描述
春天是鲜花的季节，水仙花就是其中最迷人的代表，数学上有个水仙花数，他是这样定义的：
“水仙花数”是指一个三位数，它的各位数字的立方和等于其本身，比如：153=13+53+33。
现在要求输出所有在m和n范围内的水仙花数。

要求程序定义一个narcissus()函数和一个main()函数，narcissus()函数判断一个整数n是否为水鲜花数，其余功能在main()函数中实现。

int narcissus(int n)
{
//判断n是否为水仙花数，若是函数返回1，否则返回0
}
对于C/C++代码的提交，本题要求必须通过定义narcissus函数和main函数实现，否则，提交编译错误，要提交完整的程序。
输入
输入数据有多组，每组占一行，包括两个整数m和n（100<=m<=n<=999）。
输出
对于每个测试实例，要求输出所有在给定范围内的水仙花数，就是说，输出的水仙花数必须大于等于m,并且小于等于n，如果有多个，则要求从小到大排列在一行内输出，之间用一个空格隔开;
如果给定的范围内不存在水仙花数，则输出no;
每个测试实例的输出占一行。
样例输入
100 120
300 380
样例输出
no
370 371
提示
在不知道m到n之间有多少个水仙花数的情况下，如何控制两个数之间有空格，而最后一个水仙花数之后没有空格？解决方法之一是：第一个水仙花数之前不加空格，而其后每个水仙花数之前加空格。而通过一个标识变量可以判断出是否是第一个水仙花数。
初做多实例测试，要注意变量赋初值的位置。

#include<stdio.h>
int narcissus(int n){    //判断是否是水仙花数
	int a,b,c;      //a:百位 b:十位 c:个位
	c=n%10;
	b=n/10%10;
	a=n/100;
	if(a*a*a+b*b*b+c*c*c==n)
		return 1;
	else 
		return 0; 
}

int main(){
	int m,n;
	while(scanf("%d%d",&m,&n)!=EOF){
		int flag=0;     //每次输入一组m,n，都要把flag置为0
		for(int i=m;i<=n;i++){
			if(narcissus(i)==1){
				if(flag==0){      //第一个水仙花数之前不加空格
					printf("%d",i);
					flag=1;
				}
				else       //第二个及以后的水仙花数，要在数之前加空格
					printf(" %d",i);
			}
		}
		if(flag==0)
			printf("no");
		printf("\n");       //每次执行完一次，要换行。注意格式问题
	}
	return 0;
}

1097: 计算平均成绩（函数专题）

题目描述
输入某位同学各门课的成绩，输出平均成绩。输入的成绩均为五级制成绩，五级制成绩转换为百分之成绩的规则如下：'A’转换为百分之成绩为95分，'B’对应85分，C对应75分，'D’对应65分，'E’对应40分。输出的平均成绩为一个实数，保留1位小数。

要求程序定义一个getScore()函数和一个main()函数，getScore()函数返回一个等级对应的分数，其余功能在main()函数中实现。
int getScore(char g)
{
//把等级g转换成对应的分数并返回这个分数。
}

对于C/C++代码的提交，本题要求必须通过定义getScore函数和main函数实现，否则，提交编译错误，要提交完整的程序。
输入
输入为一行只包含’A’~'E’的字母，每个字母表示一门课的成绩，
输出
输出平均成绩，为一个实数，保留一位小数。
样例输入
AABB
样例输出
90.0

#include<stdio.h>
int getScore(char g){
	int grade;
	switch(g){
		case 'A': grade=95; break;
		case 'B': grade=85; break;
		case 'C': grade=75; break;
		case 'D': grade=65; break;
		case 'E': grade=40; break;
	}
	return grade;
}
int main(){
	char ch;
	int n=0;
	double sum=0;
	while(scanf("%c",&ch),ch!='\n'){
		sum=sum+getScore(ch);
		n++;
	}
	printf("%.1f",sum/n);
	return 0;
}

1098: 复合函数求值（函数专题）

题目描述
求复合函数F(G(x))，其中函数F(x)=|x-3|+|x+1|，函数G(x)=x^2-3x。要求编写函数funF()和funG()分别求F(x)和G(x)，其余功能在main()中实现。
double funF(double x)
{
//函数返回F(x)的值；
}
double funG(double x)
{
//函数返回G(x)的值；
}
本题如果是C/C++代码提交，只需要提交funF和funG函数的定义部分，提交其它内容，编译出错。
输入
输入一个实数x。
输出
输出复合函数的值，结果保留2位小数。输出占一行。
样例输入
10.2
样例输出
144.88

double funF(double x){
	return fabs(x-3)+fabs(x+1);
}
double funG(double x){
	return x*x-3*x;
}

1099: 角谷猜想（多实例测试）

题目描述
任何一个自然数，如果是偶数，就除以2，如果是奇数，就乘以3再加1。最后，经过若干次迭代得到1。也就是说，不管怎样迭代，不断除以2以后，最后是1。现在给你一个自然数n，求出它转变为1所需要的步数。
输入
输入数据有多组，每组输入包含一个自然数n。测试数据保证输入数据及中间结果都在int范围内。
输出
对每组输入，输出经过角谷猜想变成1的步数。
样例输入
5
11
样例输出
5
14

#include<stdio.h>
int main(){
	int n,step;
	while(scanf("%d",&n)!=EOF){
		step=0;
		while(n!=1){
			if(n%2==0){  //n是偶数 
				n=n/2;
				step++; 
			}
			else{        //n是奇数 
				n=n*3+1;
				step++;
			}
		}
		printf("%d\n",step);
	}
	return 0;
}

1100: 求组合数（函数专题）

题目描述
马上要举办新生程序设计竞赛了，与以往不同的是，本次比赛以班为单位，为了全面衡量一个班级的整体水平，要求从一个班的m位同学中任选k位同学代表本班参加比赛，问有多少种组合方案。在计算组合方案时会用到计算阶乘的运算，要求编写函数fact()，实现求一个数的阶乘功能，函数原型如下。
int fact(int n)；//计算n的阶乘并返回

对于C/C++代码的提交，本题要求必须通过定义fact函数和main函数实现，否则，提交编译错误，要提交完整的程序。
输入
输入两个正整数m,k，k<=m<=12。
输出
输出一个整数，即组合方案数。
样例输入
5 3
样例输出
10
提示
求组合数公式是 m!/(k!(m-k)!)

#include<stdio.h>
int fact(int n){    //求阶乘
	int i,jc=1;
	for(i=1;i<=n;i++){
		jc=jc*i;
	}
	return jc;
}
int main(){
	int m,k;
	scanf("%d%d",&m,&k);
	printf("%d",fact(m)/(fact(k)*fact(m-k)));
	return 0;
}

1101: 逆序数字（函数专题）

题目描述
输入一个正整数n，计算n的逆序数m，输出m与n的和。要求程序定义一个inverse()函数和一个main()函数，inverse()函数接收一个整数值,返回这个数中数字逆序后的结果值。例如,给定数7631,函数返回1367 。
int inverse(int n)
{
//计算并返回n的逆序数字
}
本题如果是C/C++代码提交，只需要提交inverse函数的定义部分，提交其它内容，编译出错。
输入
一个正整数n，输入保证计算结果在int范围内。
输出
输出一个整数，n与n的逆序数的和。输出占一行。
样例输入
1780
样例输出
2651
我写的代码如下：

int inverse(int n){     
	int p=1;      //p以10的倍数变化，1,10,100，...
	int t=n;      //保存n 
	int a,b=0;    //a保存n的最后一位，b是放逆置后的数
	while(n>9){   //求位数 
		n=n/10;
		p=p*10;
	}
	while(t/10!=0){
		a=t%10;   //得到t的最后一位 
		b=b+a*p;
		t=t/10;
		p=p/10;
	}
	if(t/10==0)  //t现在只有个位
		b=b+t;
	return b;
}

参考网上更简单的代码：

#include <stdio.h>
int inverse(int n)
{
    int N = 0;
    while(n>0)
    {
        N = N*10 + n%10;
        n=n/10;
    }
    return N;
}
int main(){
	int n1,n2;
	scanf("%d",&n1);
	n2=inverse(n1);
	printf("%d",n1+n2);
	return 0;
}

1102: 火车票退票费计算（函数专题）

题目描述
2013年起，火车票退票费比例下调：票面乘车站开车时间前48小时以上的按票价5%计退票费。同时，车票退票费的计算方法不再四舍五入到元为单位，而是以5角为单位：尾数小于0.25元的舍去、不小于0.25元且小于0.75元的计为0.5元、不小于0.75元的进为1元。编写一个函数，计算退票费，假定退票时间距离开车时间在48小时以上。函数原型如下：

double CancelFee(double price);

本题如果是C/C++代码提交，只需要提交CancelFee函数的定义部分，提交其它内容，编译出错。
输入
输入一个实数，表示火车票票面价格。
输出
输出一个实数，表示退票费，结果保留一位小数。
样例输入
106
样例输出
5.5

double CancelFee(double price){
	price=price*0.05;
	if((int)price+0.25>price)
		price=(int)price;
	else if((int)price+0.25<=price&&(int)price+0.75>price)
		price=(int)price+0.5;
	else if((int)price+0.75<=price)
		price=(int)price+1;
	return price;
}

1103: 平均学分绩点（函数专题）

题目描述
平均学分绩点（Grade Point Average，即GPA）是以学分与绩点作为衡量学生学习的量与质的计算单位，以取得一定的学分和平均学分绩点作为毕业和获得学位的标准，实施多样的教育规格和较灵活的教学管理制度。

大学里每一门课程都有一定的学分。只有通过这门课的考试，才能获得相应的学分。课程绩点的计算方法通常是:（百分制成绩-50)/10 取整。成绩100，对应绩点为5，成绩90-99对应绩点为4，…，成绩60-69对应绩点为1，成绩小于60，对应绩点为0。

平均学分绩点的计算方法是：是将学生修过的每一门课程的绩点乘以该门课程的学分，累加后再除以总学分。平均学分绩点可以作为学生学习能力与质量的综合评价指标之一。请编程计算一个学生的平均学分绩点。
输入
输入n表示有n门课程，然后输入n门课程的学分和成绩，学分和成绩都是整数。
输出
输出平均学分绩点，保留一位小数。
样例输入
3
2 95
3 85
5 75
样例输出
2.7

#include<stdio.h>
int JiDian(int g){
	int xf; 
	if(g>=60)
		xf=(g-50)/10;
	//如果不写else，那么g<60时，上述公式所得结果为负数。
	//故而分大于60和小于60两种情况 
	else      
		xf=0;
	return xf;
}
int main(){
	int n;
	int m,g,total=0,t=0;  // m:学分 g:分数 total:学分 t:总学分 
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d%d",&m,&g);
		total=total+m*JiDian(g);
		t=t+m; 
	}
	double avg=1.0*total/t;
	printf("%.1f",avg);
	return 0;
}

1104: 求因子和（函数专题）

题目描述
输入正整数n（2<=n<=1000），计算并输出n的所有正因子(包括1，不包括自身)之和。要求程序定义一个FacSum ()函数和一个main()函数，FacSum ()函数计算并返回n的所有正因子之和，其余功能在main()函数中实现。
int FacSum(int n)
{
//计算n的所有正因子(包括1，不包括自身)之和sum，本函数返回sum
}
输入
输入正整数n（2<=n<=1000）。
输出
输出n的所有正因子(不包括自身)之和。
样例输入
1000
样例输出
1340

#include<stdio.h>
int FacSum(int n){
	int sum=1;
	for(int i=2;i<n;i++){   //写成 i<=n/2 也对
		if(n%i==0){
			sum=sum+i;
		}
	}
	return sum;
} 
int main(){
	int n;
	scanf("%d",&n);
	printf("%d",FacSum(n));
	return 0;
}

举例：10的因子：1，2，5
16的因子：1，2，4，8

1105: 判断友好数对（函数专题）

题目描述
输入两个正整数m和n，顺序输出m到n之间的所有友好数对。

如果两个整数的所有正因子之和（包括1，不包括自身）等于对方，就称这对数是友好的。例如：1184和1210是友好数对，因为
1184的因子之和为1+2+4+8+16+32+37+74+148+296+592=1210
1210的因子之和为1+2+5+10+11+22+55+110+121+242+605=1184
要求程序中要定义一个facsum ()函数计算并返回n的所有正因子之和。
int facsum (int n)
{
//计算n的所有正因子之和sum，本函数返回sum
}
对于C/C++代码的提交，要求必须通过定义facsum函数来求一个整数n的正因子之和，否则，提交编译错误，本题需要提交完整的程序代码。
输入
输入两个正整数m和n，1<m<=n<=10000。
输出
输出m和n之间的所有友好数对。
在输出每个友好数对时，要求小数在前、大数在后，并去掉重复的数对。例如，220和284是一对友好数，而284和220也是一对友好数，此时只需输出220和284这对友好数。每个友好数对占一行，两数之间用空格隔开。

如果m和n之间没有友好数对，则输出“No answer”。
样例输入
100 8000
样例输出
220 284
1184 1210
2620 2924
5020 5564
6232 6368

超时代码：

#include<stdio.h>
int facsum(int n){
	int sum=1;
	for(int i=2;i<=n/2;i++){
		if(n%i==0){
			sum=sum+i;
		}
	}
	return sum;
} 
int main(){
	int n,m,flag=0;
	scanf("%d%d",&m,&n);
	for(int i=m;i<=n;i++){
		for(int j=i;j<=n;j++){
			if(facsum(i)==j && facsum(j)==i){
				flag=1;
				printf("%d %d\n",i,j);
			}
		}
	}
	if(flag==0)
		printf("No answer");
	return 0;
}

AC代码：

#include<stdio.h>
int facsum(int n){
	int sum=1;
	for(int i=2;i<=n/2;i++){
		if(n%i==0){
			sum=sum+i;
		}
	}
	return sum;
} 
int main(){
	int n,m,flag=0;
	scanf("%d%d",&m,&n);
	for(int i=m;i<=n;i++){
		if(facsum(i)<=n && facsum(i)>i && facsum(facsum(i))==i){
			flag=1;
			printf("%d %d\n",i,facsum(i));
		}
	}
	if(flag==0)
		printf("No answer");
	return 0;
}

1106: 回文数（函数专题）

题目描述
一个正整数，如果从左向右读（称之为正序数）和从右向左读（称之为倒序数）是一样的，这样的数就叫回文数。输入两个整数m和n（m<n)，输出区间[m，n]之间的回文数。
输入
输入两个正整数m和n，输入保证m<n。
输出
按从小到大的顺序，输出m到n之间的回文数，每个数后面有一个空格。
样例输入
100 200
样例输出
101 111 121 131 141 151 161 171 181 191

#include<stdio.h>
int judge(int n){      //与1101求逆序相同 
	int m=0;
	int t=n;
	while(n>0){
		m=m*10+n%10;
		n=n/10;	
	}
	if(t==m)
		return 1;
	else
		return 0;
}
int main(){
	int m,n;
	scanf("%d%d",&m,&n);
	for(int i=m;i<=n;i++){
		if(judge(i)==1)
			printf("%d ",i);
	} 
	return 0;
}

1107: 回文数猜想（函数专题）

题目描述

一个正整数，如果从左向右读（称之为正序数）和从右向左读（称之为倒序数）是一样的，这样的数就叫回文数。任取一个正整数，如果不是回文数，将该数与他的倒序数相加，若其和不是回文数，则重复上述步骤，一直到获得回文数为止。例如：68变成154（68+86），再变成605（154+451），最后变成1111（605+506），而1111是回文数。于是有数学家提出一个猜想：不论开始是什么正整数，在经过有限次正序数和倒序数相加的步骤后，都会得到一个回文数。至今为止还不知道这个猜想是对还是错。现在请你编程序验证之。你已经会写求一个整数的逆序数的函数inverse()，那么如下循环可以模拟回文数猜想的验证过程：
while( m = inverse(n), m != n)
{
输出n;
把n更新为 m + n;
}

输入
输入一个正整数。特别说明：输入的数据保证中间结果小于2^31。
输出
输出占一行，变换的过程中得到的数值，两个数之间用空格隔开。
样例输入
27228
样例输出
27228 109500 115401 219912
提示
程序中要定义函数 int inverse(int n)

#include<stdio.h>
int inverse(int n){   //与1101求逆序相同 
	int m=0;
	while(n>0){
		m=m*10+n%10;
		n=n/10;	
	}
	return m;
}
int main(){
	int m,n;
	scanf("%d",&n);
	while(n!=inverse(n)){  // n不是回文数 
		printf("%d ",n);
		m=n+inverse(n);
		n=m;
	}
	printf("%d",n);       // n是回文数 
	return 0;
}

1108: 打印数字图形（函数专题）

题目描述
从键盘输入一个整数n(1≤n≤9),打印出指定的数字图形。要求在程序中定义并调用如下函数：PrintSpace(m)用来输出m个空格；PrintDigit(m)来输出一行中的数字串"12…m…21"（该行中的最大数字是m）。函数原型如下：

void PrintDigit(int m);

void PrintSpace(int m);

对于C/C++代码的提交，本题要求必须通过定义PrintSpace函数、PrintDigit函数和main函数实现，否则，返回编译错误。
输入
正整数n（1≤n≤9）。
输出
指定数字图形。
样例输入
5
样例输出
在这里插入图片描述

#include<stdio.h>
 void PrintDigit(int m){
 	for(int i=1;i<=m;i++)
 		printf("%d",i);
 	for(int i=m-1;i>=1;i--)
 		printf("%d",i);
 	printf("\n");
 }
 void PrintSpace(int m){
 	for(int i=0;i<m;i++)
 		printf(" ");
 }
int main(){
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){    //上半部分 
		PrintSpace(n-i);
		PrintDigit(i);
	}
	for(int i=1;i<=n;i++){    //下半部分 
		PrintSpace(i);
		PrintDigit(n-i);
	}
	return 0;
}

1109: 数根（函数专题）

题目描述
输入一个正整数，输出该数的数根。数根可以通过把一个数的各个位上的数字加起来得到。如果得到的数是一位数，那么这个数就是数根。如果结果是两位数或者包括更多位的数字，那么再把这些数字加起来。如此进行下去，直到得到是一位数为止。比如，对于24来说，把2和4相加得到6，由于6是一位数，因此6是24的数根。再比如39，把3和9加起来得到12，由于12不是一位数，因此还得把1和2加起来，最后得到3，这是一个一位数，因此3是39的数根。
要求使用函数，定义函数digitSum(int n)求n的各位数字和，其余功能在main()函数中实现。
int digitSum(int n)
{
//函数返回n的各位数字之和
}

对于C/C++代码的提交，本题要求必须通过定义digitSum函数和main函数实现，否则，提交编译错误，本题需要提交完整程序代码。
输入
输入一个int范围内的正整数n
输出
输出n的数根
样例输入
39
样例输出
3

#include<stdio.h>
int digitSum(int n){
	int sum=0;
	while(n>0){
		sum=sum+n%10;
		n=n/10;
	} 
	return sum;
}
int main(){
	int n;
	scanf("%d",&n);
	int m=digitSum(n);
	while(m>10){
		m=digitSum(m);
	}
	printf("%d",m);
	return 0;
}

1110: 最近共同祖先（函数专题）

题目描述
在这里插入图片描述
如上图所示，由正整数1, 2, 3, …组成了一棵无限大的二叉树。从某一个结点到根结点（编号是1 的结点）都有一条唯一的路径，比如从10 到根结点的路径是(10, 5, 2, 1)，
从4 到根结点的路径是(4, 2, 1)，从该结点到根结点的路径上的所有结点称为该结点的祖先。现在的问题就是，给定x 和y，求x和y的最近共同祖先，比如，10和4最近共同祖先是2，10和5的最近共同祖先是5。
定义递归函数
int common(int x, int y)
{
如果x==y, return x;
如果x>y，求x/2与y的共同祖先;
否则，求x与y/2的共同祖先;
}
输入
输入只有一行，包括两个正整数x 和y，这两个正整数都不大于1000。
输出
输出只有一个正整数，即x和y的最近共同祖先。
样例输入
10 4
样例输出
2

#include<stdio.h>
int common(int x,int y){
	if(x==y)
		return x;
	else if(x>y)
		common(x/2,y);
	else
		common(x,y/2);
}
int main(){
	int x,y;
	scanf("%d%d",&x,&y);
	printf("%d",common(x,y));
	return 0;
}

1111: 多个整数的逆序输出（函数专题）

题目描述
输入n和n个整数，以与输入顺序相反的顺序输出这n个整数。要求不使用数组，而使用递归函数实现。
递归函数实现过程如下：
void inverse(int n)
{

读入一个整数，存入num;

if(n >1)
{
将后面的n-1个数逆序输出: inverse(n-1);
输出num；
}
if( n == 1) 直接输出num；
}
输入
输入有两行，第一行是一个正整数n，第二行有n个整数，整数之间由空格隔开。
输出
输出n个整数，顺序与输入顺序相反，每个整数后有一个空格。
样例输入
5
11 22 33 44 55
样例输出
55 44 33 22 11

#include<stdio.h>
void inverse(int n){
	int a;
	if(n>1){
		scanf("%d",&a);    //先把第一个数字“存起来”
		inverse(n-1);
		printf("%d ",a);  //把第一个数字最后一个输出
	}
	if(n==1){    //当只有一个数字的时候，直接输出
		scanf("%d",&a);
		printf("%d ",a);
	}
}
int main(){
	int n;
	scanf("%d\n",&n);
	inverse(n);
	return 0;
}

1112: 进制转换（函数专题）

题目描述

输入一个十进制整数n，输出对应的二进制整数。常用的转换方法为“除2取余，倒序排列”。将一个十进制数除以2，得到余数和商，将得到的商再除以2，依次类推，直到商等于0为止，倒取除得的余数，即为所求的二进制数。例如，把52换算成二进制数的计算过程如下图：
在这里插入图片描述

52除以2得到的余数依次为0,0,1,0,1,1，倒序排列，得到52对应的二进制数110100。

用递归的思想来描述上述计算过程是这样的：输出n/2对应的二进制数，然后输入%2。递归函数的实现过程如下：

void convert(int n)
{
if(n > 0)
{
调用自身，输出n/2对应的二进制数;
输出n%2;
}
}
输入
输入一个正整数n。
输出
输出n对应的二进制数。
样例输入
52
样例输出
110100

#include<stdio.h>
void convert(int n){
	if(n>0){
		convert(n/2);
		printf("%d",n%2);
	}
}
int main(){
	int n;
	scanf("%d",&n);
	convert(n);
	return 0;
}

1113: 递归调用的次数统计（函数专题）

题目描述
如下程序的功能是计算 Fibonacci数列的第n项。函数fib()是一个递归函数。请你改写该程序，计算第n项的同时，统计调用了多少次函数fib（包括main()对fib()的调用）。
#include<stdio.h>
int fib(int k);
int main()
{
int n;
scanf(“%d”, &n);
printf(“%d\n”, fib(n));
return 0;
}

int fib(int k)
{
if(k == 1 || k == 2)
return 1;
else
return fib(k-1) + fib(k-2);
}
输入
输入一个正整数n。
输出
输出包含两行，第一行是一个整数，表示第n项的值；第二行输出递归调用了多少次，具体格式见输出样例。
样例输入
20
样例输出
6765
递归调用了13529次

#include<stdio.h>
int m=0;      //定义一个全局变量 
int fib(int k){
	m++;
	if(k==1 || k==2)
		return 1;
	else
		return fib(k-1)+fib(k-2);
}
int main(){
	int n;
	scanf("%d",&n);
	printf("%d\n",fib(n)); 
	printf("递归调用了%d次",m);
	return 0;
}

ran迩

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
[ZZULI]1092~1113（函数专题）

关于main()中 int i=3，而不是 i=2，理由如下：M是偶数，如果素数对第一个数是2，那么第二个数应该是M-2，还是偶数，偶数不可能是素数。要求程序定义一个prime()函数和一个main()函数，prime()函数判断一个整数n是否是素数，其余功能在main()函数中实现。main()里，如果m=1，不设置 i>=2 的话，会导致输出 1 ，而 1 不是素数，故需要设置条件 i>=2。输出和等于该偶数的所有素数对a和b，按a递增的顺序输出，(a,b)和(b,a)被视为同一个素数对。
复制链接

扫一扫