O Postulado de Bertrand afirma que, para todo número inteiro n ≥ 1, há pelo menos um primo p tal que n <p ≤ 2n . Para verificar esse teorema para n <4000 , não precisamos verificar 4000 casos: O truque Landau diz que é suficiente verificar se

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

são todos primos. Como cada um desses números é menor que o dobro do predecessor, cada intervalo {y: n <y ≤ 2n} contém pelo menos um desses números primos.

Essa sequência de números é o Bertrand Primes (OEIS A006992) e eles são definidos da seguinte maneira:

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

Desafio

Implemente essa sequência. Você pode escrever

• uma função ou programa que deu alguns retornos n a (n) (0 ou 1 indexado),
• uma função ou programa que fornece n retorna as primeiras entradas n (ou n-1 ou n + 1 ) dessa sequência,
• uma lista infinita ou fluxo ou gerador ou equivalente semelhante no seu idioma.

Oitava , 32 bytes

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

Mantém a impressão dos valores indefinidamente (cada valor é precedido por k =).

Experimente online!

Oitava , 42 bytes

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

Toma n como entrada e gera os n primeiros valores (cada valor é precedido por k =).

Experimente online!

Oitava , 51 bytes

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

Semelhante à resposta MATL de Luis Mendo . Pega n como entrada e gera a (n) (indexado 1).

Experimente online!

Oitava , 60 bytes

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

Pega n como entrada e gera a (n) (indexado 1).

Experimente online!

J , 11 bytes

_4&(p:+:)2:

Experimente online!

Indexado a 0.

_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 bytes

Economizou um byte graças a Martin Ender.

Indexado a 0.

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

Experimente online!

05AB1E , 14 7 6 bytes

$F·.ØØ

Experimente online!

Resposta indexada em 1 (a menos que 0 deva gerar 1), explicação:

$       # 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.

É indexado 1 porque todas as iterações têm uma iteração 'fictícia' n=1.

Haskell , 50 bytes

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

Experimente online!

Produz uma lista infinita.

Haskell , 40 bytes?

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

Experimente online!

Isso funciona se os números primos de Bertrand não contiverem pseudo-tempos de Fermat para 2 .

Gelatina , 6 bytes

2ḤÆp$¡

Experimente online!

Indexado a 0.

Explicação

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

MATL , 9 bytes

1i:"EZq0)

Entradas n , saídas a ( n ), indexadas em 1.

Experimente online!

Explicação

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 bytes

ü☼┌τ,æ▒ìn(

Executar casos de teste

Esse problema expôs um bug na implementação de stax :p, que é uma instrução que obtém o maior número primo menor que sua entrada. Se funcionasse corretamente, haveria uma solução de 5 6 bytes. Mas, infelizmente, não, e não há. Como criador do idioma, eu o corrigirei, mas parece meio barato corrigi-lo e usá-lo depois que o problema foi postado.

De qualquer forma, aqui está a representação ascii correspondente do programa acima.

ODH{|p}{vgs

É uma implementação relativamente direta da declaração do problema. A única coisa possivelmente interessante sobre isso é o uso da gsforma geradora. Geradores são uma família de construções que combinam uma condição inicial, uma transformação e um filtro, para produzir um ou mais valores satisfatórios. Nesse caso, é usado no lugar da :pinstrução quebrada .

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.

Edit: aqui está a solução de 6 bytes, mas requer uma correção de bug que só foi aplicada após o lançamento deste desafio.

Python 2 , 63 bytes

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

Experimente online!

Imprime para sempre.

Usa o gerador principal de Theorem de Wilson, mesmo que a geração de primos adiante seja desajeitada para esse problema. Rastreia o maior primo atual visto re o limite de duplicaçãom .

Dois bytes são salvos, P*=kmais do P*=k*kque o habitual, pois o único efeito é afirmar que 4 é primo e a sequência de duplicação erra.

CJam (15 bytes)

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

Demonstração online . Observe que esse índice é 0.

Uma abordagem mais eficiente seria pesquisar para trás, mas isso exige um caractere a mais porque não pode usar implícito ,(intervalo):

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

Japt , 16 14 13 12 bytes

Duas soluções pelo preço de uma, ambas indexadas em 1.

Enésimo termo

Finalmente, um desafio que posso escrever uma solução funcional para usar F.g().

_ôZ fj Ì}g°U

Tente

                 :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

Primeiros Termos N

ÆV=ôV fj ̪2

Tente

                 :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 bytes

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

Experimente online!

Python 2 , 64 bytes

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

Experimente online! Imprime a sequência indefinidamente

Haskell , 58 bytes

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

Experimente online!

Python 2 , 68 bytes

Imprime a sequência indefinidamente (você precisa clicar em "Executar" na segunda vez para interromper a execução).

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

Experimente online!

Python 3 , 90 bytes

Retorna o ^enésimo termo.

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

Experimente online!

C (gcc) , 97 87 86 80 79 bytes

• Salva dez bytes inserindo uma função de verificação de não primalidade Pno loop principal.
• Salvou um byte movendo a printfchamada.
• Salva seis bytes retornando o i -ésima entrada de sequência (indexada 0) em vez de gerar um fluxo interminável.
• Guardou um byte graças ao 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;}

Experimente online!

Anexo , 38 bytes

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

Experimente online!

Baseado em 0; retorna o nth Bertrand prime.

No momento, não há um builtin para encontrar os números primos anteriores / próximos, então eu uso o Seriesbuiltin para calcular todos os números primos até 2*$[_-1]. Essa última expressão usa recursão implícita (vinculada a $) para definir facilmente a relação de recorrência. A condição if é usada para determinar uma condição base.

Perl 6 , 35 bytes

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

Experimente online!

Essa expressão é uma lista infinita de números primos de Bertrand.

Retina , 39 bytes

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

*\`_

Experimente online! Explicação:

.K`_

Comece com 1.

"$+"{`

Repita o loop usando a entrada como a contagem do loop.

_
__

Dobrar o valor.

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

Encontre o primo mais alto menor que o valor.

*\`_

Imprima isso.

Ruby , 51 + 7 (-rprime) = 58 bytes

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

Experimente online!

Um lamba aceitando ne retornando o nthBertrand prime, 0-indexado. Não há muito aqui, mas deixe-me desenterrar assim mesmo:

->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
}

Ruby , 48 + 7 = 55 bytes

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

Experimente online!

Por diversão, aqui está uma solução de loop infinito. Imprime conforme necessário e requer uma interrupção. Dependendo exatamente de quando você interrompe, você pode ou não ver a saída. Ungolfed:

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

APL (Dyalog Extended) , 12 bytes

Recebe a entrada do usuário como N, retorna o enésimo elemento da sequência (indexado 0).

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

Experimente online!

Explicação:

{¯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 bytes

Dadas nsaídasa(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

Experimente online!

Ainda estou trabalhando em "Dada a saída n a (1), a (2) ... a (n)". Eu pensei que poderia apenas modificar esse código um pouco, mas parece mais difícil do que isso.