17

एक सकारात्मक पूर्णांक n आउटपुट को देखते हुए पूर्णांक a और b (ऐसा घटा हुआ अंश a / b ) बनाता है जैसे:

सूत्र a / b = k = 1 से n का उत्पाद: (p_k ^ 2 - 1) / (p_k ^ + 1)

कहाँ पी _{कश्मीर} है कश्मीर वें अभाज्य संख्या (पी के साथ ₁ = 2)।

उदाहरण:

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

संभाव्य प्रधान जाँच की अनुमति है, और यह ठीक है यदि आपका उत्तर आपकी भाषा के पूर्णांक प्रकार में सीमाओं के कारण विफल हो जाता है।

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf arithmetic

— orlp
स्रोत

क्या हम 3.0इसके बदले आउटपुट भी कर सकते हैं 3?

— अदनान

2

@ और मुझे लगता है ... सुनिश्चित करें कि आपका प्रोग्राम सभी इनपुट के लिए सही है , और बड़े इनपुट के लिए फ्लोटिंग पॉइंट त्रुटियों से ग्रस्त नहीं है।

— orlp

क्या हम उत्पादन कर सकते हैं aऔर bएक तर्कसंगत प्रकार के रूप में?

— एलेक्स ए।

2

@AlexA। केवल अगर आउटपुट स्पष्ट रूप से दोनों पूर्णांक दिखाता है।

— orlp

1

@SamYonnou वे पहले से मौजूद हैं, लेकिन किसी समस्या का तुच्छ वर्णन करने के लिए देशी संख्या प्रकारों का दुरुपयोग करना उन खामियों में से एक है जो डिफ़ॉल्ट रूप से निषिद्ध हैं।

— डेनिस

6

एम , 9 बाइट्स

RÆN²‘İḤCP

इसे ऑनलाइन आज़माएं!

सामान्य ज्ञान

मीट मी!

M, जेली का एक कांटा है, जिसका उद्देश्य गणितीय चुनौतियों को माना जाता है। जेली और एम के बीच मुख्य अंतर यह है कि एम सभी आंतरिक गणनाओं के लिए अनंत परिशुद्धता का उपयोग करता है, प्रतीकात्मक रूप से परिणामों का प्रतिनिधित्व करता है। एक बार एम अधिक परिपक्व होने के बाद, जेली धीरे-धीरे अधिक बहुउद्देश्यीय और कम गणित-उन्मुख हो जाएगी।

एम प्रगति में बहुत ज्यादा काम (कीड़े से भरा है, और वास्तव में नहीं है कि अलग अलग जेली से अभी), लेकिन यह इस चुनौती के लिए एक आकर्षण की तरह काम करता है और मैं सिर्फ विरोध नहीं कर सका।

यह काम किस प्रकार करता है

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.

— डेनिस
स्रोत

है ÆNकेवल एम विशिष्ट ऑपरेटर? इसके अलावा मेल्ली

— कैलक्यूलेटरफ़ेलीन

इनमें से कोई भी ऑपरेटर एम के लिए विशिष्ट नहीं है। अंतर यह है कि एम एक अंश की गणना करता है, जबकि जेली एक फ्लोटिंग पॉइंट संख्या की गणना करता है।

— डेनिस

9

गणितज्ञ, 32 बाइट्स

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

एक अनाम फ़ंक्शन जो पूर्णांक इनपुट लेता है और वास्तविक अंश लौटाता है।

यह इस तथ्य का उपयोग करता है कि । फिर कोड को इस तथ्य के लिए धन्यवाद दिया जाता है कि मैथेमेटिका सूची में सभी मूल अंकगणित को पिरोती है। तो हम पहले एक सूची बनाते हैं , फिर उन सभी primes को पुनः प्राप्त करते हैं और उस सूची को उपरोक्त अभिव्यक्ति में प्लग करते हैं। यह हमें सभी कारकों की एक सूची देता है। अंत में, हम आवेदन करके सब कुछ एक साथ गुणा करते हैं(p²-1)/(p²+1) = 1-2/(p²+1){1, 2, ..., n}Times सूची में , जिसे गोल्फ किया जा सकता है1##& ।

वैकल्पिक रूप से, हम Arrayएक ही बाइट गिनती के लिए उपयोग कर सकते हैं :

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

— मार्टिन एंडर
स्रोत

1-2= 1, सही है?

— कैलक्यूलेटरफिलीन

@CatsAreFluffy हाँ ( -1वास्तव में), लेकिन 1-2/x ≠ -1/x। ;)

— मार्टिन एंडर

@Range@±~Array~

— CalculatorFeline

6

पायथन 2, 106 बाइट्स

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

पहली और चौथी पंक्ति में बहुत चोट लगी ... यह सिर्फ यह निकला कि Fractionअलग-अलग गुणा करने और उपयोग करने से बेहतर था gcd, यहां तक कि पायथन 3.5+ में जहां gcdनिवास करता हैmath ।

प्राइम जनरेशन यहाँ @ xnor के उत्तर से अनुकूलित है , जो विल्सन के प्रमेय का उपयोग करता है।

— Sp3000
स्रोत

5

रूबी, 122 77 65 बाइट्स

10 बाइट शेविंग करने के लिए शर्लक का धन्यवाद।

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

एक अनाम फ़ंक्शन को परिभाषित करता है जो एक नंबर लेता है और एक रिटर्न देता है Rational।

— एक स्पैगेटो
स्रोत

4

PARI / GP , 33 बाइट्स

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

वैकल्पिक संस्करण (46 बाइट्स):

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

फ़्लोटिंग-पॉइंट ( t_REAL) परिणाम (38 बाइट्स) देने वाला गैर-प्रतिस्पर्धात्मक संस्करण :

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

— चार्ल्स
स्रोत

4

जेली , 14 13 बाइट्स

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

इसे ऑनलाइन आज़माएं! @ बाइट के लिए शुक्रिया -1 बाइट।

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

— Sp3000
स्रोत

4

Pyth, 26 25

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

इसे यहां आज़माएं या टेस्ट सूट चलाएं ।

1 बाइट जेक्यूब के लिए धन्यवाद बचा लिया!

विनिर्देशों का बहुत अच्छा कार्यान्वयन। स्पिफी "नया" का उपयोग करता है (मुझे नहीं पता कि यह कब जोड़ा गया था, लेकिन मैंने इसे पहले कभी नहीं देखा है) P<neg>जो रिटर्न करता है कि नकारात्मक संख्या का सकारात्मक मूल्य प्रमुख है या नहीं। मैपिंग के कुछ, आदि शायद गोल्फ हो सकता है ...

— FryAmTheEggman
स्रोत

3

जूलिया, 59 42 बाइट्स

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

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और अंश और हर के Rationalसाथ लौटाता है BigInt।

हम 2 n ² से कम अभाज्य संख्याओं की सूची बनाकर और पहले n तत्वों को चुनकर शुरू करते हैं। यह काम करता है क्योंकि n th prime हमेशा सभी n > 1. के लिए n ² से कम होता है ( यहाँ देखें ।)

चयनित n primes के प्रत्येक p के लिए , हम एलिमेंट पॉवर ( ) का उपयोग करके वर्ग p बनाते हैं , और तर्कसंगत 2 / ( p + 1) का निर्माण करते हैं , जहाँ 2 को पहले a में बदला जाता है।.^2BigInt को पर्याप्त परिशुद्धता सुनिश्चित करने के लिए । हम इसे 1 से घटाते हैं, परिमेय सरणी के गुणनफल को लेते हैं, और परिणामी परिमेय को लौटाते हैं।

उदाहरण का उपयोग:

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

julia> f(15)
4506715396450638759507001344//11179755611058498955501765625

Sp3000 के लिए 17 धन्यवाद बच गया!

— एलेक्स ए।
स्रोत

2

उत्तल, 28 बाइट्स

उत्तल एक नई भाषा है जिसे मैं विकसित कर रहा हूं जो कि सीजेएम और गोल्फस्क्रिप्ट पर आधारित है। दुभाषिया और आईडीई यहां पाया जा सकता है । इनपुट कमांड लाइन के तर्कों में एक पूर्णांक है। सूचकांक एक-आधारित हैं। CP-1252 एन्कोडिंग का उपयोग करता है।

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

आप इस जवाब को प्रतिस्पर्धा के लायक नहीं मान सकते हैं क्योंकि मैं कुछ सुविधाओं पर काम कर रहा था, जो कि इस कार्यक्रम का उपयोग चुनौती देने से पहले किया गया था, लेकिन जब मैंने इस चुनौती को देखा तो एक बार यह प्रतिबद्ध हो गया था।

— GamrCorps
स्रोत

2

MATL , 18 बाइट्स

:Yq2^tqpwQpZd1Mhw/

इसे ऑनलाइन आज़माएं!

बड़े इनपुट के लिए विफल रहता है क्योंकि केवल पूर्णांकों तक 2^52आंतरिक रूप से सही प्रतिनिधित्व किया जा सकता है।

व्याख्या

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

— लुइस मेंडो
स्रोत

2

गणितज्ञ, 45 बाइट्स

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

अभाज्य? भिन्न? मेथेमेटिका।

— CalculatorFeline
स्रोत

1

हास्केल, 53 बाइट्स

अनाम फ़ंक्शन, 53 वर्ण:

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

इसे यहाँ आज़माएँ (ध्यान दें: मानक GHCi में आपको यह सुनिश्चित करने के लिए सबसे पहले ज़रूरत है Data.Ratioऔर Data.Listआयात किया गया है):

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

हास्केल की सूची अनुक्रमण !!0-आधारित है। (___!!)एक है ऑपरेटर अनुभाग , कि इतने एक गुमनाम समारोह के गठन (xs !!) n == xs !! n।

पूरे अनुक्रम को उत्पन्न करने के लिए यह चार बाइट्स कम है:

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

— विल नेस
स्रोत

0

गंभीरता से, 25 बाइट्स

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

आउटपुट a\nb( \nएक नई पंक्ति है)। बड़े इनपुट में लंबा समय लगेगा (और मेमोरी से बाहर निकलने के कारण विफल हो सकता है) क्योंकि प्राइम जेनरेशन काफी धीमी है।