Giriş

Bulduğum bu soruyu belli değildi çünkü kapatıldı, henüz güzel bir fikirdi. Bunu açık bir meydan okuma haline getirmek için elimden geleni yapacağım.

Riemann Zeta fonksiyonu analitik devamı olarak tanımlanır özel bir fonksiyondur

karmaşık düzleme. Kod golf için ilginç kılan birçok eşdeğer formülü vardır.

Meydan okuma

Giriş olarak 2 şamandıra alan bir program yazın (karmaşık bir sayının gerçek ve hayali kısmı) ve bu noktada Riemann Zeta işlevini değerlendirir.

kurallar

• Konsol üzerinden giriş ve çıkış VEYA işlev giriş ve dönüş değeri
• Karmaşık sayılara yerleşik olarak izin verilmez, şamandıralar kullanın (sayı, çift, ...)
• Matematiksel fonksiyonlar + - * / pow logve gerçek değerli trig fonksiyonları (entegre etmek istiyorsanız, gama fonksiyonunu kullanın, ... bu fonksiyon tanımını koda eklemeniz gerekir)
• Giriş: 2 şamandıra
• Çıktı: 2 şamandıra
• Kodunuz, rasgele büyük / küçük yapıldığında teorik olarak keyfi hassasiyet sağlayan değer içermelidir
• Giriş 1'deki davranış önemli değildir (bu, bu fonksiyonun tek kutbudur)

Bayt cinsinden en kısa kod kazanır!

Örnek Giriş ve Çıkış

Giriş:

2, 0

Çıktı:

1.6449340668482266, 0

Giriş:

1, 1

Çıktı:

0.5821580597520037, -0.9268485643308071

Giriş:

-1, 0

Çıktı:

-0.08333333333333559, 0

Python - 385

Bu, Denklem 21'in http://mathworld.wolfram.com/RiemannZetaFunction.html adresinden basit bir uygulamasıdır. Bu, isteğe bağlı argümanlar için Python kuralını kullanır; bir kesinlik belirtmek istiyorsanız, işleve üçüncü bir argüman iletebilirsiniz, aksi takdirde varsayılan olarak 1e-24 kullanır.

import numpy as N
def z(r,i,E=1e-24):
 R=0;I=0;n=0;
 while(True):
  a=0;b=0;m=2**(-n-1)
  for k in range(0,n+1):
   M=(-1)**k*N.product([x/(x-(n-k))for x in range(n-k+1,n+1)]);A=(k+1)**-r;t=-i*N.log(k+1);a+=M*A*N.cos(t);b+=M*A*N.sin(t)
  a*=m;b*=m;R+=a;I+=b;n+=1
  if a*a+b*b<E:break
 A=2**(1-r);t=-i*N.log(2);a=1-A*N.cos(t);b=-A*N.sin(t);d=a*a+b*b;a=a/d;b=-b/d
 print(R*a-I*b,R*b+I*a)

Python 3 , 303297 bayt

Bu cevap RT'nin Python cevabına dayanmaktadır çeşitli değişikliklerle :

• İlk olarak, Binomial(n, k)olarak tanımlanır p = p * (n-k) / (k+1)bahsedilen değişiklikler Binomial(n,k)içinBinomial(n,k+1) döngü için her geçiş ile.
• İkincisi, (-1)**k * Binomial(n,k)oldup = p * (k-n) / (k+1) for döngüsünün her adımında işareti çeviren .
• Üçüncü olarak, whiledöngü hemen kontrol edilecek şekilde değiştirildia*a + b*b < E .
• Dördüncüsü, değil operatör bitsel ~onlar gibi kimliklerini kullanarak, golf yardımcı olur çeşitli yerlerde kullanılır -n-1 == ~n, n+1 == -~nven-1 == ~-n .

Daha iyi golf oynamak için birkaç küçük değişiklik yapıldı. for döngüyü bir hattaprint ondan önceki kodla bir hatta çağrı yapmak .

Golf önerileri hoş geldiniz. Çevrimiçi deneyin!

Düzenleme: Küçük değişiklikler bir dizi -6 bayt.

import math as N
def z(r,i,E=1e-40):
 R=I=n=0;a=b=1
 while a*a+b*b>E:
  a=b=0;p=1;m=2**~n
  for k in range(1,n+2):M=p/k**r;p*=(k-1-n)/k;t=-i*N.log(k);a+=M*N.cos(t);b+=M*N.sin(t)
  a*=m;b*=m;R+=a;I+=b;n+=1
 A=2**-~-r;t=-i*N.log(2);x=1-A*N.cos(t);y=A*N.sin(t);d=x*x+y*y;return(R*x-I*y)/d,(R*y+I*x)/d

Aksiyom, 413 315292 bayt

p(n,a,b)==(x:=log(n^b);y:=n^a;[y*cos(x),y*sin(x)]);z(a,b)==(r:=[0.,0.];e:=10^-digits();t:=p(2,1-a,-b);y:=(1-t.1)^2+t.2^2;y=0=>[];m:=(1-t.1)/y;q:=t.2/y;n:=0;repeat(w:=2^(-n-1);abs(w)<e=>break;r:=r+w*reduce(+,[(-1)^k*binomial(n,k)*p(k+1,-a,-b) for k in 0..n]);n:=n+1);[r.1*m-q*r.2,m*r.2+r.1*q])

Bu, http://mathworld.wolfram.com/RiemannZetaFunction.html adresinden 21 denklemini de uygulayacaktır . Yukarıda zio (a, b) fonksiyonunun zx (a, b) 16x daha yavaş olanı yukarıda belirtilmiş olmalıdır. derlenmiş olması gerekir] hepsi ungolfed ve [Zeta için 1 saniye () kayan noktadan 20 basamaklı bir değer için z () için 16 saniye karşı]. Rakam sorusu için, rakam (); işlevi, örneğin rakamlar (10); z (1,1) noktadan sonra 10 rakam yazdırmalı, ancak rakamlar (50); z (1,1) noktadan sonra 50 rakam yazmalıdır.

-- elevImm(n,a,b)=n^(a+i*b)=r+i*v=[r,v]
elevImm(n:INT,a:Float,b:Float):Vector Float==(x:=log(n^b);y:=n^a;[y*cos(x),y*sin(x)]::Vector Float);

--                      +oo               n
--                      ---              ---
--             1        \       1        \            n 
--zeta(s)= ---------- * /     ------  *  /    (-1)^k(   )(k+1)^(-s)
--          1-2^(1-s)   ---n  2^(n+1)    ---k         k  
--                       0                0


Zeta(a:Float,b:Float):List Float==
  r:Vector Float:=[0.,0.]; e:=10^-digits()

  -- 1/(1-2^(1-s))=1/(1-x-i*y)=(1-x+iy)/((1-x)^2+y^2)=(1-x)/((1-x)^2+y^2)+i*y/((1-x)^2+y^2)    

  t:=elevImm(2,1-a,-b);
  y:=(1-t.1)^2+t.2^2;
  y=0=>[] 
  m:=(1-t.1)/y; 
  q:=t.2/y
  n:=0
  repeat
     w:=2^(-n-1)
     abs(w)<e=>break  --- this always terminate because n increase
     r:=r+w*reduce(+,[(-1)^k*binomial(n,k)*elevImm(k+1,-a,-b) for k in 0..n])
     n:=n+1
  -- (m+iq)(r1+ir2)=(m*r1-q*r2)+i(m*r2+q*r1)
  [r.1*m-q*r.2,m*r.2+r.1*q]

this is one test for the z(a,b) function above:

(10) -> z(2,0)
   (10)  [1.6449340668 482264365,0.0]
                                              Type: List Expression Float
(11) -> z(1,1)
   (11)  [0.5821580597 520036482,- 0.9268485643 3080707654]
                                              Type: List Expression Float
(12) -> z(-1,0)
   (12)  [- 0.0833333333 3333333333 3,0.0]
                                              Type: List Expression Float
(13) -> z(1,0)
   (13)  []