Tarefa

Escreva uma função que aceite dois números inteiros a,bque representam o número inteiro gaussiano z = a+ib(número complexo). O programa deve retornar verdadeiro ou falso, dependendo de a+ibser um primo gaussiano ou não .

Definição:

a + bi é um primo gaussiano se, e somente se, atender a uma das seguintes condições:

• ae bsão ambos diferentes de zero e a^2 + b^2é primo
• aé zero, |b|é primo e|b| = 3 (mod 4)
• bé zero, |a|é primo e|a| = 3 (mod 4)

Detalhes

Você deve escrever apenas uma função. Se o seu idioma não tiver funções, você pode assumir que os números inteiros estão armazenados em duas variáveis ​​e imprimir o resultado ou gravá-lo em um arquivo.

Você não pode usar funções internas do seu idioma como isprimeou prime_listou nthprimeou factor. O menor número de bytes vence. O programa deve trabalhar para a,bonde a^2+b^2está um número inteiro de 32 bits (assinado) e deve terminar em não mais do que 30 segundos.

Lista principal

Os pontos representam números primos no plano gaussiano ( x= real, y= eixo imaginário):

Alguns números primos maiores:

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

Haskell - 77/ 108 107 Caracteres

uso: nas duas soluções, digitar a% b retornará se a + bi é um primo gaussiano.

o mais baixo que consegui, mas sem criatividade ou desempenho (77 caracteres)

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

essa solução apenas fornece todos os números abaixo de n para verificar se é primo.

versão não destruída:

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)

a próxima solução possui um recurso extra - memorização. depois de verificar se algum número inteiro n é primo, não será necessário recalcular a "primeiridade" de todos os números menores ou iguais a n, pois ele será armazenado no computador.

(107 caracteres. Os comentários são para esclarecer)

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

versão não destruída:

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)

isso usa a peneira de Eratóstenes para calcular uma lista infinita de todos os números primos (chamados l para lista no código). (listas infinitas são um truque bem conhecido de haskell).

como é possível ter uma lista infinita? no início do programa, a lista não é avaliada e, em vez de armazenar os elementos da lista, o computador armazena a maneira de calculá-los. mas quando o programa acessa a lista, ele se avalia parcialmente até a solicitação. portanto, se o programa solicitar o quarto item da lista, o computador calculará todos os números primos até o quarto que ainda não foram avaliados, os armazenará e o restante permanecerá sem avaliação, armazenado como a maneira de computá-los uma vez necessário.

observe que tudo isso é dado livremente pela natureza preguiçosa da linguagem Haskell, nada disso é aparente no próprio código.

as duas versões do programa estão sobrecarregadas, para que possam manipular dados de tamanho arbitrário.

C, 149 118 caracteres

Versão editada (118 caracteres):

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

Esta é uma função única:

• G ( a , b ) retorna diferente de zero (verdadeiro) se a + bi for um primo gaussiano ou zero (falso) caso contrário.

Dobra o teste de primalidade inteira em uma expressão n/d/d|n<2oculta no cálculo do valor de retorno. Esse código também utiliza a*bcomo substituto a&&b(em outras palavras a!=0 && b!=0) e outros truques envolvendo precedência de operador e divisão de número inteiro. Por exemplo, n/d/dé uma maneira mais curta de dizer n/d/d>=1, que é uma maneira segura de estourar n>=d*dou dizerd*d<=n ou na sua essência d<=sqrt(n).

Versão original (149 caracteres):

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

Funções:

• Q ( n ) retorna 0 (falso) se n for primo ou 1 (verdadeiro) se n for não primo. É uma função auxiliar para G ( a , b ).

• G ( a , b ) retorna 1 (verdadeiro) se a + bi for um primo gaussiano ou 0 (falso) caso contrário.

Saída de amostra (aumentada em 200%) para | a |, | b | ≤ 128:

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

Pega uma matriz de dois números inteiros a be retorna o valor booleano da instrução a+bi is a Gaussian integer.

Edit: +11 bytes, porque eu não entendi a definição de um primo gaussiano. +1 byte de corrigir a resposta novamente. +1 byte de uma terceira correção de bug. -2 bytes devido ao uso de um trem em vez de um dfn. -4 bytes graças ao ngn devido ao uso de um protetor em condition: if_true ⋄ if_falsevez de if_true⊣⍣condition⊢if_false. -15 bytes graças ao ngn devido a encontrar uma maneira completamente diferente de escrever a condição if-else como um trem completo.

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

Experimente online!

Explicação

{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 caracteres (novas linhas incluídas)

Aqui está uma solução Haskell relativamente simples que não usa nenhum módulo externo e tem o máximo de eficiência possível.

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

Invoque como ghci ./gprimes.hse, em seguida, você pode usá-lo no shell interativo. Nota: números negativos são complicados e devem ser colocados entre parênteses. Ou seja,

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

Python - 121 120 caracteres

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

pverifica se abs(x)é primo repetindo todos os números de 2 a abs(x)**.5(que é sqrt(abs(x))). Fá-lo cedendo x % spara cada um s. alldepois verifica se todos os valores obtidos são diferentes de zero e para de gerar valores quando encontrar um divisor de x. Em f, f(b,a)substitui o argumento b==0inspirado na resposta de Haskell de @killmous .

-1 char e correção de bug de @PeterTaylor

Python 2.7 , 341 301 253 bytes, otimizado para velocidade

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

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

Obrigado: 40 +48 - golfe inteiro para Jo King

Perl - 110 107 105 caracteres

Espero ter seguido a definição vinculada corretamente ...

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

Explicação, porque alguém perguntou: Eu li os argumentos ( @_) e colocar seus valores absolutos em $a, $bnão porque a função não necessita de seu sinal. Cada um dos critérios requer o teste da primalidade de um número, mas esse número depende se$a ou $bnão zero, o que tentei expressar da maneira mais curta possível e colocar $n. Finalmente, verifico se $né primo contando quantos números entre 2 e ele próprio o dividimos sem deixar resto (essa é a grep...<2parte) e depois verifico se um dos números é zero, o outro é igual a 3 módulo 4. A função é O valor de retorno é por padrão o valor de sua última linha e essas condições retornam algum valor verdadeiro se todas as condições forem atendidas.

golflua 147 141

A contagem acima negligencia as novas linhas que adicionei para ver as diferentes funções. Apesar da insistência em não fazê-lo, a força bruta resolve os primos nos casos.

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

Retorna 1 se verdadeiro e 0 se não.

Uma versão não-gasta de Lua,

-- 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 caracteres, 198 bytes

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}

teste:

  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  

Encantos Rúnicos , 41 bytes

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

Experimente online!

Acabou sendo muito mais fácil do que eu pensava e não havia muito espaço para a golfificação. O programa original que bloqueei foi:

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

Eu brinquei com a tentativa de comparar as duas entradas ao mesmo tempo (que salvou todos os 1 byte), mas quando isso cai na seção "uma delas é zero", não havia uma boa maneira de descobrir qual item era diferente de zero para executar a última verificação, muito menos uma maneira de fazê-lo sem gastar pelo menos 1 byte (sem economia geral).

Mathematica, 149 caracteres

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

O código não usa nenhum recurso padrão de número primo do mathematica; em vez disso, conta o número de números inteiros na lista {n / 1, n / 2, ..., n / n}; se o número for 1 ou 2, então n é primo. Uma forma elaborada da função:

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

Gráfico de bônus de todos os Primes Gaussianos de -20 a 20:

Ruby -rprime , 65 60 80 bytes

Não percebeu a regra "não é possível usar isPrime" ...

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

Experimente 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