도전

입력으로 정수 주어질 때, s ≥ 1 은 ζ ( s ) 의 값을 출력합니다 (여기서 ζ ( x ) 는 Riemann Zeta Function을 나타냄).$s$$s\geq 1$$\zeta(s)$$\zeta(x)$

추가 정보

는 다음과 같이 정의됩니다.$\zeta(s)$

답을 소수점 이하 5 자리 (더 이상, 더 이상)로 출력해야합니다. 대답이 무한대로 나오면 언어로 또는 그와 동등한 것을 출력 해야합니다.$\infty$

Riemann Zeta 내장 기능은 허용되지만 그렇게하는 것이 재미는 없습니다.)

예

출력은 아래 표시된 것과 정확히 일치해야합니다.

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

하사품

빌트인을 허용하기위한 위안으로서, 제타 함수를 사용 하지 않는 최단 답변에 100 회 현상금을 제공 할 것 입니다. (녹색 확인 표시는 여전히 전체적으로 가장 짧은 솔루션으로 이동합니다)

승리

바이트 단위의 가장 짧은 코드가 이깁니다.

수학, 9 7 11 바이트

Zeta@#~N~6&

설명:

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

내장없이 :

Mathematica, 23 UTF-8 바이트

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

Kelly Lowder에게 감사합니다

자바 스크립트, 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')
}

APL (Dyalog) , 22 21 바이트

엄마 봐, 내장이 없어! ngn 덕분에 -1입니다.

Dyalog APL에는 무한대가 없으므로 Iverson의 제안 된 표기법을 사용 합니다.

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

온라인으로 사용해보십시오!

{ 익명의 기능 :

 1=⍵: 인수가 하나 인 경우 :

  '¯' 마크로를 반환

 ⋄ 그밖에

  !9 9의 계승 (362880)

  ⍳ 먼저 많은 정수 와 ntegers

  ⍵*⍨ 논쟁의 힘으로 그들을 제기

  ÷ 상호 가치

  +/ 합집합

  5⍕ 소수점 다섯 자리 형식

} [익명 기능의 끝]

C, 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되어 기다릴 필요가 없습니다. 이것은 동일한 기능과 출력을 유지합니다.

TI 기본, 16 바이트 (내장 없음)

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

C (gcc) , 112 (101) 94 84 바이트

ceilingcat의 골프 팁에 감사드립니다.

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

온라인으로 사용해보십시오!

줄리아 , 36 바이트

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

MATL , 21 바이트

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

온라인으로 사용해보십시오!

설명

출력 1은 특수한 경우에 출력inf MATL이 무한대를 표시하는 방식입니다.

이외의 입력의 1경우 첫 번째 2e5항을 합하면 소수점 이하 5 자리의 정밀도를 달성 할 수 있습니다. 그 이유는 직접 계산에서이 수의 항은 입력에 충분하고 2지수가 클수록 계열의 꼬리가 더 작기 때문입니다.

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)

R, 54 바이트

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

합계를 직접 Inf찾고 원하는대로 형식을 지정하고 a가 1 인 경우 출력합니다. 합계 9^6는 테스트 가능하면서 5 자리 정확도를 얻을 수있는 것으로 보입니다. 9^9동일한 길이의 코드에서 더 나은 정확도를 얻을 수 있습니다. R에 적절한 삼항 연산자가 있으면 이것을 더 짧게 얻을 수 있습니다.

C, 129130128 바이트

#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");}

그것은 다음 공식을 사용합니다

테스트 및 결과

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

파이썬 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.

Perl 6, 50 bytes

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

PARI/GP, 27 26 bytes

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

Jelly, 23 bytes

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

Try it online!

How?

• Sums the first million terms
• Divides by 0 when abs(input)<=1 to yield inf (rather than 14.392726722864989) for 1
• Rounds to 5 decimal places
• Appends four zeros if abs(result)<=1 to format the 1.0 as 1.00000
• Prints the result

ȷ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

Python 3 + SciPy, 52 bytes

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

Try it online!

Jelly, 26 bytes

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

Don't try it online with this link! (Since this uses 16!~20 trillion terms, running on TIO produces a MemoryError)

Try it online with this link instead. (Uses 1 million terms instead. Much more manageable but takes one more byte)

Returns inf for input 1.

Explanation

⁵*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)

Out of the 26, bytes, 7 are used for computation, 12 are for formatting, and 7 are for producing inf on zero. There has to be a better golf for this.

MathGolf, 14 bytes (no builtins)

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

Note that in the TIO link, I have substituted ◄ for ►, which pushed $10^6$ instead of $10^7$. This is because the version submitted here timeouts for all test cases. This results in the answers for 3 and 8 to be off by 1 decimal place. However, there are way bigger 1-byte numerical literals in MathGolf, allowing for arbitrary decimal precision.

Try it online!

Explanation

┴                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

JavaScript (Node.js), 64 bytes

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

Try it online!

Pointed in Frxstrem's