Bei einer positiven ganzen Zahl n werden die ganzen Zahlen a und b (unter Bildung des reduzierten Anteils a / b ) so ausgegeben, dass:

Dabei ist p _k die k- te Primzahl (mit p ₁ = 2).

Beispiele:

1   -> 3, 5
2   -> 12, 25
3   -> 144, 325
4   -> 3456, 8125
5   -> 41472, 99125
15  -> 4506715396450638759507001344, 11179755611058498955501765625
420 -> very long

Probabilistische Prim-Checks sind erlaubt und es ist in Ordnung, wenn Ihre Antwort aufgrund von Einschränkungen im Integer-Typ Ihrer Sprache fehlschlägt.

Kürzester Code in Bytes gewinnt.

M , 9 Bytes

RÆN²‘İḤCP

Probieren Sie es online!

Trivia

Triff m!

M ist eine Gabel aus Jelly, die auf mathematische Herausforderungen ausgerichtet ist. Der Hauptunterschied zwischen Jelly und M besteht darin, dass M für alle internen Berechnungen eine unendliche Präzision verwendet und die Ergebnisse symbolisch darstellt. Sobald M reifer ist, wird Jelly allmählich vielseitiger und weniger mathematisch orientiert.

M ist sehr viel in Arbeit (voller Bugs, und nicht wirklich , dass ich von Jelly jetzt), aber es wirkt wie ein Zauber für diese Herausforderung und ich konnte einfach nicht widerstehen.

Wie es funktioniert

RÆN²‘İḤCP  Main link. Argument: n

R          Range; yield [1, ..., n].
 ÆN        Compute the kth primes for each k in that range.
   ²‘      Square and increment each prime p.
     İ     Invert; turn p² + 1 into the fraction 1 / (p² + 1).
      Ḥ    Double; yield 2 / (p² + 1).
       C   Complement; yield 1 - 2 / (p² + 1).
        P  Product; multiply all generated differences.

Mathematica, 32 Bytes

1##&@@(1-2/(Prime@Range@#^2+1))&

Eine unbenannte Funktion, die eine Ganzzahleingabe akzeptiert und den tatsächlichen Bruch zurückgibt.

Dies nutzt die Tatsache, dass . Der Code wird dann abgearbeitet, da Mathematica alle Grundrechenarten über Listen verteilt. Also erstellen wir zuerst eine Liste , rufen dann alle diese Primzahlen ab und fügen diese Liste in den obigen Ausdruck ein. Dies gibt uns eine Liste aller Faktoren. Schließlich multiplizieren wir alles miteinander, indem wir uns an die Liste wenden , auf die gespielt werden kann .(p2-1)/(p2+1) = 1-2/(p2+1){1, 2, ..., n}Times1##&

Alternativ können wir Arrayfür die gleiche Byteanzahl verwenden:

1##&@@(1-2/(Prime~Array~#^2+1))&

Python 2, 106 Bytes

from fractions import*
n=input()
F=k=P=1
while n:b=P%k>0;n-=b;F*=1-Fraction(2*b,k*k+1);P*=k*k;k+=1
print F

Die erste und vierte Zeile tun so weh ... es stellte sich nur heraus, dass das Verwenden Fractionbesser war als das separate Multiplizieren und Verwenden gcd, selbst in Python 3.5+, in dem sich gcdbefindet math.

Prime Generation angepasst von @ xnor Antwort hier , die Wilson-Theorem verwendet.

Ruby, 122 77 65 Bytes

Vielen Dank an Sherlock für das Abschneiden von 10 Bytes.

require'prime'
->n{Prime.take(n).map{|x|1-2r/(x*x+1)}.reduce(:*)}

Definiert eine anonyme Funktion, die eine Zahl annimmt und a zurückgibt Rational.

PARI / GP , 33 Bytes

n->prod(i=1,n,1-2/(prime(i)^2+1))

Alternative Version (46 Byte):

n->t=1;forprime(p=2,prime(n),t*=1-2/(p^2+1));t

Nicht konkurrierende Version mit dem Fließkomma ( t_REAL) Ergebnis (38 Bytes):

n->prodeuler(p=2,prime(n),1-2/(p^2+1))

Jelly , 14 13 Bytes

RÆN²µ’ż‘Pµ÷g/

Probieren Sie es online! Vielen Dank an @Dennis für -1 Byte.

R                       Range [1..n]
 ÆN                     Nth prime
   ²                    Square
    µ                   Start new monadic chain
     ’ż‘                Turn each p^2 into [p^2-1, p^2+1]
        P               Product
         µ              Start new monadic chain
          ÷             Divide by...
           g/           Reduce GCD

Pyth, 26 25

/RiFN=N*MCm,tdhd^R2.fP_ZQ

Probieren Sie es hier aus oder starten Sie die Test Suite .

Dank Jakube 1 Byte gespart!

Ziemlich naive Umsetzung der Vorgaben. Verwendet das schicke "new" (ich habe keine Ahnung, wann dies hinzugefügt wurde, aber ich habe es noch nie gesehen), P<neg>das zurückgibt, ob der positive Wert einer negativen Zahl eine Primzahl ist oder nicht. Ein Teil des Mappings usw. kann wahrscheinlich golfen werden ...

Julia, 59 42 Bytes

n->prod(1-big(2).//-~primes(2n^2)[1:n].^2)

Dies ist eine anonyme Funktion, die eine Ganzzahl akzeptiert und ein Rationalmit BigIntZähler und Nenner zurückgibt .

Wir beginnen mit der Erzeugung der Liste der Primzahlen kleiner als 2 n ² und der Auswahl der ersten n Elemente. Dies funktioniert, weil die n- te Primzahl für alle n > 1 immer kleiner als n ^{2 ist} . ( Siehe hier .)

Für jedes p der ausgewählten n Primzahlen quadrieren wir p mit elementweiser Potenz ( .^2) und konstruieren das rationale 2 / ( p + 1), wobei 2 zuerst in a konvertiert wird, BigIntum eine ausreichende Präzision sicherzustellen. Wir subtrahieren dies von 1, nehmen das Produkt des resultierenden Arrays von Rationalen und geben das resultierende Rationale zurück.

Anwendungsbeispiel:

julia> f = n->prod(1-big(2).//-~primes(2n^2)[1:n].^2)
(anonymous function)

julia> f(15)
4506715396450638759507001344//11179755611058498955501765625

17 dank Sp3000 gerettet!

Konvex, 28 Bytes

Convex ist eine neue Sprache, die ich entwickle und die stark auf CJam und Golfscript basiert. Den Interpreter und die IDE finden Sie hier . Die Eingabe ist eine Ganzzahl in die Befehlszeilenargumente. Indizes sind einseitig. Verwendet die CP-1252-Codierung.

,:)_{µ²1-}%×\{µ²1+}%׶_:Ðf/p

Sie können diese Antwort als konkurrierend ansehen oder auch nicht, da ich an einigen Funktionen gearbeitet habe, die dieses Programm verwendet, bevor die Herausforderung veröffentlicht wurde. Die Festschreibung wurde jedoch getätigt, sobald ich sah, dass diese Herausforderung abgelaufen ist.

MATL , 18 Bytes

:Yq2^tqpwQpZd1Mhw/

Probieren Sie es online!

Fehler bei großen Eingaben, da nur ganze Zahlen bis zu 2^52intern genau dargestellt werden können.

Erläuterung

:     % implicitly take input n. Generate range [1,...,n]
Yq    % first n prime numbers
2^    % square
tqp   % duplicate. Subtract 1. Product
wQp   % swap. Add 1. Product
Zd    % gcd of both products
1M    % push the two products again
h     % concatenate horizontally
w/    % swap. Divide by previously computed gcd. Implicitly display

Mathematica, 45 Bytes

Times@@Array[(Prime@#^2-1)/(Prime@#^2+1)&,#]&

Primes? Brüche? Mathematica.

Haskell, 53 Bytes

Anonyme Funktion, 53 Zeichen:

(scanl(*)1[1-2%(p*p+1)|p<-nubBy(((>1).).gcd)[2..]]!!)

Versuchen Sie es hier (Anmerkung: in Standard GHCi müssen Sie zuerst sicherstellen , Data.Ratiound Data.Listimportiert werden ):

λ (scanl(*)1[1-2%(p*p+1)|p<-nubBy(((>1).).gcd)[2..]]!!) 5
41472 % 99125
:: Integral a => Ratio a

Die Listenindizierung von Haskell !!basiert auf 0. (___!!)ist ein Operator-Bereich , der eine anonyme Funktion bildet, damit (xs !!) n == xs !! n.

Es sind vier Bytes weniger, um die gesamte Sequenz zu generieren:

λ mapM_ print $ take 10 $     -- just for a nicer output
    scanl(*)1[1-2%(n*n+1)|n<-[2..],all((>0).rem n)[2..n-1]]
1 % 1
3 % 5
12 % 25
144 % 325
3456 % 8125
41472 % 99125
3483648 % 8425625
501645312 % 1221715625
18059231232 % 44226105625
4767637045248 % 11719917990625
:: IO ()

Im Ernst, 25 Bytes

,r`PªD;⌐k`M┬`π`Mi│g;)@\)\

Outputs a\nb( \nist eine Newline). Große Eingaben dauern lange (und können aufgrund von Speichermangel fehlschlagen), da die Generierung von Primzahlen ziemlich langsam ist.

Probieren Sie es online!

Erläuterung:

,r`PªD;⌐k`M┬`π`Mi│g;)@\)\
,r                         push range(input)
  `PªD;⌐k`M                map:
   P                         k'th prime
    ª                        square
     D                       decrement
      ;                      dupe
       ⌐                     add 2 (results in P_k + 1)
        k                    push to list
           ┬               transpose
            `π`M           map product
                i│         flatten, duplicate stack
                  g;)      push two copies of gcd, move one to bottom of stack
                     @\    reduce denominator
                       )\  reduce numerator