Lesen Sie dies, wenn Sie verwirrt sind.

Herausforderung:

Das Ziel dieses Code-Golfs basiert auf der Zahl 8675309...

Ihr Ziel ist es, jede Primzahl von 2 bis 8675309 auszudrucken, beginnend mit der Nummer 2 und dann 8 Primzahlen überspringen, dann 6 überspringen, dann 7 überspringen usw. Überspringen Sie im Wesentlichen eine Anzahl von Primzahlen, die durch die nächste Zahl in bestimmt werden die Reihenfolge 8675309. Fahren Sie auf 8 um, sobald es 9 erreicht hat.

Ausgabe:

2
29

(8 übersprungen, um zur 10. Primzahl zu gelangen)

59

(6 übersprungen, um zur 17. Primzahl zu gelangen)

97

(7 übersprungen, um zur 25. Primzahl zu gelangen)

Beispiel: (PHP-ähnlicher Pseudocode, wobei $primeein Array alle Primzahlen enthält.)

$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;

Wenn ich 8 Primzahlen überspringe , meine ich, von der Primzahl Nr. 1 zur Primzahl Nr. 10 zu gehen (die 8 dazwischen überspringen).

Jede Nummer muss in einer neuen Zeile stehen.

Wenn Sie das erreichen 0in 8675309, drucken Sie einfach nur die nächste Primzahl ohne Skipping.

Dies ist Code-Golf, also gewinnt der kürzeste Code (in Bytes).

Mathematica 67 Bytes

Trifft 8675309 jedoch nicht - ich bin mir nicht sicher, ob OP dies beabsichtigt.

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

Wunder , 47 Bytes

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

Oh meine Güte, das wird mit der Zeit immer langsamer ...

Erläuterung

P\tk582161P;

Nimmt 582161 (Anzahl der Primzahlen <= 8675309) Elemente aus der Liste der unendlichen Primzahlen Pund ergibt das Ergebnis neu P.

(_>@(...))cyc8675309

Zyklisiert die Ziffern von 8675309 unendlich und führt eine Aufnahme für die resultierende Liste durch.

os tk1P;P\dp +1#0P

Geben Sie das erste Element in ein P, cycle item + 1löschen Sie Elemente aus P und deklarieren Sie das Ergebnis als neu P. Diese Operation Pwirkt auch als Wahrheitswert für die Aufnahme; Wenn die Liste leer / falsch ist (was bedeutet, dass wir 8675309 erreicht haben), beenden wir die Aufnahme aus der zyklischen Liste.

Schnellere Implementierung (zum Testen)

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

Immer noch sehr langsam, aber spürbar schneller.

Gelee , 23 29 24 Bytes

+6 Bytes für einen temporären Patch, um die Anforderung zum Drucken von 8675309 zu erfüllen.
-5 Bytes, die zu einem golfigeren, aber langsameren Ansatz wechseln, um dies zu beheben.

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

Jetzt zu langsam, um auf TryItOnline ausgeführt zu werden, aber es wird lokal in ein paar Minuten ausgeführt, wobei die unten gezeigten Zahlen mit dazwischen liegenden Zeilenvorschüben erzeugt werden (Anzahl der übersprungenen Primzahlen wird unten in Klammern angezeigt):

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

* Der letzte ist nur ein effektiver Sprung von 4, da er einfach an die Liste angehängt wird.

Klicken Sie hier, um eine Version mit 3659 anstelle von 8675309 zu erhalten, die 19 Sätze mit vier Sprüngen (anstelle von 12937 Sätzen mit 7) enthält und 3659 anhängt (was ein effektiver Sprung von 6 ist).

Wie?

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

Nachlaufender Zeilenumbruch am Ende der Datei unnötig und nicht bewertet.

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

Erläuterung: Pist ein Array von Primzahlen. cist ein Kandidat Prime; sist das Produkt der Reste modulo jeder kleineren Primzahl; Wenn ein solcher Rest Null ist (was anzeigt, dass er zusammengesetzt cist), swird (und bleibt) Null.

Der Primzahlengenerator ist langsam. Das Laufen dauert ziemlich lange. Das Testen wurde durchgeführt, indem ein PArray ersetzt wurde, das mit effizienteren Mitteln erzeugt wurde (insbesondere Kurzschluss bei gleichmäßiger Teilung, und es hilft auch sehr , das Testen an der Quadratwurzel zu stoppen).

Haskell, 122 Bytes

Dies könnte das sein, wonach gefragt wird:

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]

Ich konnte ein paar Bytes speichern , indem precomputing wie viel Anzahl benötigt werden , und ersetzt takeWhilemit take. Dies würde es auch ermöglichen, sich an jede Entscheidung über die zuletzt auszugebende Nummer anzupassen. In meinem Test wurden bereits Zahlen bis zu 600000 mit sehr wenig Speicher gedruckt, sodass ich denke, dass dies den ganzen Weg gehen kann.

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]

Probieren Sie es online aus! (abgeschnitten 8675309auf 8675, andernfalls tritt bei Online-Test eine Zeitüberschreitung auf )

Verwendungszweck:

* Main> [n | n0) .mod n) [2..n-1]]% Zyklus [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)

(8675137 konnte nicht gedruckt werden, weil es fehlte :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)

Durch Verschieben des Bereichsendes :partialkann der entfernt werden.

Versuchen Sie es (5 Sekunden Grenze hinzugefügt) Sehen Sie es beenden

Das erste Beispiel wurde auf 52 Minuten und 41,464 Sekunden festgelegt.

Erweitert:

$_ = 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)
  )

Das Ergebnis des rotorAufrufs ist die folgende Sequenz

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

Probieren Sie es online aus! , aber sei dir bewusst, dass es eine Zeitüberschreitung geben wird, lange bevor es das Ende erreicht. Eine kompilierte Version auf meinem lokalen Computer ist jedoch in weniger als 10 Sekunden fertig.

Erläuterung

Um die Primalität zu testen, iterieren wir über den Bereich von 2 bis sqrt ( n ) und prüfen, ob n ein Vielfaches eines dieser Werte ist - wenn nicht, ist es eine Primzahl. Dieser Prozess wird durch die Tatsache erschwert, dass der iterierte Wert in einer temporären "Variablen" gespeichert werden muss. Da Befunges Speicherzellen in ihrer Größe begrenzt sind, muss dieser Speicher auf zwei Zellen aufgeteilt werden. Um die übersprungenen Primzahlen zu verarbeiten, verwenden wir eine Nachschlagetabelle (die Sie in Zeile 5 sehen können), um die verschiedenen Bereiche zu verfolgen, die übersprungen werden müssen.

Ich werde keine detaillierte Analyse des Codes durchführen, da es ziemlich viel Interleaving-Code mit Befehlen gibt, die über verschiedene Codepfade verteilt sind, um Platz zu sparen. Dies macht es ziemlich schwierig, den Dingen zu folgen, und ich denke nicht, dass es für jemanden besonders interessant wäre, der Befunge noch nicht kennt.

Beispielausgabe

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

Bash (+ Coreutils), 9894 Bytes

EDITS:

• Optimierter Zeilenfilter ein bisschen, -4 Bytes

Golf gespielt

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

Prüfung

>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

Probieren Sie es online aus! (begrenzt auf N <1000, damit es schnell läuft)

Die Vollversion dauert auf meinem Computer ca. 15 Sekunden.