^{Цей виклик спочатку був пісочницею чарівної урви; Я прийняв і розмістив його з його дозволу.}

Це нитка копів. Нитка грабіжників тут .

Змагання

• Крок перший: Напишіть фрагмент коду (функцію або повну програму), який перевіряє наявність первинності .
• Крок другий: Видаліть фрагменти коду, замінивши символи символом █.
• Крок третій: Розмістіть відредагований код на потоці копів.
• Крок четвертий: Зачекайте, коли ваш код буде зламаний, і спробуйте зламати код інших.

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

Оцінка балів

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

Правила

• Вашій програмі потрібно обробляти лише натуральні числа. Він повинен виводити триєдне значення, якщо число є простим, а помилкове значення - в іншому випадку. Вкажіть, будь ласка, у своїй відповіді, що це дає.
• Ваш код може не містити коментарів або зайвого пробілу.
• Немає хешшю чи криптографічного затухання.
• Ваш код може бути не більше 50% відредагований (має бути показано не менше 1/2 символів). Це означає, що найвищий можливий бал - 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 дні після публікації):

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

Рішення

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). На цій платформі Newline розміщений 0x0D 0x0A. Так, ви рахуєте 20 █ замість 19 █ Один з них справжній █ і не був замінений. Мухахаха.

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

Швидкий 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}

Безумовно

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) ( Cracked by Nitrodon)

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

Спробуйте в Інтернеті!

Друкує "prime", якщо prime, "not prime", якщо композитний. Технічно працює для довільних цілих чисел, але тайм-аут TIO для чисел вище 6000

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

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

Струни! Регекс! Прими?

Там є така річ , як регулярний вираз перевірки простоти, але це не трапляється тут.

Це було зламано , але спосіб, який я задумав, був зовсім іншим, тому поки що не розкриватиму намічене рішення.

Желе , оцінка 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,20512820512 [Безпечно]

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

Друкується 1, якщо простим, 0, якщо складеним

Рішення:

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

Вузол JavaScript, оцінка: 0,4

Ось де це працює. Повна програма, яка приймає дані з аргументу першого командного рядка та виводить у stdout.

Сподіваємось, не дуже важке рішення почати це.

Використовуючи цей фрагмент для обчислення балу.

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

Спробуйте в Інтернеті!

Бере аргумент командного рядка.

Невірно = 0
Істинно =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)};};

Удачі. : с

зателефонуйте f з основним номером, який ви хочете перевірити.

> <>, оцінка 0,096, потріскана Джо Кінгом

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

Передбачувана тріщина:

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

Мозок-Флак, Оцінка: 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("█████████████")?███);}}

Спробуйте в Інтернеті!

Найцікавіший спосіб, який я бачив, щоб провірити перевірку на Яві на сьогоднішній день lol.

Japt, 19 байт, 0,315789 ... оцінка, безпечно

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

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

View solution (Пояснення найближчим часом)

C, 34/76 = 0,447368, Безпечний

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

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

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`"

ТІО

Мозг-Флак , оцінка 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.

Pyt , оцінка: 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

...but that was unintended. Original code was

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

Neither work for x<2, turns out. Oops.

JavaScript (ES7), 297 bytes, 103 redacted, .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)██)██

My previous Python answer was too straightforward, so here's an evil one ;)

The logic behind is straightforward though.