Beispielanalyse der Java-Syntax

1, n Arten von Bereichen zum Lösen von Primzahlen

1.1, heftige Zykluslösung

public class TestDemo220427 {
    public static void main(String[] args) {
//        这里以求取1~100之间的素数为例
        for(int i = 2;i <= 100;i++){//素数从2开始,所以从2开始产生到100的数
            int flg = 1;//假设是素数
            for(int j = 2;j < i;j++){
                if(i%j == 0){
                    flg = 0;
                }
            }
            if(flg == 1){
                System.out.println(i + "是素数！");
            }
        }
    }
}

1.2, versuche die erste Hälfte zu teilen

public class TestDemo220427 {
    public static void main(String[] args) {
//        这里以求取1~100之间的素数为例
        for(int i = 2;i <= 100;i++){//素数从2开始,所以从2开始产生到100的数
            int flg = 1;//假设是素数
            for(int j = 2;j < i/2;j++){
                if(i%j == 0){
                    flg = 0;
                }
            }
            if(flg == 1){
                System.out.println(i + "是素数！");
            }
        }
    }
}

# 🎜🎜# Es kann festgestellt werden, dass jede Zahl, die wir haben, durch die Multiplikation zweier Zahlen geteilt werden kann, z. B. 16: Es kann 1 16, 2 * 8, 4 * 4 sein. Sie können sehen, dass die erste Hälfte der Zahl ist kleiner als die Hälfte von sich selbst, also müssen wir nur prüfen, ob die erste Hälfte der Zahl durch sich selbst teilbar ist, denn solange es eine in der ersten Hälfte gibt, muss es eine Zahl in der zweiten Hälfte geben, die es sein kann mit sich selbst multipliziert, um sich selbst zu erhalten, sodass die Arbeitsbelastung halbiert wird. *

1.3, versuche die Zahl zu dividieren, die kleiner als das Wurzelzeichen ihrer selbst ist

import java.lang.Math;
public class TestDemo220427 {
    public static void main(String[] args) {
//        这里以求取1~100之间的素数为例
        for(int i = 2;i <= 100;i++){//素数从2开始,所以从2开始产生到100的数
            int flg = 1;//假设是素数
            for(int j = 2;j <= (int)(Math.sqrt(i));j++){
                if(i%j == 0){
                    flg = 0;
                }
            }
            if(flg == 1){
                System.out.println(i + "是素数！");
            }
        }
    }
}

Im Moment ist es immer noch das gleiche Prinzip, aber der Bereich wird wieder eingeengt, weil Eine Zahl wird in zwei Teile geteilt. In Form des Zahlenprodukts ist die erste Zahl nicht nur kleiner als die Hälfte ihrer selbst, sondern es ist grundsätzlich unmöglich, größer als ihr Quadratwurzelwert zu sein, beispielsweise 16. Tatsächlich ist Die erste Hälfte der Zahl wird nicht größer als 4 sein, denn nachdem sie größer als 4 ist, können Sie sehen, dass es unmöglich ist, dass eine Zahl gleich 16 ist, wenn sie mit einer anderen Zahl multipliziert wird. Natürlich 2 * 8 und 8 * 2 zählt nur als erster

1.4, suchen Sie nach

import java.lang.Math;
public class TestDemo220427 {
    public static void main(String[] args) {
//        这里以求取1~100之间的素数为例
        for(int i = 1;i <= 100;i += 2){//从1开始,产生到100的奇数
            int flg = 1;//假设是素数
            if(i == 1){
                System.out.println((i+1) + "是素数！");//2这里需要单拎出来考虑，比较特殊
                continue;
            }
            for(int j = 2;j <= (int)(Math.sqrt(i));j++){
                if(i%j == 0){
                    flg = 0;
                }
            }
            if(flg == 1){
                System.out.println(i + "是素数！");
            }
        }
    }
}

in ungeraden Zahlen. Wir wissen, dass, mit Ausnahme des Sonderfalls 2, nicht alle geraden Zahlen sein können Primzahlen, da sie mindestens durch 2 teilbar sind. Wenn Sie also nur innerhalb des Bereichs berücksichtigen, können Sie die Anzahl der äußeren Schleifen reduzieren, wenn Sie ungerade Zahlen erkennen müssen.

Tatsächlich gibt es Möglichkeiten, die Optimierung fortzusetzen, daher werde ich sie hier nicht alle auflisten. Wenn Sie interessiert sind, können Sie sie sich ansehen. Viele Blogger haben sehr detaillierte und ausführliche Artikel geschrieben !

Zweitens das Schaltjahrproblem

public class TestDemo220427 {
    public static boolean isleapYear(int year){
        if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)){
            return true;
        } else{
            return false;
        }
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = scan.nextInt();
        boolean ret = isleapYear(year);
        if(ret == true){
            System.out.println(year + "是闰年！");
        }else{
            System.out.println(year + "不是闰年！");
        }
    }
}

Sie müssen nur die Kriterien für ein Schaltjahr kennen, um das Problem sehr gut zu lösen.

Drei, finde den größten gemeinsamen Teiler und das kleinste gemeinsame Vielfache

3.1, finde den größten gemeinsamen Teiler

import java.util.Scanner;
public class TestDemo220427 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        int m = 0;
        while((m = a%b) != 0){//辗转相除法
            a = b;
            b = m;
        }
        System.out.println(b);
    }
}

3.2, finde das kleinste gemeinsame Vielfache

import java.util.Scanner;
public class TestDemo220427 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        for(int i = 1;i > 0;i++){
            if((a*i)%b == 0){
                System.out.println("最小公倍数：" + a*i);
                break;
            }
        }
    }
}

Tatsächlich gibt es eine andere Formel: Angenommen, der größte gemeinsame Teiler ist m, dann ist das kleinste gemeinsame Vielfache (a*b)/m.

Viertens, das Problem der Potenzierung

import java.lang.Math;
public class TestDemo220427 {
    public static boolean isNarnum(int num,int count){
        int sum = 0;
        int tmp = num;
        while(tmp != 0){
            sum += Math.pow(tmp%10,count);
            tmp /= 10;
        }
        if(sum == num){
            return true;
        }else{
            return false;
        }
    }
    public static void main(String[] args) {
//        判断一个数是不是自幂数
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num = scan.nextInt();
        int count = 0;
        int tmp = num;
        while(tmp != 0){
            count++;
            tmp /= 10;
        }
        boolean ret = isNarnum(num,count);
        if(ret == true){
            System.out.println(num + "是一个" + count +"位自幂数！");
        }else{
            System.out.println(num + "不是自幂数！");
        }
    }
}

Fünf, Zählen der Anzahl der Einsen in Binärbits

5.1, zirkuläre Rechtsverschiebung und bitweise UND 1

import java.util.Scanner;
public class TestDemo220427 {
    public static int getOnecount(int num){
        int count = 0;
        while(num != 0){//右移后不为0就继续统计
            if((num& 1) == 1){
                count++;
            }
            num = num >> 1;
        }
        return count;
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num = scan.nextInt();
        int ret =  getOnecount(num);
        System.out.println(num + "的二进制位中1的个数 ：" + ret);
    }
}

Hinweis: Dieser Code hat einen Fehler, da negative Zahlen nicht gezählt werden können. Das höchste binäre Vorzeichenbit einer negativen Zahl ist 1. Wenn Sie das Vorzeichenbit nach rechts verschieben, wird immer addiert 1 bis zum High-Bit. Dann ist der Zyklus endlos.

Lösung: num = num >> 1 —> Wechseln Sie zu num = num >>> gefüllt mit 0, gilt sowohl für positive als auch für negative Zahlen.

Erweiterung: Manche Leute fragen sich vielleicht, warum man sich nicht nach links bewegen kann, da man sich nach rechts bewegen kann?

Die Antwort lautet: Eine Linksverschiebung ist zwar möglich, aber nicht zu empfehlen, da die Effizienz zu gering ist.

public class TestDemo220427 {
    public static int getOnecount(int num){
        int count = 0;
        for(int i = 0;i < 32;i++){
            if((num & (1 << i)) != 0){
                count++;
            }
        }
        return count;
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num = scan.nextInt();
        int ret =  getOnecount(num);
        System.out.println(num + "的二进制位中1的个数 ：" + ret);
    }
}

Anstatt die Zahl zu diesem Zeitpunkt nach links zu verschieben, verschieben wir 1 nach links und führen dann ein bitweises UND mit der Zahl durch, da das Ergebnis nur 0 oder nicht 0 sein kann Nicht-0 bedeutet, dass die Position 1 im Ergebnis der Linksverschiebung 1 entspricht, daher werden wir sie zu diesem Zeitpunkt zählen. Obwohl diese Methode das Problem auch lösen kann, müssen Sie 32 Mal nach links verschieben, da Sie nicht wissen können, wie viele Einsen vor dieser Zahl stehen, und nur alle Bits vergleichen können.

5.2, das Prinzip von n & (n-1) Eliminierung von 1

import java.util.Scanner;
public class TestDemo220427 {
    public static int getOnecount(int num){
        int count = 0;
        while(num != 0){
            num = num&(num-1);
            count++;
        }
        return count;
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num = scan.nextInt();
        int ret =  getOnecount(num);
        System.out.println(num + "的二进制位中1的个数 ：" + ret);
    }

Diese Methode kann sowohl für positive als auch für negative Zahlen verwendet werden und ist sehr effizient, bitweise UND Jedes Mal, wenn num-1 einmal erfolgt, wird eine 1 eliminiert.

Erweiterung: Verwenden Sie diese Methode, um zu bestimmen, ob eine bestimmte Zahl hoch 2 hoch ist.

import java.util.Scanner;
public class TestDemo220427 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num = scan.nextInt();
        if((num & (num-1)) == 0){
            System.out.println("是2的k次方数！");
        }else{
            System.out.println("不是2的k次方数！");
        }
    }
}

Das obige ist der detaillierte Inhalt vonBeispielanalyse der Java-Syntax. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!