Java & Python 验证哥德巴赫猜想(日期： 2020年7月4日)

制作背景

大一下学期疫情时代，学习了Python基础和java基础以及一点点算法。在制作过程中发现了Python速度远远低于java运行速度，因而发现了提升程序效率的一种方法，即使用jit对函数进行修饰。

结果

程序运行正常，在十万以内均符合歌德巴赫猜想


TIM截图20201021183909.png

Python源代码

"""

歌德巴赫猜想验证

此程序只在一定范围内验证歌德巴赫猜想：所有大于2的偶数都可以表示成两个质数的和

日期： 2020年7月4日

作者： littefean

"""
from time import time
import numpy as np
import numba
from numba import jit
def main():
priNum = [2] # 为质数专门创建一个列表，只添加存放所有质数
i = 4
while i < 100000:
index = priNum[len(priNum) - 1] # index 为目前库存里最大的质数
# 当正在遍历的数字超过了质数列表中最大的质数，则扩充质数列表直到最大质数大于当前遍历数
while index < i:
index = priNum[len(priNum) - 1]
addPriNum(priNum)
if establish(i, priNum):
print(f"{i}符合哥德巴赫猜想")
else:
print(f"{i}+不符合哥德巴赫猜想！！！！！！")
break
i += 2
@jit(nopython=True)
def isPri(n):
"""
判断整数n 是否是质数
:param n:被判断的数
:return:n是否是质数
"""
step = 2
while step < (n / 2) + 1:
if n % step == 0:
return False
step += 1
return True
@jit(nopython=True)
def addPriNum(array):
"""

在list集合中增加一个大于list集合最后一个元素的最小质数

该函数改变了list集合的状态

:param array:质数集合
:return:
"""
if len(array) == 0:
array.append(2)
else:
num = array[len(array)-1]
while True:
num += 1
if isPri(num):
array.append(num)
break
@jit(nopython=True)
def establish(num, array):
"""

返回list中是否存在一个二元对的两个元素相加等于num

如果num不为偶数，返回false

:param num:待判定的数
:param array:list中知否存在一个二元对的两个元素相加等于num
:return:是否存在一个二元对的两个元素相加等于num
"""
if num % 2 == 0:
index = len(array)-1
i = 0
while i < index:
j = i
while j < len(array)-1:
if array[i] + array[j] == num:
# 被jit修饰的函数内不能够打印输出，若想打印输出需要取消jit修饰
# print(f"{num} = {array[i]} + {array[j]}\t\t\t", end="")
return True
j += 1
i += 1
return False
if __name__ == '__main__':
t1 = time()
main()
t2 = time()
print(f"耗时：{t2 - t1}")
input()
Java源代码
import java.util.ArrayList;
//import java.util.Scanner;
/**
* 此程序只在一定范围内验证歌德巴赫猜想：所有大于2的偶数都可以表示成两个质数的和
* 日期： 2020年7月4日
* 作者： littefean
*/
public class GoldbachTest {
public static void main(String[] args) {
//此集合存储质数
ArrayList priNum = new ArrayList<>();
priNum.add(2);
long t = System.nanoTime();
for(int i = 4; i<200000; i+=2) {
//如果集合里的最大质数一个元素小于i，那么扩充质数集合，直到大于i为止
int index = priNum.get(priNum.size()-1);
while(index < i){
index = priNum.get(priNum.size()-1);
addPriNum(priNum);
}
if(establish(i, priNum)){
//System.out.println("符合哥德巴赫猜想");
//System.out.println(PriNum);
}else{
System.out.println(i+" 不符合哥德巴赫猜想！！！！！！");
break;
}
}
System.out.println("cost: " + 10E-10 * (System.nanoTime()-t) + "seconds");
}
/**
* 返回list中是否存在一个二元对的两个元素相加等于num
* 如果num不为偶数，返回false
* @param num 待判定的数
* @return list中知否存在一个二元对的两个元素相加等于num
*/
private static boolean establish(int num, ArrayList list){
if(num %2 == 0) {
//i和j分别表示两个质数集合的下标
int index = list.size()-1;
for(int i = 0; i < index; i++){
for(int j = i; j < index; j++){
if(list.get(i) + list.get(j) == num){
//System.out.print(num+" = " + list.get(i)+" + "+list.get(j)+"\t\t\t");
return true;
}
}
}
}
return false;
}
/**
* 在list集合中增加一个大于list集合最后一个元素的最小质数
* 该函数改变了list集合的状态
* @param list 质数集合
*/
public static void addPriNum (ArrayList list){
//如果集合里什么都没有，那么写入第一个质数2
if (list.size() == 0){
list.add(2);
}else{
//i接收最后一个元素
int num = list.get(list.size()-1);
while(true){
num++;
if(isPri(num)){
list.add(num);
break;
}
}
}
}
/**
* 判断整数n 是否是质数
* @param n 被判断的数
* @return n是否是质数
*/
public static boolean isPri(int n){
for(int i = 2; i
if(n % i == 0){
return false;
}
}
return true;
}
}