here 및 here 관련 링크 가 있지만 여기에 짧은 버전이 있습니다.

두 개의 정수 입력 a과 b음의 무한대와 무한대 사이에 입력해야합니다 (필요한 경우 범위를 제한 할 수 있지만 함수는 여전히 음수 입력을 수락해야 함).

크로네 커 심볼의 정의

(a|b)입력 a과 b위치에 크로네 커 기호 를 반환해야합니다

(a|b) = (a|p_1)^e_1 * (a|p_2)^e_2 * ... * (a|p_n)^e_n

여기서 b = p_1^e_1 * p_2^e_2 * ... * p_n^e_n, 및 p_i과 것은 e_i의 소인수 분해의 소수 및 지수입니다 b.

홀수 소수를 들어 p, (a|p)=a^((p-1)/2) (mod p)같은 정의 여기 .

를 들어 b == 2,(n|2)={0 for n even; 1 for n odd, n=+/-1 (mod 8); -1 for n odd, n=+/-3 (mod 8)

를 들어 b == -1,(n|-1)={-1 for n<0; 1 for n>0

만약 a >= b, (a|b) == (z|b)여기서 z == a % b. 설명이 속성으로하고, 여기 및 여기에서 , a의 제곱 잉여 인 b경우 z에도있다 a >= b.

(-1|b)= 1if b == 0,1,2 (mod 4)and -1if b == 3 (mod 4). (0|b)인 0을 제외 (0|1)하는 것입니다 1때문에, (a|1)항상 1음의를 위해 a, (-a|b) == (-1|b) * (a|b).

크로네 커 심볼의 출력은 항상 -1, 0 or 1출력이고, 0경우 a와 b어떤 공통 요소를 가지고있다. If b가 홀수 인 (a|b) == 1경우 if a는 2 차 잔차 mod b이고, 2 차 잔차-1 가 아닌 경우

규칙

• 코드는 프로그램 또는 함수 여야합니다.

• 입력은 순서대로 이루어져야합니다 a b.

• 출력은 하나 여야합니다 -1, 0또는 1.

• 이것은 코드 골프이므로 코드가 효율적일 필요는 없습니다.

• 크로네 커 또는 관련 Jacobi 및 Legendre 기호를 직접 계산하는 내장 기능이 없습니다. 다른 기본 제공 (예 : 소인수 분해)은 공정한 게임입니다.

예

>>> kronecker(1, 5)
1
>>> kronecker(3, 8)
-1
>>> kronecker(15, 22)
1
>>> kronecker(21, 7)
0
>>> kronecker(5, 31)
1
>>> kronecker(31, 5)
1
>>> kronecker(7, 19)
1
>>> kronecker(19, 7)
-1
>>> kronecker(323, 455625)
1
>>> kronecker(0, 12)
0
>>> kronecker(0, 1)
1
>>> kronecker(12, 0)
0
>>> kronecker(1, 0)
1
>>> kronecker(-1, 5)
1
>>> kronecker(1, -5)
1
>>> kronecker(-1, -5)
-1
>>> kronecker(6, 7)
-1
>>> kronecker(-1, -7)
1
>>> kronecker(-6, -7)
-1

이것은 복잡한 기능이므로 불분명 한 사항이 있으면 알려주십시오.

CJam (70 바이트)

{_g\zmf+f{:P2+"W>2*(
z1=
;1
7&4-z[0W0X0]=
P%P+P(2/#P%_1>P*-"N/<W=~}:*}

온라인 데모 (Mathematica로 생성 된 테스트 사례).

해부

{               e# Anonymous function. Stack: a b
  _g\zmf+       e# Factorise b, with special treatment for negatives
                e# CJam also gives special treatment to 0 and 1
                e# Stack: e.g. a [-1 2 2 5]; or a [-1 1]; or a [0 0]; or a [1 2 2 5]
  f{            e# For each "prime" factor P, find (a|P)
    :P2+        e# Extract code for P from an array formed by splitting a string
    "W>2*(      e#   a -> (a|-1)
z1=             e#   a -> (a|0)
;1              e#   a -> (a|1)
7&4-z[0W0X0]=   e#   a -> (a|2)
P%P+P(2/#P%_1>P*-" e# a -> (a|P) for odd prime P
    N/<W=~      e# Split string and select appropriate element
  }
  :*            e# Multiply the components together
}

(a|2)동일한 문자 수 를 평가 하는 몇 가지 방법을 발견했으며 가장 명확한 표현을 사용하도록 선택했습니다.

integer array <W= IMO는 폴백을 수행하는 매우 우아한 방법입니다. 정수가 배열의 길이보다 크면 마지막 요소를 선택합니다.

다른 의견

홀수 프라임의 p경우 직접 Fermat 스타일 (a|p)이 너무 짧아서 실망 스럽습니다 . 왜냐하면 내가 사용하고 싶은 (a|n)긍정적 인 홀수 n를 찾는 매우 골프적인 방법이 있기 때문 입니다. 기본은 Zolotarev의 명예입니다.

경우 p홀수 소수와 a정수의 서로 소이며 p다음 르장 드르 기호 (a|p)순열의 표시이다x -> ax (mod p)

이것은 Frobenius에 의해 강화되었습니다

경우 a와는 b서로 소 양의 홀수의 정수는 다음 코비 기호 (a|b)순열의 표시이다x -> ax (mod b)

Lerch가

경우 b양의 홀수의 정수와 a정수의 서로 소이며 b다음 코비 기호 (a|b)순열의 표시이다x -> ax (mod b)

Brunyate와 Clark, Zolotarev-Frobenius 접근을 2 차 상호 작용으로 확장, Ramanujan Journal 37.1 (2014) : 25-50 참조.

그리고 그것은 한 단계 더 쉽게 강화 될 수 있습니다 (문헌에서 이것을 보지 못했지만).

경우 b양의 홀수의 정수이며, a정수 후 코비 심볼 (a|b)맵의 레 비치 비타 기호이다 x -> ax (mod b).

증명 : 만약 acoprime 이라면 bZolotarev-Frobenius-Lerch를 사용합니다; 그렇지 않으면 맵은 순열이 아니며 Levi-Civita 기호는 0원하는대로입니다.

이것은 Jacobi 기호 계산을 제공합니다

{_2m*{~>},@ff*\ff%::-:*g}

그러나 특별한 치료가 필요 (a|-1)하고 (a|2)나는이 방법 짧은 크로네 기호를 계산하는 방법을 발견하지 않은 것을 의미합니다 : 그것은 factorise에 짧은이고 개별적으로 소수를 처리합니다.

파이썬 3, 747 3,335 바이트

예를 들어 약간의 골프 만 치고 답이 어떻게 보일지에 대한 아이디어를 제공합니다.

그리고 그렇습니다. 소인수 분해와 런-길이-인코딩 비트는 Pyth에서 isaacg에 대한 사과와 함께 막혀 있습니다.

from itertools import*
def k(d,r):
 if d<0:a=-d;m=1
 else:a=d;m=0
 if r==1:return 1
 p=1;w=r;n=2;f=[]
 while n*n<=w:
  while w%n<1:w//=n;f+=n,
  n+=1
 if w>1:f+=w,
 z=[[k,len(list(g))]for k,g in groupby(f)]
 for i,j in z:
  if i==2:p*=pow(-1,(a*a-1)//8)
  x=pow(a,(i-1)//2,i)
  if x>1:x-=i
  p*=x**j
 if m:p*=pow(-1,(r-1)//2)
 return p

매쓰, 169 (175) 165 바이트

(1|-1)~k~0=_~k~1=1
_~k~0=0
a_~k~-1=If[a<0,-1,1]
a_~k~2=DirichletCharacter[8,2,a]
a_~k~p_/;PrimeQ@p=Mod[a^((p-1)/2),p,-1]
a_~k~b_:=1##&@@(a~k~#^#2&@@@FactorInteger@b)

LabVIEW, 44 바이트 LabVIEW 프리미티브

a가 b보다 크면 대칭 적이므로 입력을 교체했습니다.

이제 실제 공식을 나타냅니다

항상 따라 계산

진정한 경우

줄리아, 195 바이트

k(a,b)=b==0?a∈[1,-1]?1:0:b==1?1:b==2?iseven(a)?0:a%8∈[1,-1]?1:-1:b==-1?a<1?-1:1:isprime(b)&&b>2?a%b==0?0:a∈[i^2%b for i=0:b-1]?1:-1:k(a,sign(b))*prod(i->k(a,i)^factor(b)[i],keys(factor(b)))

k두 개의 정수를 허용하고 정수를 리턴하는 재귀 함수 입니다.

언 골프 드 :

function k(a::Integer, b::Integer)
    if b == 0
        return a ∈ [1, -1] ? 1 : 0
    elseif b == 1
        return 1
    elseif b == 2
        return iseven(a) ? 0 : a % 8 ∈ [1, -1] ? 1 : -1
    elseif b == -1
        return a < 1 ? -1 : 1
    elseif isprime(b) && b > 2
        return a % b == 0 ? 0 : a ∈ [i^2 % b for i = 1:b-1] ? 1 : -1
    else
        p = factor(b)
        return k(a, sign(b)) * prod(i -> k(a, i)^p[i], keys(p))
    end
end

하스켈, 286 바이트

a#0|abs a==1=1|1<2=0
a#1=1
a#2|even a=0|mod a 8`elem`[1,7]=1|1<2=(-1)
a#b|b<0=a`div`abs a*a#(-b)|all((/=0).mod b)[2..b-1]=if elem n[0,1] then n else(-1)|1<2=product$map(a#)$f b where n=a^(div(b-1)2)`mod`b
f 1=[]
f n|n<0=(-1):f(-n)|1<2=let p=head$filter((==0).mod n)[2..n]in p:f(div n p)

아마도 완전히 최적화 된 것은 아니지만 용감한 노력입니다. 크로네 커 기호는 삽입 함수 a # b, 즉

*Main>323#455265 
1