^{Este desafío fue originalmente protegido por Magic Octopus Urn; Lo adopté y lo publiqué con su permiso.}

Este es el hilo conductor de la policía. El hilo de los ladrones está aquí .

El reto

• Paso uno: escriba un fragmento de código (función o programa completo) que verifique la originalidad .
• Paso dos: elimine partes de su código reemplazando los caracteres con el símbolo █.
• Paso tres: Publique el código redactado en el hilo de la policía.
• Paso cuatro: espere a que se descifre su código e intente descifrar el código de otros.

Por ejemplo, el código Groovy {it.isPrime()}podría convertirse {██.is█████()}. (Este sería estúpidamente fácil de descifrar; además, lo sé, .isPrime()no es un método maravilloso).

Puntuación

Debe incluir el puntaje de su programa en su envío. La puntuación se define como la relación de caracteres redactados a caracteres. Entonces, si su programa tenía 20 caracteres y 5 fueron redactados, su puntaje sería 0.25. El código Groovy anterior tendría una puntuación de 0.5.

Reglas

• Su programa solo necesita manejar enteros positivos. Debería generar un valor verdadero si el número es primo y un valor falso de lo contrario. Por favor, especifique en su respuesta lo que genera.
• Su código no puede contener comentarios o espacios en blanco innecesarios.
• Sin hashing u ofuscación criptográfica.
• Su código no puede ser más del 50% redactado (se deben mostrar al menos la mitad de los caracteres). Esto significa que la puntuación más alta posible es 0.5.
• Si su respuesta no se descifra dentro de una semana, puede marcarla como segura y editarla en el crack previsto.

Victorioso

El ganador será la respuesta sin descifrar con la puntuación más baja dentro de las dos semanas posteriores a la publicación. En caso de empate, el que tenga más votos ganará. Este hilo siempre está abierto a más presentaciones, pero el ganador elegido después de dos semanas será permanente.

Functoid , puntaje = 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

Toma la entrada como argumento de línea de comandos y las salidas True(prime) o False, ¡ pruébelo en línea!

Sugerencia (agregada 4 días después de la publicación):

El primero y el cuarto █son una pista falsa: la IP de la solución prevista (y muy probablemente de todas ) seguirá la primera línea y alcanzará el ?carácter.

Solución

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

Pruébalo en línea!

Explicación

Debido a la aleatoriedad que proviene ?, no es posible aplanar el programa. Aquí está el programa plano con un signo de interrogación donde será una expresión aleatoria:

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

El {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}, tomando argumentos f(autorreferencia) xy y(la nota 0es la misma 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}es ?(yg(KZ)(C(C(BB(BS(b(C(BBI)I))))(C(BC(b(C(BBI)I)))I))(C-)))donde ?se elige aleatoriamente (dependiendo de la dirección aleatoria) de:

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

Todos estos son equivalentes entre sí, por lo que se {divides}convierte en el punto de fijación 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} es una expresión bastante ofuscada que básicamente solo f x (y-x)

8086 DOS COM, 87 bytes, puntaje 19/87 ~ = 0.2183

Agrietado por NieDzejkob

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

Este es un programa COM; espera número como argumento de línea de comando, salidas Y o N. Límite: 65535 porque el procesador de 16 bits (sizeof (int) sería 2). Newline es 0x0D 0x0A en esta plataforma. Sí, cuentas 20 █ en lugar de 19 █. Uno de ellos es un verdadero █ y no ha sido sustituido. Muhahaha

El espacio en la posición 10 es en realidad un byte NUL. El símbolo para NUL es el mismo que el espacio en la antigua fuente VGA.

Swift 4 , puntaje 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}

Pruébalo en línea!

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

Sin 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 bytes (puntuación: 0.06851) ( Agrietado por Nitrodon)

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

Pruébalo en línea!

Imprime "cebar" si ceba, "no ceba" si es compuesto. Técnicamente funciona para enteros arbitrarios, pero se agota el tiempo de espera en TIO para números superiores a 6000

Mathematica, 97 bytes, puntaje 0.2989690722 ( Agrietado )

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

¡Instrumentos de cuerda! Regex! Primes?

No es una cosa tal como una comprobación de primalidad expresiones regulares, pero eso no es qué está sucediendo aquí.

Esto se ha resuelto , pero la forma en que pretendía era bastante diferente, por lo que aún no revelaré la solución prevista.

Jalea , puntaje 0. (142857) ( agrietado )

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

Pruébalo en línea!

Publicando mi otra respuesta, esta vez con algunos bytes más revelados para evitar trampas no intencionadas.

Octava , Puntuación: 0.15 (86 bytes)

Revelé varios personajes más. Pensé que el criterio ganador era el puntaje más alto, no el más bajo .

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

Pruébalo en línea!

Buena suerte =)

Python 3, 388 bytes, .155, Agrietado

Grieta de último minuto. Sí, esta es la prueba de Miller-Rabin.

Supongo que se permiten pruebas probabilísticas, incertidumbre 2 ^ -100

Bueno, una gran pista en la oración anterior

Realizó el valor de retorno 0 como COMPUESTO y 1 como PROBABLEMENTE PRIME

* 368> 388: se corrigió el problema cuando 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

Solución:

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 , puntaje 0,20512820512 [Seguro]

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

Imprime 1 si es primo, 0 si es compuesto

Solución:

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

Nodo JavaScript, puntuación: 0.4

Aquí es donde funciona. Programa completo que toma la entrada del primer argumento de la línea de comando y sale a stdout.

Con suerte, una solución no tan difícil para comenzar esto.

Usando este fragmento para calcular la puntuación.

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)

Jalea , puntaje 0. (142857)

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

Pruébalo en línea!

Toma un argumento de línea de comandos.

Falso = 0
Verdadero =1

JavaScript, 103 bytes, puntuación 0.1923

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

Devuelve un booleano.

Crack involuntario

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

Buena suerte. :pag

llame a f con la prima que desea verificar.

> <>, puntaje 0.096, descifrado por Jo King

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

Grieta prevista:

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

Brain-Flak, Puntuación: 35/134 = 0.2612 ( ¡agrietado! )

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

Devuelve 1 para primo, 0 para compuesto.

Este es un lenguaje muy difícil para probar este desafío, ya que el formato es tan restringido que se requiere esfuerzo para no hacer obvio cuál es el carácter que falta.

Este es un lenguaje muy difícil para resolver este desafío, ya que es ridículamente difícil de leer.

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

Pruébalo en línea!

La forma más extraña que he visto para comprobar el cheque en Java con mucho, jajaja.

Japt, 19 bytes, 0.315789 ... puntaje, Seguro

No sé si oscurecí más de lo necesario, lo que me costó una mejor puntuación.

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

View solution (Explicación próximamente)

C, 34/76 = 0.447368, seguro

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

Tener tantos espacios en blanco significa que tendré muchas más probabilidades de obtener una grieta no deseada que la prevista.

Solución:

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

explicación:

econtiene un valor booleano de si el número no es primo (con algunas excepciones de casos especiales). ritera a través de los números impares menores o iguales a la raíz cuadrada de n. return e?n>1:n<3;maneja los casos especiales cuando nes 1o 2.

METRO , puntaje: 22/4 = .1818 ..., descifrado por Dennis

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

Esto puede terminar con una grieta involuntaria, tendremos que ver. Lo hizo.

Las soluciones de Dennis son

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

Pruébalo en línea!

Dejaré mi solución oculta para que alguien la descifre. Mi sugerencia a Dennis sobre su presentación de ladrón fue la palabra "zoológico".

C, 66 bytes, 29 redactados, puntaje 0.439

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

Solo una simple presentación en C; Veré cuánto tiempo lleva esto antes de publicar uno realmente malo.

Pyth , puntuación: ~ 0. (461538) (13 bytes) ( Agrietado )

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

¡Intenta descifrarlo aquí!

sh + coreutils, puntaje 19/143 ~ = 0.1328

agrietado

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

TIO

Brain-Flak , puntaje 29/140 = 0.207

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

Pruébalo en línea!

Salidas 1 para primo y 0 para no primo.

Tampio (imperativo), puntaje: 24/51 = 0.5

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

Esta es una solución obvia, espero que nadie entienda finlandés.

Tampio (imperativo), puntaje: 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 , puntuación: 0.288288 ... [Seguro]

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

Emite "Verdadero" si es primo, "Falso" si no

Olvidé mencionar que es una prueba probabilística.

Solución:

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

Esto implementa la prueba de primalidad Solovay-Strassen.

Pruébelo en línea aquí!

Rubí, 27/73 = 0.369863

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

Esto debería ser divertido.

Python 3 , puntaje: 0.386363, agrietado

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

Ir por la fruta realmente baja al principio. Encontraré una respuesta descarada pronto.

user71546 lo hizo "trabajar" con

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

... pero eso no fue intencionado. El código original era

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

Tampoco funciona para x <2. Ups

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

Mi respuesta anterior de Python fue demasiado directa, así que aquí hay una malvada;)

Sin embargo, la lógica detrás es sencilla.