Dato un intero positivo n uscita interi a e b (formando ridotta frazione a / b ) tale che:

Dove p _k è il k esimo numero primo (con p ₁ = 2).

Esempi:

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

Sono consentiti controlli probabilistici ed è ok se la tua risposta non riesce a causa di limitazioni nel tipo intero della tua lingua.

Vince il codice più breve in byte.

M , 9 byte

RÆN²‘İḤCP

Provalo online!

banalità

Incontra M!

M è un fork di Jelly, finalizzato a sfide matematiche. La differenza fondamentale tra Jelly e M è che M usa una precisione infinita per tutti i calcoli interni, che rappresentano i risultati simbolicamente. Una volta che M è più matura, Jelly diventerà gradualmente più polivalente e meno orientata alla matematica.

M è molto in progress (pieno di bug e non proprio quello diverso da Jelly in questo momento), ma funziona come un fascino per questa sfida e ho appena non poteva resistere.

Come funziona

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 byte

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

Una funzione senza nome che prende intero input e restituisce la frazione effettivo.

Questo usa il fatto che . Il codice viene quindi golfato grazie al fatto che Mathematica filtra tutta l'aritmetica di base sugli elenchi. Quindi prima creiamo un elenco , quindi recuperiamo tutti quei numeri primi e inseriamo tale elenco nell'espressione sopra. Questo ci dà un elenco di tutti i fattori. Infine, moltiplichiamo tutto insieme applicandoci all'elenco, a cui è possibile giocare a golf .(p2-1)/(p2+1) = 1-2/(p2+1){1, 2, ..., n}Times1##&

In alternativa, possiamo usare Arrayper lo stesso conteggio byte:

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

Pitone 2, 106 byte

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

La prima e la quarta riga fanno così male ... si è appena scoperto che usare Fractionera meglio che moltiplicare separatamente e usare gcd, anche in Python 3.5+ dove gcdrisiedemath .

La prima generazione adattata dalla risposta di @ xnor qui , che utilizza il teorema di Wilson.

Rubino, 122 77 65 byte

Grazie a Sherlock per la rasatura di 10 byte.

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

Definisce una funzione anonima che accetta un numero e restituisce a Rational.

PARI / GP , 33 byte

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

Versione alternativa (46 byte):

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

Versione non competitiva che dà il risultato in virgola mobile ( t_REAL) (38 byte):

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

Gelatina , 14 13 byte

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

Provalo online! Grazie a @Dennis per -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

Provalo qui o esegui Test Suite .

1 byte salvato grazie a Jakube!

Implementazione piuttosto ingenua delle specifiche. Usa lo spiffy "nuovo" (non ho idea di quando sia stato aggiunto, ma non l'ho mai visto prima) P<neg>che restituisce se il valore positivo di un numero negativo è primo o no. Alcune delle mappe, ecc. Possono probabilmente essere giocate a golf ...

Julia, 59 42 byte

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

Questa è una funzione anonima che accetta un numero intero e restituisce una Rationalcon BigIntnumeratore e denominatore.

Iniziamo generando un elenco di numeri primi inferiori a 2 n ² e selezionando i primi n elementi. Questo funziona perché la n ° Prime è sempre inferiore a n ² per tutti gli n > 1. ( Vedi qui .)

Per ogni p degli n numeri primi selezionati, quadriamo p usando elementwise power ( .^2) e costruiamo il razionale 2 / ( p + 1), dove 2 viene prima convertito in a BigIntper garantire una precisione sufficiente. Sottraiamo questo da 1, prendiamo il prodotto della matrice risultante di razionali e restituiamo la risultante razionale.

Esempio di utilizzo:

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

julia> f(15)
4506715396450638759507001344//11179755611058498955501765625

Salvato 17 grazie a SP3000!

Convesso, 28 byte

Convex è un nuovo linguaggio che sto sviluppando che è fortemente basato su CJam e Golfscript. L'interprete e l'IDE sono disponibili qui . L'input è un numero intero negli argomenti della riga di comando. Gli indici sono a base singola. Utilizza la codifica CP-1252.

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

Puoi o meno considerare questa risposta come competitiva poiché stavo lavorando su alcune funzionalità che questo programma utilizza prima che la sfida fosse pubblicata, ma il commit è stato fatto una volta che ho visto uscire la sfida.

MATL , 18 byte

:Yq2^tqpwQpZd1Mhw/

Provalo online!

Non riesce per input di grandi dimensioni perché solo gli interi fino a 2^52possono essere rappresentati accuratamente internamente.

Spiegazione

:     % 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 byte

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

Primes? Frazioni? Matematica.

Haskell, 53 byte

Funzione anonima, 53 caratteri:

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

Provalo qui (nota: nella norma GHCi è necessario prima per assicurarsi Data.Ratioe Data.Listsono importati):

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

L'indicizzazione dell'elenco di Haskell !!è basata su 0.(___!!)è una sezione operatore , che forma una funzione anonima in modo che (xs !!) n == xs !! n.

Sono quattro byte in meno per generare l'intera sequenza:

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

Scherzi a parte, 25 byte

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

Uscite a\nb ( \nè una nuova riga). Gli input di grandi dimensioni richiederanno molto tempo (e potrebbero non funzionare a causa dell'esaurimento della memoria) perché la generazione primaria è piuttosto lenta.

Provalo online!

Spiegazione:

,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