Leia isso se estiver confuso.

Desafio:

O objetivo deste código-golfe é baseado no número 8675309...

Seu objetivo é imprimir todos os números primos de 2 a 8675309, começando com o número 2 e depois pulando 8 números primos, depois pulando 6 e depois 7, etc. Em essência, pule vários números primos determinados pelo próximo número em a sequência 8675309. Passando de bicicleta para 8 quando chegar a 9.

Resultado:

2
29

(saltou 8 para chegar ao 10º prime)

59

(saltou 6 para chegar ao 17º prime)

97

(saltou 7 para chegar ao 25º prime)

Exemplo: (pseudo-código semelhante ao PHP, em que $primeuma matriz contém todos os números primos).

$tn=1;
$c=1;
$na=array(8,6,7,5,3,0,9);
l:
output($prime[$tn]);
if ($prime[$tn]>=8675309) {exit(8675309)};
$c+=1;
if ($c>=8) {$c=1};
$tn+=$na[$c];
goto l;

Quando digo pular 8 números primos, quero passar do número 1 primo para o número 10 primo (pulando 8 no meio).

Cada número deve estar em uma nova linha.

Quando você chegar ao 0no 8675309, apenas apenas imprimir o próximo número primo, sem pular nenhuma.

Isso é código-golfe, e o código mais curto (em bytes) vence.

Mathematica 67 bytes

Mas não atinge 8675309 - não tenho certeza da intenção do OP sobre isso.

Column@FoldList[NextPrime,2,Flatten@Array[{9,7,8,6,4,1,10}&,12937]]

Maravilha , 47 bytes

P\tk582161P;(_>@(os tk1P;P\dp +1#0P))cyc8675309

Oh nossa, isso fica cada vez mais lento com o passar do tempo ...

Explicação

P\tk582161P;

Pega 582161 (quantidade de números primos <= 8675309) da lista de números primos infinitos Pe redefine o resultado como P.

(_>@(...))cyc8675309

Alterna infinitamente os dígitos de 8675309 e executa um takewhile na lista resultante.

os tk1P;P\dp +1#0P

Envie o primeiro item P, solte cycle item + 1elementos de P e redecare o resultado como P. Esta operação Ptambém atua como um valor de verdade por um período de tempo; se a lista estiver vazia / falsa (o que significa que alcançamos 8675309), paramos de retirar da lista ciclada.

Implementação mais rápida (para teste)

P\tk582161P;(_>@(os tk1P;P\dp +1#0P;#0))cyc8675309

Ainda muito lento, mas notavelmente mais rápido.

Geléia , 23 29 24 bytes

+6 bytes para um patch temporário para atender ao requisito de imprimir 8675309.
-5 bytes movendo-se para uma abordagem mais golfista, mas mais lenta, para resolver isso.

“⁹Ṁ:’©D‘ẋ“2Ṿ’R®ÆR¤ṁḢ€;®Y

Agora, é muito lento para executar no TryItOnline, mas é executado localmente em alguns minutos, produzindo os números mostrados abaixo com os feeds de linha no meio (número de primos ignorados mostrado abaixo entre parênteses):

2, 29, 59, 97, 127, 149, 151, 199, 257, 293, 349, 383, 409, 419, ...
 (8) (6) (7) (5)  (3)  (0)  (9)  (8)  (6)  (7)  (5)  (3)  (0)

..., 8674537, 8674727, 8674867, 8675003, 8675053, 8675113, 8675137, 8675309
            (8)      (6)      (7)      (5)      (3)      (0)      (4)*

* o último é apenas um salto efetivo de 4, pois é simplesmente anexado à lista.

Clique aqui para obter uma versão usando 3659 em vez de 8675309, que possui 19 conjuntos de quatro pulos (em vez de 12937 conjuntos de 7) e anexa 3659 (que é um pulo efetivo de 6).

Quão?

“⁹Ṁ:’©D‘ẋ“2Ṿ’R®ÆR¤ṁḢ€;®Y - Main link: no arguments
“⁹Ṁ:’                    - base 250 number: 8675309
     ©                   - save in register
      D                  - convert to a decimal list: [8, 6, 7, 5, 3, 0, 9]
       ‘                 - increment: [9,7,8,6,4,1,10]
         “2Ṿ’            - base 250 number: 12937
        ẋ                - repeat: [9,7,8,6,4,1,10,9,7,8,6,4,1,10, ... ,9,7,8,6,4,1,10]
             R           - range (vectorises) [[1,2,3,4,5,6,7,8,9],[1,2,3,4,5,6,7], ...]
                 ¤       - nilad followed by link(s) as a nilad
              ®          - retrieve value from register: 8675309
               ÆR        - prime range [2,3,5,7, ... ,8675309]
                  ṁ      - mould the primes like the range list:
                               [[2,3,5,7,11,13,17,19,23],[29,31,37,41,43,47,53],...]
                   Ḣ€    - head €ach: [2,29,59,97,127,149,151,199, ..., 8675137]
                      ®  - retrieve value from register: 8675309
                     ;   - concatenate: [2,29,59,97,127,149,151,199, ..., 8675137, 8675309]
                       Y - join with line feeds
                         - implicit print

Ruby, 121 bytes

Trailing newline no final do arquivo desnecessário e sem pontuação.

P=[]
(2..8675309).map{|c|s=1;P.map{|p|s*=c%p};P<<c if s!=0}
S=[9,7,8,6,4,1,10]*P[-1]
while y=P[0]
p y
P.shift S.shift
end

Explicação: Pé uma matriz de números primos. cé um candidato a candidato; sé o produto do módulo de resíduos a cada primo menor; se qualquer resíduo desse tipo for zero (indicando que cé composto), storna-se (e permanece) zero.

O gerador de números primos está lento. Levará muito tempo para executar. O teste foi realizado substituindo uma Pmatriz gerada por meios mais eficientes (especificamente, curto-circuito na divisão par, e também ajuda muito a interromper o teste na raiz quadrada).

Haskell, 122 bytes

Pode ser o que é solicitado:

s(a:b)=a:s[c|c<-b,c`mod`a>0]
f(a:b)(s:t)=a:f(drop s b)t
main=mapM print$takeWhile(<8675310)$f(s[2..])$cycle[8,6,7,5,3,0,9]

Eu poderia economizar alguns bytes pré-computando quantos números são necessários e substituindo takeWhilepor take. Isso também permitiria se adaptar a qualquer decisão sobre o último número a ser produzido. Ele já imprimiu números de até 600000 usando muito pouca memória no meu teste, então acho que pode ir até o fim.

Haskell, 109 bytes

(p:z)%(x:r)=print p>>(drop x z)%r
p%x=pure()
[n|n<-[2..8675309],all((>0).mod n)[2..n-1]]%cycle[8,6,7,5,3,0,9]

Experimente online! (truncado 8675309para 8675, caso contrário, o tempo limite será excedido ) Experimente on-line )

Uso:

* Principal> [n | n0) .mod n) [2..n-1]]% ciclo [8,6,7,5,3,0,9]
2
29
59.
97
127
149
151
199
257
293
349
383
409
419
467
541
587
631
661
691
701
769
829
881
941
983
1013
...

Perl 6 ,  65 73  67 bytes

$_=8675309;.[0].put for (2..$_).grep(*.is-prime).rotor(1 X+.comb)

(falha ao imprimir 8675137 devido a falta :partial)

$_=8675309;.[0].put for ^$_ .grep(*.is-prime).rotor((1 X+.comb),:partial)

$_=8675309;.[0].put for ^($_+33) .grep(*.is-prime).rotor(1 X+.comb)

Ao mudar o final do intervalo, o :partialpode ser removido.

Experimente (5 limite de segunda adicionado) Veja-o terminar

O exemplo inicial foi cronometrado em 52 minutos e 41.464 segundos.

Expandido:

$_ = 8675309;

  .[0]              # get the first value out of inner list
  .put              # print with trailing newline

for                 # for every one of the following

  ^($_+33)          # the Range ( add 33 so that ｢.rotor｣ doesn't need ｢:partial｣ )
  .grep(*.is-prime) # the primes
  .rotor(
    1 X+ .comb      # (1 X+ (8,6,7,5,3,0,9)) eqv (9,7,8,6,4,1,10)
  )

O resultado da rotorchamada é a seguinte sequência

(
 (  2   3   5   7  11  13  17  19  23)     #  9 (8)
 ( 29  31  37  41  43  47  53)             #  7 (6)
 ( 59  61  67  71  73  79  83  89)         #  8 (7)
 ( 97 101 103 107 109 113)                 #  6 (5)
 (127 131 137 139)                         #  4 (3)
 (149)                                     #  1 (0)
 (151 157 163 167 173 179 181 191 193 197) # 10 (9)

 (199 211 223 227 229 233 239 241 251)     #  9 (8)
 (257 263 269 271 277 281 283)             #  7 (6)
 (293 307 311 313 317 331 337 347)         #  8 (7)
 (349 353 359 367 373 379)                 #  6 (5)
 (383 389 397 401)                         #  4 (3)
 (409)                                     #  1 (0)
 (419 421 431 433 439 443 449 457 461 463) # 10 (9)

 ...
)

Befunge, 136 bytes

p2>:1>1+:"~"%55p:"~"/45p:*\`!v
1+^<+ 1<_:#!v#%+g55@#*"~"g54:_\:!#v_1-\
p00%7+1: ,+64g00.:_^#!`***"'(CS":$<^0-"/"g4
>5g#*^#"~"g5<
8675309

Experimente online! , mas esteja ciente de que o tempo limite expirará muito antes de chegar ao fim. Uma versão compilada na minha máquina local é concluída em menos de 10 segundos.

Explicação

Para testar a primalidade, iteramos no intervalo de 2 a sqrt ( n ) e verificamos se n é um múltiplo de algum desses valores - se não, é primo. Esse processo é complicado pelo fato de que o valor iterado precisa ser armazenado em uma "variável" temporária e, como as células de memória do Befunge são limitadas em tamanho, esse armazenamento deve ser dividido em duas células. Para lidar com os primos ignorados, usamos uma "tabela" de pesquisa (que você pode ver na linha 5) para acompanhar os diferentes intervalos que precisam ser ignorados.

Não vou fazer uma análise detalhada do código, porque há bastante código de intercalação com comandos compartilhados em diferentes caminhos de código para economizar espaço. Isso torna as coisas bastante difíceis de seguir e eu não acho que seria particularmente interessante para alguém que não estava familiarizado com o Befunge.

Saída de amostra

2
29
59
97
127
149
151
199
...
8674397
8674537
8674727
8674867
8675003
8675053
8675113
8675137

Bash (+ coreutils), 98, 94 bytes

EDITAR% S:

• Filtro de linha otimizado um pouco, -4 bytes

Golfe

seq 8675309|factor|grep -oP "^.*(?=: \S*$)"|sed 1b\;`printf '%d~45b;' {10,17,25,31,35,36,46}`d

Teste

>seq 8675309|factor|grep -oP "^.*(?=: \S*$)"|sed 1b\;`printf '%d~45b;' {10,17,25,31,35,36,46}`d| head -25
2
29
59
97
127
149
151
199
257
293
349
383
409
419
467
541
587
631
661
691
701
769
829
881
941

Experimente Online! (limitado a N <1000, para acelerar a execução)

A versão completa leva cerca de 15 segundos para ser concluída na minha máquina.