算法小合集（一些有趣的数）(一)

例 1：编写程序判断一个数是否为素数

##（素数定义）

#include<stdio.h>
int main()
{
	int number;
	printf("请输入一个数");
	scanf_s("%d", &number);
	int tag=1;
	for (int i = 2;i < number;i++)
	{
		if (number % i == 0)
		{
			tag = 0;
			break;
		}

	}
	if (tag == 0)
	{
		printf("%d不是素数", number);
	}
	else
	{
		printf("%d是素数",number);

	}
}

例2：输出2-300间的素数；

我们已经知道怎么判断素数了，只要在这个基础上，对每一个数判断一次即可
；

#include<stdio.h>
int main()
{
	void IsPrime(int n);
	for(int i=2;i<300;i++)
	{
		IsPrime(i);
	
	}
}
void IsPrime(int n)
{
	int tag = 1;
	for(int i=2;i<n;i++)
	{
		if (n % i == 0)
		{
			tag = 0;
			break;
			return;
		}
	}
	if (tag == 1)
	{
		printf("%d是素数\n", n);
	}
}

例3，求1000以内的回文素数

回文素数：从左读和从右都一样的素数。

分析：只要在素数基础上判断回文了；
那么怎么判断回文呢；
回文：也就是对称；
书上因为是1000以内，所以最多有3位
一位不用判断
两位的话，判断10位和个位是否相等，
三位的话，判断百位和个位是否相等
于是有了以下代码

#include<stdio.h>
int main()
{
	int IsPrime(int n);
	int Judge(int n);
	int judge1;
	int judge2;
	for(int i=2;i<1000;i++)
	{
		judge1=IsPrime(i);
		judge2 = Judge(i);
		if (judge1 == 1&&judge2==1)
		{
			printf("%d是回文素数\n", i);
			
		}
	
	}
	int a = 7;
	printf("%d\n",a / 10 * 10);
	
	
}
int IsPrime(int n)
{
	int tag = 1;
	for(int i=2;i<n;i++)
	{
		if (n % i == 0)
		{
			tag = 0;
			break;
			return tag;
		}
	}
	return tag;
}
int Judge(int n)
{
	if (n < 10)
	{
		return 1;
	}
	if (n < 99)
	{
		if (n / 10 == n-n/10*10)
		{
			return 1;
		}
		return 0;

	}
	if (99 < n < 1000)
	{
		if (n / 100 == n-n/10*10)
		{
			return 1;
		}
		return 0;

	}
}

1000以内回文数上述解法不具有一般性，若n以内的回文数呢
于是我有了以下想法

1. 将一个数的各个位数进行分解。放在数组里；
2. (假设有m位)数组从0开始；
3. 第0位和第m-i位比较，第1位与m-2位比较，第i位于m-i位比较
4. 若m为奇数，则比较m/2次；若m为偶数。则比较m/2次。所以不论m是多少,最多都是比较m/2次；
5. 出现一个不匹配就中断
   然后问题变成了如何求出一个数的各个位数
   假设1234
   ==========================================
   $1234-1234/10\ast 10=4$
   $123-123/10\ast 10=3$
   $12-12/10\ast 10=2$
   $1-1/10\ast 10=1$
   $0-0/10\ast 10=0$
   每次先进行判断，如果余数不为零，余数便是当先情况下的最低位
   然后该数/10；

void divide(int n)
{
	int count=0;
	int a[10];
	for (n;n - n / 10 * 10 != 0;n /= 10)
	{
		count++;
		a[count] = n - n / 10 * 10;
		printf("%d", a[count]);
	}

}

这将一个数给分解了，分解后排序是逆序的，因为不知道怎么返回数组，这里想放一放；过几天学会了，在继续完善；

例4：求孪生素数

孪生素数指的是间隔为二的两个相邻的素数。编程求出3-1000内的所有孪生素数
分析：先判断素数，在判断孪生
孪生的判断：如果n为素数，n+2也为素数的话。即为孪生素数

#include<stdio.h>
int main()
{
	int IsPrime(int n);
	int tag1;
	int tag2;
	for (int i = 3;i < 998;i++)
	{
		tag1 = IsPrime(i);
		tag2 = IsPrime(i + 2);
		if (tag1 == 1 && tag2 == 1)
		{
			printf("%d和%d是孪生素数\n", i, i + 2);
		}
	}

}
int IsPrime(int n)
{
	int tag=1;
	for (int i = 2;i < n;i++)
	{
		if (n % i == 0)
		{
			tag = 0;
			break;
		}
		
	}
	return tag;
}

例5:求2-300范围内完数的个数

如果一个数等于它的因子之和，则称这个数为完数
分析：求因子；
求和判断；

1. 求因子；有点求素数那味道；如果能被整除则是因子；
2. 因子，一求就是两个；所以求一个根号下就可以，后面的因子会被前面除出来；
3. ab=c
4. 
   b=c/a;图像
   我们要求出满足条件的a,b的正整数解；
   那么只要求一半的就好了，a=b为分界线；因为反比例函数具有对称性；
   有一个特别的情况那就是正好能开方。除出来的数一样；要特别考虑；
5. a和b必然一个大一个小，最极限的状态两个相等；大的因子可以被小的除出来

如果a是因子，那么b=c/a也是因子；于是

#include<stdio.h>
#include<math.h>
int main()
{
	void JudgeWanShu(int n);
	int a = 45;
	JudgeWanShu(a);

	for (int i = 2;i <= 300;i++)
	{
		JudgeWanShu(i);
	}
}
void JudgeWanShu(int n)
{
	int sum = 0;
	for (int i = 1;i <= sqrt(n);i++)
	{
		if (n % i == 0&&n/i!=i&&n/i!=n)
		{
			sum = sum + i + n / i;
		}
		else
		{
			sum += i;
		}
	}
	if (sum == n)
	{
		printf("%d是完数\n", n);
	}
	

}

这个代码是错的。但是我不知道为什么错了，希望有人看出来可以告诉我
改好了

#include<stdio.h>
#include<math.h>
int main()
{
	void JudgeWanShu(int n);
	int a = 45;
	for (int i = 2;i <= 10000;i++)
	{
		JudgeWanShu(i);
	}
}
void JudgeWanShu(int n)
{
	int sum = 0;
	for (int i = 1;i <= sqrt(n);i++)
	{
		if (n % i == 0 )
		{
			if (n / i == i||n/i==n)
			{
				sum += i;
			}
			else {
				sum = sum + i + n / i;
			}
		}

	}
	if (sum == n)
	{
		printf("%d是完数\n", n);
	}


}

网络遍历版本

#include<stdio.h>
int main()
{
	int i, j, s;
	
	for (i = 2;i <= 300;i++)
	{
		s = 0;
		for (j = 1;j < i;j++)
		{
			if (i % j == 0)
			{
				s += j;
			}
		}
		if (s == i)
		{
			printf("%d\n", i);
		}
	}
	
}

例6判断一个数是否为回文数

打印出所有不超过n(取n<256)的其平方具有对称性质的数（也就是回文数）

1. 平方很好解决
2. 回文怎么判断
   上述的切分位数已经实现

int divide(int n,int a[])
{
	 int count=-1;
	for (n;n%10!= 0;n /= 10)
	{
		count++;
		a[count] = n % 10;
	}
	return count;

但是判断前后匹配失败不知道为什么
下面采用另一种思路：
因为是回文数所以逆序重新组合和原来的数相等
所以只要把切分的数搞成一个新数和原来的数比较，如果相同则是回文数

判断回文数的函数

int JudgeHuiWen(int n)
{
	int current=0;
	int remainder;
	int original = n;
	for (n;n % 10 != 0;n/=10)
	{
		remainder = n % 10;
		current *= 10;
		current += remainder;	
	}
	if (current == original)
	{
		return 1;
	}
	return 0;
}

主函数

#include<stdio.h>
int main()
{
	int JudgeHuiWen(int n);
	int judge;
	for (int i = 0; i < 10000;i++)
	{
		judge = JudgeHuiWen(i);
		if (judge == 1)
		{
			printf("%d是回文数\n", i);
		}
	 }
	
}

注意作用域：用original保存n的值