^{Ce défi était à l'origine mis en bac par Magic Octopus Urn; Je l'ai adopté et posté avec sa permission.}

Ceci est le fil des flics. Le fil des voleurs est ici .

Le défi

• Première étape: Écrivez un morceau de code (fonction ou programme complet) qui vérifie la primauté .
• Deuxième étape: supprimez des morceaux de votre code en remplaçant les caractères par le symbole █.
• Troisième étape: publiez le code expurgé sur le fil de la police.
• Quatrième étape: attendez que votre code soit craqué et essayez de casser le code des autres.

Par exemple, le code Groovy {it.isPrime()}pourrait devenir {██.is█████()}. (Celui-ci serait stupidement facile à casser; je sais aussi que ce .isPrime()n'est pas une méthode Groovy.)

Notation

Vous devez inclure la note de votre programme dans sa soumission. Le score est défini comme le rapport des caractères expurgés aux caractères. Donc, si votre programme avait 20 caractères et 5 ont été caviardés, votre score serait de 0,25. Le code Groovy ci-dessus aurait un score de 0,5.

Règles

• Votre programme n'a besoin que de gérer des nombres entiers positifs. Il devrait sortir une valeur véridique si le nombre est premier et une valeur fausse sinon. Veuillez préciser dans votre réponse ce qu'elle produit.
• Votre code ne doit contenir aucun commentaire ni espace inutile.
• Aucun hachage ou obscurcissement cryptographique.
• Votre code ne doit pas être expurgé à plus de 50% (au moins la moitié des caractères doivent être affichés). Cela signifie que le score le plus élevé possible est de 0,5.
• Si votre réponse n'est pas fissurée dans une semaine, vous pouvez la marquer comme sûre et la modifier dans la fissure voulue.

Gagnant

Le gagnant sera la réponse non fissurée ayant obtenu le score le plus bas dans les deux semaines suivant sa publication. En cas d'égalité, celui qui a le plus de voix gagnera. Ce fil est toujours ouvert à plus de soumissions, mais le gagnant choisi après deux semaines sera permanent.

Functoid , score = 14/223 ≈ 0,062780 [sûr]

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

Prend entrée comme argument de ligne de commande et les sorties True(prime) ou False, essayer en ligne!

Astuce (ajouté 4 jours après la publication):

Le premier et le 4ème █sont un hareng rouge: l'IP de la solution prévue (et probablement de chaque ) suivra la première ligne et atteindra le ?personnage.

Solution

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

Essayez-le en ligne!

Explication

En raison du caractère aléatoire qui en résulte, ?il n'est pas possible d'aplatir le programme. Voici le programme plat avec un point d'interrogation où une expression aléatoire sera:

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

Programme complet:

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

Le {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}, en prenant des arguments f(auto-référence), xet y(la note 0est la même que 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}est ?(yg(KZ)(C(C(BB(BS(b(C(BBI)I))))(C(BC(b(C(BBI)I)))I))(C-)))où ?est choisi au hasard (en fonction de la direction aléatoire) parmi:

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

Ce sont tous équivalents les uns aux autres, {divides}devient ainsi le point fixe de:

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} est une expression assez obscurcie qui ne fait que f x (y-x)

8086 DOS COM, 87 octets, score 19/87 ~ = 0,2183

Fissurée par NieDzejkob

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

Il s'agit d'un programme COM; attend le nombre comme argument de ligne de commande, affiche Y ou N. Limite: 65535 car le processeur 16 bits (sizeof (int) serait 2). La nouvelle ligne est 0x0D 0x0A sur cette plate-forme. Oui, vous comptez 20 █ au lieu de 19 █. L'un d'eux est un vrai █ et n'a pas été remplacé. Muhahaha.

L'espace en position 10 est en fait un octet NUL. Le symbole pour NUL est le même que l'espace dans l'ancienne police VGA.

Swift 4 , score 26/170 ≈ 0,153, sûr

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}

Essayez-le en ligne!

Fissure prévue

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}

Non golfé

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 octets (score: 0,06851) ( fissuré par Nitrodon)

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

Essayez-le en ligne!

Imprime "premier" si premier, "pas premier" si composite. Fonctionne techniquement pour les entiers arbitraires mais expire sur TIO pour les nombres supérieurs à 6000

Mathematica, 97 octets, score de 0,2989690722 ( fissuré )

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

Cordes! Regex! Primes?

Il existe une chose comme une expression rationnelle de vérification de primalité, mais ce n'est pas ce qui se passe ici.

Cela a été fissuré , mais la façon dont je le voulais était assez différente, donc je ne révélerai pas encore la solution prévue.

Jelly , score 0. (142857) ( fissuré )

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

Essayez-le en ligne!

Republiez mon autre réponse, cette fois avec quelques octets supplémentaires révélés pour éviter les tricheurs involontaires.

Octave , score: 0,15 (86 octets)

J'ai révélé plusieurs autres personnages. Je pensais que le critère gagnant était le score le plus élevé, pas le plus bas .

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

Essayez-le en ligne!

Bonne chance =)

Python 3, 388 octets, .155, fissuré

Fissure de dernière minute. Oui, c'est le test de Miller-Rabin.

Je suppose que les tests probabilistes sont autorisés, incertitude 2 ^ -100

Eh bien, un bon indice dans la phrase précédente

Valeur renvoyée 0 comme COMPOSITE et 1 comme PROBABLEMENT PRIME

* 368> 388: correction du problème lorsque 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

Solution:

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 [Coffre-fort]

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

Imprime 1 si premier, 0 si composite

Solution:

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

Node JavaScript, score: 0,4

Voici où cela fonctionne. Programme complet qui prend les entrées du premier argument de ligne de commande et les sorties vers stdout.

Avec un peu de chance, une solution pas si difficile pour commencer.

Utiliser cet extrait pour calculer le 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█████

Essayez-le en ligne!

Prend un argument de ligne de commande.

Faux = 0
Vrai =1

JavaScript, 103 octets, score de 0,1923

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

Renvoie un booléen.

Fissure involontaire

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

Bonne chance. : p

appelez f avec le nombre premier que vous souhaitez vérifier.

> <>, score 0,096, cracké par Jo King

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

Fissure prévue:

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

Brain-Flak, Score: 35/134 = 0,2612 ( craqué! )

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

Renvoie 1 pour prime, 0 pour composite.

C'est un langage très difficile pour relever ce défi, car le formatage est si restreint qu'il faut faire des efforts pour ne pas rendre évident le caractère manquant.

C'est un langage très difficile à résoudre pour ce défi, car il est ridiculement difficile à lire.

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

Essayez-le en ligne!

De la façon la plus étrange que j'ai vue pour amorcer un check in Java de loin lol.

Japt, 19 octets, 0,315789 ... score, Safe

Je ne sais pas si j'ai obscurci plus que ce dont j'avais besoin, me coûtant un meilleur score.

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

View solution (Explication à venir)

C, 34/76 = 0,447368, sûr

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

Avoir autant de blancs signifie que je serai beaucoup plus susceptible d'avoir une fissure involontaire que celle prévue.

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

explication:

econtient une valeur booléenne indiquant si le nombre n'est pas premier (à quelques exceptions près). ritère à travers les nombres impairs inférieurs ou égaux à la racine carrée de n. return e?n>1:n<3;gère les cas particuliers lorsque nest 1ou 2.

M , score: 4/22 = .1818 ..., craqué par Dennis

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

Cela peut se terminer par une fissure involontaire, nous devrons voir. Ça faisait.

Les solutions de Dennis sont

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

Essayez-le en ligne!

Je laisserai ma solution cachée pour que quelqu'un craque. Mon indice à Dennis sur sa soumission de voleur était le mot "zoo".

C, 66 octets, 29 caviardés, score de 0,439

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

Juste une simple soumission C; Je verrai combien de temps cela prendra avant d'en poster un vraiment mauvais.

Pyth , score: ~ 0. (461538) (13 octets) ( Cracké )

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

Essayez de le casser ici!

sh + coreutils, score 19/143 ~ = 0,1328

fissuré

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

TIO

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

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

Essayez-le en ligne!

Sorties 1 pour prime et 0 pour non-prime.

Tampio (impératif), score: 24/51 = 0,5

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

C'est une solution évidente, j'espère que personne ici ne comprend le finnois.

Tampio (impératif), 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 ... [Sûr]

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

Sorties "True" si premier, "False" sinon

J'ai oublié de mentionner qu'il s'agit d'un test probabiliste.

Solution:

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

Cela met en œuvre le test de primalité de Solovay-Strassen.

Essayez-le en ligne ici!

Rubis, 27/73 = 0,3696863

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

Cela devrait être amusant.

Python 3 , score: 0,386363, fissuré

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

Opter pour les fruits très bas au début. Je trouverai bientôt une réponse effrontée.

user71546 l'a fait "fonctionner" avec

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

... mais c'était involontaire. Le code d'origine était

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

Ni l'un ni l'autre ne fonctionne pour x <2. Oups.

JavaScript (ES7), 297 octets, 103 expurgé, .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)██)██

Ma réponse Python précédente était trop simple, alors voici une mauvaise réponse;)

La logique derrière est cependant simple.