^{Diese Herausforderung wurde ursprünglich von Magic Octopus Urn sandboxed; Ich habe es mit seiner Erlaubnis adoptiert und veröffentlicht.}

Das ist der Faden der Bullen. Der Räuberfaden ist da .

Die Herausforderung

• Erster Schritt: Schreiben Sie einen Code (Funktion oder vollständiges Programm), der auf Primalität prüft .
• Schritt 2: Entfernen Sie Teile Ihres Codes, indem Sie die Zeichen durch das Symbol ersetzen █.
• Schritt Drei: Poste den überarbeiteten Code auf dem Cops-Thread.
• Vierter Schritt: Warten Sie, bis Ihr Code geknackt ist, und versuchen Sie, den Code eines anderen zu knacken.

Beispielsweise könnte der Groovy-Code {it.isPrime()}werden {██.is█████()}. (Dieser wäre blöd leicht zu knacken; ich weiß auch, dass .isPrime()es keine Groovy-Methode ist.)

Wertung

Sie müssen die Punktzahl Ihres Programms in die Einreichung einbeziehen. Die Punktzahl ist definiert als das Verhältnis von redigierten Zeichen zu Zeichen. Wenn Ihr Programm also 20 Zeichen hätte und 5 Zeichen redigiert würden, wäre Ihre Punktzahl 0,25. Der obige Groovy-Code hätte eine Punktzahl von 0,5.

Regeln

• Ihr Programm muss nur positive ganze Zahlen verarbeiten. Es sollte ein wahrer Wert ausgegeben werden, wenn die Zahl eine Primzahl ist, andernfalls ein falscher Wert. Bitte geben Sie in Ihrer Antwort an, was ausgegeben wird.
• Ihr Code enthält möglicherweise keine Kommentare oder unnötige Leerzeichen.
• Kein Hashing oder kryptografische Verschleierung.
• Ihr Code darf nicht mehr als 50% reduziert sein (mindestens die Hälfte der Zeichen muss angezeigt werden). Dies bedeutet , dass die höchste mögliche Punktzahl ist 0,5.
• Wenn Ihre Antwort nicht innerhalb einer Woche geknackt wird, können Sie sie als sicher markieren und im beabsichtigten Riss bearbeiten.

Gewinnen

Der Gewinner ist die ungerissene Antwort mit der niedrigsten Punktzahl innerhalb von zwei Wochen nach der Veröffentlichung. Bei einem Unentschieden gewinnt derjenige, der die meisten Stimmen hat. Dieser Thread ist immer offen für weitere Einreichungen, aber der Gewinner, der nach zwei Wochen ausgewählt wird, ist endgültig.

Functoid , score = 14/223 ≈ 0.062780 [sicher]

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

Nimmt die Eingabe als Befehlszeilenargument und Ausgänge True(prime) oder False, versuchen Sie es online!

Hinweis (hinzugefügt 4 Tage nach der Veröffentlichung):

Der erste und der vierte █sind ein roter Hering: Die IP der beabsichtigten (und höchstwahrscheinlich jeder ) Lösung folgt der ersten Zeile und erreicht das ?Zeichen.

Lösung

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

Probieren Sie es online!

Erläuterung

Aufgrund der Zufälligkeit ist ?es nicht möglich, das Programm zu reduzieren. Hier ist das flache Programm mit einem Fragezeichen, in dem ein zufälliger Ausdruck steht:

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

Volles Programm:

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

Die {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}, Argumente nehmen f(Selbstreferenz) xund y(Notiz 0ist dasselbe wie 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}ist, ?(yg(KZ)(C(C(BB(BS(b(C(BBI)I))))(C(BC(b(C(BBI)I)))I))(C-)))wo ?zufällig ausgewählt wird (abhängig von der zufälligen Richtung) von:

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

Diese sind alle gleichwertig und werden so {divides}zum Fixpunkt von:

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} ist ein ziemlich verschleierter Ausdruck, der im Grunde genommen einfach funktioniert f x (y-x)

8086 DOS COM, 87 Bytes, Score 19/87 ~ = 0,2183

Gebrochene von NieDzejkob

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

Dies ist ein COM-Programm. Erwartet Zahl als Befehlszeilenargument, gibt Y oder N aus. Limit: 65535, da 16-Bit-Prozessor (sizeof (int) wäre 2). Newline ist 0x0D 0x0A auf dieser Plattform. Ja, Sie zählen 20 █ statt 19 █. Einer von ihnen ist ein echter █ und wurde nicht ausgewechselt. Muhahaha.

Das Leerzeichen in Position 10 ist eigentlich ein NUL-Byte. Das Symbol für NUL entspricht dem Leerzeichen in der alten VGA-Schriftart.

Swift 4 , Score 26/170 ≈ 0.153, sicher

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}

Probieren Sie es online!

Beabsichtigter Riss

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 Bytes (Score: 0.06851) ( Gebrochen von Nitrodon)

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

Probieren Sie es online!

Gibt "prime" aus, wenn prime, "not prime", wenn composite. Funktioniert technisch für beliebige Ganzzahlen, überschreitet jedoch das Zeitlimit für TIO für Zahlen über 6000

Mathematica, 97 Bytes, Ergebnis 0.2989690722 ( Gebrochen )

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

Saiten! Regex! Primes?

Gibt es so etwas wie einen Regex, der die Primalität überprüft, aber das ist nicht das, was hier passiert.

Dies wurde geknackt , aber die Art und Weise, wie ich beabsichtigte, war ganz anders, so dass ich die beabsichtigte Lösung noch nicht verraten werde.

Gelee , Punktzahl 0. (142857) ( geknackt )

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

Probieren Sie es online!

Repost meiner anderen Antwort, diesmal mit ein paar weiteren offenbarten Bytes, um unbeabsichtigte Cheats zu vermeiden.

Oktave , Partitur: 0.15 (86 Bytes)

Ich habe noch einige Charaktere enthüllt. Ich dachte, das Gewinnkriterium sei die höchste Punktzahl, nicht die niedrigste .

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

Probieren Sie es online!

Viel glück =)

Python 3, 388 Bytes, .155, geknackt

Last-Minute-Riss. Ja, das ist der Miller-Rabin-Test.

Ich nehme an, dass probabilistische Tests erlaubt sind, Unsicherheit 2 ^ -100

Nun, ein toller Hinweis im vorherigen Satz

Rückgabewert 0 als COMPOSITE und 1 als PROBABLY PRIME

* 368> 388: Das Problem wurde behoben, wenn z <4 ist

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

Lösung:

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 , score 0.20512820512 [Sicher]

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

Gibt 1 aus, wenn Primzahl, 0, wenn zusammengesetzt

Lösung:

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

Knoten JavaScript, Score: 0,4

Here's where it works. Full program that takes input from first command line argument, and outputs to stdout.

Hopefully, a not-so-difficult solution to start this off.

Using this snippet to calculate score.

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)

Jelly, score 0.(142857)

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

Try it online!

Takes a command-line argument.

False = 0
True = 1

JavaScript, 103 bytes, score 0.1923

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

Returns a boolean.

Unintended crack

Javascript, score 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)};};

Good luck. :p

call f with the prime you want to check.

><>, score 0.096, cracked by Jo King

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

Intended crack:

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

Brain-Flak, Score: 35/134 = 0.2612 (cracked!)

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

Returns 1 for prime, 0 for composite.

This is a very hard language to try this challenge in, as the formatting is so restricted that it takes effort not to make it obvious what the missing character is.

This is a very hard language to solve this challenge in, as it is ridiculously hard to read.

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

Try it online!

Weirdest way I've seen to prime check in Java by far lol.

Japt, 19 bytes, 0.315789... score, Safe

I don't know if I obscured more of this than I needed to, costing myself a better score.

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

View solution (Explanation coming soon)

C, 34/76 = 0.447368, Safe

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

Having this many blanks means that I will be much more likely to get an unintended crack than the intended one.

Solution:

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

explanation:

e holds a boolean value of whether or not the number is not prime (with a few special case exceptions). r iterates through the odd numbers less than or equal to the square root of n. return e?n>1:n<3; handles the special cases when n is 1 or 2.

M, score: 4/22 = .1818..., cracked by Dennis

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

This may end up with an unintended crack, we'll have to see. It did.

Dennis' solutions is

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

Try it online!

I will leave my solution hidden for someone to crack. My hint to Dennis on his robber submission was the word "zoo".

C, 66 bytes, 29 redacted, score 0.439

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

Just a simple C submission; I'll see how long this one takes before I post a really evil one.

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.