[Question]
  [
This challenge was originally sandboxed by Magic Octopus Urn; I adopted and posted it with his permission.
*This is the cops' thread. The robbers' thread is [here](https://codegolf.stackexchange.com/q/154742/61563).*
## The challenge
* **Step One:** Write a piece of code (function or full program) which checks for [primality](https://en.wikipedia.org/wiki/Primality_test).
* **Step Two:** Remove pieces of your code by replacing characters with the symbol `█`.
* **Step Three:** Post the redacted code on the cops thread.
* **Step Four:** Wait for your code to be cracked and try to crack other's code.
For example, the Groovy code `{it.isPrime()}` could become `{██.is█████()}`.
 (This one would be stupidly easy to crack; also, I know, `.isPrime()` is not a Groovy method.)
---
## Scoring
You must include your program's score in its submission. The score is defined as the ratio of redacted characters to characters. So if your program had 20 characters and 5 were redacted, your score would be 0.25. The Groovy code above would have a score of 0.5.
---
## Rules
* Your program only needs to handle *positive integers.* It should output a truthy value if the number is prime and a falsy value otherwise. Please specify in your answer what it outputs.
* Your code may not contain any comments or unnecessary whitespace.
* No hashing or cryptographic obfuscation.
* Your code may be no more than 50% redacted (at least 1/2 the characters must be shown). This means that the *highest* possible score is 0.5.
* If your answer is not cracked within a week you may mark it safe and edit in the intended crack.
---
## Winning
The winner will be the lowest-scoring uncracked answer within two weeks of posting. In the case of a tie, whichever has the most votes will win. This thread is always open to more submissions, but the winner chosen after two weeks will be permanent.
  
[Answer]
## 8086 DOS COM, 87 bytes, score 19/87 ~= 0.2183
[Cracked](https://codegolf.stackexchange.com/a/154980) by [NieDzejkob](https://codegolf.stackexchange.com/users/55934/niedzejkob)
```
1└╣██1█╛ü ¼<█t<< u≈¼<█t█,0|/<██+ô≈ßô☺├δδâ√█|█╞█S█Y╣██9┘t█ë╪1╥≈±○╥t█Aδ∩╞█S█N┤█║S█═!├A
$
```
This is a COM program; expects number as a command line argument, outputs Y or N. Limit: 65535 because 16 bit processor (sizeof(int) would be 2). Newline is 0x0D 0x0A on this platform. Yes you count 20 █ instead of 19 █. One of them's a real █ and has not been substituted. Muhahaha.
The space in position 10 is actually a NUL byte. The symbol for NUL is the same as space in the old VGA font.
[Answer]
# [Swift 4](https://swift.org), score 26 / 170 ≈ 0.153, safe
```
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}
```
[Try it online!](https://tio.run/##TU9BCsIwELz3FTmIZEFTBT2opAdvXr2KSKmRRNK0NKkVSu@@wAf6kbgxIkJ2djI7O7C2Uxe38P7SmoLU1Kx3xsE021aV7j/a6/mgp4BhMvkx9CD2t7whktM5Y0wDK/O6H83Qga@MLemk0oKWXLKiajHhqwOb95IfMONI5QEFTDjCsGmEaxtDyiH5MhxlcWVMgy3yT4IyZ3FHdsUyUZxBxkMbEHiU9ODTlOxFrfNCECeVJZ1ykjhhHSlyK2xSN8o4Gq5fAvz9VgDevwE)
## Intended Crack
```
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
}
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 37/540 bytes (score: 0.06851) ([Cracked](https://codegolf.stackexchange.com/a/155238/69059) by Nitrodon)
```
>>>>>+>,[>++++++[-<-------->]<+>,]<[-[█<█<]++++++++++<]>[-]>>██[>█>>█>]+[<]<<[<]>█<<+>>[>]█>[>]█+[<]<<[<]>-█>]>>[->]<[-[[<]<]++++++++++<]>[-]>[<█]>]>[>]<[[█]<]<<<<<[<]<<██>>[>]<█[->+<]<█>>[>]<[-[[<]<]++++++++++<]>███>[<<]>[[[>]>████[<]<[-[[<]<]++++++++++<]>[-]>[█<]>]>[>]<[[-]>+[>]<-<[<]<]+<<<<<[<]>[[>]+[[>]>]>[>]>[-<+>]<[<]<[>+[<]>>-<<<<<[[<]<]>>███████>[[█]>]<]<[[<]<]<[█]>]>>>[[>]<->>]]>[[>]>]<<[[[█]<]<]<<<[█]<<█>>>[>]█[-[[<]<]++++++++++<]>>[[>]+[------->++<]>.+.+++++.[---->+<]>+++.>>]>[>]+[------->++<]>++.++.---------.++++.--------.
```
[Try it online!](https://tio.run/##fVJBagMxDHyQYxPa6zAfETq0hUII9FDoH/KCPDAf2WikXSdpQ8Xu2pJGGnm8799vh6/Pn4/jslDWuDO2NOvoq9ERCYd1u5xP0OttGpzWnYxwPKY1HXozOBAfuYgeNLoytdzSPeGRFlWwKPGXwcTsgTOhNIqrAbIHUPzJoX30ikLM0NO2VZMjQSwWyFtQXfDfQKnEHCgiTbuOgm@jUV1btk5o1IYWnqhQWwj2AmchHya4G9Hq/CpLINZAXJwlMenFRgk7JZJItS85Vv2fnmsddrv5jI02Mj2sYhGSxzrOL3ATeGy/Ts/K6Y5lednvX68 "brainfuck – Try It Online")
Prints "prime" if prime, "not prime" if composite. Technically works for arbitrary integers but times out on TIO for numbers above 6000
[Answer]
# [Functoid](https://github.com/bforte/Functoid), score = 14 / 223 ≈ 0.062780 [safe]
```
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
```
Takes input as command-line argument and outputs `True` (prime) or `False`, [try it online!](https://tio.run/##LU8xDsIwDNzzigwd7A3UsZWpnAFFGTOBxAKIigUWiMQPeAEP5CPhnBLFTnzO3TmX5@30uF/Pte7otSVN388bm0kpk2YKpMGSAigOtbYuUkColOS9ZrSZUSej5I0TSnumRiyyKPr/EkRZoNGZVp77yN3gJ1FjH5tb5FjEXGYH5cgWES7B@nYA4bGYZ3CxvVgBWcaFjrYrzAG6g/HtibQBeJmmGyarIr5aa133Pw "Functoid – Try It Online")
**Hint (added 4 days after posting):**
> 
>  The first and 4th `█` are a red herring: The intended (and most likely *every*) solution's IP will follow the first line and reach the `?` character.
> 
> 
> 
### 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
```
[Try it online!](https://tio.run/##LU@xCgIxDN37FR1uSAZB78Y7oqSDhAo3dDpBBxUPF120cF9fk2ohafJe3kt7/zyv79fjVsoEyx44HloEhgScIAAHS6xAdtrziOCDZ8rRe05KII7RRtPWEcQjQhVkGtH/D2nkyQ/ujGnuBJve74hNc6negpIJltmpl6CFqG8w1i5FcMi4Ck4qv9b@9zD14FrqOgXdydQ2QnUttpqbfme16JdKKZvuCw "Functoid – Try It Online")
### Explanation
Due to the randomness that comes from `?` it's not possible to flatten the program. Here's the flat program with a question mark where a random expression will be:
```
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$;@
```
Full program:
```
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
```
The `{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}`, taking arguments `f` (self-reference), `x` and `y` (note `0` is the same as `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}` is `?(yg(KZ)(C(C(BB(BS(b(C(BBI)I))))(C(BC(b(C(BBI)I)))I))(C-)))` where `?` is randomly chosen (depending on the random direction) from:
* `Y`
* `S(CBO)(CBO)`
* `S(SB(KO))(BBSBKO)`
These are all equivalent to each other, so `{divides}` becomes the fix-point of:
```
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}` is a pretty obfuscated expression that basically just does `f x (y-x)`
[Answer]
# Mathematica, 97 bytes, score 0.2989690722 ([Cracked](https://codegolf.stackexchange.com/a/154750/69850))
```
f[x_]:=(██ToString███████████████;StringMatchQ[████Infinity,RegularExpression@"█\█\█{█\█+, ███"])
```
Strings! Regex! Primes?
There *is* such a thing as a primality checking regex, but that's not whats happening here.
This has been [cracked](https://codegolf.stackexchange.com/a/154750/60042), but the way I intended was quite different, so I won't reveal the intended solution yet.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), score 0.(142857) ([cracked](https://codegolf.stackexchange.com/a/154835/41024))
```
25██26█966836897364918299█0█1█65849159233270█02█837903312854349029387313█ị██v
```
[Try it online!](https://tio.run/##JY3BCYBAEANbutvc7W4K8iO@BTsQ/NuM1WgjZ0RI8phAMk/Lso1h/Tl3yVxB94QnA95Y00jBIlfZewp2GmDxwWKKRLAA1bI3NBYjMlCh6r6Of3sd@nkB "Jelly – Try It Online")
Repost of my other answer, this time with a few more bytes revealed to avoid unintended cheats.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), Score: 0.15 (86 bytes)
I revealed several more characters. I thought the winning criterion was *highest* score, not *lowest*.
```
@(x)eval([(str2num(cell2mat([cellstr(reshape('0█1███1█0█0█00',████))])')█'█')','(x)'])
```
[Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999Bo0IztSwxRyNao7ikyCivNFcjOTUnxyg3sUQjGsQCimoUpRZnJBakaqgbPJrWYQjEEARiGcCwgboOXAKINDVjNdU1gQx1ENZU11EHWqQeq/k/TcNIkytNwxhEmIAIUxBhpvkfAA "Octave – Try It Online")
Good luck =)
[Answer]
# Python 3, 388 bytes, .155, Cracked
Last-minute crack. Yes, this is the Miller-Rabin test.
I suppose probabilistic tests are allowed, uncertainty 2^-100
Well, a great hint in the previous sentence though
Made return value 0 as COMPOSITE and 1 as PROBABLY PRIME
\*368 > 388 : Fixed the problem when 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
```
[Answer]
# [095](https://github.com/nosekill/095), score 0.20512820512 [Safe]
```
1id#█#=(DD#█#█{d_█%(█D0█]D}██s]D1.=[1s]
```
Prints 1 if prime, 0 if composite
Solution:
```
1id#2#=(DD#2#-{d_.%(rD0R]D}drs]D1.=[1s]
```
[Answer]
# Node JavaScript, score: 0.4
[Here's where it works.](https://tio.run/##fU9bCsIwEDyNkmALSWpMSh8epPRjbftRP6KJDzyCJ/CAXiQmJAgtWthlZh/D7hzhDpfOjOdrqk79YK0Z9G00w/v1XA5WliywWs1GZvQddPgnfeBZA@WMUoc7mZE4Q5B0uKqh6RrSLn@COvx7Axd99S02qtDVxIAQggea8902aTjxhnie@E9a3DhocQFRpGsy8YhUpR2Cy7XLVKfxKARUK70PLOoQzQTl/oRkgiSMMSkxAmytpfQD) 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](https://tio.run/##fU/RCoIwFH3vKyQqdslsruYUnX2ISKxl5MtqK6H6gr6gD@xHbKIERQm7nLNz7@HeY6rNta41HyWeKcTWk3thToOjoz15qNQZDZ@P@xCcuRVO5a3wzof1rq5NoavSFLbX/0iSkJal6qtlykZBm3/WC3wJKCK@bzEIF7jrIeFK4KnIZIbz/kuQhN8TEG/5@zNVseYfARhjtKURDZZuRnETiEZuc0kOmYUcYtGZdIo/MiLFtUVha2JrpmfdUtGiGutVyzof8hfMp82KkDDsEkLCEJCAFw) 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)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), score 0.(142857)
```
25██26█9668368973649182992051██5849159233270202█837903312854349029387313█████
```
[Try it online!](https://tio.run/##PY3BCcAwDANXcqTYsQbqp2SBbtAJOmAXSQ2BwqHHIaHzmPNaC/4@d4GoUEQyUoPR1RISzNsueJZygcQwGEolh4xsSO/sMog52LgHP6tePg "Jelly – Try It Online")
Takes a command-line argument.
False = `0`  
True = `1`
[Answer]
# 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](https://codegolf.stackexchange.com/questions/154742/cops-and-robbers-redacted-primality-robbers-thread/154819#154819)
[Answer]
## 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.
[Answer]
# ><>, score 0.096, [cracked by Jo King](https://codegolf.stackexchange.com/a/154979/61384)
```
:1@v>~~:?1n;█$-1<█?=2:}*{█@:$@:
```
Intended crack:
> 
> 
> ```
> :1@v>~~:?1n;
> $-1<^?=2:}*{%@:$@:
> ```
> 
> 
> 
> 
[Answer]
# Brain-Flak, Score: 35/134 = 0.2612 ([cracked!](https://codegolf.stackexchange.com/a/154825/69059))
`(({████){██[████)█>(({}))<>}<>{}███{}((██({}))█████{}]██)({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})██[██()██(()█[()]██{}██}{}<>{})`
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.
[Answer]
# [Java 1.4+](http://openjdk.java.net/), 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!](https://tio.run/##y0osS9TNL0jNy0rJ/v8/OSexuFghorqgNCknM1mhuCSxBEiV5WemKOQmZuZpBJcUZealR8cmFqUXa1YHVxaXpObq5ZeW6BUAxUty8jTyUssVIIo0Hk3rwIqiPfNKUtNTi/QKEouKU4EcDZBp0QaxmrGaermJJckZqcUaSrh0oyElTXs4W9O6tvb/f5P/hiYA "Java (OpenJDK 8) – Try It Online")
---
Weirdest way I've seen to prime check in Java by far lol.
[Answer]
# 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](https://ethproductions.github.io/japt/?v=1.4.5&code=I2g4NTc1pSMK51XiynHKxCBuMg==&input=OA==)` (Explanation coming soon)
[Answer]
# 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`.
> 
> 
> 
[Answer]
# [M](https://github.com/DennisMitchell/m), score: 4/22 = .1818..., [cracked](https://codegolf.stackexchange.com/questions/154742/cops-and-robbers-redacted-primality-robbers-thread/156382#156382) by [Dennis](https://codegolf.stackexchange.com/users/12012/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!](https://tio.run/##y/3//3BbwOEdjxrmWFsDiUO7w/wf7lhsFPyocau2tvHD3T1A0bkBZf///zcCAA)
I will leave my solution hidden for someone to crack. My hint to Dennis on his robber submission was the word "zoo".
[Answer]
# 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.
[Answer]
# [Pyth](https://pyth.readthedocs.io), score: ~0.(461538) (13 bytes) ([Cracked](https://codegolf.stackexchange.com/a/154818/59487))
```
█]█Q ██Q{█M█P
```
[Try to crack it here!](http://pyth.herokuapp.com/?code=q%5DtQ+%23aQ%7B%2aMyP%0A%E2%96%88%5D%E2%96%88Q+%E2%96%88%E2%96%88Q%7B%E2%96%88M%E2%96%88P&input=70&debug=0)
[Answer]
## sh + coreutils, score 19 / 143 ~= 0.1328
[cracked](https://codegolf.stackexchange.com/a/154914/14306)
```
e█ec█s█ █c "██████WyAkKHNoIC1jICJg█WNobyBabUZqZEc5eWZIUnlJQ2█2SnlBblhHNG5m██JoYVd3Z0t6SjhkMk1nTFhjSyB8YmFzZTY0IC1kYCIpIC1lcSAxIF0K█b█se6███d`"
```
[TIO](https://tio.run/##S0oszvj/P/XRtI7UZCBRDMQKQJysoAQk0VB4pWO2t4dfvqezYZans1c6SMgvP6nSKTEpNKowyjXZNDU8yjM0L8cr0AgoZxScl@OUlJPh4edumgsxwSs/MizFOMqgxCw4KyPbN9swL8QtIyu40skiMtetKiok0gBodnaks2cBkM5JDnas8HQz8AZqTAK5LdUM7pSUBKX//wE)
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), score 29 / 140 = 0.207
`({}██()██<>){██({}[()])██{}{}███({<({}[()])><>({})<>}{}██████{}██){(({})){({}[()])<>}{}}<>([{}()]{}<>{})<>}(<>██{}({}████)((){[()]██{}██}{})`
[Try it online!](https://tio.run/##VUzLCYAwDF0nObhByCLFQz0IonjwGnJ3Agd0kRjbRiw8eMn7TUde9mHe8moGovd1OgArE6M0RTQBjk0XjWSxKFwm9hOJ//6H0FDgTTm1Wsmrd5Oo/@JnXQHiqEK/iAAob7mf9h00ewA)
Outputs 1 for prime and 0 for non-prime.
[Answer]
# [Tampio](https://github.com/fergusq/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.
[Answer]
# [Tampio](https://github.com/fergusq/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.
```
[Answer]
# [Pyt](https://github.com/mudkip201/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!](https://tio.run/##K6gs@f//yASjR@07H03rODrjyIQjE442AplQ1L7zVMORCY/aphyZYHpiBpCGKAQiW5D6qShyQK0zIZoQBkAQSM7kxAyQMrhk@07jEzMObTAwgZg7rQPIhVoOZBmYwoSBCkFqDDAtB4qAXIDkYogGMOPoVAhEEUaVhHAPrTm05v9/Q0tzAA)
[Answer]
# Ruby, 27/73 = 0.369863
```
def p n;███████(██n.times████a[2..-1].map{|s|█.██n████s}██.█*█|██})█);end
```
This should be fun.
[Answer]
# [Python 3](https://docs.python.org/3/), score: 0.386363, [cracked](https://codegolf.stackexchange.com/questions/154742/cops-and-robbers-redacted-primality-robbers-thread/156225#156225)
```
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.
[Answer]
# 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.
[Answer]
# Python 3, 48 bytes, 24 redacted, .5
```
def p(x):
  return ███(██████████████████(█,██))
```
Just a simple answer, probably gonna be solved in under 24 hours.
]