^{To wyzwanie zostało pierwotnie wykonane w piaskownicy przez Magic Octopus Urn; Przyjąłem i opublikowałem za jego zgodą.}

To jest wątek gliniarzy. Wątek rabusiów jest tutaj .

Wyzwanie

• Krok pierwszy: napisać kawałek kodu (funkcja lub pełny program), który sprawdza pierwszości .
• Krok drugi: Usuń fragmenty kodu, zastępując znaki symbolem █.
• Krok trzeci: Opublikuj zredagowany kod w wątku gliniarzy.
• Krok czwarty: Zaczekaj na złamanie kodu i spróbuj złamać kod innej osoby.

Na przykład kod Groovy {it.isPrime()}może zostać {██.is█████()}. (Ten byłby głupio łatwy do złamania; wiem też, że .isPrime()nie jest to metoda Groovy).

Punktacja

Musisz dołączyć wynik swojego programu do jego przesłania. Wynik jest definiowany jako stosunek zredagowanych znaków do znaków. Więc jeśli twój program miał 20 znaków, a 5 zostało zredagowanych, twój wynik wyniósłby 0,25. Powyższy kod Groovy miałby wynik 0,5.

Zasady

• Twój program musi obsługiwać tylko liczby całkowite dodatnie. Powinien wyprowadzać prawdziwą wartość, jeśli liczba jest liczbą pierwszą, aw przeciwnym razie wartość fałsz. Podaj w swojej odpowiedzi, jakie dane wyjściowe.
• Twój kod nie może zawierać żadnych komentarzy ani niepotrzebnych białych znaków.
• Bez haszowania ani kryptograficznego zaciemniania.
• Twój kod może być nie więcej niż 50% zredagowany (co najmniej 1/2 znaków musi być pokazana). Oznacza to, że najwyższy możliwy wynik to 0,5.
• Jeśli twoja odpowiedź nie zostanie złamana w ciągu tygodnia, możesz oznaczyć ją jako bezpieczną i edytować w zamierzonym pęknięciu.

Zwycięski

Zwycięzca otrzyma nieskradzioną odpowiedź o najniższej liczbie punktów w ciągu dwóch tygodni od opublikowania. W przypadku remisu wygra ten, który ma najwięcej głosów. Wątek ten jest zawsze otwarty na więcej zgłoszeń, ale zwycięzca wybrany po dwóch tygodniach będzie stały.

Functoid , wynik = 14/223 ≈ 0,062780 [bezpieczny]

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

Zajmuje wejście jako argument wiersza polecenia i wyjść True(prime) lub False, spróbuj go w Internecie!

Wskazówka (dodana 4 dni po opublikowaniu):

Pierwszy i czwarty █to czerwony śledź: adres IP zamierzonego (i najprawdopodobniej każdego ) rozwiązania podąża za pierwszą linią i dociera do ?postaci.

Rozwiązanie

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

Wypróbuj online!

Wyjaśnienie

Ze względu na losowość wynikającą z ?tego nie można spłaszczyć programu. Oto płaski program ze znakiem zapytania, w którym będzie wyrażenie losowe:

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$;@

Pełny program:

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

{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}, biorąc argumenty f(samookreślenie) xi y(uwaga 0jest taka sama jak 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}jest ?(yg(KZ)(C(C(BB(BS(b(C(BBI)I))))(C(BC(b(C(BBI)I)))I))(C-))), gdy ?jest wybierana losowo (w zależności od kierunku losowych) z:

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

Wszystkie są sobie równe, więc {divides}staje się punktem stałym dla:

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} jest dość zaciemnionym wyrazem, który po prostu robi f x (y-x)

8086 DOS COM, 87 bajtów, wynik 19/87 ~ = 0,2183

Pęknięty przez NieDzejkoba

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

To jest program COM; oczekuje liczby jako argumentu wiersza poleceń, wyprowadza Y lub N. Limit: 65535, ponieważ 16-bitowy procesor (sizeof (int) wynosiłby 2). Nowa linia to 0x0D 0x0A na tej platformie. Tak, liczysz 20 █ zamiast 19 █. Jeden z nich to prawdziwy █ i nie został zastąpiony. Muhahaha.

Spacja w pozycji 10 jest tak naprawdę bajtem NUL. Symbol NUL jest taki sam, jak spacja w starej czcionce VGA.

Szybki 4 , wynik 26/170 ≈ 0,153, bezpieczny

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}

Wypróbuj online!

Zamierzone pęknięcie

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}

Nie golfił

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 bajtów (wynik: 0,06851) ( Cracked przez Nitrodon)

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

Wypróbuj online!

Drukuje „pierwszą”, jeśli pierwsza, „nie pierwszą”, jeśli złożona. Technicznie działa dla dowolnych liczb całkowitych, ale przekracza limit czasu dla TIO dla liczb powyżej 6000

Mathematica, 97 bajtów, wynik 0,2989690722 ( pęknięty )

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

Smyczki! Regex! Liczby pierwsze?

Nie ma czegoś takiego jak pierwszości sprawdzania regex, ale nie jest to co dzieje się tutaj.

Zostało to złamane , ale sposób, który zamierzałem, był zupełnie inny, więc nie ujawnię jeszcze zamierzonego rozwiązania.

Galaretka , wynik 0. (142857) ( pęknięty )

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

Wypróbuj online!

Repost mojej drugiej odpowiedzi, tym razem z kilkoma odkrytymi bajtami, aby uniknąć niezamierzonych oszustw.

Oktawa , wynik: 0,15 (86 bajtów)

Ujawniłem kilka innych postaci. Myślałem, że kryterium zwycięstwa był najwyższy wynik, a nie najniższy .

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

Wypróbuj online!

Powodzenia =)

Python 3, 388 bajtów, .155, pęknięty

Crack w ostatniej chwili. Tak, to jest test Millera-Rabina.

Przypuszczam, że testy probabilistyczne są dozwolone, niepewność 2 ^ -100

Cóż, świetna wskazówka w poprzednim zdaniu

Ustawiono zwracaną wartość 0 jako KOMPOZYTOWĄ i 1 jako PRAWDOPODOBNIE PRIME

* 368> 388: Naprawiono problem, gdy 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

Rozwiązanie:

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 , wynik 0.20512820512 [Bezpieczny]

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

Drukuje 1 jeśli pierwsza, 0 jeśli kompozytowa

Rozwiązanie:

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

Węzeł JavaScript, wynik: 0,4

Oto gdzie to działa. Pełny program, który pobiera dane wejściowe z pierwszego argumentu wiersza poleceń i wyświetla dane wyjściowe na standardowe wyjście.

Mamy nadzieję, że niezbyt trudne rozwiązanie na początek.

Korzystanie z tego fragmentu kodu do obliczania wyniku.

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)

Galaretka , wynik 0. (142857)

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

Wypróbuj online!

Bierze argument wiersza polecenia.

Fałsz = 0
prawda =1

JavaScript, 103 bajty, wynik 0,1923

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

Zwraca wartość logiczną.

Niezamierzone pęknięcie

JavaScript, wynik 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)};};

Powodzenia. : p

dzwoń do liczby pierwszej, którą chcesz sprawdzić.

> <>, wynik 0,096, złamany przez Jo Kinga

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

Zamierzone pęknięcie:

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

Brain-Flak, wynik: 35/134 = 0,2612 ( pęknięty! )

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

Zwraca 1 dla liczby pierwszej, 0 dla kompozytu.

Jest to bardzo trudny język do wypróbowania tego wyzwania, ponieważ formatowanie jest tak ograniczone, że nie trzeba ujawniać, czym jest brakujący znak.

Jest to bardzo trudny język do rozwiązania tego wyzwania, ponieważ jest absurdalnie trudny do odczytania.

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("█████████████")?███);}}

Wypróbuj online!

Najdziwniejszy sposób, w jaki widziałem sprawdzanie kodu w Javie zdecydowanie lol.

Japt, 19 bajtów, 0,315789 ... wynik, bezpieczny

Nie wiem, czy zasłoniłem to więcej, niż potrzebowałem, co kosztowało mnie lepszy wynik.

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

View solution (Wyjaśnienie wkrótce)

C, 34/76 = 0,447368, bezpieczny

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

Posiadanie tak wielu pustych miejsc oznacza, że ​​będę o wiele bardziej narażony na niezamierzone pęknięcie niż zamierzone.

Rozwiązanie:

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

wyjaśnienie:

ezawiera wartość logiczną określającą, czy liczba nie jest liczbą pierwszą (z kilkoma wyjątkami wyjątków). riteruje przez liczby nieparzyste mniejsze lub równe pierwiastkowi kwadratowemu z n. return e?n>1:n<3;obsługuje specjalne przypadki, gdy njest 1lub 2.

M , wynik: 4/22 = .1818 ..., pęknięty przez Dennisa

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

To może skończyć się niezamierzonym pęknięciem, musimy to zobaczyć.Tak było.

Rozwiązania Dennisa to

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

Wypróbuj online!

Pozostawię swoje rozwiązanie ukryte, aby ktoś mógł je złamać. Moją wskazówką dla Dennisa na temat jego złodzieja było słowo „zoo”.

C, 66 bajtów, 29 zredagowane, wynik 0,439

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

Po prostu proste przesłanie C; Zobaczę, jak długo to potrwa, zanim opublikuję naprawdę zły.

Pyth, score: ~0.(461538) (13 bytes) (Cracked)

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

Try to crack it here!

sh + coreutils, score 19 / 143 ~= 0.1328

cracked

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

TIO

Brain-Flak, score 29 / 140 = 0.207

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

Try it online!

Outputs 1 for prime and 0 for non-prime.

Tampio (imperative), score: 24/51 = 0.5

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

This is an obvious solution, I hope no one here understands Finnish.

Tampio (imperative), score: 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, score: 0.288288... [Safe]

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

Outputs "True" if prime, "False" if not

Forgot to mention that it is a probabilistic test.

Solution:

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

This implements the Solovay-Strassen primality test.

Try it online here!

Ruby, 27/73 = 0.369863

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

This should be fun.

Python 3, score: 0.386363, cracked

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

Going for the really low hanging fruit at first. I'll come up with a cheeky answer soon.

user71546 made it "work" with

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.