Dado un número entero positivo n , los enteros a y b (formando una fracción reducida a / b ) tal que:

Donde p _k es el k número primo (con p ₁ = 2).

Ejemplos:

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

Se permiten verificaciones primarias probabilísticas, y está bien si su respuesta falla debido a limitaciones en el tipo de entero de su idioma.

El código más corto en bytes gana.

M , 9 bytes

RÆN²‘İḤCP

Pruébalo en línea!

Trivialidades

¡Conoce a M!

M es un tenedor de gelatina, dirigido a desafíos matemáticos. La diferencia principal entre Jelly y M es que M usa precisión infinita para todos los cálculos internos, representando los resultados simbólicamente. Una vez que M sea más maduro, Jelly gradualmente se volverá más polivalente y menos orientado a las matemáticas.

M es mucho trabajo en progreso (lleno de errores, y en realidad no es tan diferente de Jelly en este momento), pero funciona de maravilla para este desafío y simplemente no pude resistirme.

Cómo funciona

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

Una función sin nombre que toma una entrada entera y devuelve la fracción real.

Esto usa el hecho de que . Luego, el código se juega gracias al hecho de que Mathematica enhebra todas las operaciones aritméticas básicas sobre listas. Entonces, primero creamos una lista , luego recuperamos todos esos números primos y conectamos esa lista a la expresión anterior. Esto nos da una lista de todos los factores. Finalmente, multiplicamos todo junto aplicando a la lista, a la que se puede jugar .(p2-1)/(p2+1) = 1-2/(p2+1){1, 2, ..., n}Times1##&

Alternativamente, podemos usar Arraypara el mismo conteo de bytes:

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

La primera y la cuarta línea duelen tanto ... simplemente resultó que usar Fractionera mejor que multiplicar por separado y usar gcd, incluso en Python 3.5+ donde gcdresidemath .

Primera generación adaptada de la respuesta de @ xnor aquí , que utiliza el teorema de Wilson.

Ruby, 122 77 65 bytes

Gracias a Sherlock por reducir 10 bytes.

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

Define una función anónima que toma un número y devuelve a Rational.

PARI / GP , 33 bytes

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

Versión alternativa (46 bytes):

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

Versión no competitiva que da el resultado de coma flotante ( t_REAL) (38 bytes):

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

Jalea , 14 13 bytes

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

Pruébalo en línea! Gracias a @Dennis por -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

Pruébelo aquí o ejecute Test Suite .

¡1 byte guardado gracias a Jakube!

Implementación bastante ingenua de las especificaciones. Utiliza el "nuevo" spiffy (no tengo idea de cuándo se agregó esto, pero nunca lo he visto antes) P<neg>que devuelve si el valor positivo de un número negativo es primo o no. Algunos de los mapas, etc., probablemente se pueden jugar al golf ...

Julia, 59 42 bytes

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

Esta es una función anónima que acepta un número entero y devuelve un Rationalcon BigIntnumerador y denominador.

Comenzamos generando la lista de números primos menores que 2 n ² y seleccionando los primeros n elementos. Esto funciona porque el n º Prime es siempre menor que n ² para todos n > 1. ( Ver aquí ).

Para cada p de los n primos seleccionados, elevamos al cuadrado p usando elementwise power ( .^2), y construimos el racional 2 / ( p + 1), donde 2 se convierte primero en a BigIntpara garantizar una precisión suficiente. Restamos esto de 1, tomamos el producto del conjunto resultante de racionales y devolvemos el racional resultante.

Ejemplo de uso:

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

julia> f(15)
4506715396450638759507001344//11179755611058498955501765625

¡Ahorrado 17 gracias a Sp3000!

Convexo, 28 bytes

Convex es un nuevo lenguaje que estoy desarrollando que se basa en gran medida en CJam y Golfscript. El intérprete y el IDE se pueden encontrar aquí . La entrada es un número entero en los argumentos de la línea de comando. Los índices están basados ​​en uno. Utiliza la codificación CP-1252.

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

Puede o no considerar que esta respuesta es competitiva ya que estaba trabajando en algunas características que utiliza este programa antes de que se publicara el desafío, pero el compromiso se realizó una vez que vi que este desafío desaparecía.

MATL , 18 bytes

:Yq2^tqpwQpZd1Mhw/

Pruébalo en línea!

Falla para entradas grandes porque solo los enteros hasta 2^52se pueden representar con precisión internamente.

Explicación

:     % 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? Fracciones? Mathematica

Haskell, 53 bytes

Función anónima, 53 caracteres:

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

Pruébelo aquí (nota: en GHCi estándar, primero debe asegurarse Data.Ratioy Data.Listse importan):

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

La indexación de la lista de Haskell !!se basa en 0. (___!!)es una sección de operador , que forma una función anónima para que (xs !!) n == xs !! n.

Son cuatro bytes menos para generar la secuencia completa:

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

En serio, 25 bytes

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

Salidas a\nb( \nes una nueva línea). Las entradas grandes tardarán mucho tiempo (y podrían fallar debido a la falta de memoria) porque la generación principal es bastante lenta.

Pruébalo en línea!

Explicación:

,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