^{Этот вызов был изначально изолирован в песочнице Урной Магического Осьминога; Я принял и разместил его с его разрешения.}

Это нить полицейских. Нить грабителей здесь .

Соревнование

• Шаг первый: напишите фрагмент кода (функция или полная программа), который проверяет простоту .
• Шаг второй: удалите кусочки вашего кода, заменив символы на символ █.
• Шаг третий: Опубликовать отредактированный код в ветке полицейских.
• Шаг четвертый: Подождите, пока ваш код будет взломан, и попробуйте взломать код другого.

Например, Groovy код {it.isPrime()}может стать {██.is█████()}. (Это было бы глупо легко взломать; также, я знаю, .isPrime()это не метод Groovy.)

счет

Вы должны включить оценку вашей программы в ее представлении. Оценка определяется как отношение отредактированных символов к символам. Таким образом, если бы в вашей программе было 20 символов и 5 были отредактированы, ваш счет был бы равен 0,25. Код Groovy, приведенный выше, будет иметь оценку 0,5.

правила

• Ваша программа должна обрабатывать только положительные целые числа. Он должен вывести истинное значение, если число простое, и ложное значение в противном случае. Пожалуйста, укажите в своем ответе, что он выводит.
• Ваш код не может содержать комментарии или ненужные пробелы.
• Нет хеширования или криптографического запутывания.
• Ваш код может быть отредактирован не более чем на 50% (должно быть указано не менее половины символов). Это означает, что максимально возможная оценка составляет 0,5.
• Если ваш ответ не был взломан в течение недели, вы можете пометить его как безопасный и отредактировать его.

выигрыш

Победитель получит самый низкий балл без ответов в течение двух недель после публикации. В случае ничьей победит тот, кто наберет наибольшее количество голосов. Эта ветка всегда открыта для дополнительных материалов, но победитель, выбранный через две недели, будет постоянным.

Функтоид , балл = 14/223 ≈ 0,062780 [безопасно]

Y(yG(BK██)(B(S(BS(C(BC(C(BB(B(v
S(CB█)(█C█B>vK  BSBB())█K(BS(S?
>(KZ)(C(C(Bv>██        >   v██<
█)Sg3I)$; @>B(BS(b(C(BBI)Iv>(█g
())I)))I)IBB(C(b(CB(C())))<v)█C
I))I))0)))(C(BC(B(BB)(C(BBv>)))
]I))))I))>    >)█   $;@   >I)(B

Принимает входные данные как аргумент командной строки и выходы True(простой) или False, попробовать его в Интернете!

Подсказка (добавлено через 4 дня после публикации):

Первая и четвертая █- красная сельдь: IP-адрес предполагаемого (и, скорее всего, каждого ) решения будет следовать за первой строкой и достигнет ?персонажа.

Решение

Y(yG(BKL2)(B(S(BS(C(BC(C(BB(B(v
S(CBO)( C B>vK  BSBB())OK(BS(S?
>(KZ)(C(C(Bv>O)        >   vY <
^)Sg3I)$; @>B(BS(b(C(BBI)Iv>(yg
())I)))I)IBB(C(b(CB(C())))<v)-C
I))I))0)))(C(BC(B(BB)(C(BBv>)))
]I))))I))>    >)2   $;@   >I)(B

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

объяснение

Из-за случайности, которая возникает из-за ?этого, невозможно сгладить программу. Вот плоская программа с вопросительным знаком, где будет случайное выражение:

Y(yG(BKL2)(B(S(BS(C(BC(C(BB(B(?(yg(KZ)(C(C(BB(BS(b(C(BBI)I))))(C(BC(b(C(BBI)I)))I))(C-))))I))I))0)))(C(BC(B(BB)(C(BBI)(B]I))))I)))2$;@

Полная программа:

Y{trial_division}      --  fix-point of {trial_division}
                 2     --  apply 2 (begin division with 2)
                  $    --  apply argument (work with the supplied input)
                   ;   --  print result as boolean
                    @  --  terminate program

The {trial_division}:

y                         -- recursive function with two arguments x,y
 G                        -- | base predicate: x >= y
  (BKL2)                  -- | base function:  BKL2 x y
                             |  ->             K(L2) x y
                             |  ->             L2 y
                             |  ->             2 <= y
        {recursive_call}  -- | recursive call

{recursive_call}, принимая аргументы f(самостоятельная ссылка), xи y(примечание 0такое же, как False)

  B (S(BS(C(BC(C(BB(B{divides}I))I))0))) (C(BC(B(BB)(C(BBI)(B]I))))I) f x y
->       (C(BC(C(BB(B{divides}I))I))0) x y (BC(B(BB)(C(BBI)(B]I)))) f I x y)
->       (C(BC(C(BB(B{divides}I))I))0) x y (BC(B(BB)(C(BBI)(B]I)))) f I x y)
->            (C(BB(B{divides}I))I) x y 0  (BC(B(BB)(C(BBI)(B]I)))) f I x y)
->            (C(BB(B{divides}I))I) x y 0  (   B(BB)(C(BBI)(B]I))   f x I y)
->                   {divides}      x y 0  (         C(BBI)(B]I)    f x y  )
->              if x `divides` y then 0 else         C(BBI)(B]I)    f x y
->                                                    f (B]I x)  y
->                                                    f (] x) y
->                                                    f (x+1) y

{divides}это ?(yg(KZ)(C(C(BB(BS(b(C(BBI)I))))(C(BC(b(C(BBI)I)))I))(C-)))где ?случайным образом выбирается ( в зависимости от случайного направления) от:

• Y
• S(CBO)(CBO)
• S(SB(KO))(BBSBKO)

Все они эквивалентны друг другу, поэтому {divides}становится точкой отсчета:

y                       -- recursive function with two arguments x,y
 g                      -- | base predicate: x > y
  (KZ)                  -- | base function:  KZ x y
                        -- |  ->              0 == y
      {recursive_call}  -- | recursive call

{recursive_call} это довольно запутанное выражение, которое в основном просто делает f x (y-x)

8086 DOS COM, 87 байт, оценка 19/87 ~ = 0,2183

Трещины на NieDzejkob

1└╣██1█╛ü ¼<█t<< u≈¼<█t█,0|/<██+ô≈ßô☺├δδâ√█|█╞█S█Y╣██9┘t█ë╪1╥≈±○╥t█Aδ∩╞█S█N┤█║S█═!├A
$

Это программа COM; ожидает число в качестве аргумента командной строки, выводит Y или N. Предел: 65535, потому что 16-битный процессор (sizeof (int) будет 2). Новая строка 0x0D 0x0A на этой платформе. Да, вы считаете 20 █ вместо 19 █. Один из них настоящий █ и не был заменен. Muhahaha.

Пробел в позиции 10 на самом деле является байтом NUL. Символ для NUL такой же, как пробел в старом шрифте VGA.

Swift 4 , оценка 26/170 ≈ 0,153, безопасно

func p(n:Int)->Bool{func █(_ █:Int,_ █:Int)->Int{var h=(1...l).map{$0██m██
while(m=h.count,m██).1{h=[Int](h[█...])};return m}
return █>██&(█.███).index█j█n██0)>=█0}█=██l}

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

Преднамеренная трещина

func p(n:Int)->Bool{func j(_ l:Int,_ k:Int)->Int{var h=(1...l).map{$0},m=l
while(m=h.count,m>k).1{h=[Int](h[k...])};return m}
return n>1&&(2..<n).index{j(n,$0)>=$0}==nil}

Ungolfed

func p(n:Int)->Bool{
  func j(_ l:Int,_ k:Int)->Int{    // Modulus function (l mod k)
    var h=(1...l).map{$0},m=l      //  Create an array h of size l
    while(m=h.count,m>k).1{        //  While h has more than k elements:
      h=[Int](h[k...])             //   Remove k elements from h
    }
    return m                       //  Return the length of h (equal to k if l divides k)
  }
  return n>1&&                     // Test if n > 1
  (2..<n).index{j(n, $0)>=$0}==nil //  and no number from 2 to n-1 divides n
}

brainfuck , 37/540 байт (оценка: 0,06851) ( взломано нитродоном)

>>>>>+>,[>++++++[-<-------->]<+>,]<[-[█<█<]++++++++++<]>[-]>>██[>█>>█>]+[<]<<[<]>█<<+>>[>]█>[>]█+[<]<<[<]>-█>]>>[->]<[-[[<]<]++++++++++<]>[-]>[<█]>]>[>]<[[█]<]<<<<<[<]<<██>>[>]<█[->+<]<█>>[>]<[-[[<]<]++++++++++<]>███>[<<]>[[[>]>████[<]<[-[[<]<]++++++++++<]>[-]>[█<]>]>[>]<[[-]>+[>]<-<[<]<]+<<<<<[<]>[[>]+[[>]>]>[>]>[-<+>]<[<]<[>+[<]>>-<<<<<[[<]<]>>███████>[[█]>]<]<[[<]<]<[█]>]>>>[[>]<->>]]>[[>]>]<<[[[█]<]<]<<<[█]<<█>>>[>]█[-[[<]<]++++++++++<]>>[[>]+[------->++<]>.+.+++++.[---->+<]>+++.>>]>[>]+[------->++<]>++.++.---------.++++.--------.

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

Печатает «простое», если простое, «не простое», если составное. Технически работает для произвольных целых чисел, но время ожидания на TIO для чисел выше 6000

Система Mathematica, 97 байт, оценка 0,2989690722 ( Трещины )

f[x_]:=(██ToString███████████████;StringMatchQ[████Infinity,RegularExpression@"█\█\█{█\█+, ███"])

Строки! Regex! Штрихи?

Там является такая вещь , как регулярное выражение проверки простоты, но это не случается здесь.

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

Желе , оценка 0. (142857) ( трещины )

25██26█966836897364918299█0█1█65849159233270█02█837903312854349029387313█ị██v

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

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

Октава , счет: 0,15 (86 байт)

Я обнаружил еще несколько персонажей. Я думал, что критерием победы был самый высокий балл, а не самый низкий .

@(x)eval([(str2num(cell2mat([cellstr(reshape('0█1███1█0█0█00',████))])')█'█')','(x)'])

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

Удачи =)

Python 3, 388 байт, .155, треснувший

Трещина в последнюю минуту. Да, это тест Миллера-Рабина.

Я предполагаю, что вероятностные тесты разрешены, неопределенность 2 ^ -100

Ну, отличный совет в предыдущем предложении, хотя

Сделано возвращаемое значение 0 как композитный и 1 как вероятный премьер

* 368> 388: исправлена ​​проблема, когда z <4

import ██████
def f(z):
 if z<4:return z>>1
 d,s,n,e,c=██z,0,z,0,50
 while not ██1:d//=2;s+=1
 while n>0:n//=2;e+=1
 ███████████()
 while c>0:
  a=0
  while a<2or a>z-█:
   a,b=0,e
   while b>0:a=a*2+██████████████(0,1);b-=█
  x,r=███(█,█,z),██s
  if ██x and x!=██z:
   while r>0:
    x,r=███(█,█,z),██r
    if not ██x:return 0
    elif x==██z:break
   else:return 0
  c-=█
 else:return 1

Решение:

import random
def f(z):
 if z<4:return z>>1
 d,s,n,e,c=~-z,0,z,0,50
 while not d&1:d//=2;s+=1
 while n>0:n//=2;e+=1
 random.seed()
 while c>0:
  a=0
  while a<2or a>z-1:
   a,b=0,e
   while b>0:a=a*2+random.randint(0,1);b-=1
  x,r=pow(a,d,z),~-s
  if ~-x and x!=~-z:
   while r>0:
    x,r=pow(x,2,z),~-r
    if not ~-x:return 0
    elif x==~-z:break
   else:return 0
  c-=1
 else:return 1

095 , оценка 0,201212820512 [Сейф]

1id#█#=(DD#█#█{d_█%(█D0█]D}██s]D1.=[1s]

Печатает 1, если простое, 0, если составное

Решение:

1id#2#=(DD#2#-{d_.%(rD0R]D}drs]D1.=[1s]

Узел JavaScript, оценка: 0,4

Вот где это работает.Полная программа, которая принимает входные данные из первого аргумента командной строки и выводит их в стандартный вывод.

Надеюсь, это не очень сложное решение, чтобы начать это.

Используя этот фрагмент для подсчета очков.

require███████████2<<2██>n█████rin█(b████████x)█████(9211█6830)██(a,c)=>a[c[0]██████████(c)]███████);d=███+n;q=████27775██9564,[502█59,█6])[█]);a=██q>0████r(n=q█a█&█-q-██)a██n%q?██0██(137152█8270,22288)(a)

Желе , оценка 0. (142857)

25██26█9668368973649182992051██5849159233270202█837903312854349029387313█████

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

Принимает аргумент командной строки.

False = 0
True =1

JavaScript, 103 байта, оценка 0,1923

x=>{if(x<4)return(!0);for(y=x>>>Math.log10(p=████;--y-1;(p=x/y%1)████if(██&&(███))break████return(███)}

Возвращает логическое значение.

Непреднамеренная трещина

Javascript, оценка 0,1894093686354379

let t=[2,3,3,3,3,3,3,5,7,5,7,5,7,7,11,12,13,11,13,13,1,2,17,13,2,3,17,19,23,29,19,19,41,23,23,29,23,"","",29,7,31,31,524,31,37,33,34,41]; function r(a, b) {█████████████████████████████████████████████████████████████};function l(t){let a=0;let b=[];while(true){b.push(t[a]);█████████████;if(!t[a]){return█████};function p(v) {let i=0;let a=r(2,v██);for (i in a){if(v%(█████████a█i██)==0){return false;}};return true;};function f(v){if(l(t).indexOf(v)!=-1){return true;}else{return p(v)};};

Удачи. :п

позвоните е с тем простым числом, которое хотите проверить.

> <>, оценка 0.096, взломан Джо Кингом

:1@v>~~:?1n;█$-1<█?=2:}*{█@:$@:

Преднамеренная трещина:

:1@v>~~:?1n;
$-1<^?=2:}*{%@:$@:

Brain-Flak, счет: 35/134 = 0,2612 ( треснул! )

(({████){██[████)█>(({}))<>}<>{}███{}((██({}))█████{}]██)({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})██[██()██(()█[()]██{}██}{}<>{})

Возвращает 1 для простого, 0 для составного.

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

Это очень сложный язык для решения этой проблемы, так как его нелегко читать.

Java 1.4+ , 24/145 (0.16551724137)

class X{public static void main(String[]args){System.out.println(new String(████████[Integer.parseInt(args[0])]).matches("█████████████")?███);}}

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

Самый странный способ, которым я видел, чтобы проверить на Java, безусловно, лол.

Japt, 19 байт, 0.315789 ... оценка, сейф

Я не знаю, скрыл ли я больше этого, чем нужно, стоило мне лучшего результата.

█h8575¥█
█UâÊ█Ê█ █2

View solution (Объяснение в ближайшее время)

C 34/76 = 0,447368, Safe

int p(int n){int r███████2;██r███r++)███+███n;████&███r));return███████n██;}

Наличие такого количества пробелов означает, что у меня будет гораздо больше шансов получить непреднамеренную трещину, чем намеченная.

Решение:

int p(int n){int r=1,e=n%2;for(;(r++)*(r++)<n;e=e&&(n%r));return e?n>1:n<3;}

объяснение:

eсодержит логическое значение того, является ли число не простым (с несколькими исключениями в особых случаях). rперебирает нечетные числа, меньшие или равные квадратному корню из n. return e?n>1:n<3;обрабатывает особые случаи, когда nесть 1или 2.

M , оценка: 4/22 = 0,1818 ..., трещины от Dennis

███“;;█»VOḣ2S⁵++3Ọ;”Pv

Это может привести к непреднамеренной трещине, мы должны это увидеть. Это сделал.

Решения Денниса это

ÆPø“;;“»VOḣ2S⁵++3Ọ;”Pv

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

Я оставлю свое решение скрытым, чтобы кто-то взломал. Моим намеком на Денниса в его подчинении было слово «зоопарк».

C, 66 байт, 29 отредактировано, оценка 0,439

i;p(n){█████2███████ 0███████2;███;███)if(████)return 0;return 1;}

Просто простая подача C; Я посмотрю, сколько времени это займет, прежде чем я опубликую действительно злого.

Pyth , оценка: ~ 0. (461538) (13 байт) ( треснувший )

█]█Q ██Q{█M█P

Попробуйте взломать это здесь!

sh + coreutils, оценка 19/143 ~ = 0,1328

Трещины

e█ec█s█ █c "██████WyAkKHNoIC1jICJg█WNobyBabUZqZEc5eWZIUnlJQ2█2SnlBblhHNG5m██JoYVd3Z0t6SjhkMk1nTFhjSyB8YmFzZTY0IC1kYCIpIC1lcSAxIF0K█b█se6███d`"

TIO

Brain-Flak , оценка 29/140 = 0,207

({}██()██<>){██({}[()])██{}{}███({<({}[()])><>({})<>}{}██████{}██){(({})){({}[()])<>}{}}<>([{}()]{}<>{})<>}(<>██{}({}████)((){[()]██{}██}{})

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

Выходы 1 для простого и 0 для не простого.

Тампио (обязательно), оценка: 24/51 = 0,5

Luku on alkuluku,jos ████████████e███████ on █████.

Это очевидное решение, я надеюсь, что никто здесь не понимает финский.

Тампио (обязательно), оценка: 26/223 = 0,11659 ...

Luvun kokonaislukuarvot ovat riippuen siitä,onko se yksi,joko listan,jonka alkioita ovat yksi █████████████████████,alkiot tai █████ liitettynä sen alkutekijöihin.Luku on alkuluku,jos sen kokonaislukuarvojen summa on nolla.

Пыть , оценка: 0,288288 ... [Сейф]

Đ2⇹█ŘĐĐŁ███⇹ʀĐ↔Đ5Ș↔⇹██=█ŕĐ↔Đ5Ș↔Đř█⇹█████↔Đ4Ș5Ș⇹██⇹3Ș°04Ș↔█3ȘĐŁ█3Ș05Ș↔█⇹04Ș0↔⇹██=█ŕ↔ŕĐĐŁ██↔██↔ŕŕŕŕ█↔████↔ŕŕŕ██¬¬

Выводит «True», если простое, «False», если нет

Забыл упомянуть, что это вероятностный тест.

Решение:

Đ2⇹⁻ŘĐĐŁ₂`⁻⇹ʀĐ↔Đ5Ș↔⇹Ǥ1=?ŕĐ↔Đ5Ș↔Đř²⇹%∈2*⁻↔Đ4Ș5Ș⇹⁻₂⇹3Ș°04Ș↔+3ȘĐŁ⁺3Ș05Ș↔+⇹04Ș0↔⇹%+=?ŕ↔ŕĐĐŁ⁺⁺↔ł:↔ŕŕŕŕ;↔⁺⁻±?↔ŕŕŕ:;¬¬

Это реализует критерий примитивности Соловея-Штрассена.

Попробуйте онлайн здесь!

Рубин, 27/73 = 0,369863

def p n;███████(██n.times████a[2..-1].map{|s|█.██n████s}██.█*█|██})█);end

Это должно быть весело.

Python 3 , оценка: 0,386363, трещины

p=lambda x,i=2:█████or(x%i and ████████)████

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

user71546 сделал это "работа" с

p=lambda x,i=2:i>=x or(x%i and p(x,i+1))or 0

... но это было непреднамеренно. Исходный код был

p=lambda x,i=2:i>x/2or(x%i and p(x,i+1))or 0

Оказывается, ни одна из них не работает для x <2. К сожалению.

JavaScript (ES7), 297 байт, 103 отредактировано, .347

M=(N,X=N,F=(n,a=█████)=>a>1e-20?█████+F(n,█████████):1,G=(n,a=█████)=>a>1e-20?█████+G(n,███████):n==2?0:G(n-1),H=(n,a=█████)=>a>1e-20?█████-H(n,███████):0,I=n=>████████I(████),J=n=>I(n)*████+H(█████████-1),K=(n,l=n|0)=>(n-l>=.5)+l,L=(a,b)=>██████████(a)+█(b)████,Z=L(--N,N)██)=>L(Z,████M(N,X)██)██

Мой предыдущий ответ на Python был слишком прямолинейным, так что вот злой;)

Однако логика проста.