क्रॉकर प्रतीक की गणना करें


9

यहाँ और यहाँ प्रासंगिक लिंक , लेकिन यहाँ संक्षिप्त संस्करण है:

आपके पास दो पूर्णांक 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)= 1यदि b == 0,1,2 (mod 4)और -1यदि 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कोई भी सामान्य कारक होता है। तो b, एक अजीब प्रधानमंत्री है (a|b) == 1, तो aएक है द्विघात अवशेषों आधुनिक b, और -1अगर है यह एक द्विघात अवशेषों नहीं है।

नियम

  • आपका कोड एक प्रोग्राम या एक फ़ंक्शन होना चाहिए।

  • इनपुट क्रम में होना चाहिए a b

  • उत्पादन या तो होना चाहिए -1, 0या 1

  • यह कोड गोल्फ है, इसलिए आपके कोड को कुशल होने की जरूरत नहीं है, बस संक्षिप्त है।

  • कोई बिल्ट-इन जो सीधे क्रॉंकर या संबंधित जैकोबी और लिजेंड्रे प्रतीकों की गणना नहीं करता है। अन्य बिल्ट-इन (मुख्य कारक के लिए, उदाहरण के लिए) उचित खेल हैं।

उदाहरण

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

यह एक जटिल कार्य है, इसलिए कृपया मुझे बताएं कि क्या कुछ स्पष्ट नहीं है।


क्या आप वाकई बिल-इन को अस्वीकार नहीं करना चाहते हैं? reference.wolfram.com/language/ref/KroneckerSymbol.html
मार्टिन एंडर

@ मार्टिनबटनर जब मैंने आपकी टिप्पणी देखी तो मैं उदाहरणों में संपादन कर रहा था। मैं बिल्ट-इन को अस्वीकार कर दूंगा जो सीधे क्रोनकर, जैकोबी या लीजेंड्री प्रतीकों की गणना करता है, लेकिन कुछ और (प्राइम फैक्टराइजेशन फ़ंक्शन सहित) निष्पक्ष खेल होना चाहिए।
शर्लक

im पूरी तरह से सुनिश्चित नहीं है कि क्यों (31 | 5) देता है 1. एक चतुष्कोणीय अवशेष नहीं होना चाहिए, इसलिए यह -1 क्यों नहीं है?
Eumel

यह भी 7/19 होना चाहिए 1 और 19/7 आपके द्वारा जुड़े विकी के अनुसार -1 होना चाहिए
यूमेल

3
यदि समाधानों को नकारात्मक और शून्य इनपुट को सही तरीके से संभालना है, तो आपको निश्चित रूप से उसके लिए कुछ परीक्षण मामलों को जोड़ना चाहिए।
मार्टिन एंडर

जवाबों:


2

CJam (70 बाइट्स)

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

ऑनलाइन डेमो (गणित के साथ उत्पन्न परीक्षण मामले)।

विच्छेदन

{               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लिए प्रत्यक्ष (a|p)फ़र्मेट -स्टाइल बहुत कम है, क्योंकि (a|n)सकारात्मक विषम के लिए खोजने का एक बहुत ही गॉस्टी तरीका है nजिसका मैं उपयोग करना चाहता था। आधार है ज़ोलोटेरेव का लेम्मा:

यदि pएक विषम प्राइम है और aयह पूर्णांक pप्रतीक (a|p)है तो लीजेंड्रे प्रतीक क्रमपरिवर्तन का संकेत हैx -> ax (mod p)

यह फ्रोबेनियस द्वारा मजबूत किया गया था

यदि aऔर bसहानुभूति सकारात्मक विषम पूर्णांक हैं तो जैकोबी प्रतीक (a|b)क्रमचय का संकेत हैx -> ax (mod b)

और लिर्च द्वारा

यदि bएक सकारात्मक विषम पूर्णांक है और aएक पूर्णांक है bतो जैकोबी प्रतीक (a|b)क्रमपरिवर्तन का संकेत हैx -> ax (mod b)

ब्रूनिट और क्लार्क को देखें, द्विघात पारस्परिकता के लिए ज़ोलोटेरेव-फ्रोबेनियस दृष्टिकोण का विस्तार करते हुए , द रामानुजन जर्नल 37.1 (2014): 25-50 संदर्भों के लिए।

और इसे आसानी से एक कदम और मजबूत किया जा सकता है (हालाँकि मैंने इसे साहित्य में नहीं देखा है)

यदि bएक सकारात्मक विषम पूर्णांक है और aएक पूर्णांक है तो जैकोबी प्रतीक (a|b)मानचित्र का लेवी-सिविता प्रतीक है x -> ax (mod b)

प्रमाण: यदि aसहानुभूति है bतो हम Zolotarev-Frobenius-Lerch का उपयोग करते हैं; अन्यथा नक्शा क्रमपरिवर्तन नहीं है, और लेवी-सिविता प्रतीक 0वांछित है।

यह जैकोबी प्रतीक गणना देता है

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

लेकिन इसके लिए आवश्यक विशेष उपचार (a|-1)और (a|2)इसका मतलब है कि मुझे क्रोनकर प्रतीक की गणना करने का एक तरीका नहीं मिला है जो इस दृष्टिकोण से छोटा है: यह व्यक्तिगत रूप से अपराधों को कारक और इलाज करने के लिए छोटा है।


4

पायथन 3, 747 369 335 बाइट्स

एक उदाहरण के जवाब के रूप में, केवल थोड़ा गोल्फ वाला है, और आपको यह अनुमान लगाने के लिए कि एक उत्तर कैसा दिखेगा।

और हाँ, प्रधान कारक और रन-लंबाई-एन्कोडिंग बिट्स को पाइथ से माफी के साथ इस्साकग को लिखा जाता है

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

4
माफी स्वीकार कर ली - मुझे खुशी है कि किसी ने पायथ स्रोत कोड पढ़ा।
isaacg

2

गणितज्ञ, 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)

2

LabVIEW, 44 बाइट्स LabVIEW प्रिमिटिव

इसके सममिति के बाद से मैंने इनपुट की अदला-बदली की अगर बी से बड़ा होता।

अब असली सूत्र का प्रतिनिधित्व करता है

हमेशा की तरह गिनती

सच्चे मामले के लिए


दुर्भाग्य से, (a|b) != (b|a)सभी मामलों में। ज्यादातर मामलों में, हां, लेकिन उन सभी में नहीं। हालांकि यह काम करेगा यदि आप a mod bउन्हें स्वैप करने के बजाय कम कर देते हैं।
शेरलाक

चूँकि मेरे पास अब अन्वेषण है, मैं इसे संपादित कर सकता हूं, मुझे एक मिनट दे सकता हूं
Eumel

1
क्या कोई तरीका है जिससे मैं इसका परीक्षण कर सकता हूं? मैं वास्तव में नहीं समझता कि LabView कैसे काम करता है।
शर्लक

यह एक अच्छा सवाल है, मैं 2 तरीकों के बारे में सोच सकता हूं। पहले मैं एक .exe का निर्माण कर सकता हूं और आपको इसे भेज सकता हूं, दूसरा आप एक लैबव्यू टेस्ट संस्करण प्राप्त कर सकते हैं और मैं आपको vi भेज सकता हूं या आप इसे तस्वीर से पुनर्निर्माण कर सकते हैं।
Eumel

7
यह 44 बाइट्स नहीं है। यदि आप एक स्कोरिंग सिस्टम को परिभाषित करते हैं जो फ़ाइल के आकार पर आधारित नहीं है, तो आपको इसे बाइट्स के अलावा कुछ और कॉल करना चाहिए।
फेर्सुम

1

जूलिया, 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जो दो पूर्णांकों को स्वीकार करता है और एक पूर्णांक देता है।

Ungolfed:

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

1

हास्केल, 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
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.