Insbesondere das PRIMEGAME von Conway .

Dies ist ein Algorithmus, der von John H. Conway entwickelt wurde, um Primzahlen mit einer Folge von 14 rationalen Zahlen zu erzeugen:

 A   B   C   D   E   F   G   H   I   J   K   L   M   N
17  78  19  23  29  77  95  77   1  11  13  15  15  55
--  --  --  --  --  --  --  --  --  --  --  --  --  --
91  85  51  38  33  29  23  19  17  13  11  14   2   1

Zum Beispiel ist F der Bruch 77/29.

So findet der Algorithmus die Primzahlen. 2Suchen Sie ausgehend von der Zahl den ersten Eintrag in der Sequenz, der bei Multiplikation eine ganze Zahl ergibt. Hier ist es M, 15/2, die produziert 15. 15Suchen Sie dann für diese Ganzzahl den ersten Eintrag in der Sequenz, der bei Multiplikation eine Ganzzahl ergibt. Das ist der letzte N, oder 55/1, der nachgibt 825. Schreiben Sie die entsprechende Reihenfolge auf. (Die Schlauen unter Ihnen können dies als ein FRACTRAN- Programm erkennen.)

Nach einigen Iterationen erhalten Sie Folgendes:

2, 15, 825, 725, 1925, 2275, 425, 390, 330, 290, 770, 910, 170, 156, 132, 116, 308, 364, 68, 4 ...

Beachten Sie, dass das zuletzt aufgeführte Element 4oder ist 2^2. Schauen Sie sich unsere erste 2mit diesem Algorithmus erzeugte Primzahl (den Exponenten) an! Schließlich sieht die Sequenz folgendermaßen aus:

2 ... 2^2 ... 2^3 ... 2^5 ... 2^7 ... etc.

So ergeben sich die Primzahlen. Dies ist OEIS A007542 .

Die Herausforderung

Bei einer eingegebenen Nummer n, entweder null- oder einsindiziert (Ihre Wahl), geben Sie entweder die ersten nNummern dieser Sequenz oder die nth-Nummer dieser Sequenz aus.

Beispiele

In den folgenden Beispielen wird der ndritte Term der nullindexierten Sequenz ausgegeben.

 n   output
 5   2275
19   4
40   408

Regeln

• Gegebenenfalls können Sie davon ausgehen, dass die Eingabe / Ausgabe in den systemeigenen Integer-Typ Ihrer Sprache passt.
• Die Eingabe und Ausgabe kann durch jede bequeme Methode erfolgen .
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Python 3 , 173 165 153 145 144 136 135 127 126 125 108 107 104 Byte

f=lambda n:2>>n*2or[f(n-1)*t//d for t,d in zip(b"NM_M\r7",b"[U3&!\r")if f(n-1)*t%d<1][0]

Probieren Sie es online!

• -30 Bytes dank Jonathan Frech!
• -3 Bytes danke an Lynn!

2>>n*2ist 2für n==0und 0ansonsten.

103 Bytes, wenn wir floats zurückgeben können.

FRACTRAN , 99 Bytes

17/2821 78/2635 19/1581 23/1178 29/1023 77/899 95/713 77/589 1/527 11/403 13/341 15/434 15/62 55/31

Probieren Sie es online!

Das Programm nimmt 2*31^nals Eingabe, die als Ausgangszustand verwendet wird.

Alle Brüche im ursprünglichen FRACTRAN-Programm wurden durch 31 (das erste nicht verwendete Primregister) geteilt, sodass das Programm bei der n-ten Iteration stoppt.

Jelly , 49 43 Bytes

ד×NŒçøM_M¢¿ÆÐÐ7‘“[U3&!øçŒ×Æ¿Ç£¢‘:@xḍɗḢ
2Ç¡

Probieren Sie es online!

• -6 Bytes dank Meilen

Python 3 , 107 Bytes

f=lambda n,k=2:n and f(n-1,[k*a//b for a,b in zip(b"NM_M\r7",b"[U3&!\r")if k*a%b<1][0])or k

Probieren Sie es online!

Codiert die Liste der Brüche durch zipEingabe von zwei Bytestrings, die nicht druckbare Niedrig-ASCII-Zeichen enthalten.

Wenn nNull ist, geben wir das Argument zurück k. ansonsten greifen wir auf neue Parameter zurück. Unser neuer kWert ist der erste Wert k*a//b, der einem Bruch (a, b)in der Liste entspricht, k*a//balso eine ganze Zahl, d k*a%b<1. H.

MATL , 50 Bytes

Hi:"'0m26<l~l *,..V'31-*'{uSFA=731-+."!'32-&\w~)1)

Probieren Sie es online!

J , 116 110 Bytes

g=.3 :0
((1047856500267924709512946135x%&(96#.inv])5405040820893044303890643137x)([:({.@I.@(=<.){[)*)])^:y 2
)

Probieren Sie es online!

0-indiziert; gibt die n-te Zahl zurück

Einige Bytes können gespeichert werden, indem man das Verb tacit macht, aber ich habe Probleme, ^:Arbeit zu machen.

Erläuterung:

J beschreibt die rationalen Zahlen in der Form NrD, wobei N der Zähler und D der Nenner ist. Zum Beispiel habe 17r91 78r85 19r51 23r38...ich 2 separate Listen für die Zähler und Nenner erstellt und daraus 2 Basis-96-Zahlen erstellt.

1047856500267924709512946135x%&(96#.inv])5405040820893044303890643137x konvertiert die Base-96-Zahlen in Listen und erstellt eine Liste von Brüchen durch Teilen der beiden Listen.

   1047856500267924709512946135x%&(96#.inv])5405040820893044303890643137x
17r91 78r85 19r51 23r38 29r33 77r29 95r23 77r19 1r17 11r13 13r11 15r14 15r2 55

2 Beginnen Sie mit 2

^:yWiederhole das Verb zu seinen linken nZeiten (y ist das Argument für die Funktion)

] das richtige Argument (beginnt bei 2 und verwendet dann das Ergebnis jeder Iteration)

* Multiplizieren Sie die Liste der Brüche mit dem richtigen Argument

(=<.) sind die Ergebnisse ganzzahlig (vergleichen Sie jede Zahl mit ihrem Boden)

{.@I.@Findet den Index I.der ersten {.ganzen Zahl

{[ Verwendet den Index, um die Nummer abzurufen

05AB1E ,  44  43 Bytes

0-indiziert

2sF•Ë₁ǝßÌ?ƒ¥"h2ÔδD‡béαA5À>,•тв2ä`Š*s‰ʒθ_}нн

Probieren Sie es online!

Erläuterung

2                                             # initialize stack with 2
 sF                                           # input times do:
   •Ë₁ǝßÌ?ƒ¥"h2ÔδD‡béαA5À>,•                  # push a base-255 compressed large number
                            тв                # convert to a list of base-100 digits
                              2ä`             # split in 2 parts to stack
                                 Š            # move denominators to bottom of stack
                                  *           # multiply the last result by the numerators
                                   s‰         # divmod with denominators
                                     ʒθ_}     # filter, keep only those with mod result 0
                                         нн   # get the div result

Die große Zahl ist geschoben 17781923297795770111131515559185513833292319171311140201

Pari / GP , 121 Bytes

n->a=2;for(i=1,n,a=[x|x<-a*[17/91,78/85,19/51,23/38,29/33,77/29,95/23,77/19,1/17,11/13,13/11,15/14,15/2,55],x\1==x][1]);a

Probieren Sie es online!

JavaScript (Node.js) , 106 95 Bytes

• Danke an @Arnauld und @Neil für die Reduzierung um 11 Bytes

(n,N=2,I=13,B=Buffer(`[U3&!\rNM_M\r7`))=>n--?f(n,N/B.find(x=>N%x<!!++I)*B[I]):N

Probieren Sie es online!

Netzhaut , 213 Bytes

K`17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶2
\d+
*
"$+"+`((_+)/(_+)¶(.+¶)*)(\3)+$
$1$#5*$2
r`_\G

Probieren Sie es online! Erläuterung:

K`17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶17/91¶78/85¶19/51¶23/38¶29/33¶77/29¶95/23¶77/19¶1/17¶11/13¶13/11¶15/2¶1/7¶55/1¶2

Ersetzen Sie die Eingabe durch eine Liste aller Brüche plus der Anfangszahl.

\d+
*

Wandle alles in Einzahl um.

"$+"+`

Wiederholen Sie die Ersetzung so oft wie in der ursprünglichen Eingabe angegeben.

((_+)/(_+)¶(.+¶)*)(\3)+$

Suchen Sie einen Nenner, der die ganze Zahl gleichmäßig teilt.

$1$#5*$2

Ersetzen Sie die Ganzzahl durch das Ergebnis der Division multipliziert mit dem Zähler.

r`_\G

Wandle die ganze Zahl in eine Dezimalzahl um und gib das Ergebnis aus.

Attache , 81 Bytes

Nest<~{Find[Integral,_*&`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]]},2~>

Probieren Sie es online! Gibt einen Bruch über 1 aus. Beispiel: Eingabe5 zurückgegeben 2275/1. Dies kann durch Voranstellen mit plus 2 Bytes behoben werdenN@ an das Programm werden.

Erläuterung

Dies ist eine Curry-Funktion, die Nest mit zwei vordefinierten Argumenten ausgeführt wird:

{Find[Integral,_*&`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]]}

und 2 . Dieses letzte Argument ist einfach der Anfangsstartwert, und das an diese Funktion übergebene Argument gibt die Anzahl der Iterationen an, mit denen die angegebene Funktion verschachtelt wird.

Folgendes wird verwendet, um PRIMEGAME zu kodieren:

&`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]]

Dies wird als solches gewertet:

A> "0zmt2R6E<@l<~6l2 0*,,*.-.!V "
"0zmt2R6E<@l<~6l2 0*,,*.-.!V "
A> Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "
[48, 122, 109, 116, 50, 82, 54, 69, 60, 64, 108, 60, 126, 54, 108, 50, 32, 48, 42, 44, 44, 42, 46, 45, 46, 33, 86, 32]
A> Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31
[17, 91, 78, 85, 19, 51, 23, 38, 29, 33, 77, 29, 95, 23, 77, 19, 1, 17, 11, 13, 13, 11, 15, 14, 15, 2, 55, 1]
A> Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]
 17 91
 78 85
 19 51
 23 38
 29 33
 77 29
 95 23
 77 19
  1 17
 11 13
 13 11
 15 14
 15  2
 55  1
A> &`//=>Chop[Ords!"0zmt2R6E<@l<~6l2 0*,,*.-.!V "-31,2]
[(17/91), (78/85), (19/51), (23/38), (29/33), (77/29), (95/23), (77/19), (1/17), (11/13), (13/11), (15/14), (15/2), (55/1)]

Ersetzen wir diesen Ausdruck Gin der Erklärung durch. Unsere erste Funktion wird:

{Find[Integral,_*G]}

Dies führt eine einzelne Iteration des FRACTRAN-Codes über _die Eingabe in die Funktion durch. Es ist Findein IntegralMitglied (eines, das eine ganze Zahl ist) des Arrays _*G, das die _mit jedem Mitglied von multiplizierte Eingabe ist G. NestWendet diese Transformation einfach die angegebene Anzahl von Malen an.

Attache, 42 Bytes

Ich habe Teile der $langsBibliothek implementiert und mich von dieser Herausforderung inspirieren lassen. Daher markiere ich diesen Abschnitt als nicht konkurrierend.

Needs[$langs]2&FRACTRAN_EXAMPLES.prime.run

Dies fragt einfach die Liste von FRACTRAN_EXAMPLESmir ab. Jedes Beispiel ist eine FractranExampleInstanz, die die eingebaute FRACTRANFunktion aufruft . Das primeBeispiel ist Conways PRIMEGAME.

F # (Mono) , 215 Bytes

let q m=
 let rec i x y=
  if y=m then x 
  else[17;91;78;85;19;51;23;38;29;33;77;29;95;23;77;19;1;17;11;13;13;11;15;14;15;2;55;1]|>List.chunkBySize 2|>List.find(fun[n;d]->x*n%d=0)|>fun[n;d]->i(x*n/d)(y+1)   
 i 2 0

Probieren Sie es online!

PHP, 183 Bytes (189 mit "php" -Tag)

Golf gespielt:

$t=2;for(;@$i++<$argv[1];){foreach([17/91,78/85,19/51,23/38,29/33,77/29,95/23,77/19,1/17,11/13,13/11,15/14,15/2,55/1]as$n){$a=$t*$n;if(preg_match('/^\d+$/',$a)){$t=$a;break;}}}echo$t;

Ungolfed:

<?php 
$t=2;
for(;@$i++<$argv[1];){
    foreach([17/91,78/85,19/51,23/38,29/33,77/29,95/23,77/19,1/17,11/13,13/11,15/14,15/2,55/1] as $n){
        $a=$t*$n;
        if(preg_match('/^\d+$/',$a)){
            $t=$a;break;
        }
    }
}
echo $t;

Probieren Sie es online!