In dieser Herausforderung von xnor wurden wir gebeten, die XOR-Multiplikation zu implementieren. In dieser Herausforderung besteht das Ziel darin, die ersten nXOR-Primzahlen zu finden . XOR-Primzahlen sind regulären Primzahlen sehr ähnlich, wie die folgenden Definitionen zeigen:

Definition der Primzahl: Eine positive Zahl größer als 1, die nicht durch Multiplikation zweier Zahlen gebildet werden kann, außer durch Multiplikation von 1 und sich selbst.

Definition von XOR-Primzahl: Eine positive Zahl größer als 1, die nicht durch XOR-Multiplikation zweier Zahlen gebildet werden kann, außer durch die XOR-Multiplikation von 1 und sich selbst. Beachten Sie, dass die XOR-Primzahlen die Sequenz A014580 bilden .

XOR-Multiplikation ist als binäre Langmultiplikation ohne Übertragen definiert. Weitere Informationen zur XOR-Multiplikation finden Sie unter xnors Herausforderung .

Eingang:

Eine ganze Zahl n.

Ausgabe:

Die ersten nXOR-Primzahlen.

Hier sind die XOR-Primzahlen unter 500:

2 3 7 11 13 19 25 31 37 41 47 55 59 61 67 73 87 91 97 103 109 115 117 131 137 143 145 157 167 171 185 191 193 203 211 213 229 239 241 247 253 283 285 299 301 313 319 333 351 355 357 361 369 375 379 391 395 397 415 419 425 433 445 451 463 471 477 487 499

Pyth, 26 Bytes

.fq2/muxyG*Hhdjed2 0^SZ2ZQ

Demonstration

Zur Prüfung , ob eine Zahl ein XOR-Primzahl ist, erzeugen wir die komplette Multiplikationstabelle auf diese Zahl nach oben unter Verwendung des Algorithmus von hier , und dann , wie oft diese Zahl erscheint zählen. Wenn es genau 2 ist, ist die Zahl eine Primzahl.

Dann .fgibt die ersten n Primzahlen.

Mathematica, 100 bis 99 Bytes

$\mathbb{F}_2[x]$

For[p=i=0,i<#,If[IrreduciblePolynomialQ[++p~IntegerDigits~2~FromDigits~x,Modulus->2],Print@p;i++]]&

Pari / GP , 74 Bytes

4 Bytes gespart dank Charles .

$\mathbb{F}_2[x]$

n->p=0;while(n,if(polisirreducible(Mod(Pol(binary(p++)),2)),print(p);n--))

Probieren Sie es online!

Grundsätzlich das Gleiche wie meine Mathematica-Antwort , aber PARI / GP hat kürzere Funktionsnamen.

Ceylon, 166 Bytes

Das kann natürlich nicht mit Pyth & Co mithalten ...

{Integer*}p(Integer n)=>loop(2)(1.plus).filter((m)=>{for(i in 2:m-2)for(j in 2:m-2)if(m==[for(k in 0:64)if(j.get(k))i*2^k].fold(0)((y,z)=>y.xor(z)))i}.empty).take(n);

Formatiert:

{Integer*} p(Integer n) =>
        loop(2)(1.plus).filter((m) => {
            for (i in 2 : m-2)
                for (j in 2 : m-2)
                    if (m == [
                            for (k in 0:64)
                                if (j.get(k))
                                    i * 2^k
                        ].fold(0)((y, z) => y.xor(z))) i
        }.empty).take(n);

Dies erzeugt eine unendliche Iteration von ganzen Zahlen (beginnend mit 2), filtert sie, indem überprüft wird, ob eine Zahl eine XOR-Primzahl ist, und nimmt die ersten nElemente davon.

Diese Filterung funktioniert, indem alle Elemente von 2 bis m-1 (welche m-2 sind) durchlaufen werden und jedes Paar überprüft wird, ob das xor-Produkt gibt m. Wenn das dadurch erzeugte Iterable leer ist, mist es ein Xor-Prime und daher eingeschlossen.

Das XOR-Produkt selbst wird mit demselben Algorithmus (und fast demselben Code) berechnet wie in meiner Antwort für die XOR-Produktberechnung .

Julia, 116 Bytes

f(a,b)=b%2*a$(b>0&&f(2a,b÷2))
n->(A=[i=2];while endof(A)<n i+=1;i∈[f(a,b)for a=2:i-1,b=2:i-1]||push!(A,i)end;A[n])

Die primäre Funktion ist die anonyme Funktion in der zweiten Zeile. Es ruft eine fHilfsfunktion auf (was übrigens meine Vorlage für xnors Herausforderung ist).

Ungolfed:

function xor_mult(a::Integer, b::Integer)
    return b % 2 * a $ (b > 0 && f(2a, b÷2))
end

function xor_prime(n::Integer)
    # Initialize an array to hold the generated XOR primes as well as
    # an index at which to start the search
    A = [i = 2]

    # Loop while we've generated fewer than n XOR primes
    while endof(A) < n
        # Increment the prime candidate
        i += 1

        # If the number does not appear in the XOR multiplication
        # table of all numbers from 2 to n-1, it's an XOR prime
        i ∈ [xor_mult(a, b) for a in 2:i-1, b in 2:i-1] || push!(A, i)
    end

    # Return the nth XOR prime
    return A[n]
end