Il postulato di Bertrand afferma che per ogni numero intero n ≥ 1 esiste almeno un primo p tale che n <p ≤ 2n . Per verificare questo teorema per n <4000 non dobbiamo controllare 4000 casi: il trucco di Landau dice che è sufficiente verificare che

2, 3, 5, 7, 13, 23, 43, 83, 163, 317, 631, 1259, 2503, 5003

sono tutti primi. Poiché ciascuno di questi numeri è meno del doppio del suo predecessore, ogni intervallo {y: n <y ≤ 2n} contiene almeno uno di quei numeri primi.

Questa sequenza di numeri sono i Bertrand Primes (OEIS A006992) e sono definiti come segue:

a(1) = 2
a(n) = largest prime below 2a(n-1)

Sfida

Implementa questa sequenza. Puoi scrivere

• una funzione o un programma che ha dato alcuni n restituisce a (n) (0 o 1 indicizzato),
• una funzione o un programma che ha dato alcuni n restituisce le prime n (o n-1 o n + 1 ) voci di questa sequenza,
• un elenco infinito o stream o generatore o equivalente simile nella tua lingua.

Ottava , 32 byte

k=2
do k=primes(k+k)(end)until 0

Continua a stampare i valori indefinitamente (ogni valore è preceduto da k =).

Provalo online!

Ottava , 42 byte

k=2
for i=2:input('')k=primes(k+k)(end)end

Prende n come input e genera i primi n valori (ogni valore è preceduto da k =).

Provalo online!

Ottava , 51 byte

k=2;for i=2:input('')k=primes(k+k)(end);end
disp(k)

Simile alla risposta MATL di Luis Mendo . Prende n come input e genera a (n) (1 indicizzato).

Provalo online!

Ottava , 60 byte

k=2;for i=2:input('')k*=2;while~isprime(--k)
end
end
disp(k)

Prende n come input e genera a (n) (1 indicizzato).

Provalo online!

J , 11 byte

_4&(p:+:)2:

Provalo online!

0-indicizzati.

_4&(p:+:)2:  Input: integer n
         2:  Constant 2
_4&(    )    Repeat n times
      +:       Double
_4  p:         Find the largest prime less than the double

Wolfram Language (Mathematica) , 27 byte

Salvato un byte grazie a Martin Ender.

0-indicizzati.

Nest[-NextPrime[-2#]&,2,#]&

Provalo online!

05AB1E , 14 7 6 byte

$F·.ØØ

Provalo online!

1 risposta indicizzata (a meno che 0 non debba produrre 1), spiegazione:

$       # Push 1 and input (n)...
 F      # n-times do... 
  ·     # Double the current prime (first iteration is 1*2=2).
   .ØØ  # Find prime slightly less than double the current prime.

È 1 indicizzato perché tutte le iterazioni hanno un'iterazione 'fittizia' con n=1.

Haskell , 50 byte

f p|sum(gcd p<$>[1..p-1])<p=p:f(2*p)|1>0=f$p-1
f 2

Provalo online!

Emette un elenco infinito.

Haskell , 40 byte?

f p|mod(2^p-2)p<1=p:f(2*p)|1>0=f$p-1
f 2

Provalo online!

Questo funziona se i numeri primi di Bertrand non contengono pseudoprimi di Fermat per 2 .

Gelatina , 6 byte

2ḤÆp$¡

Provalo online!

0-indicizzati.

Spiegazione

2ḤÆp$¡  Main link. Input: n
2       Constant 2
    $¡  Repeat n times
 Ḥ        Double
  Æp      Find the largest prime less than the double

MATL , 9 byte

1i:"EZq0)

Ingressi n , uscite a ( n ), 1 indicizzato.

Provalo online!

Spiegazione

1       % Push 1
i       % Push input n
:"      % Do the following that many times
  E     %   Multiply by 2
  Zq    %   Primes up to that
  0)    %   Get last entry
        % End (implicit). Display (implicit)

Stax , 10 byte

ü☼┌τ,æ▒ìn(

Esegui casi di test

Questo problema ha messo in luce un bug nell'implementazione di stax :p, che è un'istruzione che ottiene il massimo primo meno del suo input. Se funzionasse correttamente, ci sarebbe una soluzione da 5 6 byte. Ma ahimè, non lo è, e non c'è. Come creatore del linguaggio, lo risolverò, ma sembra un po 'economico ripararlo e usarlo dopo che il problema è stato pubblicato.

Comunque, ecco la corrispondente rappresentazione ASCII del programma sopra.

ODH{|p}{vgs

È un'implementazione relativamente semplice della dichiarazione del problema. L'unica cosa forse interessante al riguardo è l'uso del gsmodulo generatore. I generatori sono una famiglia di costruzioni che combinano una condizione iniziale, una trasformazione e un filtro per produrre uno o più valori soddisfacenti. In questo caso, viene utilizzato al posto :pdell'istruzione rotta .

O               Push integer 1 underneath the input number.
 D              Pop the input and repeat the rest of the program that many times.
  H             Double number.
   {|p}         Predicate block: is prime?
       {vgs     Decrement until the predicate is satisfied.
                Output is implicitly printed.

Modifica: ecco la soluzione a 6 byte, ma richiede una correzione di bug che è stata applicata solo dopo che questa sfida è stata pubblicata.

Python 2 , 63 byte

r=m=k=P=2
while k:
 P*=k;k+=1
 if k>m:print r;m=r*2
 if P%k:r=k

Provalo online!

Stampa per sempre.

Utilizza il generatore di teoremi del Wilson Theorem anche se la generazione di numeri primi in avanti è ingombrante per questo problema. Tiene traccia dell'attuale più grande primo visto re del limite del raddoppio m.

Due byte vengono salvati facendo P*=k piuttosto che P*=k*kcome al solito, poiché l'unico effetto è affermare che 4 è primo e la sequenza di raddoppio lo manca.

CJam (15 byte)

2{2*{mp},W=}qi*

Demo online . Si noti che questo è indicizzato 0.

Un approccio più efficiente sarebbe cercare all'indietro, ma ciò richiede un carattere in più perché non può usare implicito ,(intervallo):

2{2*,W%{mp}=}qi*

Japt , 16 anni 14 13 12 byte

Due soluzioni al prezzo di una, entrambe indicizzate.

Nth Term

Infine, una sfida che posso scrivere una soluzione funzionante per l'utilizzo F.g().

_ôZ fj Ì}g°U

Provalo

                 :Implicit input of integer U
_       }g       :Starting with the array [0,1] take the last element (Z),
                 :pass it through the following function
                 :and push the returned value to the array
 ôZ              :  Range [Z,Z+Z]
    fj           :  Filter primes
       Ì         :  Get the last item
          °U     :Repeat that process U+1 times and return the last element in the array

Primi N Termini

ÆV=ôV fj ̪2

Provalo

                 :Implicit input of integer U
                 :Also makes use of variable V, which defaults to 0
Æ                :Create range [0,U) and pass each through a function
  ôV             :  Range [V,V+V]
     fj          :  Filter primes
        Ì        :  Get the last item
         ª2      :  Logical OR with 2, because the above will return undefined on the first iteration
 V=              :  Assign the result of the above to V

Pari / GP , 34 byte

a(n)=if(n<2,2,precprime(2*a(n-1)))

Provalo online!

Python 2 , 64 byte

n=2
while 1:
 if all(n%i for i in range(2,n)):print n;n*=2
 n-=1

Provalo online! Stampa la sequenza indefinitamente

Haskell , 58 byte

a 1=2
a n=last[p|p<-[2..2*a(n-1)],all((>0).mod p)[2..p-1]]

Provalo online!

Python 2 , 68 byte

Stampa la sequenza indefinitamente (è necessario fare clic su "Esegui" la seconda volta per interrompere l'esecuzione).

k=2
while 1:
 print k;k+=k
 while any(k%u<1for u in range(2,k)):k-=1

Provalo online!

Python 3 , 90 byte

Restituisce l' ^ennesimo termine.

f=lambda n,i=1,p=1:n*[0]and p%i*[i]+f(n-1,i+1,p*i*i) 
a=lambda n:n and f(2*a(n-1))[-1]or 1

Provalo online!

C (gcc) , 97 87 86 80 79 byte

• Ho salvato dieci byte incorporando una funzione di controllo di non primalità P nel ciclo principale.
• Salvato un byte spostando il printf chiamata.
• Hai salvato sei byte restituendo la ivoce di sequenza -th (indicizzata 0) invece di emettere un flusso infinito.
• Salvataggio di un byte grazie a ceilingcat .

f(p,r,i,m,e){for(r=2;p--;)for(e=0,i=r+r;e=m=!e;r=i--)for(;i-++m;e=e&&i%m);p=r;}

Provalo online!

Attache , 38 byte

{If[_,Last[Series[Prime,2*$[_-1]]],2]}

Provalo online!

0-based; restituisce il nprimo Bertrand.

Al momento non esiste un builtin per trovare i numeri primi precedenti / successivi, quindi uso il file Seriesincorporato per calcolare tutti i numeri primi fino a 2*$[_-1]. Quest'ultima espressione usa la ricorsione implicita (legata a $) per definire facilmente la relazione di ricorrenza. La condizione if viene utilizzata per determinare una condizione di base.

Perl 6 , 35 byte

2,{(2*$_,*-1...&is-prime).tail}...*

Provalo online!

Questa espressione è un elenco infinito di numeri primi di Bertrand.

Retina , 39 byte

.K`_
"$+"{`_
__
+`^(?=(..+)\1+$).

*\`_

Provalo online! Spiegazione:

.K`_

Inizia con 1.

"$+"{`

Ripeti il ​​loop usando l'ingresso come numero di loop.

_
__

Raddoppia il valore.

+`^(?=(..+)\1+$).

Trova il primo più alto in meno del valore.

*\`_

Stampalo.

Rubino , 51 + 7 (-rprime) = 58 byte

->n{x=2
n.times{x=(x..2*x).select(&:prime?)[-1]}
x}

Provalo online!

Una lamba che accetta ne restituisce il nthprimo di Bertrand, indicizzato 0. Non c'è molto qui, ma lasciami deselezionarlo comunque:

->n{
  x=2                       # With a starting value of 2
  n.times{                  # Repeat n times:
    x=(x..2*x)              # Take the range from x to its double
      .select(&:prime?)[-1] # Filter to only primes, and take the last
  }
  x                         # Return
}

Rubino , 48 + 7 = 55 byte

x=2
loop{puts x
x*=2
loop{(x-=1).prime?&&break}}

Provalo online!

Per divertimento, ecco una soluzione a ciclo infinito. Stampa mentre procede e richiede un interrupt. A seconda di esattamente quando si interrompe, è possibile che l'output venga visualizzato o meno. Ungolfed:

x=2
loop{
  puts x
  x*=2
  loop{
    (x-=1).prime? && break
  }
}

APL (Dyalog Extended) , 12 byte

Prende input dall'utente come N, restituisce l'ennesimo elemento della sequenza (indicizzato 0).

{¯4⍭2×⍵}⍣⎕⊢2

Provalo online!

Spiegazione:

{¯4⍭2×⍵}⍣⎕⊢2 ⍝ Full program
          ⎕   ⍝ Get input from user - call it 'N'
         ⍣ ⊢2 ⍝ Repeat the left function N times, beginning with 2
    2×⍵       ⍝ Double the function input
 ¯4⍭          ⍝ Find the largest prime less than above

R , 87 byte

trovati nuscitea(n)

j=scan();n=2;while(j-1){for(i in (n+1):(2*n)){n=ifelse(any(i%%2:(i-1)<1),n,i)};j=j-1};n

Provalo online!

Sto ancora lavorando su "Dato n output a (1), a (2) ... a (n)". Ho pensato di poter modificare leggermente questo codice, ma sembra più difficile di così.