In questa sfida posta da xnor, ci è stato chiesto di implementare la moltiplicazione XOR. In questa sfida l'obiettivo è trovare i primi nnumeri primi XOR. I numeri primi XOR sono molto simili ai numeri primi normali, come puoi vedere dalle seguenti definizioni:

Definizione di numero primo: un numero positivo maggiore di 1 che non può essere formato attraverso la moltiplicazione di due numeri se non attraverso la moltiplicazione di 1 e se stessa.

Definizione di XOR Prime: un numero positivo maggiore di 1 che non può essere formato attraverso la moltiplicazione XOR di due numeri se non attraverso la moltiplicazione XOR di 1 e se stesso. Notare che i numeri primi XOR compongono la sequenza oeis A014580 .

La moltiplicazione XOR è definita come una moltiplicazione binaria lunga senza trasporto. Puoi trovare maggiori informazioni sulla moltiplicazione XOR nella sfida di xnor .

Ingresso:

Un numero intero n.

Produzione:

I primi nnumeri primi di XOR.

Ecco i numeri primi XOR sotto i 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 byte

.fq2/muxyG*Hhdjed2 0^SZ2ZQ

Dimostrazione

Per verificare se un numero è un XOR-prime, generiamo la tabella di moltiplicazione completa fino a quel numero usando l'algoritmo da qui , quindi contiamo quante volte appare quel numero. Se è esattamente 2, il numero è primo.

Quindi, .frestituisce i primi n numeri primi.

Mathematica, 100 99 byte

$\mathbb{F}_2[x]$

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

Pari / GP , 74 byte

Salvato 4 byte grazie a Charles .

$\mathbb{F}_2[x]$

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

Provalo online!

Praticamente lo stesso della mia risposta Mathematica , ma PARI / GP ha nomi di funzione più brevi.

Ceylon, 166 byte

Naturalmente questo non può competere con Pyth & Co ...

{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);

formattato:

{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);

Questo crea un iterabile infinito di numeri interi (a partire da 2), lo filtra controllando se un numero è un XOR-prime e prende il primo n elementi.

Questo filtro funziona eseguendo il loop su tutti gli elementi da 2 a m-1 (che sono m-2) e controllando ogni coppia se il prodotto xor fornisce m. Se l'iterabile creato da quello è vuoto, mè un xor-prime e quindi incluso.

Il prodotto xor stesso viene calcolato utilizzando lo stesso algoritmo (e quasi lo stesso codice) della mia risposta per il calcolo del prodotto XOR .

Julia, 116 byte

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])

La funzione principale è la funzione anonima sulla seconda riga. Chiama una funzione di aiutof (che è per inciso la mia presentazione per la sfida di xnor).

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