^{Esse desafio foi originalmente protegido por Magic Octopus Urn; Eu adotei e publiquei com sua permissão.}

Este é o tópico dos policiais. A discussão dos ladrões está aqui .

O desafio

• Etapa 1: Escreva um código (função ou programa completo) que verifique a primalidade .
• Etapa 2: Remova partes do seu código substituindo caracteres pelo símbolo █.
• Etapa três: Poste o código editado no tópico da polícia.
• Etapa quatro: espere que seu código seja decifrado e tente decifrar o código de outra pessoa.

Por exemplo, o código Groovy {it.isPrime()}pode se tornar {██.is█████()}. (Este seria estupidamente fácil de decifrar; também, eu sei, .isPrime()não é um método Groovy.)

Pontuação

Você deve incluir a pontuação do seu programa em seu envio. A pontuação é definida como a proporção de caracteres editados por caracteres. Portanto, se seu programa tivesse 20 caracteres e 5 fossem editados, sua pontuação seria 0,25. O código Groovy acima teria uma pontuação de 0,5.

Regras

• Seu programa só precisa manipular números inteiros positivos. Deverá gerar um valor verdadeiro se o número for primo e um valor falso, caso contrário. Especifique na sua resposta o que ele gera.
• Seu código não pode conter nenhum comentário ou espaço em branco desnecessário.
• Sem hash ou ofuscação criptográfica.
• Seu código não pode ter mais de 50% de redação (pelo menos 1/2 dos caracteres devem ser mostrados). Isso significa que a pontuação mais alta possível é 0,5.
• Se a sua resposta não for apresentada dentro de uma semana, você pode marcá-la como segura e editá-la no crack pretendido.

Ganhando

O vencedor será a resposta sem quebra de pontuação mais baixa dentro de duas semanas após a publicação. No caso de empate, o que tiver mais votos ganhará. Este tópico está sempre aberto a mais submissões, mas o vencedor escolhido após duas semanas será permanente.

Functoide , pontuação = 14/223 ≈ 0,062780 [seguro]

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

Recebe a entrada como argumento da linha de comando e gera saídas True(prime) ou False, experimente online!

Dica (adicionada 4 dias após a postagem):

O primeiro e o quarto █são um arenque vermelho: o IP da solução pretendida (e provavelmente de todas ) a seguirá a primeira linha e alcançará o ?personagem.

Solução

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

Experimente online!

Explicação

Devido à aleatoriedade resultante ?, não é possível achatar o programa. Aqui está o programa simples com um ponto de interrogação onde uma expressão aleatória estará:

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

Programa 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

O {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}, recebendo argumentos f(auto-referência) xe y(a nota 0é a mesma 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}é ?(yg(KZ)(C(C(BB(BS(b(C(BBI)I))))(C(BC(b(C(BBI)I)))I))(C-)))onde ?é escolhido aleatoriamente (dependendo da direção aleatória) entre:

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

Eles são todos equivalentes entre si, então {divides}se torna o ponto de correção 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} é uma expressão bastante ofuscada que basicamente apenas f x (y-x)

8086 DOS COM, 87 bytes, pontuação 19/87 ~ = 0,2183

Rachado por NieDzejkob

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

Este é um programa COM; espera número como argumento da linha de comando, gera Y ou N. Limite: 65535 porque o processador de 16 bits (sizeof (int) seria 2). A nova linha é 0x0D 0x0A nesta plataforma. Sim, você conta 20 █ em vez de 19 █. Um deles é real e não foi substituído. Muhahaha.

O espaço na posição 10 é realmente um byte NUL. O símbolo para NUL é o mesmo que espaço na fonte VGA antiga.

Swift 4 , pontuação 26/170 ≈ 0.153, seguro

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}

Experimente online!

Rachadura pretendida

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) ( Rachado por Nitrodon)

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

Experimente online!

Imprime "prime" se prime, "not prime" se composto. Tecnicamente funciona para números inteiros arbitrários, mas expira o tempo limite no TIO para números acima de 6000

Mathematica, 97 bytes, pontuação 0,2989690722 ( Rachado )

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

Cordas! Regex! Primes?

Não é uma coisa como um primality verificando regex, mas isso não é o que está acontecendo aqui.

Isso foi decifrado , mas a maneira como eu pretendia era bem diferente, então ainda não revelarei a solução pretendida.

Geléia , pontuação 0. (142857) ( rachado )

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

Experimente online!

Repost da minha outra resposta, desta vez com mais alguns bytes revelados para evitar truques não intencionais.

Oitava , Pontuação: 0.15 (86 bytes)

Eu revelei vários outros personagens. Eu pensei que o critério de vitória era a pontuação mais alta, não a mais baixa .

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

Experimente online!

Boa sorte =)

Python 3, 388 bytes, .155, Rachado

Rachadura de última hora. Sim, este é o teste de Miller-Rabin.

Suponho que testes probabilísticos sejam permitidos, incerteza 2 ^ -100

Bem, uma ótima dica na frase anterior

Tornou o valor de retorno 0 como COMPOSTO e 1 como PROVÁVEL PRIME

* 368> 388: Corrigido o 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

Solução:

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 , pontuação 0,20512820512 [Seguro]

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

Imprime 1 se prime, 0 se composto

Solução:

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

Nó JavaScript, pontuação: 0.4

Aqui é onde funciona. Programa completo que recebe a entrada do primeiro argumento da linha de comando e produz para o stdout.

Felizmente, uma solução não tão difícil para começar isso.

Usando esse trecho para calcular a pontuação.

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)

Geléia , pontuação 0. (142857)

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

Experimente online!

Aceita um argumento de linha de comando.

Falso = 0
Verdadeiro =1

JavaScript, 103 bytes, pontuação 0.1923

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

Retorna um booleano.

Rachadura não intencional

Javascript, pontuação 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)};};

Boa sorte. : p

chame f com o primo que deseja verificar.

> <>, pontuação 0,096, quebrada por Jo King

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

Rachadura pretendida:

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

Brain-Flak, Pontuação: 35/134 = 0.2612 ( rachado! )

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

Retorna 1 para prime, 0 para composto.

Essa é uma linguagem muito difícil de enfrentar esse desafio, pois a formatação é tão restrita que é necessário um esforço para não tornar óbvio qual é o caractere ausente.

Essa é uma linguagem muito difícil de resolver, pois é ridiculamente difícil de ler.

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

Experimente online!

Maneira mais estranha que eu já vi fazer o check-in em Java de longe, lol.

Japt, 19 bytes, 0.315789 ... pontuação, Seguro

Não sei se obscureci mais do que precisava, custando-me uma pontuação melhor.

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

View solution (Explicação em breve)

C, 34/76 = 0,447368, Seguro

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

Ter tantos espaços em branco significa que terei muito mais chances de ter uma rachadura não intencional do que a pretendida.

Solução:

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

explicação:

emantém um valor booleano de o número não ser primo ou não (com algumas exceções de caso especiais). ritera através dos números ímpares menores ou iguais à raiz quadrada de n. return e?n>1:n<3;lida com casos especiais quando né 1ou 2.

M , pontuação: 4/22 = 0,1818 ..., rachado por Dennis

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

Isso pode acabar com uma rachadura não intencional, teremos que ver. Sim.

As soluções de Dennis são

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

Experimente online!

Deixarei minha solução oculta para alguém quebrar. Minha dica para Dennis na submissão de ladrão foi a palavra "zoológico".

C, 66 bytes, 29 redigido, pontuação 0,439

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

Apenas um simples envio de C; Vou ver quanto tempo demora para publicar uma realmente má.

Pyth , pontuação: ~ 0. (461538) (13 bytes) ( Cracked )

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

Tente decifrá-lo aqui!

sh + coreutils, pontuação 19/143 ~ = 0.1328

rachado

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

TIO

Brain-Flak , pontuação 29/140 = 0.207

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

Experimente online!

Saídas 1 para prime e 0 para não prime.

Tampio (imperativo), pontuação: 24/51 = 0,5

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

Esta é uma solução óbvia, espero que ninguém aqui compreenda finlandês.

Tampio (imperativo), pontuação: 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 , pontuação: 0.288288 ... [Seguro]

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

Saídas "True" se for prime, "False" se não for

Esqueci de mencionar que é um teste probabilístico.

Solução:

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

Isso implementa o teste de primalidade de Solovay-Strassen.

Experimente online aqui!

Ruby, 27/73 = 0,369863

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

Isso deve ser divertido.

Python 3 , pontuação: 0.386363, rachado

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

Indo para a fruta realmente baixa em primeiro lugar. Em breve, apresentarei uma resposta atrevida.

user71546 fez com que "funcionasse" com

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

... mas isso não foi intencional. O código original era

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

Nem trabalho para x <2, acaba. Opa

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

Minha resposta anterior do Python foi muito direta, então aqui está uma má;)

A lógica por trás é simples, porém.