算法趣题（Java随笔）—数学系列

目录

一、判断闰年

二、矩阵乘积

三、哥德巴赫猜想

四、完全数

五、亲密数

六、数转数组

七、分解质因数

八、待续......

---

---

一、判断闰年

四年一闰，百年不闰，四百年再闰；

//1、判断闰年
	static boolean isLeapYear(int year){
		if((year%4==0)&&(year%100!=0)||(year%400==0)){
			return true;
		}
		return false;
	}

运行测试：

// 1、判断闰年(main方法中执行)
		System.out.println(isLeapYear(2008) ? "2008是闰年" : "2008不是闰年");
		System.out.println(isLeapYear(2018) ? "2018是闰年" : "2018不是闰年");

运行结果：
2008是闰年
2018不是闰年

二、矩阵乘积

矩阵A和B的乘积C满足C=A*B!=B*A；且要求A的行数必须等于B的列数，如：

//2、求矩阵积
	/*
	 * 二维数组data1的行数必须等于data2的列数
	 */
	static int[][] matrixMul(int[][] data1,int[][] data2){
		int[][] data=new int[data1.length][data1.length];
		for(int i=0;i<data1.length;i++){
			for(int j=0;j<data1.length;j++){
				data[i][j]=0;
				for(int k=0;k<data2.length;k++){
					data[i][j]+=(data1[i][k]*data2[k][j]);
				}
			}
		}
		return data;
	}

运行测试：

// 2、矩阵乘积(main方法中执行)
		int[][] data1 = { { 1, 2, 3, 5 }
						, { 4, 5, 6, 9 }
						, { 4, 5, 6, 9 } };
		int[][] data2 = { { 3, 6, 3 }
						, { 2, 5, 5 }
						, { 1, 4, 8 }
						, { 4, 5, 3 } };
		int[][] data = matrixMul(data1, data2);
		for (int[] i : data) {
			for (int j : i) {
				System.out.print(j + "\t");
			}
			System.out.println();
		}

运行结果：
30	53	52	
64	118	112	
64	118	112

三、哥德巴赫猜想

——任意一个大于二的偶数都可以写为两个素数之和

//哥德巴赫猜想
	//1、判断是否为素数
	static boolean isSuShu(int n){
		for(int i=2;i<n/2;i++){
			if(n%i==0){
				return false;
			}
		}
		return true;
	}
	//2、判断是否满足哥德巴赫猜想
	static boolean isGeDe(int i){
		if(i<=2||i%2!=0){//不是大于2的偶数
			return false;
		}else{
			for(int j=2;j<=i/2;j++){
				if(isSuShu(j)&&isSuShu(i-j)){
					return true;
				}
			}
		}
		return false;
	}

运行测试：

//3、哥德巴赫猜想(main方法中执行)
	for(int i=4;i<101;i+=2){
		System.out.print(isGeDe(i)+" ");
	}

运行结果：
true true true true true true true true...

四、完全数

——一个自然数的所有真因子的和等于这个自然数，即完全数。

// 完全数——在某一范围内查找完全数
	static void isWQShu(int data, int size) {
		int sum;
		int k;// 在保存因子的数组中指向因子地址
		int[] yinzi = new int[size];// 保存完全数的所有因子
		for (int i = 1; i <= data; i++) {
			sum = i;
			k = 0;
			for (int j = 1; j < i; j++) {
				if (i % j == 0) {
					yinzi[k++] = j;
					sum -= j;// 每找到一个因子，用sum减去该因子
				}
			}
			// 输出完全数
			if (sum == 0) {
				System.out.print(i + "是一个完全数  因子为：");
				for (int n = 0; n < k; n++) {
					System.out.print(yinzi[n] + "  ");
				}
				System.out.println();
			}
		}
	}

运行测试：

// 4、完全数(在main方法中执行)
		isWQShu(10000, 100);//查找10000以内的所有完全数

运行结果：
6是一个完全数  因子为：1  2  3  
28是一个完全数  因子为：1  2  4  7  14  
496是一个完全数  因子为：1  2  4  8  16  31  62  124  248  
8128是一个完全数  因子为：1  2  4  8  16  32  64  127  254  508  1016  2032  4064 

五、亲密数

——a的真因子和等于b，b的真因子和等于a，即a与b为亲密数对。

// 亲密数——判断一个数有无亲密数
	static void isQMShu(int data, int size) {
		int[] yinzi1 = new int[size];// 原数据因子数组
		int[] yinzi2 = new int[size];// 亲密数因子数组
		int sum = 0;// 保存原数据因子之和(亲密数)
		int k1 = 0;// 原数据的因子个数
		int k2 = 0;// 亲密数的因子个数
		// 获取原数据因子
		for (int i = 1; i < data / 2 + 1; i++) {
			if (data % i == 0) {
				yinzi1[k1++] = i;
				sum += i;
			}
		}
		int temp = 0;
		// 获取亲密数因子
		for (int j = 1; j < sum / 2 + 1; j++) {
			if (sum % j == 0) {
				yinzi2[k2++] = j;
				temp += j;
			}
		}
		// 输出原数据因子
		System.out.print("原数据：" + data + "  因子：");
		for (int i = 0; i < k1; i++) {
			System.out.print(yinzi1[i] + "  ");
		}
		// 存在亲密数，输出亲密数和因子
		if (temp == data) {
			System.out.print("\n亲密数：" + sum + "  因子：");
			for (int i = 0; i < k2; i++) {
				System.out.print(yinzi2[i] + "  ");
			}
		} else {
			System.out.print("\n亲密数：无");
		}
	}

运行测试：

// 5、亲密数(在main方法中执行)
		 isQMShu(220, 100);//判断220有无亲密数

运行结果：
原数据：220  因子：1  2  4  5  10  11  20  22  44  55  110  
亲密数：284  因子：1  2  4  71  142  

六、数转数组

// 核心算法
		int k = 0;
		int temp;
		while (data != 0) {
			temp = (int) (data % 10);
			array[k++] = temp;
			data = (data - temp) / 10;
		}

七、分解质因数

——如：18=2x3x3    180=2x2x3x3x5 即要求每一个因数都是不可再分的素数

// 7、分解质因数(判断是否是素数，进行分解)
	// 7—1 判断是否是素数
	static boolean isPrime(int n) {
		if (n == 2 || n == 3) {
			return true;
		}
		for (int i = 2; i <= n / 2; i++) {
			if (n % i == 0) {
				return false;
			}
		}
		return true;
	}

	// 7—2 分解
	static void fenJie(int n) {
		//主要是检查被分解数是否是素数，如果是，则输出后程序结束
		if (isPrime(n)) {
			System.out.print("->" + n);
		} else {
			for (int i = 2; i <= n / 2; i++) {
				if (n % i == 0) {///找到第一个因数
					System.out.print("->" + i);// 第一个因数肯定是素数
					if (isPrime(n / i)) {//判断第二个因数是否为素数
						System.out.print("->" + n / i);
						break;//如果第二个因数是素数，则表示所有因数不可分解，程序结束
					} else {
						fenJie(n / i);//第二个因数不是素数，递归继续分解
					}
					break;//因数查找结束，退出循环
				}
			}
		}
	}

运行测试：

// 7、分解质因数(main方法中执行)
		for(int i=990;i<1000;i+=2){
			System.out.print(i + "的分解因数为：");
			fenJie(i);
			System.out.println();
		}

运行结果：
990的分解因数为：->2->3->3->5->11
992的分解因数为：->2->2->2->2->2->31
994的分解因数为：->2->7->71
996的分解因数为：->2->2->3->83
998的分解因数为：->2->499

八、待续......