Sechs-Wege-Primzahlenfolge Adventskalender 2018 Java-Ausgabe

Dieser Artikel ist "Sick Prime Number Sequence Adventskalender 2018" Tag 2.

Einzelheiten finden Sie auf der entsprechenden Seite des Adventskalenders. Wenn Sie den Inhalt des Problems grob zusammenfassen: "Wenn eine positive ganze Zahl N von 100 oder weniger angegeben wird, wird die N-te" kranke Primzahl "berechnet und durch Kommas getrennt ausgegeben. Tu es. " "Kranke Primzahl" bezieht sich auf eine Primzahl von 4 oder 9.

Da es sich um ein einfaches Problem handelt, gibt es meines Erachtens verschiedene Lösungen. Wenn es jedoch eine API gibt, die die folgenden externen Spezifikationen erfüllt, kann die Antwort auf das Problem derzeit durch Kombination dieser Lösungen erhalten werden.

hasFourOrNine: Wenn eine natürliche Zahl x als Argument angegeben wird, wird true zurückgegeben, wenn x 4 oder 9 enthält, andernfalls false.
isPrime: Wenn eine natürliche Zahl x als Argument angegeben wird, wird true zurückgegeben, wenn x eine Primzahl ist, andernfalls false.
lösen: Wenn eine natürliche Zahl n von 100 oder weniger als Argument angegeben wird, wird eine Zeichenfolge zurückgegeben, in der die n-te" shikusiku-Primzahl "durch Kommas getrennt verkettet ist.

Fahren wir nun mit der Implementierung fort. Wenn es sich jedoch um eine etwas ältere Version von Java um Java 6 oder Java 7 handelt, sollte sie wie folgt geschrieben worden sein (obwohl sie "etwas alt" ist, sind Java-Systeme im Allgemeinen Es dauert lange, also wenn es eine Version dieses Zeitalters ist, denke ich, dass es viele gibt, die noch in Betrieb sind ...)

`Main1.java`



public class Main1 {
    public static void main(String[] args) {
        int n = 100;
        System.out.println(solve(n));
    }
    
    public static String solve(int n) {
        StringBuilder answer = new StringBuilder();
        for (int x = 1; n > 0; x++) {
            if (isPrime(x) && hasFourOrNine(x)) {
                answer.append(x);
                if (--n > 0) {
                    answer.append(",");
                }
            }
        }
        return answer.toString();
    }
    
    public static boolean hasFourOrNine(int x) {
        while (x > 0) {
            int i = x % 10;
            if (i == 4 || i == 9) {
                return true;
            }
            x /= 10;
        }
        return false;
    }
    
    public static boolean isPrime(int x) {
        if (x < 2) {
            return false;
        }
        
        for (int i = 2; i <= Math.sqrt(x); i++) {
            if (x % i == 0) {
                return false;
            }
        }
        return true;
    }
}

Das obige Beispiel hat einen starken Farbton der prozeduralen Programmierung, und das Gesamterscheinungsbild ist Porträt. Lassen Sie es uns wie die neueste Version von Java 11 heute umschreiben, ohne die externen Spezifikationen zu ändern (obwohl ich keine Java 11-ähnlichen Funktionen verwendet habe ...)

`Main2.java`


import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main2 {
    public static void main(String[] args) {
        int n = 100;
        System.out.println(solve(n));
    }
    
    public static String solve(int n) {
        return IntStream.iterate(1, x -> x + 1)
                        .filter(Main2::isPrime)
                        .filter(Main2::hasFourOrNine)
                        .mapToObj(String::valueOf)
                        .limit(n)
                        .collect(Collectors.joining(","));
    }
    
    public static boolean hasFourOrNine(int x) {
        return IntStream.iterate(x, i -> i > 0, i -> i / 10)
                        .map(i -> i % 10)
                        .anyMatch(i -> i == 4 || i == 9);
    }
    
    public static boolean isPrime(int x) {
        return x >= 2 && IntStream.rangeClosed(2, (int)Math.sqrt(x)).allMatch(i -> x % i != 0);
    }
}

Durch die starke Verwendung der Stream-API- und Lambda-Ausdrücke wurde die vertikale Länge verkürzt und der gesamte horizontale Code vervollständigt. Es ist keine funktionale Programmierung, aber es führt zumindest einen Teil dieses Paradigmas ein.

"Lesbarkeit" ist beim Programmieren wichtig, aber es fühlt sich bei dieser Länge nicht nach Lesbarkeit an ... Letzteres macht jedoch Spaß und ist angenehm, persönlich zu schreiben. Methodenkette wird zur Gewohnheit (´ ´ ω ・｀)

Schließlich ist die Lösung des Problems bei n = 100 unten gezeigt. In der Spezifikation des Problems wurde es jedoch "durch Kommas getrennt", aber aus Gründen der Lesbarkeit wird es unten durch "durch Zeilenumbrüche getrennt" gezeigt. Bitte beachten Sie.