Java经典算法编程（素数相关）

第一次写博客，新手，自己找的几道算法编程，错误之处还望指正。

Java经典算法编程

 
1、素数（质数）指的是不能被分解的数，除了1和它本身之外就没有其他数能够整除。求100以内的所有素数。

2、若两个素数之差为2，则这两个素数就是孪生素数。编写程序找出1~100之间的所有孪生素数。

3、编写程序找出1~900之间的所有可逆素数（可逆素数是指一个素数的各位数值顺序颠倒后得到的数仍为素数，如113、311）。

4、回文素数问题的求解：

所谓回文素数是指，对一个整数n从左向右和从右向左读的结果值相同且是素数，即称为回文素数。

求不超过1000的回文素数。

5、平方回文素数问题的求解：

素数的平方是回文数，比如素数11*11=121。求不超过1000的回文素数。

6、相亲数问题的求解

220的真因数之和为1+2+4+5+10+11+20+22+44+55+110=284

284的真因数之和为1+2+4+71+142=220

毕达哥拉斯把这样的数对A、B称为相亲数：A的真因数之和为B，而B的真因数之和为A。求100000以内的相亲数。

 

import sun.org.mozilla.javascript.internal.regexp.SubString;

import java.util.ArrayList;

public class Main {

public static void main(String[] args) {
Main main = new Main();
long start = System.currentTimeMillis();
// main.printSushu(100);
main.printDouble(100);
main.printGoback(900);
main.printHuiwen(1000);
main.printSqure(1000);
long end = System.currentTimeMillis();
System.out.println();
System.out.println("计算用时共"+(end-start)+"ms");
}
/**
* Java经典算法编程

1、素数（质数）指的是不能被分解的数，除了1和它本身之外就没有其他数能够整除。求100以内的所有素数。
2、若两个素数之差为2，则这两个素数就是孪生素数。编写程序找出1~100之间的所有孪生素数。
3、编写程序找出1~900之间的所有可逆素数（可逆素数是指一个素数的各位数值顺序颠倒后得到的数仍为素数，如113、311）。
4、回文素数问题的求解：
所谓回文素数是指，对一个整数n从左向右和从右向左读的结果值相同且是素数，即称为回文素数。
求不超过1000的回文素数。
5、平方回文素数问题的求解：
素数的平方是回文数，比如素数11*11=121。求不超过1000的回文素数。
6、相亲数问题的求解
220的真因数之和为1+2+4+5+10+11+20+22+44+55+110=284
284的真因数之和为1+2+4+71+142=220
毕达哥拉斯把这样的数对A、B称为相亲数：A的真因数之和为B，而B的真因数之和为A。求100000以内的相亲数。

*/
public ArrayList<Integer> printSushu(int num){
ArrayList<Integer> arrayList = new ArrayList<Integer>();
int i =2,j=1,count=0,arrNum=0;
while (i<=num){
while (j<=i){
if (i%j==0){
count++;
}
j++;
}
if (count==2){
System.out.print(i+",");
arrayList.add(arrNum,i);
arrNum++;
}
j=1;
count=0;
i++;
}
System.out.println("");
return arrayList;
}
public void printDouble(int num){
ArrayList<Integer> list = printSushu(num);
System.out.println(num+"以内孪生素数对有：");
int i=1;
while (i<list.size()){
if (list.get(i)-list.get(i-1)==2)
System.out.print("["+list.get(i-1)+","+list.get(i)+"]");
i++;
}
}
public void printGoback(int num){
ArrayList list = printSushu(num);
int i =0;
System.out.println(num+"以内可逆素数有：");
while (i<list.size()){
int isGoback = (int) list.get(i);
if (judge(isGoback)){
System.out.print(isGoback+",");
}
i++;
}
}
public boolean judge(int num){
int newNum = num;
int numLength = String.valueOf(num).length();
int[] split = new int[numLength];
int count = numLength;
int[] newSplit = new int[split.length];
for (int i = 0;i<numLength;i++){
split[i]= (int) (newNum/Math.pow(10,count-1));
newNum=newNum-(split[i]*(int) (Math.pow(10,count-1)));
count--;

}
for (int j=0;j<split.length;j++){
newSplit[j]=split[split.length-j-1];
}
int time=0,goBackNum=0;
while (time<numLength){
goBackNum+=newSplit[time]*Math.pow(10,numLength-time-1);
time++;
}
int whole=0;
for (int k=1;k<goBackNum;k++){
if (goBackNum%k==0)
whole++;
}
if (whole==1)
return true;
return false;
}
public void printHuiwen(int num){
ArrayList huiwenList=printSushu(num);
System.out.println(num+"以内回文素数有：");
for (int i=0;i<huiwenList.size();i++){
int huiwenBit=0;//回文数位数
int huiwenNum = (int) huiwenList.get(i);
for (int j=0 ;j<huiwenNum;j++){
if (huiwenNum>=Math.pow(10,j)&&huiwenNum< Math.pow(10,j+1)){
huiwenBit=j+1;
break;
}
}
int[] huiwenArr=new int[huiwenBit];
for (int j=0;j<huiwenBit;j++){
String huiwenStr=String.valueOf(huiwenNum);

huiwenArr[j]= Integer.parseInt(huiwenStr.substring(j,j+1));
}
String afterNUm="";
for (int j=huiwenBit;j>0;j--){
afterNUm+=String.valueOf(huiwenArr[j-1]);
}
if (String.valueOf(huiwenNum).equals(afterNUm))
System.out.print(huiwenNum+",");
}
System.out.println();
}
public void printSqure(int num){
System.out.pri
9e18
nt(num+"以内平方回文素数有：");
int squreNum;
ArrayList squreList = printSushu(num);
for (int i=0;i<squreList.size();i++){
squreNum= (int) Math.pow((int) squreList.get(i),2);
if (isHuiwen(squreNum)){
System.out.print(squreList.get(i)+"*"+squreList.get(i)+"="+squreNum+",");
}
}
}
public boolean isHuiwen(int num){
int tempNum = num;
int sum=0;
int numBit=String.valueOf(num).length();
int tempBit = numBit;
int[] numArr=new int[numBit];
for (int i=0;i<numBit;i++){
numArr[i]= (int) (tempNum/Math.pow(10,tempBit-1));
tempNum= (int) (tempNum-numArr[i]*Math.pow(10,tempBit-1));
tempBit--;
}
for (int i=numArr.length-1;i>=0;i--){
sum+=numArr[i]*Math.pow(10,i);
}
if (sum==num)
return true;
return false;

}

}