C语言题-红皮书

已掌握1.将一个正整数分解质因数，例如：输入90，打印出“90=2 * 3* 3 *5”。
算法思路：
A.从2开始的质因数去除该正整数n,能整除就输出该质因数，直到不能整除。
B.换下一个质数去除，重复上述操作，最后输出剩下的最后一个质因数。

void main()
{
	int n;
	scanf("%d",&n);
	printf("%d=",n);
	int flag=0;
	for(int i=2;i<=n;i++)
	{
		if(n%i==0&&zs(i)==1)
		{
			while(n%i==0)
			{
				if(flag==0)
				{
					printf("%d",i);
					flag=1;
				}
				else
					printf("*%d",i);
				n=n/i;
			}
		}
	}
}

3.编写函数，判断两个整数是否互质，其中使用辗转相除法求两个正整数M,N的最大公约数。
思路：
A.利用辗转相除法求出最大公约数
B.如果最大公约数为1，则互质。

bool gcd(int m,int n)
{
	int temp;
	while(n!=0)
	{
		temp=m%n;
		m=n;
		n=temp; //利用辗转相除法，求的最大公约数存放在m中
	}
	if(m==1)return true; //如果最大公约数为1，则互质
	else return false;
}

4.给出年月日，计算该日是该年的第几天。

#include<stdio.h>
int Is_LeapYear(int y)  //闰年：1. 能被4整除但是不能被100整除 2. 能被400整除。
{
	if((y%4==0&&y%100!=0)||y%400==0)
		return 1;
	else
		return 0;
}
void main()
{
	int monthes[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
	int year,month,day;
	int i,days=0;
	scanf("%d%d%d",&year,&month,&day);
	if(Is_LeapYear(year)==1)//闰年的2月有29天
	{
		monthes[2]=29;
	}
	for(i=1;i<month;i++)
	{
		days+=monthes[i];
	}
	days+=day;
	printf("%d",days);

}

5.求1+2！+3！+…+20！的和。

#include<stdio.h>
long long n(int i)
{
	if(i==1)
		return 1;
	else
		return n(i-1)*i;
}
void main()
{
	long long sum=0;//要用long long 类型来存储结果，用int会溢出
	int i;
	for(i=1;i<=20;i++)
		sum=sum+n(i);
	printf("%lld\n",sum);
}

重点题/难题 6.编写一个程序，对输入的任意正整数n，打印出集合{0，1，…,n-1}的所有子集。例如：输入3时，输出是：{}，{0}，{1}，{0，1}，{2}，{0，2}，{1，2}，{0，1，2}。

#include<stdio.h>
int main()
{
    int n;
    scanf("%d",&n);
    for(int i = 0; i < (1<<n); i++) //从0～2^n-1个状态,共2^n个集合，（1<<n）等于1*(2^n)
    {
		printf("{");
		int flag=0;
        for(int j = 0; j < n; j++) //遍历二进制的每一位
        {
            if(i & (1 << j))//判断二进制第j位是否存在    按位与&运算，同1才为1,1<<j等于1的二进制左移j位
            {
				if(flag==1)//每个集合的第一个元素不用打逗号
				  printf(",");
                printf("%d",j);//如果存在输出第j个元素
				flag=1;
				
            }
			
        }
		printf("}\n");
    }
    return 0;
}
//相关知识参考文章：https://blog.csdn.net/sugarbliss/article/details/81099340

7.十进制转换为二进制输出
思路：用十进制不断除2求余数，将余数存入数组，直到十进制数除到0为止。最后把得到的余数作为二进制，将数组从高位到低位输出。

#include<stdio.h>
void main()
{
	int n;
	scanf("%d",&n);
	int a[32],i=0;
	while(n>0)
	{
		a[i++]=n%2;
		n=n/2;
	}
	i--;
	while(i>=0)
	{
		printf("%d",a[i]);
		i--;
	}

}

8.设计一个函数，将整数数组a[n]划分为左右两部分，使左边所有元素值为奇数，右边所有元素值为偶数。
思路：i和j分别从首尾从前往后，从后往前遍历从左边找到第一个偶数，从右边找到第一个奇数，并进行交换。只要i<j就重复之前的操作。

#include<stdio.h>
void divide(int a[],int n)//n为数组长度
{
	int i=0,j=n-1,temp;
	while(i<j)
	{
		while(i<j&&a[i]%2!=0)//从左找到第一个偶数
			i++;
		while(i<j&&a[j]%2!=1)//从右找到第一个奇数
			j--;
		if(i<j)//交换两个数
		{
			temp=a[i];
			a[i]=a[j];
			a[j]=temp;
		}
	}
}

9.设给定一个m行n列整形矩阵A，编写一个函数swap，使得他对A的元素进行交换，具体如下：第一个元素和倒数第一个元素交换，第二个元素和倒数第二个元素交换。

#include<stdio.h>
#define m 3
#define n 4
void swap(int a[m][n])
{
	int i,j,temp;
	int count=0;
	for(i=0;i<m;i++)
		for(j=0;j<n;j++)
		{
			if(count==(m*n)/2)//因为是前后互换，所以只用交换到中间的一半就行了
				return;
			temp=a[i][j];
			a[i][j]=a[m-1-i][n-1-j];
			a[m-1-i][n-1-j]=temp;
			count++;
		}
}

10.设给定数组A[m]和B[n]是有序递增的，将A和B合并为一个有序递增的数组C
思路：只要A和B数组未遍历完，比较当前A[i]和B[j]中较小的元素存入C中，同时数组C下标加1.若A数组遍历完，则将B数组剩余元素接入C,反之亦然。

#include<stdio.h>
int m=5,n=5;
void fun(int a[],int b[],int c[])
{
	int i=0,j=0,k=0;
	while((i<m)&&(j<n)) //只要a和b的数组未遍历完
	{
		if(a[i]<b[j])
		{
			c[k]=a[i];
			i++;
		}
		else
		{
			c[k]=b[j];
			j++;
		}
		k++;
	}
	if(i==m)//若a数组遍历完
	{
		for(int d=j;d<n;d++)//将剩下的数组b接入c
		{
			c[k]=b[d];
			k++;
		}
	}
	if(j==n)//若b数组遍历完
	{
		for(int d=i;d<m;d++)//将数组b接入c
		{
			c[k]=a[d];
			k++;
		}
	}
}

11.编写一个函数，从给定的数组A中删除元素值在X到Y之间的所有元素，但要保证数组的连续性。
思路：1.循环遍历数组，判断元素是否在x,y之间。
2.用k来统计当前已删除的元素个数，遍历时遇到非删除元素的就前移k个位置。

int del(int A[],int n,int x,int y)
{
	int i=0,k=0;
	while(i<n)
	{
		if((A[i]>=x)&&(A[i]<=y))//元素值在x到y之间
			k++;   //统计删除元素个数
		else
			A[i-k]=A[i];  //后面的元素往前移动
		i++;
	}
	return n-k;  //返回删除之后的元素个数
}

12.编写函数把整数数组中值相同的元素删除得只剩一个，并把剩余元素全部移到前面。
思路：第一层：循环遍历数组元素，第二层遍历判断元素是否等于a[i]
用k来统计删除的元素个数，遍历时遇到非删除元素就前移

#include<stdio.h>
int Delete(int a[],int n)
{
	int i=0,j;
	int k=0;
	while(i<n)
	{
		
	for(j=i+1;j<n;j++){
	   if(a[j]==a[i])  //找与a[i]相同的值
	   {
		   k++;
	   }
	   else
		   a[j-k]=a[j];   //不相同的往前移
	   
	}
		n=n-k;  //如果每一轮有重复k个元素，将数组长度减少k
		i++;
		k=0;
	}
	return n;
}

13.使用数组精确计算M/N（0<M<N<=100）的各小数位的值。如果M/N是无限循环小数，则计算并输出它的第一循环节，同时要求输出循环节的起止位置（小数的序号）。
思路：求各小数位的值就是用余数乘10整除的结果，然后得到的新的余数，一直重复算到余数为0或出现循环。如果分子小于分母，那分子一来就相当于是余数。

#include<stdio.h>
void main()
{
	int a[100];//a存小数，b存余数
	int m,n,i=0,s=0;
	printf("请输入分子分母：");
	scanf("%d%d",&m,&n);//输入分子m，分母n
	if(m>n)  //如果分子大于分母
	{
		s=m/n;//得到整数部分
		m=m%n;  //得到余数为分子
		
	}
	while(m!=0)
	{
		m=m*10;
		a[i]=m/n; //a[i]存放的是余数再整除得到的整数部分
		m=m%n; //更新余数
		for(int h=0;h<i;h++)
		{
			if(a[h]==a[i])//有重复值时开始循环
			{
				printf("从小数点%d位开始循环，到%d位结束\n",h+1,i);
				m=0;
				i--;
				break;
			}
		}
		i++;
	}
	printf("%d.",s);//输出整数部分
	for(int j=0;j<i;j++)
	{
		printf("%d",a[j]);
	}
	printf("\n");
}

14.螺旋矩阵是整数的一种排列方式，例如5*5的螺旋矩阵如下：

               1      2     3     4     5

               16     17   18     19    6

               15     24    25    20    7

               14     23   22    21     8

               13     12    11   10     9   

编写程序生成并输出10*10的螺旋矩阵。

#include<stdio.h>
#define N 10
void main()
{
	int a[10][10];
	int k,n,i,j,num=1;
	for(n=0;n<=N/2;n++)
	{
		for(j=n;j<=N-n-1;j++) //上半部分的行，从左向右
			a[n][j]=num++;
		for(i=n+1;i<N-n-1;i++) //右侧列，从上至下
			a[i][N-n-1]=num++;
		for(j=N-n-1;j>n;j--)//下半部分的行，从右至左
			a[N-n-1][j]=num++;
		for(i=N-n-1;i>n;i--)//左侧列，从下至上
			a[i][n]=num++;
	}
	for(i=0;i<N;i++)
	{
		for(j=0;j<N;j++)
			printf("%d\t",a[i][j]);
		printf("\n");
	}
}

15.设A为55的二维数组，编一函数，求A中出现频度最高的数。例如，55的矩阵如下：
3 2 4 5 1
10 9 3 4 2
8 7 6 7 7
3 3 4 1 2
4 5 3 1 1
出现频度最高的为3.
思路：用一维数组b来统计二维数组中各个数字出现的频度。
遍历二维数组，若a[i][j]出现，则以a[i][j]为下标的b数组值+1

#include<stdio.h>
int fun(int a[5][5])
{
	int b[11]={0};
	int i=0,j=0,k=0,count=0,max;
	for(i=0;i<5;i++)
		for(j=0;j<5;j++)
		{
			b[a[i][j]]++;
			count++;
		}
	max=0;
	for(k=0;k<count;k++)
		if(b[k]>b[max])
			max=k;
	return max;
}

16.用二分法求方程：2x^3- 4x^2+3x-6=0,位于（-10，10）之间的一个根。
思路：根据零点定理判断f(a)*f(b)<0,则f(X)在(a,b)上至少有一个零点。

#include<stdio.h>
#include<math.h>
double f(double x)
{
	return 2*x*x*x-4*x*x+3*x-6;
}
void main()
{
	double a=-10,b=10;
	double mid,y;
	if(f(a)*f(b)<0)
	{
		while(a<=b)
		{
			mid=(a+b)/2;
			y=f(mid);
			if(y==0)
				break;
			else if(f(mid)*f(a)<0)//左移
				b=mid;
			else if(f(mid)*f(b)<0)//右移
				a=mid;
		}
	}
	
	printf("x=%.2lf\n",mid);
}

17.写一个函数，用牛顿迭代法求方程：2x³-4x²+3x-6=0在x=1.5附近的根。
思路：迭代公式x2=x1-f(x1)/f^/(x1)
利用循环，只要x1,x2之差大于1e-8则不断进行x1=x2,x2=x1-f(x1)/f^/(x1)
最后x2即为所求根值

#include<stdio.h>
#include<math.h>
float fun(float x)  //x点函数值
{
	return 2*x*x*x-4*x*x+3*x-6;
}
float fun1(float x)//求x点的导数值
{
	return 6*x*x-8*x+3;
}
float Newton()
{
	float x1=1.5,x2=x1-fun(x1)/fun1(x1);
	while(fabs(x1-x2)>1e-8)
	{
		x1=x2;
		x2=x1-fun(x1)/fun1(x1);
	}
	return x2;
}

18.编写程序，输入A,B,C,D四个点的坐标，假设ABC三点可以构成一个三角形，判断D点是否落在三角形内。
思路：若D点落在三角形内，则S(ADB)+S(ADC)+S(BDC)=S(ABC).
若不等，则没有落在三角形内。

#include<stdio.h>
#include<math.h>
typedef struct Point
{
	double x,y;
}Point;
double dis(Point a,Point b)
{
	double d;
	d=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
	return d;
}
double area(Point a,Point b,Point c)
{
	double p,s;
    double A,B,C;
	A=dis(a,b);
	B=dis(a,c);
	C=dis(b,c);
	p=(A+B+C)/2;
	s=sqrt(p*(p-A)*(p-B)*(p-C));//海伦公式
	return s;
}
void Judge(Point A,Point B,Point C,Point D)
{
	double s1,s2,s3,s;
	s=area(A,B,C);
	s1=area(A,B,D);
	s2=area(A,C,D);
	s3=area(B,D,C);
	if(fabs(s-(s1+s2+s3))<1e-8)  //等价于(s=s1+s2+s3),因为有开根号，所以可能不会完全相等，取一定误差范围的值就行。
	{
		printf("D点落在三角形内\n");
	}
	else
		printf("D点没有落在三角形内\n");
	return;
}
void main()
{
	Point A,B,C,D;
	A.x=1,A.y=1;
	B.x=0,B.y=0;
	C.x=2,C.y=0;
	D.x=1,D.y=0.5;
	Judge(A,B,C,D);
}

19.编写一个递归函数，计算组成给定正整数n的所有数字之和。

int f(int n)
{
	if(n<10)//只有个位数时为递归出口
		return n;
	return n%10+f(n/10);//个位数加上递归调用
}

20.编写一个递归函数，求两个数X和Y的最大公约数。

int gcd(int x,int y)
{
	if(y==0)
		return x;
	return gcd(y,x%y);
}

21.N(1<=N<90)阶楼梯上楼问题：一次可以走两阶或一阶，问有多少种上楼方式（要求采用非递归）

#include<stdio.h>
void main()
{
	long long F[91];
	F[1]=1;
	F[2]=2;
	int i;
	for(i=3;i<=90;i++)
		F[i]=F[i-1]+F[i-2];
	int n;
	scanf("%d",&n);
	printf("%lld\n",F[n]);
}

22.求解两字符串的最长公共子串长度。
思路：

#include<stdio.h>
#include<string.h>
int dp[101][101];
#include<stdio.h>
int max(int a,int b)
{
	return a>b?a:b;
}
void main()
{
	    char s1[101],s2[101];
	    scanf("%s%s",s1,s2);
		int l1=strlen(s1);
		int l2=strlen(s2);
		for(int i=0;i<=l1;i++)
			dp[i][0]=0;
		for(int j=0;j<=l2;j++)
			dp[0][j]=0;
		int max=0;
		for(int i=1;i<=l1;i++)
		  for(int j=1;j<=l2;j++)
		  {
		
				if(s1[i-1]==s2[j-1])
					dp[i][j]=dp[i-1][j-1]+1;
				else 
					dp[i][j]=0;
				if(max<dp[i][j])max=dp[i][j];
		   }
		
		printf("%d\n",max);
}

23.最长公共子序列（LCS）给定两个字符串A,B，求一个字符串，使得这个字符串是A和B的最长公共部分（子序列可以不连续）。

思路：

//dp[i][j]表示S1前i个字符的前缀子串和S2前j个字符的前缀子串的最长公共子串长度
//s1[i]=s2[j]时，dp[i][j]=dp[i-1][j-1]+1;
//s1[i]!=s2[j]时，dp[i][j]=max(dp[i-1][j],dp[i][j-1])
#include<stdio.h>
#include<string.h>
int dp[101][101];
#include<stdio.h>
int max(int a,int b)
{
	return a>b?a:b;
}
void main()
{
	    char s1[101],s2[101];
	    scanf("%s%s",s1,s2);
		int l1=strlen(s1);
		int l2=strlen(s2);
		for(int i=0;i<=l1;i++)
			dp[i][0]=0;
		for(int j=0;j<=l2;j++)
			dp[0][j]=0;
		for(int i=1;i<=l1;i++)
			{for(int j=1;j<=l2;j++){
				if(s1[i-1]!=s2[j-1])
					dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
				else
					dp[i][j]=dp[i-1][j-1]+1;
		}
		}
		printf("%d\n",dp[l1][l2]);
}

24.01背包问题：有n件物品，每件物品重量为w[i],价值为c[i]。现有一个容量为V的背包，问如何选取物品放入背包，使得背包内物品的总价值最大。其中每种物品都只有1件。
思路：dp[i][v]表示前i件物品装入容量为v的背包中的最大价值。
对于第i件物品，放：dp[i][v]=dp[i-1][v-w[i]]+c[i];
不放:dp[i][v]=dp[i-1][v];
放的前提是v-w[i]>=0,如果v-w[i]<0，那么只能不放。即当前容量小于该物品重量，放不下。
所以，状态转移方程是：dp[i][v]=max(dp[i-1][v],dp[i-1][v-w[i]]+c[i]),1<=i<=n,0<=v<=V;
边界是dp[0][v]=0.即前0件物品放入任何容量的背包中价值都为0.

#include<stdio.h>
int max(int a,int b)
{
	return a>b?a:b;
}
int w[100],c[100],dp[100][100];
void main()
{
	int n,V;
	scanf("%d%d",&n,&V);//输入n,v
	for(int i=1;i<=n;i++)
		scanf("%d",&w[i]);//每件物品的重量
	for(int i=1;i<=n;i++)
		scanf("%d",&c[i]);//每件物品的价值
	for(int i=0;i<=V;i++) //边界
		dp[0][i]=0;   
	int Max=0;
	for(int i=1;i<=n;i++)
		for(int v=0;v<=V;v++)
		{
			if(v<w[i])//当前背包容量小于物品重量，则无法放入该物品
				dp[i][v]=dp[i-1][v];
			else //能放
			    dp[i][v]=max(dp[i-1][v],dp[i-1][v-w[i]]+c[i]);  //取放或不放的最大值
			if(Max<dp[i][v])Max=dp[i][v];  //记录最大总价值
		}
	printf("%d\n",Max);

	
}

25.给定一个整数数组nums,找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
思路：定义dp[i]表示以nums[i]作为结尾的连续序列的最大和。
dp[i]=max(dp[i-1]+nums[i],nums[i])。每次比较nums[i]单独成为一段和加入dp[i-1]对应的那一段的大小。

#include<stdio.h>
int max(int a,int b)
{
	return a>b?a:b;
}
int nums[100],dp[100];
void main()
{
	int n,i;
	scanf("%d",&n);
	for(i=0;i<n;i++)
		scanf("%d",&nums[i]);
	dp[0]=nums[0];
	int m=nums[0];
	for(i=1;i<n;i++)
	{
		dp[i]=max(dp[i-1]+nums[i],nums[i]);
		if(m<dp[i])
			m=dp[i];
	}
	printf("%d\n",m);
}