is_gaussian_prime (z)?

Question

कार्य

एक फ़ंक्शन लिखें जो दो पूर्णांकों को स्वीकार करता है a,bजो गॉसियन पूर्णांक z = a+ib(जटिल संख्या) का प्रतिनिधित्व करते हैं । कार्यक्रम सही या गलत आधार पर उस लौटना चाहिए a+ibएक है गाऊसी प्रधानमंत्री या नहीं ।

परिभाषा:

a + bi एक गौसियन प्राइम है और यदि यह निम्नलिखित स्थितियों में से एक को पूरा करता है:

• aऔर bदोनों नॉनजेरो हैं और a^2 + b^2प्राइम हैं
• aशून्य है, |b|प्रधान है और|b| = 3 (mod 4)
• bशून्य है, |a|प्रधान है और|a| = 3 (mod 4)

विवरण

आपको केवल एक फ़ंक्शन लिखना चाहिए। यदि आपकी भाषा में फ़ंक्शन नहीं हैं, तो आप मान सकते हैं कि पूर्णांक दो चर में संग्रहीत हैं और परिणाम प्रिंट करें या इसे एक फ़ाइल में लिखें।

आप अंतर्निहित नहीं उपयोग कर सकते हैं की तरह अपनी भाषा के कार्यों isprimeया prime_listया nthprimeया factor। बाइट्स की सबसे कम संख्या जीतती है। कार्यक्रम के लिए काम करना चाहिए a,bजहां a^2+b^232 बिट (हस्ताक्षरित) पूर्णांक है और 30 सेकंड से अधिक नहीं होना चाहिए।

प्रधान सूची

डॉट्स गॉसियन प्लेन ( x= वास्तविक, yकाल्पनिक अक्ष) पर प्रमुख संख्याओं का प्रतिनिधित्व करते हैं :

कुछ बड़े अपराध:

(9940, 43833)
(4190, 42741)
(9557, 41412)
(1437, 44090)

Comments

क्या हमें फैक्टरिस फ़ंक्शंस ( factorबैश में, mfऔर mFसीजाम में, ...) का उपयोग करने की अनुमति है

अरे नहीं, मैं उन फैक्टराइजिंग तरीकों को भूल गया, कोई कृपया नहीं =) और 32bit की सीमा ^ 2 + b ^ 2 पर लागू होती है, अन्यथा इसका कोई मतलब नहीं होगा। आपके इनपुट के लिए धन्यवाद! मैंने सवाल अपडेट किया।

— निर्दोष

मैंने पोस्ट में गॉसियन प्रिम्स की एक परिभाषा जोड़ी। यदि आपको यह पसंद नहीं है कि मैंने इसे कैसे किया है, तो इसे वापस रोल करने के लिए स्वतंत्र महसूस करें, लेकिन मैं निश्चित रूप से कहीं न कहीं परिभाषा सहित सिफारिश करूंगा।

— अंडरग्राउंडोरेल

यह अच्छा है, मैं मूल रूप से सीधे यह इंगित नहीं करना चाहता था कि लोगों को रचनात्मक पाने के लिए मौलिकता का निर्धारण कैसे किया जाए =)

— त्रुटी

1 1073741857 मुझे गौसियन प्राइम नहीं लगता है क्योंकि 1 ^ 2 + 1073741857 ^ 2 एक सम संख्या है ...

— RosLuP

Answer 1

हास्केल - 77/ 108 107 वर्ण

उपयोग: दोनों समाधानों में,% b टाइप करने पर वापस आ जाएगा कि क्या a + bi एक गॉसियन प्राइम है।

सबसे कम मैं कामयाब रहा, लेकिन कोई रचनात्मकता या प्रदर्शन (77 वर्ण)

p n=all(\x->rem n x>0)[2..n-1]
a%0=rem a 4==3&&p(abs a)
0%a=a%0
a%b=p$a^2+b^2

यदि यह प्रधान है, तो यह समाधान n के नीचे सभी नंबरों के माध्यम से अधिकार देता है।

अपंग संस्करण:

isprime = all (\x -> rem n x != 0) [2..n-1] -- none of the numbers between 2 and n-1 divide n.
isGaussianPrime a 0 = rem a 4==3 && isprime (abs a)
isGaussianPrime 0 a = isGaussianPrime a 0   -- the definition is symmetric
isGaussianPrime a b = isprime (a^2 + b^2)

अगले समाधान में एक अतिरिक्त विशेषता है - संस्मरण। एक बार जब आप जाँचते हैं कि कुछ पूर्णांक n अभाज्य है, तो आपको सभी संख्याओं की "प्रधानता" को पुनर्गठित करने की आवश्यकता नहीं होगी, क्योंकि यह कंप्यूटर में संग्रहीत या n के बराबर होगी।

(107 वर्ण, टिप्पणियाँ स्पष्टता के लिए हैं)

s(p:x)=p:s[n|n<-x,rem n p>0] --the sieve function
l=s[2..]                     --infinite list of primes
p n=n==filter(>=n)l!!0       --check whether n is in the list of primes
a%0=rem a 4==3&&p(abs a)
0%a=a%0
a%b=p$a*a+b*b

अपंग संस्करण:

primes = sieve [2..] where
    sieve (p:xs) = p:filter (\n -> rem n p /= 0) xs
isprime n = n == head (filter (>=n) primes) -- checks if the first prime >= n is equal to n. if it is, n is prime.
isGaussianPrime a 0 = rem a 4==3 && isprime (abs a)
isGaussianPrime 0 a = isGaussianPrime a 0   -- the definition is symmetric
isGaussianPrime a b = isprime (a^2 + b^2)

यह सभी अपराधों की एक अनंत सूची (कोड में सूची के लिए एल) की गणना करने के लिए एराटोस्थनीज की छलनी का उपयोग करता है। (अनंत सूचियाँ हैसेल की एक जानी-मानी चाल है)।

अनंत सूची होना कैसे संभव है? कार्यक्रम की शुरुआत में, सूची का मूल्यांकन नहीं किया जाता है, और सूची तत्वों को संग्रहीत करने के बजाय, कंप्यूटर उन्हें संकलित करने का तरीका संग्रहीत करता है। लेकिन जैसा कि कार्यक्रम सूची तक पहुँचता है यह आंशिक रूप से अनुरोध तक ही मूल्यांकन करता है। इसलिए, यदि प्रोग्राम सूची में चौथे आइटम का अनुरोध करने के लिए था, तो कंप्यूटर सभी प्राइमों को आगे तक गणना करेगा जो पहले से ही मूल्यांकन नहीं किए गए हैं, उन्हें स्टोर करें, और बाकी अनवैल्यूड रहेंगे, उन्हें एक बार गणना करने के तरीके के रूप में संग्रहीत किया जाएगा। जरूरत है।

ध्यान दें कि यह सब हास्केल भाषा के आलसी स्वभाव द्वारा स्वतंत्र रूप से दिया गया है, इनमें से कोई भी कोड से स्पष्ट नहीं है।

कार्यक्रम के दोनों संस्करण अतिभारित हैं, इसलिए वे मनमाने ढंग से डेटा को संभाल सकते हैं।

Comments

मेरी गिनती से, आपका पहला समाधान वास्तव में 77 अक्षर है: D

— किलमास

मैं newlines गिना, मैं नहीं चाहिए?

— गर्वित हैकेलर

मैं

— ous४

आप सही कह रहे हैं, ऐसा लगता है कि किसी कारण से नोटपैड ++ नई वर्णमाला से पहले वर्ण जोड़ता है। धन्यवाद!

— गर्वित हैकेलर

इसलिए मैं उदात्त का उपयोग करता हूं;) मदद करने में खुशी है!

— बलात्कार

Answer 2

सी, १४ ९ ११ 149 अक्षर

संपादित संस्करण (118 अक्षर):

int G(int a,int b){a=abs(a);b=abs(b);int n=a*b?a*a+b*b:a+b,
d=2;for(;n/d/d&&n%d;d++);return n/d/d|n<2?0:(a+b&3)>2|a*b;}

यह एक एकल कार्य है:

• G ( a , b ) नॉनजेरो (सही) लौटाता है अगर a + bi एक गाऊसी प्राइम है, या शून्य (झूठा) अन्यथा।

यह पूर्णांक प्रतिक्षेप परीक्षण को n/d/d|n<2रिटर्न वैल्यू गणना में छिपी अभिव्यक्ति में बदल देता है। यह गॉल्फर्ड कोड ऑपरेटर (दूसरे शब्दों में ) और ऑपरेटर चाल और पूर्णांक विभाजन से जुड़े अन्य ट्रिक्स के a*bविकल्प के रूप में भी उपयोग करता है । उदाहरण के लिए , कहने का एक छोटा तरीका है , जो कहने या सार में एक अतिप्रवाह-सुरक्षित तरीका है ।a&&ba!=0 && b!=0n/d/dn/d/d>=1n>=d*dd*d<=nd<=sqrt(n)

---

मूल संस्करण (149 अक्षर):

int Q(int n){int d=2;for(;n/d/d&&n%d;d++);return n/d/d||n<2;}
int G(int a,int b){a=abs(a);b=abs(b);return!((a|b%4<3|Q(b))*(b|a%4<3|Q(a))*Q(a*a+b*b));}

कार्य:

• क्यू ( n ) रिटर्न 0 (गलत) है अगर n प्राइम है, या 1 (ट्रू) यदि n नॉनप्राइम है। यह जी ( ए , बी ) के लिए एक सहायक कार्य है ।

• G ( a , b ) 1 (सच्चा) लौटाता है अगर a + Bi एक गाऊसी प्राइम है, या 0 (गलत) अन्यथा।

नमूना उत्पादन (200% तक बढ़ा) | ए |, | बी | ≤ 128:

Comments

छवि के लिए +1! क्या आप पहले चतुर्थांश (क्योंकि समरूपता) में भी उसी आकार के बारे में एक कर सकते हैं, यह वास्तव में यहाँ बहुत अच्छा लग रहा है =)

— त्रुटी

आप d = 2 को प्रतिस्थापित करके कुछ वर्णों को सहेज सकते हैं; (; n / d / d && n% d; d ++) के लिए; के साथ (d = 2; n / d / d && n% d ++;);

— अल्काइमर

@Alchymist - यह वास्तव में पात्रों को बचाता है, लेकिन गलत परिणाम उत्पन्न करता है। यह महत्वपूर्ण है कि d++स्थिति के हिस्से के रूप में ऐसा न हो, अन्यथा यह निम्नलिखित तर्क को गड़बड़ कर देता है। इसके अलावा, लूप के d=2अंदर जाने से forवास्तव में चरित्र की गिनती कम होने के बजाय बढ़ जाती है, क्योंकि लूप से पहले dभी घोषित intकिए जाने की आवश्यकता होती forहै। क्या मैं कुछ भूल रहा हूँ?

— टॉड लेहमन

बिल्कुल सही। एक कोडिंग वातावरण से दूर इसे देखने के जोखिम और निकटता से पर्याप्त नहीं। इन्क्रीमेंटिंग को वहीं रहना है जहाँ यह है और आरंभीकरण केवल आपके मूल समाधान में मदद करता है। यदि आप int को निर्दिष्ट किए बिना एन एंड डी की घोषणा करते हैं, तो स्पष्ट बचत होती है, और उन्हें लूप के लिए इनिशियलाइज़ करते हैं, लेकिन मुझे लगता है कि आप फंक्शन को स्व-निहित बना रहे हैं, जो आवश्यकताओं की एक सख्त व्याख्या है।

— अल्छमिस्ट

प्राइम-टेस्टिंग लूप यहाँ कुछ शानदार गोल्फिंग है! हालाँकि यह संभव है कि रिटर्न प्रकार और तर्कों के लिए अंतर प्रकार निर्दिष्ट करने वालों के लिए एक चर का उपयोग करके और भी अधिक बचत प्राप्त की जा सके। + | बी | और रिटर्न स्टेटमेंट का अनुकूलन: G(a,b){int s=abs(a)+abs(b),n=a*b?a*a+b*b:s,d=2;for(;n/d/d&&n%d;d++);return n>1>n/d/d&&s%4/3|a*b;}केवल 97 वर्णों के लिए आता है।

— feersum

Answer 3

APL (Dyalog Unicode) , 36 47 48 49 47 43 28 बाइट्स

दो पूर्णांकों की एक सरणी लेता है a bऔर विवरण का बूलियन मान लौटाता है a+bi is a Gaussian integer।

संपादित करें: +11 बाइट्स क्योंकि मैंने एक गाऊसी प्राइम की परिभाषा को गलत समझा। +1 बाइट फिर से उत्तर को सही करने से। एक तीसरे बग फिक्स से +1 बाइट। Dfn के बजाय ट्रेन का उपयोग करने के कारण -2 बाइट्स। -4 बाइट्स के condition: if_true ⋄ if_falseबजाय एक गार्ड का उपयोग करने के कारण ngn के लिए धन्यवाद if_true⊣⍣condition⊢if_false। -15 बाइट्स ngn के लिए धन्यवाद एक पूरी तरह से ट्रेन लिखने के लिए पूरी तरह से अलग रास्ता खोजने के कारण।

{2=≢∪⍵∨⍳⍵}|+.×0∘∊⊃|{⍺⍵}3=4||

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

व्याख्या

{2=≢∪⍵∨⍳⍵}|+.×0∘∊⊃|{⍺⍵}3=4||

                           |  ⍝ abs(a), abs(b) or abs(list)
                       3=4|   ⍝ Check if a and b are congruent to 3 (mod 4)
                  |{⍺⍵}       ⍝ Combine with (abs(a), abs(b))
              0∘∊⊃            ⍝ Pick out the original abs(list) if both are non-zero
                              ⍝ Else pick out (if 3 mod 4)
          |+.×                ⍝ Dot product with abs(list) returns any of
                              ⍝ - All zeroes if neither check passed
                              ⍝ - The zero and the number that IS 3 mod 4
                              ⍝ - a^2 + b^2
{2=≢∪⍵∨⍳⍵}                    ⍝ Check if any of the above are prime, and return

Answer 4

हास्केल - 121 वर्ण (शामिल नईं)

यहाँ एक अपेक्षाकृत सरल हास्केल समाधान है जो किसी भी बाहरी मॉड्यूल का उपयोग नहीं करता है और जितना मुझे मिल सकता है उतना नीचे गोल्फ किया जाता है।

a%1=[]
a%n|n`mod`a<1=a:2%(n`div`a)|1>0=(a+1)%n
0#b=2%d==[d]&&d`mod`4==3where d=abs(b)
a#0=0#a
a#b=2%c==[c]where c=a^2+b^2

के रूप में आमंत्रित करें ghci ./gprimes.hsऔर फिर आप इसे इंटरेक्टिव शेल में उपयोग कर सकते हैं। नोट: ऋणात्मक संख्याएं सूक्ष्म हैं और उन्हें कोष्ठक में रखा जाना चाहिए। अर्थात

*Main>1#1
True
*Main>(-3)#0
True
*Main>2#2
False

Answer 5

पायथन - 121 120 वर्ण

def p(x,s=2):
 while s*s<=abs(x):yield x%s;s+=1
f=lambda a,b:(all(p(a*a+b*b))if b else f(b,a))if a else(b%4>2)&all(p(b))

pजाँचता है कि क्या abs(x)2 से लेकर abs(x)**.5(जो है sqrt(abs(x))) सभी नंबरों पर पुनरावृत्ति करके प्रमुख है । यह उपज द्वारा ऐसा करता हैx % s प्रत्येक के लिएs । allफिर जाँचता है कि क्या सभी उपज मूल्य गैर-शून्य हैं और एक बार एक विभाजक का सामना करने पर मूल्यों को उत्पन्न करना बंद कर देता है x। में f, @killmous 'हास्केल जवाब से प्रेरित होकर f(b,a)मामले को बदल देता है ।b==0

---

@PeterTaylor से -1 चार और बगफिक्स

Comments

खुशी है कि मैं मदद कर सकता हूँ :)

— हत्यारे

आप 2 की बचत के s<abs(x)**.5साथ बदल सकते हैं s*s<abs(x)। हालांकि वास्तव में आपको जाँच करनी चाहिए <=, इसलिए यह वर्तमान में छोटी गाड़ी है।

— पीटर टेलर

— @PeterTaylor

मेरे दुभाषिया के साथ f(0,15)पैदावार बुला TypeError: unsupported operand type(s) for &: 'bool' and 'generator'। :(

— फाल्को

f(0,15)Falseमेरे लिए, 2.7.6 और 3.4.1 (OS X पर) दोनों के लिए देता है । आप किस संस्करण पर हैं?

— hlt

Answer 6

पायथन 2.7 , 341 301 253 बाइट्स, गति के लिए अनुकूलित

lambda x,y:(x==0and g(y))or(y==0and g(x))or(x*y and p(x*x+y*y))
def p(n,r=[2]):a=lambda n:r+range(r[-1],int(n**.5)+1);r+=[i for i in a(n)if all(i%j for j in a(i))]if n>r[-1]**2else[];return all(n%i for i in r if i*i<n)
g=lambda x:abs(x)%4>2and p(abs(x))

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

#pRimes. need at least one for r[-1]
r=[2]
#list of primes and other to-check-for-primarity numbers 
#(between max(r) and sqrt(n))
a=lambda n:r+list(range(r[-1],int(n**.5)+1))
#is_prime, using a(n)
f=lambda n:all(n%i for i in a(n))
#is_prime, using r
def p(n):
    global r
    #if r is not enough, update r
    if n>r[-1]**2:
        r+=[i for i in a(n) if f(i)]
    return all(n%i for i in r if i*i<n)
#sub-function for testing (0,y) and (x,0)
g=lambda x:abs(x)%4==3 and p(abs(x))
#the testing function
h=lambda x,y:(x==0 and g(y)) or (y==0 and g(x)) or (x and y and p(x*x+y*y))

साभार: ४० +४ 40 - जो किंग को पूरी गोल्फ

Comments

fलैम्ब्डा भी uneccesary है, के साथ साथ listकॉल। 257 बाइट्स उन लोगों के बिना, साथ ही कुछ व्हाट्सएप हटाने। यह शायद उतना कुशल नहीं है, हालांकि

— जो राजा

(१५,०) अब २५ by बाइट्स संस्करण में सच है और रन समय में ५.५ की वृद्धि हुई है, क्षमा करें

— एलेक्सी

Answer 7

पर्ल - 110 107 105 वर्ण

मुझे आशा है कि मैंने लिंक की गई परिभाषा का सही ढंग से पालन किया है ...

sub f{($a,$b)=map abs,@_;$n=$a**(1+!!$b)+$b**(1+!!$a);(grep{$n%$_<1}2..$n)<2&&($a||$b%4>2)&&($b||$a%4>2)}

Ungolfed:

sub f {
  ($a,$b) = map abs, @_;
  $n = $a**(1+!!$b) + $b**(1+!!$a);
  (grep {$n%$_<1} 2..$n)<2 && ($a || $b%4==3) && ($b || $a%4==3)
}

स्पष्टीकरण, क्योंकि किसी ने पूछा: मैं तर्क (पढ़ @_) और में उनके शुद्ध मान रखा $a, $b, उनके हस्ताक्षर की जरूरत नहीं है क्योंकि समारोह करता है। प्रत्येक मानदंड में किसी संख्या की प्रधानता का परीक्षण करने की आवश्यकता होती है, लेकिन यह संख्या इस बात पर निर्भर करती है कि शून्य है $aया नहीं $b, जिसे मैंने कम से कम तरीके से व्यक्त करने का प्रयास किया है $n। अंत में मैं जांचता हूं कि क्या $nगिनती से अभिप्राय है कि 2 के बीच कितनी संख्याएँ हैं और स्वयं इसे शेष के बिना विभाजित करते हैं (जो कि grep...<2भाग है), और फिर जाँच करें कि यदि संख्याओं में से एक शून्य है, तो अन्य 3 3 के बराबर है। फ़ंक्शन का वापसी मूल्य डिफ़ॉल्ट रूप से इसकी अंतिम पंक्ति का मान होता है, और ये शर्तें कुछ सत्य मान लौटाती हैं यदि सभी शर्तें पूरी हुई थीं।

Comments

मैं इसे नकारात्मक मापदंडों के लिए काम नहीं कर सकता।

— बत्तीस

@killmous तुम सही हो, बस इसे ठीक कर दिया

— ताल

क्या आप एल्गोरिथ्म की व्याख्या कर सकते हैं?

— गर्वित हैकेलर

अच्छा! वैसे, मुझे लगता है कि आप एक दो अक्षर लिखकर शेव कर सकते हैं$a%4>2 इसके बजाय हैं $a%4==3।

— टॉड लेहमन

Answer 8

golflua 147 141

उपर्युक्त गणना नए कार्यों की उपेक्षा करती है जो मैंने विभिन्न कार्यों को देखने के लिए जोड़ा है। ऐसा न करने की जिद के बावजूद, मैं पाशविक बल के मामलों में मामलों को हल करता हूं।

\p(x)s=2@s*s<=M.a(x)?(x%s==0)~0$s=s+1$~1$
\g(a,b)?a*b!=0~p(a^2+b^2)??a==0~p(b)+M.a(b)%4>2??b==0~p(a)+M.a(a)%4>2!?~0$$
w(g(tn(I.r()),tn(I.r())))

1 रिटर्न अगर सच है और 0 अगर नहीं।

एक अनगुल्ड लुआ संस्करण,

-- prime number checker
function p(x)
   s=2
   while s*s<=math.abs(x) do
      if(x%s==0) then return 0 end
      s=s+1
   end
   return 1
end

-- check gaussian primes
function g(a,b)
   if a*b~=0 then
      return p(a^2+b^2)
   elseif a==0 then
      return p(b) + math.abs(b)%4>2
   elseif b==0 then
      return p(a) + math.abs(a)%4>2
   else
      return 0
   end
end


a=tonumber(io.read())
b=tonumber(io.read())
print(g(a,b))

Comments

आप अंत में tonumber(io.read())एक तर्क के रूप में प्लगिंग करके 6 वर्णों को बचा सकते हैं g, और 2 के

— नए खंडों

@mniip: नए अंक नहीं गिने गए थे, मैंने सिर्फ उन लोगों को स्पष्टता के लिए जोड़ा है (कोई बगैर स्क्रॉल किए)। जब मैं थोड़े से काम में लग जाऊंगा तो जी में पढ़ता हूं। धन्यवाद!

— काइल कानोस

अच्छी तरह से यह अभी भी बड़ी संख्या के लिए एक उचित समय में काम करता है? मैं मुख्य रूप से सभी गाऊसी पूर्णांकों जाँच के रास्ते में bruteforcing के बारे में सोचा aहै, जहां |a| <= |z|अगर a | z(यदि aविभाजित z)।

— अउर

@flawr: मैंने इसे = 2147483644, b = 896234511 के साथ परीक्षण किया और 0 के बारे में 0.002 सेकेंड में प्राप्त किया। मैंने इसे २१४48४36३६२ ९ और २१४35४ 21३५ two two (दो बहुत बड़े अपराधों) के साथ परीक्षण किया और ०.००२ सेकेंड में ० मिला। मैं संख्याओं की एक बड़ी जोड़ी को खोजने की कोशिश कर रहा हूं, जैसे कि ^ 2 + b ^ 2 अभाज्य है और यह सुनिश्चित करता है कि मुझे इतनी बड़ी संख्या के लिए एक कार्यशील समाधान मिल गया है।

— काइल कानोस

@flawr: एक = 4600 & b = 5603 (ए ^ 2 + बी ^ 2 = 2147393609 प्राइम & <2 ^ 32-1) के साथ परीक्षण किया गया है और वापसी के लिए वही 0.002 सेकंड लगे 1. याय!

— काइल कानोस

Answer 9

एपीएल (एनएआरएस), 99 चार्ट, 198 बाइट्स

r←p w;i;k
r←0⋄→0×⍳w<2⋄i←2⋄k←√w⋄→3
→0×⍳0=i∣w⋄i+←1
→2×⍳i≤k
r←1

f←{v←√k←+/2*⍨⍺⍵⋄0=⍺×⍵:(p v)∧3=4∣v⋄p k}

परीक्षा:

  0 f 13
0
  0 f 9
0
  2 f 3
1
  3 f 4
0
  0 f 7
1
  0 f 9
0
  4600 f 5603
1  

Answer 10

रूनिक एनकाउंटर , 41 बाइट्स

>ii:0)?\S:0)?\:*S:*+'PA@
3%4A|'S/;$=?4/?3

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

जितना मैंने सोचा था, उससे बहुत आसान होने के नाते और गोल्फ के लिए ज्यादा जगह नहीं थी। मूल कार्यक्रम जिसे मैंने अवरोधित किया था:

>ii:0)?\S:0)?\:*S:*+'PA@
3%4A|'S/!   S/;$=

मैं एक ही समय में दोनों इनपुटों की तुलना करने की कोशिश कर रहा था (जो कि एक 1 बाइट बचाते हैं), लेकिन जब वह "उनमें से एक शून्य है" अनुभाग में गिरता है, तो यह पता लगाने का एक अच्छा तरीका नहीं था कि कौन सा आइटम अंतिम जांच करने के लिए गैर-शून्य था, कम से कम 1 बाइट (कोई समग्र बचत) खर्च किए बिना इसे कम करने का एक तरीका।

Answer 11

गणितज्ञ, 149 वर्ण

If[a==0,#[[3]]&&Mod[Abs@b,4]==3,If[b==0,#[[2]]&&Mod[Abs@a,4]==3,#[[1]]]]&[(q=#;Total[Boole@IntegerQ[q/#]&/@Range@q]<3&&q!=0)&/@{a^2+b^2,Abs@a,Abs@b}]

कोड गणित के किसी भी मानक प्राइम नंबर सुविधाओं का उपयोग नहीं करता है, इसके बजाय यह सूची में पूर्णांकों की संख्या {n / 1, n / 2, ..., n / n} को गिनता है; यदि संख्या 1 या 2 है, तो n अभाज्य है। समारोह का एक विस्तृत रूप:

MyIsPrime[p_] := (q = Abs@p; 
  Total[Boole@IntegerQ[q/#] & /@ Range@q] < 3 && q != 0)

-20 से 20 तक सभी गौसियन अपराधों का बोनस प्लॉट:

Answer 12

रूबी -rprime , ६५ ६० 80 बाइट्स

ध्यान दें "नियम का उपयोग नहीं कर सकते हैं" नियम ...

->a,b{r=->n{(2...n).all?{|i|n%i>0}};c=(a+b).abs;r[a*a+b*b]||a*b==0&&r[c]&&c%4>2}

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

Answer 13

अजगर - 117 122 121

def f(a,b):
 v=(a**2+b**2,a+b)[a*b==0]
 for i in range(2,abs(v)):
  if v%i<1:a=b=0
 return abs((a,b)[a==0])%4==3or a*b!=0

Comments

क्योंकि 3 सबसे बड़ा है एक नंबर आधुनिक 4 हो सकता है, आप बदल सकते ==3साथ>2

— FlipTack