^{Questa sfida è stata originariamente sandbox da Magic Octopus Urn; L'ho adottato e pubblicato con il suo permesso.}

Questo è il filo della polizia. Il thread dei ladri è qui .

La sfida

• Fase 1: scrivere un pezzo di codice (funzione o programma completo) che controlli la primalità .
• Passaggio 2: rimuovere parti del codice sostituendo i caratteri con il simbolo █.
• Terzo passaggio: pubblica il codice redatto sul thread della polizia.
• Quarto passaggio: attendi che il codice venga crackato e prova a decifrare il codice di altri.

Ad esempio, il codice Groovy {it.isPrime()}potrebbe diventare {██.is█████()}. (Questo sarebbe stupidamente facile da decifrare; inoltre, lo so, .isPrime()non è un metodo Groovy.)

punteggio

Devi includere il punteggio del tuo programma nella sua presentazione. Il punteggio è definito come il rapporto tra caratteri redatte e caratteri. Quindi, se il tuo programma avesse 20 caratteri e 5 fossero redatti, il tuo punteggio sarebbe 0,25. Il codice Groovy sopra avrebbe un punteggio di 0,5.

Regole

• Il tuo programma deve solo gestire numeri interi positivi. Dovrebbe produrre un valore di verità se il numero è primo e un valore di falsa in caso contrario. Si prega di specificare nella risposta ciò che produce.
• Il codice non può contenere commenti o spazi bianchi non necessari.
• Nessun hash o offuscamento crittografico.
• Il codice non può essere redatto più del 50% (devono essere indicati almeno 1/2 caratteri). Ciò significa che il punteggio più alto possibile è 0,5.
• Se la tua risposta non viene decifrata entro una settimana, puoi contrassegnarla come sicura e modificarla nella fessura prevista.

vincente

Il vincitore sarà la risposta non classificata con il punteggio più basso entro due settimane dalla pubblicazione. In caso di pareggio, vincerà il numero maggiore di voti. Questa discussione è sempre aperta a più proposte, ma il vincitore scelto dopo due settimane sarà permanente.

Functoid , punteggio = 14/223 ≈ 0,062780 [sicuro]

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

Accetta input come argomento della riga di comando e output True(prime) o False, provalo online!

Suggerimento (aggiunto 4 giorni dopo la pubblicazione):

Il primo e il quarto █sono un'aringa rossa: l'IP della soluzione prevista (e molto probabilmente ogni ) seguirà la prima riga e raggiungerà il ?personaggio.

Soluzione

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

Provalo online!

Spiegazione

A causa della casualità che ne deriva ?non è possibile appiattire il programma. Ecco il programma flat con un punto interrogativo in cui sarà un'espressione casuale:

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

Programma completo:

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

Il {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}, prendendo argomenti f(autoreferenziazione) xe y(la nota 0è la stessa di 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-)))dove ?viene scelto a caso (a seconda della direzione casuale) tra:

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

Questi sono tutti equivalenti tra loro, quindi {divides}diventa il punto fisso di:

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} è un'espressione piuttosto offuscata che praticamente lo fa f x (y-x)

8086 DOS COM, 87 byte, punteggio 19/87 ~ = 0,2183

Incrinato da NieDzejkob

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

Questo è un programma COM; si aspetta il numero come argomento della riga di comando, genera Y o N. Limite: 65535 perché il processore a 16 bit (sizeof (int) sarebbe 2). Newline è 0x0D 0x0A su questa piattaforma. Sì, conti 20 █ invece di 19 █. Uno di questi è un vero █ e non è stato sostituito. Muhahaha.

Lo spazio in posizione 10 è in realtà un byte NUL. Il simbolo per NUL è uguale allo spazio nel vecchio carattere VGA.

Swift 4 , punteggio 26/170 ≈ 0,153, sicuro

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}

Provalo online!

Crepa prevista

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 byte (punteggio: 0,06,851 mila) ( Cracked da Nitrodon)

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

Provalo online!

Stampa "prime" se prime, "non prime" se composito. Funziona tecnicamente per numeri interi arbitrari ma va in timeout su TIO per numeri superiori a 6000

Mathematica, 97 byte, punteggio 0.2989690722 ( Cracked )

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

Stringhe! Regex! Primes?

Là V'è una cosa come un primalità controllo regex, ma non è questo quello che accade qui.

Questo è stato risolto , ma il modo in cui intendevo era abbastanza diverso, quindi non rivelerò ancora la soluzione voluta.

Jelly , punteggio 0. (142857) ( crackato )

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

Provalo online!

Repost della mia altra risposta, questa volta con qualche byte in più rivelato per evitare cheat involontari.

Ottava , punteggio: 0,15 (86 byte)

Ho rivelato molti altri personaggi. Pensavo che il criterio vincente fosse il punteggio più alto, non il più basso .

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

Provalo online!

Buona fortuna =)

Python 3, 388 byte, .155, Cracked

Crepa dell'ultimo minuto. Sì, questo è il test di Miller-Rabin.

Suppongo che siano consentiti test probabilistici, incertezza 2 ^ -100

Bene, un grande suggerimento nella frase precedente però

Valore restituito 0 come COMPOSITO e 1 come PROBABLY PRIME

* 368> 388: risolto il problema quando 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

Soluzione:

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 , punteggio 0.20512820512 [Sicuro]

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

Stampa 1 se primo, 0 se composito

Soluzione:

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

Nodo JavaScript, punteggio: 0,4

Ecco dove funziona. Programma completo che accetta input dal primo argomento della riga di comando e li invia a stdout.

Eventualmente, una soluzione non così difficile per iniziare.

Utilizzando questo frammento per calcolare il punteggio.

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 , punteggio 0. (142857)

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

Provalo online!

Accetta un argomento da riga di comando.

Falso = 0
Vero =1

JavaScript, 103 byte, punteggio 0,1923

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

Restituisce un valore booleano.

Crepa involontaria

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

In bocca al lupo. : p

chiama f con il numero primo che vuoi controllare.

> <>, punteggio 0,096, crackato da Jo King

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

Crepa prevista:

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

Brain-Flak, Punteggio: 35/134 = 0,2612 ( crackato! )

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

Restituisce 1 per il numero primo, 0 per il composito.

Questo è un linguaggio molto difficile in cui provare questa sfida, poiché la formattazione è così limitata che ci si impegna a non rendere evidente quale sia il personaggio mancante.

Questo è un linguaggio molto difficile in cui risolvere questa sfida, poiché è ridicolmente difficile da leggere.

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

Provalo online!

Il modo più strano che abbia mai visto controllare in Java di gran lunga lol.

Japt, 19 byte, 0,315789 ... punteggio, sicuro

Non so se l'ho oscurato più di quanto avrei dovuto, costandomi un punteggio migliore.

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

View solution (Spiegazione in arrivo)

C, 34/76 = 0.447368, Sicuro

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

Avere così tanti spazi vuoti significa che avrò molte più probabilità di ottenere un crack involontario rispetto a quello previsto.

Soluzione:

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

spiegazione:

econtiene un valore booleano del fatto che il numero non sia o meno primo (con alcune eccezioni di casi speciali). rscorre tra i numeri dispari minori o uguali alla radice quadrata di n. return e?n>1:n<3;gestisce i casi speciali quando nè 1o 2.

M , punteggio: 4/22 = .1818 ..., rotto da Dennis

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

Questo potrebbe finire con una crepa non intenzionale, dovremo vedere.Lo ha fatto.

Le soluzioni di Dennis sono

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

Provalo online!

Lascerò la mia soluzione nascosta per qualcuno da rompere. Il mio suggerimento a Dennis sulla sua proposta di rapinatore era la parola "zoo".

C, 66 byte, 29 redatto, punteggio 0.439

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

Solo una semplice presentazione in C; Vedrò quanto tempo impiegherà questo prima di pubblicarne uno davvero malvagio.

Pyth , punteggio: ~ 0. (461538) (13 byte) ( Cracked )

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

Prova a romperlo qui!

sh + coreutils, punteggio 19/143 ~ = 0.1328

Cracked

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

TIO

Brain-Flak , punteggio 29/140 = 0,207

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

Provalo online!

Uscite 1 per prime e 0 per non prime.

Tampio (imperativo), punteggio: 24/51 = 0,5

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

Questa è una soluzione ovvia, spero che nessuno qui capisca il finlandese.

Tampio (imperativo), punteggio: 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 , punteggio: 0,288288 ... [Sicuro]

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

Emette "Vero" se primo, "Falso" in caso contrario

Ho dimenticato di dire che è un test probabilistico.

Soluzione:

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

Questo implementa il test di primalità Solovay-Strassen.

Provalo online qui!

Rubino, 27/73 = 0.369863

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

Questo dovrebbe essere divertente.

Python 3 , punteggio: 0,386363, crackato

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

Dapprima per la frutta davvero bassa. Presto troverò una risposta sfacciata.

user71546 l'ha fatto "lavorare" con

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

... ma non era intenzionale. Il codice originale era

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

Né funziona per x <2, risulta. Ops.

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

La mia precedente risposta di Python era troppo semplice, quindi eccone una cattiva;)

La logica alla base è semplice però.