задача

Напишите функцию, которая принимает два целых числа, a,bкоторые представляют гауссово целое число z = a+ib(комплексное число). Программа должна возвращать true или false в зависимости от того, 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^2является 32 - битной (подпись) целое и должны закончить в значительно не более 30 секунд.

Главный список

Точки представляют простые числа на плоскости Гаусса ( x= действительная, y= мнимая ось):

Некоторые большие простые числа:

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

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

здесь используется сито Эратосфена для вычисления бесконечного списка всех простых чисел (в коде это называется l для списка). (бесконечные списки - хорошо известный трюк с haskell).

как можно иметь бесконечный список? в начале программы список не оценивается, и вместо хранения элементов списков компьютер сохраняет способ их вычисления. но когда программа обращается к списку, она частично оценивает себя до запроса. поэтому, если бы программа запрашивала четвертый элемент в списке, компьютер вычислял бы все простые числа до четвертого, которые еще не были оценены, сохранял их, а остальное оставалось бы без оценки, сохраняясь как способ вычисления их один раз необходимо.

обратите внимание, что все это дается свободно ленивой природой языка Haskell, ничего из этого не видно из самого кода.

обе версии программы перегружены, поэтому они могут обрабатывать данные произвольного размера.

C, 149 118 знаков

Отредактированная версия (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;}

Это единственная функция:

• грамм ( a , b ) возвращает ненулевое (true), если a + bi - простое гауссово, или ноль (false) в противном случае.

Он складывает тест целочисленной простоты в выражение n/d/d|n<2 скрытое в вычислении возвращаемого значения. Этот гольф-код также использует a*bв качестве замены a&&b(другими словами a!=0 && b!=0) и других приемов, связанных с приоритетом оператора и целочисленным делением. Например n/d/dболее короткий способ сказать n/d/d>=1, что переполнение безопасным способом сказать n>=d*dили d*d<=nили в сущности d<=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));}

Функции:

• Q ( n ) возвращает 0 (false), если n простое число, или 1 (true), если n не простое число. Это вспомогательная функция для G ( a , b ).

• G ( а , b ) возвращает 1 (true), если a + bi - простое гауссово, или 0 (false) в противном случае.

Пример вывода (увеличен на 200%) для | |, | б | ≤ 128:

APL (Dyalog Unicode) , 36 47 48 49 47 43 28 байт

Принимает массив из двух целых чисел a bи возвращает логическое значение оператора a+bi is a Gaussian integer.

Изменить: +11 байт, потому что я неправильно понял определение простого гауссова. +1 байт от исправления ответа снова. +1 байт из третьего исправления ошибки. -2 байта из-за использования поезда вместо dfn. -4 байта благодаря ngn благодаря использованию охранника condition: if_true ⋄ if_falseвместоif_true⊣⍣condition⊢if_false . -15 байт благодаря ngn благодаря нахождению совершенно другого способа записи условия if-else как полноценного поезда.

{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

Haskell - 121 символ (включая новые строки)

Вот сравнительно простое решение на Haskell, которое не использует никаких внешних модулей и использует как можно больше.

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

Питон - 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, f(b,a)заменяет случай b==0, вдохновленный ответом Хаскелла @killmous .

-1 символ и исправление от @PeterTaylor

Python 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 +48 - вся игра в гольф для Джо Кинга

Perl - 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 по модулю 4. Функция возвращаемое значение по умолчанию является значением его последней строки, и эти условия возвращают некоторое истинное значение, если все условия были выполнены.

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, если нет.

Версия 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 символов, 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  

Рунические чары , 41 байт

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

Попробуйте онлайн!

В итоге оказалось намного проще, чем я думал, и не было много места для игры в гольф. Исходная программа, которую я заблокировал, была:

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

Я попытался сравнить оба входа одновременно (что позволило сохранить все один 1 байт), но когда это упало в раздел «один из них равен нулю», не было хорошего способа выяснить, какой элемент был ненулевым, чтобы выполнить последнюю проверку, тем более способ сделать это, не тратя как минимум 1 байт (без общей экономии).

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

Код не использует никаких стандартных функций простых чисел mathematica, вместо этого он подсчитывает количество целых чисел в списке {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:

Рубин -rprime , 65 60 80 байт

Не заметил правила "не могу использовать 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}

Попробуйте онлайн!

Питон - 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