चुनौती

एक पूर्णांक को देखते हुए, , इनपुट जहां के रूप में उत्पादन का मूल्य (कहाँ का प्रतिनिधित्व करता है Riemann जीटा समारोह )। $s$ $s\geq 1$ $\zeta(s)$ $\zeta(x)$

अग्रिम जानकारी

के रूप में परिभाषित किया गया है: $\zeta(s)$

ζ (s) = \sum_{n = 1}^{\infty} \frac{1}{n^{रों}}

$\zeta(s) = \sum\limits^\infty_{n=1}\frac{1}{n^s}$

आपको अपना उत्तर 5 दशमलव स्थानों पर (कोई अधिक, कोई कम नहीं) आउटपुट देना चाहिए। इस सवाल का जवाब बाहर आता है तो अनंत होने के लिए आपको उत्पादन करना चाहिए या अपनी भाषा में बराबर। $\infty$

रीमैन ज़ेटा बिल्ट-इन की अनुमति है, लेकिन इसे इस तरह से करना कम मज़ेदार है;)

उदाहरण

आउटपुट बिल्कुल नीचे दिखाए गए अनुसार होना चाहिए

Input -> Output
1 -> ∞ or inf etc.
2 -> 1.64493
3 -> 1.20206
4 -> 1.08232
8 -> 1.00408
19 -> 1.00000

इनाम

बिल्ट-इन की अनुमति के लिए सांत्वना के रूप में, मैं सबसे छोटे उत्तर के लिए 100-प्रतिनिधि इनाम की पेशकश करूंगा जो बिल्ट-इन ज़ीटा फ़ंक्शन का उपयोग नहीं करता है। (हरे रंग का चेकमार्क अभी भी समग्र समाधान के लिए जाएगा)

जीतना

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

code-golf math

— बीटा डिके
स्रोत

7

इस चुनौती में इस तरह की क्षमता थी ... जब तक आप

— बिल्डरों को

@ हेपर न्युट्रीनो येप, मैंने पोस्ट किया क्योंकि मैंने देखा कि चुनौती बिल्डरों को दी गई थी। FGITW

— NoOneIsHere

2

"5 दशमलव स्थानों की सटीकता के लिए" सख्त है? (यानी हम और अधिक परिशुद्धता के लिए उत्पादन कर सकते हैं?) नहीं तो परीक्षण मामलों वास्तव में 6dp दिखाना चाहिए।

— जोनाथन एलन

@JonathanAllen मैंने राउंडिंग कल्पना को साफ़ कर दिया है

— बीटा डेके

3

@BetaDecay (sigh no ping) क्या 19 वास्तव में टेक्स्ट को आउटपुट करना चाहिए 1.00000? मान्य नहीं होगा 1या नहीं 1.0? ऐसा लगता है कि आपने इसे गिरगिट की चुनौती बना दिया है।

— जोनाथन एलन

11

गणितज्ञ, ९ by ११ बाइट्स

Zeta@#~N~6&

स्पष्टीकरण:

Zeta@#       (* Zeta performed on input *)
      ~N     (* Piped into the N function *)
        ~6   (* With 6 digits (5 decimals) *)
          &  (* Make into function *)

बिना बिलिन:

गणितज्ञ, 23 यूटीएफ -8 बाइट्स

Sum[1/n^#,{n,∞}]~N~6&

केली लोडर को धन्यवाद

— यहाँ कोई नहीं हे
स्रोत

3

N@*Zetaदो बाइट बचाता है।

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

@*(बाएं) कंपोजिशन ऑपरेटर: f@*gएक फ़ंक्शन को दर्शाता है जिसका तर्क xमें मान है f[g[x]]।

— ग्रेग मार्टिन

@BetaDecay इसके लिए 1आउटपुट करता है ComplexInfinity, और यह 5स्थानों पर चक्कर लगाता है । (जैसे 1.64493)

— NoOneIsHere

@MartinEnder कैसे *काम करता है ?

— NoOneIsHere

1

@NoOneIsHere आपका उत्तर उपयोग करता है N~5लेकिन आपका स्पष्टीकरण उपयोग करता है 6।

— नंबरमान

8

जावास्क्रिप्ट, 81 70 66 65 बाइट्स

s=>s-1?new Int8Array(1e6).reduce((a,b,i)=>a+i**-s).toFixed(5):1/0

चलने योग्य उदाहरण:

ζ=s=>s-1?new Int8Array(1e6).reduce((a,b,i)=>a+i**-s).toFixed(5):1/0

const values = [ 1, 2, 3, 4, 8, 19 ];
document.write('<pre>');
for(let s of values) {
  document.write('ζ(' + s + ') = ' + ζ(s) + '\n')
}

स्निपेट का विस्तार करें

— Frxstrem
स्रोत

इसे Z क्यों कहते हैं? जेटा प्रतीक जेएस में एक मान्य फ़ंक्शन नाम है, और आपको इसे गोल्फ होने की आवश्यकता नहीं है।

— निधि मोनिका का मुकदमा

के Array(1e6).fill()साथ बदलें [...Array(1e6)], और पहले के (s)साथ बदलेंs

— कॉनर ओ'ब्रायन

1

@QPaysTaxes अच्छी बात है! यूनिकोड चर नाम ftw!

— फ्रैक्स्ट्रेम

@ ConorO'Brien Huh, मुझे कभी भी महसूस नहीं हुआ कि ऐरे ट्रिक (मुझे लगा कि विरल सरणियों ने पुनरावृति नहीं की है, लेकिन मुझे लगता है कि मैं गलत था)। धन्यवाद!

— फ्रैक्स्ट्रेम

@ फ्रेडस्ट्रीम ध्यान दें कि

— कोकोऑन

6

APL (Dyalog) , 22 21 बाइट्स

देखो मा, कोई बिल्ट-इन नहीं! -1 ngn के लिए धन्यवाद।

चूँकि Dyalog APL में असीमता नहीं है, मैं उपयोग करता हूँ Iverson की प्रस्तावित संकेतन का ।

{1=⍵:'¯'⋄5⍕+/÷⍵*⍨⍳!9}

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

{ अनाम फ़ंक्शन:

1=⍵: यदि तर्क एक है, तो:

'¯' एक मैक्रोन लौटें

⋄ अन्य

!9 नौ का गुट (362880)

⍳ पहले कि कई पूर्णांक i ntegers

⍵*⍨ उन्हें तर्क की शक्ति तक बढ़ाएं

÷ पारस्परिक मूल्य

+/ योग

5⍕ पांच दशमलव के साथ प्रारूप

} [अनाम फ़ंक्शन का अंत]

— एडम
स्रोत

1

1E6-> !9

— ngn

@ngn धन्यवाद।

— Adám

5

सी, 74 70 69 बाइट्स

n;f(s){double z=n=0;for(;++n>0;)z+=pow(n,-s);printf("%.5f",z/=s!=1);}

संकलन -fwrapv । आउटपुट के उत्पादन में कुछ समय लगेगा।

इसे यहां देखें । भाग ++n>0को बदल दिया गया है ++n<999999, इसलिए आपको प्रतीक्षा करने की आवश्यकता नहीं है। यह समान कार्यक्षमता और आउटपुट रखता है।

— 2501
स्रोत

floatकाम करता है ?

— l4m2

5

टीआई-बेसिक, 16 बाइट्स (कोई बिलियन नहीं)

Fix 5:Σ(X^~Ans,X,1,99

— Timtech
स्रोत

आपको वास्तव में Ans = 2 का उत्तर पाने के लिए लगभग 150000 तक जाने की आवश्यकता है, जो कि 84 Plus CE पर गणना करने के लिए आधे घंटे से अधिक समय लेगा। इसके अलावा, आप Ans (1) ^ 0 से गुणा कर सकते हैं। Ans = 1 के लिए त्रुटि प्राप्त करने के लिए, TI-Basic की अनंतता का निकटतम निरूपण!

— pizzapants184

@ pizzapants184 मुझे पूरी तरह पता है कि 2, 3, इत्यादि 99 से अधिक पुनरावृत्तियों को ले सकते हैं। आप बदल कर भी इस कार्यक्षमता प्राप्त कर सकते हैं 99के साथ E9जहां ई, वैज्ञानिक ई है यानी 10 ^ 9 प्रतिनिधित्व। (या स्पष्ट रूप से E5 की तरह कुछ छोटा)। यह समझना कि आमतौर पर E99 का उपयोग सकारात्मक अनंतता के लिए किया जाता है, सैद्धांतिक रूप से इस कार्यक्षमता के लिए भी अनुमति देता है, यदि योग की ऊपरी सीमा थी E99। एमुलेटर इसे भौतिक कैलकुलेटर की तुलना में बहुत तेजी से प्रदान कर सकते हैं। आपके विचारों के लिए धन्यवाद :)

— टाइमटेक

मुझे नहीं लगता कि यह अनंत को प्रदर्शित करता है। फ्लोटिंग-पॉइंट इंप्रेशन के कारण, यदि आपने 1 बार जोड़ा है तो यह एक त्रुटि भी नहीं होगी।

— lirtosiast

4

सी (जीसीसी) , 112 101 94 84 बाइट्स

सीलिंग से गोल्फिंग टिप्स के लिए धन्यवाद।

n;f(s){float r;for(n=98;n;r+=pow(n--,-s));printf("%.5f",r+pow(99,-s)*(.5+99./--s));}

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

— cleblanc
स्रोत

1

प्रश्न संपादित किया गया है। आप भाषा देशी अनंत प्रतीकों का उत्पादन कर सकते हैं।

— 2501

@2501 I reverted back to the previous answer, although I'm still quite a few bytes away from your solution.

— cleblanc

@ceilingcat f(1) doesn't seem correct.

— cleblanc

83 bytes

— ceilingcat

3

Julia, 36 bytes

x->x!=1?@sprintf("%.5f",zeta(x)):Inf

— Uriel
स्रोत

2

MATL, 21 bytes

q?'%.5f'2e5:G_^sYD}YY

Try it online!

Explanation

Input 1 is special-cased to output inf, which is how MATL displays infinity.

For inputs other than 1, summing the first 2e5 terms suffices to achieve a precision of 5 decimal places. The reason is that, from direct computation, this number of terms suffices for input 2, and for greater exponents the tail of the series is smaller.

q         % Input (implicit) minus 1
?         % If non-zero
  '%.5f'  %   Push string: format specifier
  2e5:    %   Push [1 2 ... 2e5]
  G       %   Push input again
  _       %   Negate
  ^       %   Power. element-wise
  s       %   Sum of array
  YD      %   Format string with sprintf
}         % Else
YY        %   Push infinity
          % End (implicit)
          % Display (implicit)

— Luis Mendo
स्रोत

2

R, 54 bytes

function(a){round(ifelse(a==1,Inf,sum((1:9^6)^-a)),5)}

Finds the sum directly and formats as desired, outputs Inf if a is 1. Summing out to 9^6 appears to be enough to get five-place accuracy while still being testable; 9^9 would get better accuracy in the same length of code. I could get this shorter if R had a proper ternary operator.

— Michael Lugo
स्रोत

1

function(a)round("if"(a-1,sum((1:9^6)^-a)),5) is a few bytes shorter.

— Giuseppe

Yes, but it throws an error if a = 1. function(a)round("if"(a-1,sum((1:9^6)^-a),Inf),5) works and is still shorter than my original solution.

— Michael Lugo

Oh yes of course! I forgot to include the Inf, that's what I get for typing code into the comment box directly...

— Giuseppe

2

C,129 130 128 bytes

#include<math.h>
f(s,n){double r=0;for(n=1;n<999;++n)r+=(n&1?1:-1)*pow(n,-s);s-1?printf("%.5f\n",r/(1-pow(2,1-s))):puts("oo");}

it uses the following formula

$\ zeta (s) = \ frac {1} {1-2 ^ {1-s}} \ sum \ limit_ {n = 1} ^ {\ infty} {\ frac {(1) ^ {n + 1} } {n ^ रों}}$

test and results

main(){f(2,0);f(1,0);f(3,0);f(4,0);f(8,0);f(19,0);}

1.64493
+oo
1.20206
1.08232
1.00408
1.00000

— RosLuP
स्रोत

Why this equation instead of Σ(1/(n^s))? It seems much more complicated...

— Beta Decay

@ BetaDecay क्योंकि परिणाम खोजने में यह मुझे अधिक तेज लगता है; यहाँ in (n (१ / (n ^ s)) ’में १.९९९ में राशि के लिए सीमा है। १.१० ^ ६ में

— आवश्यकता है

1

समझा। FYI करें, बस ooठीक है, आपको इसे सकारात्मक के रूप में निर्दिष्ट करने की आवश्यकता नहीं है

— बीटा डिके

1

85 बाइट्स

— छत

@ceilingcat आप इस प्रश्न के लिए एक अन्य प्रविष्टि लिख सकते हैं ... ऐसा लगता है कि मुझे यहां गणित के बिना याद है। हेडर यह लिंक नहीं है ...

— RosLuP

2

अजगर 3: 67 बाइट्स (कोई बिल्ट-इन नहीं)

f=lambda a:"∞"if a<2else"%.5f"%sum([m**-a for m in range(1,10**6)])

Nothing fancy, only uses python 3 because of the implicit utf-8 encoding.

Try it online with test cases.

— Chris H
स्रोत

1

Perl 6, 50 bytes

{$_-1??(1..1e6).map(* **-$_).sum.fmt('%.5f')!!∞}

— Sean
स्रोत

1

PARI / GP, 27 26 बाइट्स

\p 6
s->trap(,inf,zeta(s))

— alephalpha
स्रोत

1

जेली , 23 बाइट्स

ȷ6Rİ*⁸S÷Ị¬$ær5;ḷỊ?”0ẋ4¤

Try it online!

कैसे?

Sums the first million terms
द्वारा विभाजित 0जब abs(input)<=1उपज के लिए inf(बजाय14.392726722864989 ) के लिए1
5 दशमलव स्थानों पर घाव
abs(result)<=1प्रारूप करने के लिए चार शून्य जोड़ता है1.0 के रूप में1.00000
परिणाम प्रिंट करता है

ȷ6Rİ*⁸S÷Ị¬$ær5;ḷỊ?”0ẋ4¤ - Main link: s
ȷ6                      - literal one million
  R                     - range: [1,2,...,1000000]
   İ                    - inverse (vectorises)
     ⁸                  - link's left argument, s
    *                   - exponentiate
      S                 - sum
          $             - last two links as a monad:
        Ị               -   insignificant? (absolute value of s less than or equal to 1?)
         ¬              -   not (0 when s=1, 1 when s>1)
       ÷                - divide (yielding inf when s=1, no effect when s>1)
           ær5          - round to 10^-5
                      ¤ - nilad followed by link(s) as a nilad:
                  ”0    -   literal '0'
                    ẋ4  -   repeated four times
                Ị?      - if insignificant (absolute value less than or equal to 1?)
              ;         -       concatenate the "0000" (which displays as "1.00000")
               ḷ        - else: left argument
                        - implicit print

— जोनाथन एलन
स्रोत

1

अजगर 3 + SciPy, 52 बाइट्स

lambda n:'%.5f'%zeta(n,1)
from scipy.special import*

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

— totallyhuman
स्रोत

1

क्या यह आउटपुट ∞इनपुट के लिए है 1?

— ETHproductions

1

इसी तरह, क्या यह पांच दशमलव स्थानों के लिए गोल है?

— बीटा डिके

1

@ETHproductions यह आउटपुट infकी अनुमति देता है।

— पूरी तरह से

सुपर लेट, लेकिन क्या आप zetac(n)इसके बजाय सिर्फ उपयोग नहीं कर सकते थे zeta(n,1)?

— NoOneIsHere

0

जेली , 26 बाइट्स

⁵*5İH+µŒṘḣ7
⁴!Rİ*³SÇµ’İµ’?

इस लिंक के साथ ऑनलाइन कोशिश मत करो ! (चूँकि यह 16 का उपयोग करता है! ~ 20 ट्रिलियन शब्द, TIO पर चलने से मेमोरी मेमोरी बनता है)

इसे ऑनलाइन आज़माएंइसके बजाय इस लिंक से । (इसके बजाय 1 मिलियन शब्दों का उपयोग करता है। बहुत अधिक प्रबंधनीय लेकिन एक और बाइट लेता है)

infइनपुट 1 के लिए रिटर्न

व्याख्या

⁵*5İH+µŒṘḣ7    - format the output number
⁵*5İH+         - add 0.000005
      µŒṘ      - get a string representation
         ḣ7    - trim after the fifth decimal.

⁴!Rİ*³SÇµ’İµ’? - main link, input s
           µ’? - if input minus 1 is not 0...
⁴!R            -   [1,2,3,...,16!] provides enough terms.
   İ           -   take the inverse of each term
    *³         -   raise each term to the power of s
      S        -   sum all terms
       Ç       -   format with the above link
               - else:
        µ’İ    -   return the reciprocal of the input minus 1 (evaluates to inf)

26 में से, बाइट्स, 7 का उपयोग गणना के लिए किया जाता है, 12 प्रारूपण के लिए, और 7 infशून्य पर उत्पादन के लिए होते हैं । इसके लिए बेहतर गोल्फ होना जरूरी है।

— fireflame241
स्रोत

ȷ6फैक्टरियल वर्कअराउंड को हटाते हुए एक मिलियन का न्यूमेरिक शाब्दिक है।

— जोनाथन एलन

0

मैथॉल्फ़ , 14 बाइट्स (कोई बिलियन नहीं)

┴¿Å'∞{◄╒▬∩Σ░7<

ध्यान दें कि TIO लिंक में, मैंने प्रतिस्थापित ◄किया है ►, जिसने धक्का दिया $10^6$ के बजाय $10^7$ । इसका कारण यह है कि संस्करण को सभी परीक्षण मामलों के लिए यहां प्रस्तुत किया गया है। इसके परिणामस्वरूप 3 और 8 के उत्तर 1 दशमलव स्थान से बंद हो जाते हैं। हालांकि, मैथॉल्फ में बड़े पैमाने पर 1-बाइट संख्यात्मक शाब्दिक हैं, जो मनमानी दशमलव परिशुद्धता के लिए अनुमति देते हैं।

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

व्याख्या

┴                check if equal to 1
 ¿               if/else (uses one of the next two characters/blocks in the code)
  Å              start block of length 2
   '∞            push single character "∞"
     {           start block or arbitrary length
      ◄          push 10000000
       ╒         range(1,n+1)
        ▬        pop a, b : push(b**a)
         ∩       pop a : push 1/a (implicit map)
          Σ      sum(list), digit sum(int)
           ░     convert to string (implicit map)
            7    push 7
             <   pop(a, b), push(a<b), slicing for lists/strings

— maxb
स्रोत

0

जावास्क्रिप्ट (Node.js) , 64 बाइट्स

s=>[...Array(1e6)].reduce((a,b,i)=>s>1>i?a:i**-s+a,0).toFixed(5)

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

Frxstrem की ओर इशारा किया

— l4m2
स्रोत

के मान की गणना

चुनौती

अग्रिम जानकारी

उदाहरण

इनाम

जीतना

गणितज्ञ, ९ by ११ बाइट्स

गणितज्ञ, 23 यूटीएफ -8 बाइट्स

जावास्क्रिप्ट, 81 70 66 65 बाइट्स

चलने योग्य उदाहरण:

APL (Dyalog) , 22 21 बाइट्स

सी, 74 70 69 बाइट्स

टीआई-बेसिक, 16 बाइट्स (कोई बिलियन नहीं)

सी (जीसीसी) , 112 101 94 84 बाइट्स

Julia, 36 bytes

MATL, 21 bytes

Explanation

R, 54 bytes

C,129 130 128 bytes

अजगर 3: 67 बाइट्स (कोई बिल्ट-इन नहीं)

Perl 6, 50 bytes

PARI / GP, 27 26 बाइट्स

जेली , 23 बाइट्स

कैसे?

अजगर 3 + SciPy, 52 बाइट्स

जेली , 26 बाइट्स

मैथॉल्फ़ , 14 बाइट्स (कोई बिलियन नहीं)

व्याख्या

जावास्क्रिप्ट (Node.js) , 64 बाइट्स