Lee esto si estás confundido.

Desafío:

El objetivo de este código de golf se basa en el número 8675309...

Su objetivo es imprimir cada número primo del 2 al 8675309, comenzando con el número 2 y luego omitiendo 8 números primos, luego omitiendo 6, luego omitiendo 7, etc. En esencia, omita un número de primos determinados por el siguiente número en La secuencia 8675309. Ciclismo a 8 una vez que llega a 9.

Salida:

2
29

(se saltó 8 para llegar al décimo primer)

59

(se saltó 6 para llegar a la prima 17)

97

(se saltó 7 para llegar al 25 ° prime)

Ejemplo: (pseudocódigo similar a PHP donde $primees una matriz que contiene todos los 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;

Cuando digo omitir 8 primos, me refiero a pasar del primo n. ° 1 al primo n. ° 10 (omitiendo el 8 en el medio).

Cada número debe estar en una nueva línea.

Al llegar a la 0en 8675309, justo acaba de imprimir el siguiente número primo, sin saltarse ninguna.

Este es el código de golf, por lo que gana el código más corto (en bytes).

Mathematica 67 bytes

Sin embargo, no alcanza 8675309, no estoy seguro de la intención de OP sobre esto.

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

Maravilla , 47 bytes

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

Oh, Dios, esto se vuelve más y más lento a medida que pasa el tiempo ...

Explicación

P\tk582161P;

Toma 582161 (cantidad de primos <= 8675309) elementos de la lista de primos infinitos Py redeclara el resultado como P.

(_>@(...))cyc8675309

Cambia infinitamente los dígitos de 8675309 y realiza una toma en la lista resultante.

os tk1P;P\dp +1#0P

Imprime el primer elemento P, suelta cycle item + 1elementos de P y redeclara el resultado como P. Esta operación Ptambién actúa como un valor de verdad para llevar; Si la lista está vacía / falsa (lo que significa que hemos llegado a 8675309), entonces dejamos de tomar de la lista cíclica.

Implementación más rápida (para pruebas)

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

Todavía muy lento, pero notablemente más rápido.

Jalea , 23 29 24 bytes

+6 bytes para un parche temporal para cumplir con el requisito de imprimir 8675309.
-5 bytes moviéndose a un enfoque más golfista pero más lento para abordar eso.

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

Ahora es demasiado lento para ejecutarse en TryItOnline, pero se ejecuta localmente en un par de minutos, produciendo los números que se muestran a continuación con saltos de línea intermedios (el número de primos omitidos se muestra a continuación entre paréntesis):

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

* el último es solo un salto efectivo de 4, ya que simplemente se agrega a la lista.

Haga clic aquí para obtener una versión con 3659 en lugar de 8675309, que tiene 19 conjuntos de cuatro saltos (en lugar de 12937 conjuntos de 7) y agrega 3659 (que es un salto efectivo de 6).

¿Cómo?

“⁹Ṁ:’©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

Nueva línea al final del archivo innecesaria y sin puntaje.

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

Explicación: Pes una matriz de primos. ces un candidato principal; ses el producto del módulo de residuos cada primo más pequeño; si alguno de estos residuos es cero (lo que indica que ces compuesto), se sconvierte (y permanece) en cero.

El generador de números primos es lento. Tomará mucho tiempo correr. La prueba se realizó mediante la sustitución de una Pmatriz generada por medios más eficientes (específicamente, cortocircuito en la división uniforme, y también ayuda mucho a detener la prueba en la raíz cuadrada).

Haskell, 122 bytes

Esto podría ser lo que se solicita:

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]

Podría ahorrar algunos bytes calculando previamente cuántos números se necesitan y reemplazándolos takeWhilepor take. Eso también permitiría adaptarse a cualquier decisión sobre el último número que se emitirá. Ya ha impreso números de hasta 600000 con muy poca memoria en mi prueba, por lo que creo que puede llegar hasta el final.

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]

Pruébalo en línea! (truncado 8675309a 8675, de lo contrario se agota el tiempo de prueba en línea )

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)

(no se pudo imprimir 8675137 por 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)

Al subir el final de la gama, :partialse puede eliminar.

Pruébelo (límite de 5 segundos agregado) Verlo terminar

El ejemplo inicial fue cronometrado en 52 minutos y 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)
  )

El resultado de la rotorllamada es la siguiente secuencia

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

Pruébalo en línea! , pero tenga en cuenta que va a expirar mucho antes de que llegue al final. Sin embargo, una versión compilada en mi máquina local se completa en menos de 10 segundos.

Explicación

Para probar la primalidad, iteramos sobre el rango de 2 a sqrt ( n ) y verificamos si n es un múltiplo de cualquiera de esos valores; de lo contrario, es un primo. Este proceso se complica por el hecho de que el valor iterado debe almacenarse en una "variable" temporal, y dado que las celdas de memoria de Befunge tienen un tamaño limitado, ese almacenamiento debe dividirse en dos celdas. Para manejar los números primos omitidos, utilizamos una "tabla" de búsqueda (que puede ver en la línea 5) para realizar un seguimiento de los diferentes rangos que deben omitirse.

No voy a hacer un análisis detallado del código, porque hay bastante código entrelazado con comandos compartidos en diferentes rutas de código para ahorrar espacio. Esto hace que las cosas sean bastante difíciles de seguir y no creo que sea particularmente interesante para alguien que no esté familiarizado con Befunge.

Salida de muestra

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

Bash (+ coreutils), 9894 bytes

EDICIONES:

• Filtro de fila optimizado un poco, -4 bytes

Golfed

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

Prueba

>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

¡Pruébelo en línea! (limitado a N <1000, para que funcione rápido)

La versión completa tarda unos 15 segundos en completarse en mi máquina.