Aufgabe

Schreiben Sie eine Funktion, die zwei Ganzzahlen akzeptiert a,b, die die Gaußsche Ganzzahl z = a+ib(komplexe Zahl) darstellen. Das Programm muss true oder false zurückgeben, je nachdem, ob a+ibes sich um eine Gaußsche Primzahl handelt oder nicht .

Definition:

a + bi ist genau dann eine Gaußsche Primzahl, wenn sie eine der folgenden Bedingungen erfüllt:

• aund bsind beide ungleich Null und a^2 + b^2sind Primzahl
• aist Null, |b|ist Primzahl und|b| = 3 (mod 4)
• bist Null, |a|ist Primzahl und|a| = 3 (mod 4)

Einzelheiten

Sie sollten nur eine Funktion schreiben. Wenn Ihre Sprache keine Funktionen hat, können Sie davon ausgehen, dass die Ganzzahlen in zwei Variablen gespeichert sind und das Ergebnis drucken oder in eine Datei schreiben.

Sie können keine eingebauten Funktionen Ihrer Sprache wie isprimeoder prime_listoder nthprimeoder verwenden factor. Die niedrigste Anzahl von Bytes gewinnt. Das Programm muss Arbeit für , a,bwo a^2+b^2ein 32 - Bit (signiert) integer und sollte in nicht wesentlich mehr als 30 Sekunden beenden.

Prime-Liste

Die Punkte repräsentieren Primzahlen auf der Gaußschen Ebene ( x= reelle, y= imaginäre Achse):

Einige größere Primzahlen:

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

Haskell - 77/108 107 Zeichen

Verwendung: In beiden Lösungen gibt die Eingabe von a% b zurück, ob a + bi eine Gaußsche Primzahl ist.

das niedrigste, das ich geschafft habe, aber keine Kreativität oder Leistung (77 Zeichen)

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

Diese Lösung durchläuft nur alle Zahlen unter n, um zu prüfen, ob es sich um eine Primzahl handelt.

ungolfed version:

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)

Die nächste Lösung hat eine zusätzliche Funktion - Memoization. Wenn Sie überprüft haben, ob eine Ganzzahl n eine Primzahl ist, müssen Sie die "Primzahl" aller Zahlen, die kleiner oder gleich n sind, nicht neu berechnen, da sie im Computer gespeichert werden.

(107 Zeichen. Die Kommentare dienen der Klarheit.)

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

ungolfed version:

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)

Dabei wird das Sieb von Eratosthenes verwendet, um eine unendliche Liste aller Primzahlen zu berechnen (im Code als l für Liste bezeichnet). (Unendliche Listen sind ein bekannter Trick von Haskell).

Wie ist es möglich, eine unendliche Liste zu haben? Zu Beginn des Programms wird die Liste nicht ausgewertet. Statt die Listenelemente zu speichern, speichert der Computer die Berechnungsmethode. Wenn das Programm jedoch auf die Liste zugreift, wertet es sich teilweise selbst bis zur Anforderung aus. Wenn das Programm also das vierte Element in der Liste anfordert, berechnet der Computer alle Primzahlen bis zum vierten Element, die noch nicht ausgewertet wurden, speichert sie, und der Rest bleibt unbewertet und wird als Berechnungsmethode einmal gespeichert erforderlich.

Beachten Sie, dass all dies durch die Trägheit der Haskell-Sprache frei gegeben ist, nichts davon geht aus dem Code selbst hervor.

Beide Programmversionen sind überlastet, sodass sie Daten beliebiger Größe verarbeiten können.

C, 149 118 Zeichen

Bearbeitete Version (118 Zeichen):

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

Dies ist eine einzelne Funktion:

• G ( a , b ) gibt ungleich Null (wahr) zurück, wenn a + bi eine Gaußsche Primzahl ist, oder sonst Null (falsch).

Es faltet den ganzzahligen Primalitätstest in einen Ausdruck n/d/d|n<2, der in der Rückgabewertberechnung verborgen ist. Dieser Golf-Code wird auch a*bals Ersatz für a&&b(mit anderen Worten a!=0 && b!=0) und andere Tricks verwendet, bei denen der Operator Vorrang hat und die Ganzzahlteilung eine Rolle spielt. Zum Beispiel n/d/dist eine kürzere Art zu sagen n/d/d>=1, die eine überlaufsichere Art zu sagen ist n>=d*doder d*d<=noder im Wesentlichen d<=sqrt(n).

Originalfassung (149 Zeichen):

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

Funktionen:

• Q ( n ) gibt 0 (falsch) zurück, wenn n eine Primzahl ist, oder 1 (wahr), wenn n keine Primzahl ist. Es ist eine Hilfsfunktion für G ( a , b ).

• G ( a , b ) gibt 1 (wahr) zurück, wenn a + bi eine Gaußsche Primzahl ist, oder 0 (falsch), wenn dies nicht der Fall ist.

Beispielausgabe (200% vergrößert) für | a |, | b | ≤ 128:

APL (Dyalog Unicode) , 36 47 48 49 47 43 28 Bytes

Nimmt ein Array mit zwei Ganzzahlen a bund gibt den Booleschen Wert der Anweisung zurück a+bi is a Gaussian integer.

Edit: +11 Bytes, weil ich die Definition einer Gaußschen Primzahl falsch verstanden habe. +1 Byte von der erneuten Korrektur der Antwort. +1 Byte von einer dritten Fehlerbehebung. -2 Bytes aufgrund der Verwendung eines Zuges anstelle eines DFN. -4 Bytes dank ngn aufgrund der Verwendung eines Guard condition: if_true ⋄ if_falseanstelle von if_true⊣⍣condition⊢if_false. -15 Bytes dank ngn, da ein völlig anderer Weg gefunden wurde, um die Bedingung-if-else als vollen Zug zu schreiben.

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

Probieren Sie es online!

Erläuterung

{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

Haskell - 121 Zeichen (einschließlich Zeilenumbrüche)

Hier ist eine relativ einfache Haskell-Lösung, bei der keine externen Module verwendet werden und die so weit wie möglich heruntergespielt wird.

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

Aufrufen als ghci ./gprimes.hsund dann können Sie es in der interaktiven Shell verwenden. Hinweis: Negative Zahlen sind heikel und müssen in Klammern gesetzt werden. Dh

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

Python - 121 120 Zeichen

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Überprüft, ob abs(x)eine Primzahl vorliegt, indem alle Zahlen von 2 bis abs(x)**.5(was ist sqrt(abs(x))) durchlaufen werden . Es tut dies, indem es x % sfür jeden nachgibt s. allüberprüft dann, ob alle ausgegebenen Werte ungleich Null sind, und beendet die Generierung von Werten, sobald ein Divisor von angetroffen wird x. In f, f(b,a)ersetzt den Fall für b==0, inspiriert von @killmous 'Haskell Antwort.

-1 char und Bugfix von @PeterTaylor

Python 2.7 , 341 301 253 Bytes, optimiert für Geschwindigkeit

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

Probieren Sie es online!

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

Danke: 40 +48 - ganzes Golfen an Jo King

Perl - 110 107 105 Zeichen

Ich hoffe, ich habe die verknüpfte Definition korrekt befolgt ...

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

Erklärung, weil jemand gefragt: ich die Argumente lesen ( @_) und setzen ihre absoluten Werte in $a, $b, weil die Funktion braucht nicht ihre Zeichen. Für jedes Kriterium muss die Primalität einer Zahl getestet werden. Diese Zahl hängt jedoch davon ab, ob sie Null ist $aoder nicht. $bIch habe versucht, sie auf kürzestem Weg auszudrücken und sie einzugeben $n. Schließlich überprüfe ich, ob $nPrimzahl ist, indem ich zähle, wie viele Zahlen zwischen 2 und sich selbst ohne Rest teilen (das ist der grep...<2Teil), und prüfe dann zusätzlich, dass, wenn eine der Zahlen Null ist, die andere 3 Modulo 4 entspricht. Die Funktion ist Rückgabewert ist standardmäßig der Wert der letzten Zeile, und diese Bedingungen geben einen Wahrheitswert zurück, wenn alle Bedingungen erfüllt sind.

Golflua 147 141

Die obige Anzahl vernachlässigt die Zeilenumbrüche, die ich hinzugefügt habe, um die verschiedenen Funktionen zu sehen. Trotz des Bestehens, dies nicht zu tun, löse ich Primzahlen mit brachialer Gewalt in den Fällen.

\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())))

Gibt 1 zurück, wenn wahr, und 0, wenn nicht.

Eine ungolfed Lua Version,

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

APL (NARS), 99 Zeichen, 198 Byte

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}

Prüfung:

  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  

Runenverzauberungen , 41 Bytes

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

Probieren Sie es online!

Am Ende war es viel einfacher als ich dachte und es gab nicht viel Raum für Golf. Das ursprüngliche Programm, das ich gesperrt habe, war:

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

Ich habe versucht, beide Eingänge gleichzeitig zu vergleichen (was alles von einem Byte sparte), aber wenn das in den Abschnitt "einer von ihnen ist Null" fällt, gab es keinen guten Weg, um herauszufinden, welches Element war ungleich Null, um die letzte Prüfung durchzuführen, geschweige denn eine Möglichkeit, dies zu tun, ohne mindestens 1 Byte auszugeben (keine Gesamteinsparung).

Mathematica, 149 Zeichen

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

Der Code verwendet keine Standardmerkmale für Primzahlen in Mathematica, sondern zählt die Anzahl der Ganzzahlen in der Liste {n / 1, n / 2, ..., n / n}. Wenn die Zahl 1 oder 2 ist, ist n eine Primzahl. Eine ausgearbeitete Form der Funktion:

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

Bonusplot aller Gaußschen Primzahlen von -20 bis 20:

Ruby -rprime , 65 60 80 Bytes

Die Regel "isPrime kann nicht verwendet werden" wurde nicht beachtet ...

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

Probieren Sie es online!

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