Pozitif bir tamsayı n verildiğinde , a ve b tamsayıları ( azaltılmış fraksiyon a / b'yi oluşturur ) şu şekilde:

Burada p _k olan K asal sayı th (p ₁ = 2).

Örnekler:

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

Olasılıksal ana denetimlere izin verilir ve dilinizin tamsayı türündeki sınırlamalar nedeniyle yanıtınız başarısız olursa sorun olmaz.

Bayt cinsinden en kısa kod kazanır.

M , 9 bayt

RÆN²‘İḤCP

Çevrimiçi deneyin!

önemsiz şeyler

M ile tanışın!

M, matematiksel zorlukları hedefleyen bir Jelly çataldır. Jelly ve M arasındaki temel fark, M'nin tüm dahili hesaplamalar için sonuçları sembolik olarak temsil eden sonsuz hassasiyet kullanmasıdır. M daha olgunlaştığında, Jelly yavaş yavaş daha çok amaçlı ve daha az matematik odaklı olacaktır.

M, devam etmekte olan çok fazla iştir (böceklerle dolu ve gerçekten değil farklı Jelly dan şu anda), ancak bu meydan okuma için bir cazibe gibi çalışır ve sadece karşı koyamadım.

Nasıl çalışır

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 bayt

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

Tamsayı girişi alan ve gerçek kesri döndüren adsız bir işlev.

Bu gerçeği kullanır . Daha sonra Mathematica'nın tüm temel aritmetiği listeler üzerine işlediği için kod golf oynar. Bu yüzden önce bir liste oluştururuz , sonra tüm bu asalları alırız ve bu listeyi yukarıdaki ifadeye ekleriz. Bu bize tüm faktörlerin bir listesini verir. Son olarak, golf oynayabileceğiniz listeye başvurarak her şeyi bir araya getiriyoruz .(p2-1)/(p2+1) = 1-2/(p2+1){1, 2, ..., n}Times1##&

Alternatif olarak, Arrayaynı bayt sayısı için kullanabiliriz :

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

Python 2, 106 bayt

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

Birinci ve dördüncü satırları çok ... sadece kullanılarak ortaya çıktı zarar Fractiondaha ayrı çarparak ve kullanmaktan daha oldu gcdbile Python 3.5+ yılında, nerede gcdbulunduğu yermath .

Başbakan nesil @ XNOR cevabı uyarlanan Burada Wilson'un teoremini kullanır.

Yakut, 122 77 65 bayt

10 bayt tıraş ettiği için Sherlock'a teşekkürler.

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

Bir sayı alan ve döndüren anonim bir işlevi tanımlar Rational.

PARI / GP , 33 bayt

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

Alternatif sürüm (46 bayt):

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

Kayan nokta ( t_REAL) sonucunu veren rakip olmayan sürüm (38 bayt):

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

Jöle , 14 13 bayt

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

Çevrimiçi deneyin! -1 bayt için @Dennis'e teşekkürler.

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

Burada deneyin veya Test Suite'i çalıştırın .

Jakube sayesinde 1 bayt kurtarıldı!

Şartnamelerin oldukça naif uygulanması. P<neg>Negatif bir sayının pozitif değerinin asal olup olmadığını döndüren şık "yeni" (bunun ne zaman eklendiğini bilmiyorum, ama daha önce hiç görmedim) kullanır . Bazı haritalama, vb muhtemelen golf olabilir ...

Julia, 59 42 bayt

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

Bu, bir tamsayıyı kabul eden Rationalve BigIntpay ve payda içeren bir anonim işlevdir .

Biz az 2 asal sayıların listesini oluşturarak başlamak n ² ve birinci seçilerek n elemanlarını. Bu işe yarar çünkü n. Üssü tüm n > 1 için her zaman n ^2'den azdır . ( Buraya bakınız .)

Her biri için p ve n, seçilen asal, bir kare s elementwise gücü (kullanarak .^2) ve rasyonel 2 / (yapı p 2, ilk bir dönüştürülür + 1), BigIntyeteri kadar hassas sağlamak. Bunu 1'den çıkarırız, ortaya çıkan rasyonel dizinin ürününü alırız ve ortaya çıkan rasyonel olanı döndürürüz.

Örnek kullanım:

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

julia> f(15)
4506715396450638759507001344//11179755611058498955501765625

Sp3000 sayesinde 17 tasarruf!

Dışbükey, 28 bayt

Dışbükey, geliştirdiğim ve CJam ve Golfscript'e dayanan yeni bir dildir. Tercüman ve IDE burada bulunabilir . Girdi, komut satırı bağımsız değişkenlerine bir tam sayıdır. Dizinler tek tabanlıdır. CP-1252 kodlamasını kullanır.

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

Bu program, meydan okuma gönderilmeden önce bu programın kullandığı birkaç özellik üzerinde çalıştığımdan beri bu cevabın rekabet halinde olduğunu düşünebilir veya düşünmeyebilirsiniz, ancak bu meydan okumanın dışarı çıktığını gördüm.

MATL , 18 bayt

:Yq2^tqpwQpZd1Mhw/

Çevrimiçi deneyin!

Yalnızca en fazla tam sayı 2^52dahili olarak doğru şekilde temsil edilebildiğinden büyük girdiler için başarısız olur .

açıklama

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

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

Asal sayılar? Kesirler? Mathematica.

Haskell, 53 bayt

Anonim işlev, 53 karakter:

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

Dene Burada (not: standart GHCi'de önce emin olmanız Data.Ratiove Data.Listiçe aktarmanız gerekir ):

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

Haskell'in liste dizini oluşturma !! 0 tabanlıdır. anonim bir işlev oluşturan (___!!)bir operatör bölümüdür(xs !!) n == xs !! n .

Tüm diziyi oluşturmak için dört bayt daha az:

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

Ciddi, 25 bayt

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

çıktılar a\nb ( \nyeni satır). Büyük girişler uzun zaman alacaktır (ve bellek yetersiz kalması nedeniyle başarısız olabilir) çünkü ana üretim oldukça yavaştır.

Çevrimiçi deneyin!

Açıklama:

,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