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.print(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;

    }

}