Dado um número inteiro positivo n, os números a e b (formando a fração reduzida a / b ) são tais que:

Onde p _k é o k th número primo (com p ₁ = 2).

Exemplos:

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

As verificações principais probabilísticas são permitidas e tudo bem se sua resposta falhar devido a limitações no tipo inteiro do seu idioma.

O menor código em bytes vence.

M , 9 bytes

RÆN²‘İḤCP

Experimente online!

Curiosidades

Conheça M!

M é um garfo de geléia, voltado para desafios matemáticos. A principal diferença entre Jelly e M é que M usa precisão infinita para todos os cálculos internos, representando os resultados simbolicamente. Quando M estiver mais maduro, Jelly gradualmente se tornará mais polivalente e menos orientado para a matemática.

M é muito trabalho em andamento (cheio de bugs, e não realmente que diferente de Jelly agora), mas funciona como um encanto para este desafio e eu não pude resistir.

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

Uma função sem nome que recebe entrada inteira e retorna a fração real.

Isso usa o fato de que . O código é então modificado, graças ao fato de o Mathematica encadear todas as listas aritméticas básicas. Então, primeiro criamos uma lista , depois recuperamos todos esses números primos e inserimos essa lista na expressão acima. Isso nos dá uma lista de todos os fatores. Por fim, multiplicamos tudo aplicando a lista à qual você pode jogar golfe .(p2-1)/(p2+1) = 1-2/(p2+1){1, 2, ..., n}Times1##&

Como alternativa, podemos usar Arraya mesma contagem 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

A primeira e a quarta linhas doem tanto ... acabou que usar Fractionera melhor do que multiplicar separadamente e usar gcd, mesmo no Python 3.5+, onde gcdreside math.

A geração principal adaptada da resposta de @ xnor aqui , que usa o teorema de Wilson.

Ruby, 122 77 65 bytes

Agradecimentos a Sherlock por reduzir 10 bytes.

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

Define uma função anônima que pega um número e retorna a Rational.

PARI / GP , 33 bytes

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

Versão alternativa (46 bytes):

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

Versão não concorrente que fornece o t_REALresultado de ponto flutuante ( ) (38 bytes):

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

Geléia , 14 13 bytes

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

Experimente online! Obrigado 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

Experimente aqui ou execute o Test Suite .

1 byte salvo graças ao Jakube!

Implementação bastante ingênua das especificações. Usa o spiffy "new" (não tenho idéia de quando isso foi adicionado, mas nunca o vi antes) P<neg>que retorna se o valor positivo de um número negativo é primo ou não. Alguns dos mapas, etc, provavelmente podem ser jogados de golfe ...

Julia, 59 42 bytes

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

Esta é uma função anônima que aceita um número inteiro e retorna a Rationalcom BigIntnumerador e denominador.

Começamos gerando a lista de números primos menor que 2 n ² e selecionando os primeiros n elementos. Isso funciona porque o n º Prime é sempre menor do que n ² para todo n > 1. ( Veja aqui .)

Para cada p dos n primos selecionados, fazemos o quadrado de p usando a força elementar ( .^2) e construímos o racional 2 / ( p + 1), onde 2 é primeiro convertido em a BigIntpara garantir precisão suficiente. Subtraímos isso de 1, pegamos o produto da matriz resultante de racionais e retornamos a racional resultante.

Exemplo de uso:

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

julia> f(15)
4506715396450638759507001344//11179755611058498955501765625

Guardado 17 graças a Sp3000!

Convexo, 28 bytes

Convexo é uma nova linguagem que estou desenvolvendo que é fortemente baseada em CJam e Golfscript. O intérprete e o IDE podem ser encontrados aqui . A entrada é um número inteiro nos argumentos da linha de comandos. Os índices são baseados em um. Usa a codificação CP-1252.

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

Você pode ou não considerar essa resposta como concorrente, pois eu estava trabalhando em alguns recursos que este programa usa antes do lançamento do desafio, mas o commit foi feito assim que o desafio foi lançado.

MATL , 18 bytes

:Yq2^tqpwQpZd1Mhw/

Experimente online!

Falha em entradas grandes porque apenas números inteiros até 2^52podem ser representados com precisão internamente.

Explicação

:     % 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? Frações? Mathematica.

Haskell, 53 bytes

Função anônima, 53 caracteres:

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

Experimente aqui (observação: no GHCi padrão, você precisa primeiro certificar-se Data.Ratioe Data.Listimportar):

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

A indexação de lista de Haskell !!é baseada em 0. (___!!)é uma seção do operador , formando uma função anônima para que (xs !!) n == xs !! n.

São quatro bytes a menos para gerar a sequência inteira:

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

Sério, 25 bytes

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

Saídas a\nb( \né uma nova linha). As entradas grandes levarão muito tempo (e poderão falhar devido à falta de memória) porque a geração principal é muito lenta.

Experimente online!

Explicação:

,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