Dato un numero naturale $n$ , restituisce l' ennesimo $n$ cubano primo .

Primes cubani

Un numero primo cubano è un numero primo del modulo

p = \frac{x^{3} - y^{3}}{x - y}

$p = \frac{x^3-y^3}{x-y}$

dove $y>0$ e $x = 1+y$ oppure $x = 2+y$

Dettagli

È possibile utilizzare l'indicizzazione basata su 0 o 1, a seconda delle esigenze.
È possibile restituire l' $n$ -esimo primo dato l'indice $n$ o i primi $n$ primi in ordine crescente, oppure in alternativa è possibile restituire un elenco / generatore infinito che produce i numeri primi in ordine crescente.

Casi test

I primi termini sono i seguenti:

(#1-13)   7, 13, 19, 37, 61, 109, 127, 193, 271, 331, 397, 433, 547,
(#14-24) 631, 769, 919, 1201, 1453, 1657, 1801, 1951, 2029, 2269, 2437,
(#25-34) 2791, 3169, 3469, 3571, 3889, 4219, 4447, 4801, 5167, 5419,
(#35-43) 6211, 7057, 7351, 8269, 9241, 10093, 10267, 11719, 12097,
(#44-52) 12289, 13267, 13669, 13873, 16651, 18253, 19441, 19927, 20173

Altri termini sono disponibili su OEIS: sono suddivisi in due sequenze, a seconda di wheter $x = 1+y$ oppure $x = 2+y$ : A002407 e A002648

— flawr
fonte

2

Possiamo restituire i primi n numeri primi non ordinati?

— J42161217

@ J42161217 No, i numeri primi dovrebbero essere in ordine crescente.

— flawr

23

JavaScript (V8) , 54 byte

Un programma completo che stampa numeri primi cubani per sempre.

for(x=0;;){for(k=N=~(3/4*++x*x);N%++k;);~k||print(-N)}

Provalo online!

^{NB: A meno che non si disponga di carta infinita nella stampante, non tentare di eseguirla nella console del browser , dove print()potrebbe avere un significato diverso.}

JavaScript (ES6), 63 61 60 59 byte

Restituisce l' ennesimo $n$ cubano primo, 1 indicizzato.

f=(n,x)=>(p=k=>N%++k?p(k):n-=!~k)(N=~(3/4*x*x))?f(n,-~x):-N

Provalo online!

Come?

Questo si basa sul fatto che i numeri primi cubani sono numeri primi della forma:

p_{n} = ⌊ \frac{3 n^{2}}{4} ⌋ + 1, n \geq 3

$p_n=\left\lfloor\frac{3n^2}{4}\right\rfloor+1,\;n\ge3$

La formula sopra può essere scritta come:

p_{n} = {\begin{cases} \frac{3 n^{2} + 1}{4} Se n è strano \\ \frac{3 n^{2} + 4}{4} Se n è anche \end{cases}

$p_n=\begin{cases} \dfrac{3n^2+1}{4}\;\text{ if }n\text{ is odd}\\ \dfrac{3n^2+4}{4}\;\text{ if }n\text{ is even} \end{cases}$

o per qualsiasi $y>0$ :

p_{2 y + 1} = \frac{3 (2 y + 1)^{2} + 1}{4} = 3 y^{2} + 3 y + 1

$p_{2y+1}=\dfrac{3(2y+1)^2+1}{4}=3y^2+3y+1$

p_{2 y + 2} = \frac{3 (2 y + 2)^{2} + 4}{4} = 3 y^{2} + 6 y + 4

$p_{2y+2}=\dfrac{3(2y+2)^2+4}{4}=3y^2+6y+4$

che è $\dfrac{x^3-y^3}{x-y}$ per $x=y+1$ e $x=y+2$ rispettivamente.

— Arnauld
fonte

7

05AB1E , 16 12 9 byte

Genera un elenco infinito. Hai
salvato 4 byte con la formula del porto di Arnaulds di Kevin Cruijssen .
Salvati altri 3 byte grazie a Grimy

∞n3*4÷>ʒp

Provalo online!

Spiegazione

∞          # on the list of infinite positive integers
 n3*4÷>    # calculate (3*N^2)//4+1 for each
       ʒp  # and filter to only keep primes

— Emigna
fonte

Hai fatto un refuso nella tua spiegazione: " mettere una copia N^2+3in pila " dovrebbe essere 3*N^2. Inoltre, perché )invece di ¯? Perché è più facile da scrivere? E per qualche motivo ho la sensazione che NnN‚3*¬sO‚possa essere più corto di 1 byte, ma non lo vedo. Una leggera alternativa a byte uguale è Nn3*DN3*+‚. Ma probabilmente vedo solo cose che non ci sono ..;) Bella risposta, quindi +1 da parte mia.

— Kevin Cruijssen,

1

In realtà ho provato a trasferire la mia risposta su 05AB1E, ma ho fallito miseramente. : D

— Arnauld

1

In realtà, generare un elenco infinito è più conveniente: 9 byte con ∞n3 * 4 ÷> ʒp

— Grimmy

1

OK, non sono abituato alle specifiche che si contraddicono. :-)

— WGroleau

6

@WGroleau Suppongo che non hai mai sviluppato software professionalmente allora. Sono più preoccupato quando ottengo specifiche che non si contraddicono.

— MikeTheLiar

7

R , 75 73 byte

n=scan()
while(F<n)F=F+any(!(((T<-T+1)*1:4-1)/3)^.5%%1)*all(T%%(3:T-1))
T

Provalo online!

-2 byte notando che posso rimuovere le parentesi se uso al *posto di &(precedenza diversa).

Emette il nprimo cubano (1 indicizzato).

Usa il fatto (dato in OEIS) che i numeri primi cubani sono della forma $p=1+3n^2$ o $4p=1+3n^2$ per alcuni $n$ , cioè $n=\sqrt{\frac{a\cdot p-1}{3}}$ è un numero intero per $a=1$ o $a=4$ .

Il trucco è che nessun numero primo può essere nella forma $2p=1+3n^2$ o $3p=1+3n^2$ (*), quindi possiamo salvare 2 byte controllando la formula per $a\in\{1, 2, 3, 4\}$ (1:4) invece di $a\in\{1, 4\}$ (c(1,4)).

Versione leggermente non modificata del codice:

# F and T are implicitly initialized at 0 and 1
# F is number of Cuban primes found so far
# T is number currently being tested for being a Cuban prime
n = scan()                       # input
while(F<n){
  T = T+1                        # increment T 
  F = F +                        # increment F if
    (!all(((T*1:4-1)/3)^.5 %% 1) # there is an integer of the form sqrt(((T*a)-1)/3)
     & all(T%%(3:T-1)))          # and T is prime (not divisible by any number between 2 and T-1)
  }
T                                # output T

(*) Nessun numero primo può essere nella forma $3p=1+3n^2$ , altrimenti $1=3(p-n^2)$ sarebbe divisibile per $3$ .

Nessun primo diverso da $p=2$ (che non è un primo cubano) può avere la forma $2p=1+3n^2$ : $n$ dovrebbe essere dispari, cioè $n=2k+1$ . L'espansione dà $2p=4+12k(k+1)$ , quindi $p=2+6k(k+1)$ e $p$ sarebbe pari.

— Robin Ryder
fonte

che dire di evitare un ciclo usando un limite superiore sull'ennesimo numero primo cubano?

— Xi'an

@ Xi'an Ci ho pensato, ma non sono riuscito a trovare un tale limite. Ne hai uno?

— Robin Ryder,

5

Wolfram Language (Mathematica) , 66 65 56 byte

(f=1+⌊3#/4#⌋&;For[n=i=0,i<#,PrimeQ@f@++n&&i++];f@n)&

Provalo online!

J42161217 -1 utilizzando ⌊ ⌋invece diFloor[ ]
attinat
- -1 usando ⌊3#/4#⌋invece di⌊3#^2/4⌋
- -8 per For[n=i=0,i<#,PrimeQ@f@++n&&i++]anzichén=2;i=#;While[i>0,i-=Boole@PrimeQ@f@++n]

— speedstyle
fonte

1

65 byte . Benvenuto in ppcg. Bella prima risposta! +1

— J42161217

Grazie! (In agguato da molto tempo.) Non ho potuto analizzare la tua risposta esistente, quindi ho scritto la mia ed è uscita un po 'più breve. Potrei fare anche uno Python.

— speedstyle

2

56 byte

— attinat

@attinat Ho pensato che la formula di Arnauld funzionasse solo per n> 2, quindi non ho iniziato con 0 - anche se come nel tuo esempio funziona per tutti n (perché inizia 1 1 4 7 13 ... quindi i numeri primi sono 7 13. ..)

— speedstyle

3

Java 8, 94 88 86 84 byte

v->{for(int i=3,n,x;;System.out.print(x<1?++n+" ":""))for(x=n=i*i++*3/4;~n%x--<0;);}

-6 byte usando il primo controllo Java di @SaraJ , quindi assicurati di votarla!
-2 byte grazie a @ OlivierGrégoire . Dal momento che il primo numero che controlliamo è 7, possiamo eliminare il trailing %ndal primo checker di Sara, che deve terminare il loop per n=1.
-2 byte grazie a @ OlivierGrégoire eseguendo il porting della risposta di @Arnauld .

Output delimitato da spazi indefinitamente.

Provalo online.

Spiegazione (della vecchia versione di 86 byte): TODO: aggiornamento della spiegazione

$p_n=\left\lfloor\frac{3n^2}{4}\right\rfloor+1,\;n\ge3$

v->{                     // Method with empty unused parameter and no return-type
  for(int i=3,           //  Loop-integer, starting at 3
          n,x            //  Temp integers
      ;                  //  Loop indefinitely:
      ;                  //    After every iteration:
       System.out.print( //     Print:
        n==x?            //      If `n` equals `x`, which means `n` is a prime:
         n+" "           //       Print `n` with a space delimiter
        :                //      Else:
         ""))            //       Print nothing
    for(n=i*i++*3/4+1,   //   Set `n` to `(3*i^2)//4+1
                         //   (and increase `i` by 1 afterwards with `i++`)
        x=1;             //   Set `x` to 1
        n%++x            //   Loop as long as `n` modulo `x+1`
                         //   (after we've first increased `x` by 1 with `++x`)
             >0;);}      //   is not 0 yet
                         //   (if `n` is equal to `x`, it means it's a prime)

— Kevin Cruijssen
fonte

Non credo sia fattibile, ma un altro modo di trovare i numeri primi cubani utilizza questa formula: v->{for(int n=7,i=3,p,x,d,r=0;;i+=++r%2*3,n+=i,System.out.print(x>1?x+" ":""))for(x=n,d=1;++d<n;x=x%d<1?0:n);}forse qualcuno può usarlo per giocare a golf? Non potrei.

— Olivier Grégoire

1

@ OlivierGrégoire Puoi giocare a golf un po 'di più rimuovendo il non utilizzato ,pe cambiando i+=++r%2*3,n+=iin n+=i+=++r%2*3, ma poi finirò ancora a 106 byte. Utilizzo di Java 11 di String#repeatcon il Primo-regex è di 105 byte: v->{for(int n=7,i=3,r=0;;n+=i+=++r%2*3)if(!"x".repeat(n).matches(".?|(..+?)\\1+"))System.out.println(n);}.

— Kevin Cruijssen

Sì, immaginavo che non fosse molto giocabile nonostante i miei (ora ovvi) errori. Grazie per averci dato un passaggio;)

— Olivier Grégoire

@ OlivierGrégoire Forse anche bello da sapere per te, ma a quanto pare c'è un ciclo di verifica dei primi più breve in Java. Vedi la mia modifica e la risposta di primo controllo di SaraJ.

— Kevin Cruijssen,

Potrei sbagliarmi, ma l'ultimo %nnon è necessario, vero?

— Olivier Grégoire

2

Wolfram Language (Mathematica) , 83 byte

(t=1;While[Length[l=Select[Join@@Array[{(v=3#^2+1)+3#,v}&,t++],PrimeQ]]<#];Sort@l)&

Provalo online!

— J42161217
fonte

2

Gelatina , 12 byte

²×3:4‘
ÇẒ$#Ç

Provalo online!

Basato sul metodo di @ Arnauld . Prende n stdin e restituisce molti numeri primi cubani.

— Nick Kennedy
fonte

1

Wolfram Language (Mathematica) , 83 byte

Questa soluzione produrrà l'ennesimo numero primo cubano con l'ulteriore vantaggio di essere veloce e di ricordare tutti i risultati precedenti nel simbolo f.

(d:=1+3y(c=1+y)+3b c;e:=If[PrimeQ@d,n++;f@n=d];For[n=y=b=0,n<#,e;b=1-b;e,y++];f@#)&

Provalo online!

— Kelly Lowder
fonte

1

Spazio bianco , 180 byte

[S S S T    S N
_Push_2][S N
S _Duplicate][N
S S N
_Create_Label_OUTER_LOOP][S N
N
_Discard_top_stack][S S S T N
_Push_1][T  S S S _Add][S N
S _Duplicate][S N
S _Duplicate][T S S N
_Multiply][S S S T  T   N
_Push_3][T  S S N
_Multiply][S S S T  S S N
_Push_4][T  S T S _Integer_divide][S S S T  N
_Push_1][T  S S S _Add][S S S T N
_Push_1][S N
S _Duplicate_1][N
S S S N
_Create_Label_INNER_LOOP][S N
N
_Discard_top_stack][S S S T N
_Push_1][T  S S S _Add][S N
S _Duplicate][S N
S _Duplicate][S T   S S T   T   N
_Copy_0-based_3rd][T    S S T   _Subtract][N
T   S T N
_Jump_to_Label_PRINT_if_0][S T  S S T   S N
_Copy_0-based_2nd][S N
T   _Swap_top_two][T    S T T   _Modulo][S N
S _Duplicate][N
T   S S S N
_Jump_to_Label_FALSE_if_0][N
S N
S N
_Jump_to_Label_INNER_LOOP][N
S S T   N
_Create_Label_PRINT][T  N
S T _Print_as_integer][S S S T  S T S N
_Push_10_(newline)][T   N
S S _Print_as_character][S N
S _Duplicate][N
S S S S N
_Create_Label_FALSE][S N
N
_Discard_top_stack][S N
N
_Discard_top_stack][N
S N
N
_Jump_to_Label_OUTER_LOOP]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Output delimitato da newline a tempo indeterminato.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Spiegazione in pseudo-codice:

$p_n=\left\lfloor\frac{3n^2}{4}\right\rfloor+1,\;n\ge3$

Integer i = 2
Start OUTER_LOOP:
  i = i + 1
  Integer n = i*i*3//4+1
  Integer x = 1
  Start INNER_LOOP:
    x = x + 1
    If(x == n):
      Call function PRINT
    If(n % x == 0):
      Go to next iteration of OUTER_LOOP
    Go to next iteration of INNER_LOOP

function PRINT:
  Print integer n
  Print character '\n'
  Go to next iteration of OUTER_LOOP

— Kevin Cruijssen
fonte

1

Python 3 , 110 108 102 byte

Metodo simile alla mia risposta Mathematica (cioè isPrime(1+⌊¾n²⌋) else n++) usando questo golf checker primo e restituendo un generatore infinito anonimo

from itertools import*
(x for x in map(lambda n:1+3*n**2//4,count(2)) if all(x%j for j in range(2,x)))

Provalo online!

mypetlion -2 perché probabilmente i generatori anonimi sono più permessi di quelli nominati
-6 a partire countda 2 _{+1 in} modo che il controllo and x>1a prima che ho preso in prestito non sia necessario _-7

— speedstyle
fonte

La risposta che va in una variabile di solito non è considerata una forma valida di "output". Potresti rielaborare la tua risposta in modo che il risultato venga emesso su stdout o restituito da una funzione?

— mypetlion

1

poiché sono consentite funzioni anonime e la sfida consente esplicitamente un generatore infinito, l'ho rimosso g=. L'avevo incluso solo in primo luogo perché consentiva una rapida visualizzazione su TIO con print(next(g) for i in range(52)).

— speedstyle

1

Japt , 14 13 byte

Adattato dalla formula di Arnauld . 1-indicizzati.

@µXj}f@Ò(X²*¾

Provalo

1 byte salvato grazie a EmbodimentOfIgnorance.

— ispido
fonte

13 byte? Non testato a fondo però.

— Incarnazione dell'ignoranza

Grazie, @EmbodimentofIgnorance. Ci avevo provato ma non funzionava; risulta che avevo dimenticato il (.

— Shaggy,

1

Racchetta , 124 byte

(require math)(define(f n[i 3])(let([t(+(exact-floor(* 3/4 i i))1)][k(+ 1 i)])(if(prime? t)(if(= 0 n)t(f(- n 1)k))(f n k))))

Provalo online!

Restituisce l'n-esimo primo cubano, indicizzato 0.

Utilizza la formula della risposta JavaScript di @ Arnauld

— Galen Ivanov
fonte

1

Python 3 , 83 byte

stampa i numeri primi cubani per sempre.

P=k=1
while 1:P*=k*k;x=k;k+=1;P%k>0==((x/3)**.5%1)*((x/3+.25)**.5%1-.5)and print(k)

Provalo online!

$x = 1+y$ $x=2+y$

p = \frac{(1 + y)^{3} - y^{3}}{(1 + y) - y} = 1 + 3 y + 3 y^{2} \Leftrightarrow y = - \frac{1}{2} \pm \sqrt{\frac{1}{4} + \frac{p - 1}{3}}

$p=\frac{(1+y)^3-y^3}{(1+y)-y} = 1 + 3y +3y^2 \Leftrightarrow y = -\frac{1}{2}\pm\sqrt{\frac{1}{4}+\frac{p-1}{3}}$

p = \frac{(2 + y)^{3} - y^{3}}{(1 + y) - y} = 4 + 6 y + 3 y^{2} \Leftrightarrow y = - 1 \pm \sqrt{\frac{p - 1}{3}}

$p=\frac{(2+y)^3-y^3}{(1+y)-y} = 4 + 6y +3y^2 \Leftrightarrow y = -1 \pm\sqrt{\frac{p-1}{3}}$

y

$y$

\pm

$\pm$

- 1

$-1$

— OVS
fonte

1

Perl 6 , 33 31 byte

-2 byte grazie a Grimy

{grep &is-prime,1+|¾*$++²xx*}

Provalo online!

Blocco di codice anonimo che restituisce un elenco infinito di pigri numeri primi cubani. Questo usa la formula di Arnauld per generare possibili numeri primi cubani, quindi &is-primeper filtrarli.

Spiegazione:

{                           }  # Anonymous code block
 grep &is-prime,               # Filter the primes from
                         xx*   # The infinite list
                   ¾*          # Of three quarters
                     $++²      # Of an increasing number squared
                1+|            # Add one by ORing with 1

— Jo King
fonte

1

1+0+|può essere solo1+|

— Grimmy

0

Pari / GP , 51 byte

Usando la formula di Arnauld .

n->a=0;for(i=1,n,until(isprime(p=3*a^2\4+1),a++));p

Provalo online!

— alephalpha
fonte

0

APL (NARS), 98 caratteri, 196 byte

r←h w;y;c;v
r←c←y←0⋄→4
→3×⍳∼0πv←1+3×y×1+y+←1⋄r←v⋄→0×⍳w≤c+←1
→2×⍳∼0πv+←3×y+1⋄c+←1⋄r←v
→2×⍳w>c

rientrato:

r←h w;y;c;v
r←c←y←0⋄→4
    →3×⍳∼0πv←1+3×y×1+y+←1⋄r←v⋄→0×⍳w≤c+←1
    →2×⍳∼0πv+←3×y+1⋄c+←1⋄r←v
    →2×⍳w>c

test:

  h ¨1..20
7 13 19 37 61 109 127 193 271 331 397 433 547 631 769 919 1201 1453 1657 1801 
  h 1000
25789873
  h 10000
4765143511

si basa su: se y in N, un possibile primo cubano è

S1=1+3y(y+1)

il prossimo possibile primo cubano sarà

S2=3(y+1)+S1

— RosLuP
fonte