^{Bu meydan okuma aslında Magic Octopus Urn tarafından sanallaştırılmıştı; İzniyle kabul ettim ve yayınladım.}

Bu polislerin iş parçacığı. Soyguncuların ipi burada .

Meydan okuma

• Birinci Adım: Önceliği kontrol eden bir parça kod (işlev veya tam program) yazın .
• İkinci Adım: Karakterleri sembolle değiştirerek kodunuzun parçalarını kaldırın █.
• Üçüncü Adım: Düzeltilen kodu polisler iş parçacığına kaydedin.
• Dördüncü Adım: Kodunuzun kırılmasını bekleyin ve başkalarının kodunu kırmaya çalışın.

Örneğin, Groovy kodu {it.isPrime()}olabilir {██.is█████()}. (Bu aptalca çatlamak kolay olurdu; ayrıca, biliyorum, .isPrime()Groovy bir yöntem değil.)

puanlama

Programınızın puanını başvurunuza dahil etmelisiniz. Puan, düzeltilmiş karakterlerin karakterlere oranı olarak tanımlanır. Programınız 20 karaktere ve 5 karaktere sahip olsaydı puanınız 0.25 olur. Yukarıdaki Groovy kodu 0,5 puan alacaktır.

kurallar

• Programınızın yalnızca pozitif tamsayıları işlemesi gerekir . Sayının asal olması durumunda bir doğruluk değeri, aksi takdirde bir yanlış değer vermesi gerekir. Lütfen yanıtınızda ne çıkardığını belirtin.
• Kodunuz herhangi bir yorum veya gereksiz boşluk içeremez.
• Karma veya kriptografik gizleme yok.
• Kodunuz en fazla% 50 oranında redaksiyonlu olabilir (en az 1/2 karakter gösterilmelidir). Bu, mümkün olan en yüksek puanın 0,5 olduğu anlamına gelir .
• Cevabınız bir hafta içinde çatlamazsa, onu güvenli olarak işaretleyebilir ve istenen çatlakta düzenleyebilirsiniz.

Kazanan

Kazanan, gönderildikten sonraki iki hafta içinde en düşük puan alan çatlamayan cevap olacaktır. Beraberlik durumunda, en çok oyu hangisi kazanırsa. Bu konu her zaman daha fazla gönderime açıktır, ancak iki hafta sonra seçilen kazanan kalıcı olacaktır.

Functoid , skor = 14/223 ≈ 0,062780 [güvenli]

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

Komut satırı argümanı ve çıkışlar olarak girdi Alır True(asal) ya da False, çevrimiçi deneyin!

İpucu (yayınladıktan 4 gün sonra eklendi):

Birincisi ve dördüncüsü █kırmızı bir ringa balığıdır: Amaçlanan (ve büyük olasılıkla her ) çözümün IP'si ilk satırı izleyecek ve ?karaktere ulaşacaktır .

Çözüm

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

Çevrimiçi deneyin!

açıklama

Gelen rastgelelik nedeniyle ?programı düzleştirmek mümkün değildir. Rastgele bir ifadenin nerede olacağı soru işaretli düz program:

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

Tam 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

{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}, bağımsız değişkenler alarak f(öz referans) xve y(not 0ile aynıdır 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}olduğu ?(yg(KZ)(C(C(BB(BS(b(C(BBI)I))))(C(BC(b(C(BBI)I)))I))(C-)))yerde ?rastgele dan (rasgele bir yöne bağlı olarak) seçilir:

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

Bunların hepsi birbirine eşdeğerdir, bu nedenle {divides}aşağıdakilerin düzeltme noktası olur:

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} temelde sadece f x (y-x)

8086 DOS COM, 87 bayt, skor 19/87 ~ = 0.2183

Çatlak tarafından NieDzejkob

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

Bu bir COM programıdır; bir komut satırı bağımsız değişkeni olarak sayı bekliyor, Y veya N çıktısı. Sınır: 65535 çünkü 16 bit işlemci (sizeof (int) 2 olacaktır). Newline bu platformda 0x0D 0x0A. Evet, 19 █ yerine 20 count sayıyorsunuz. Bunlardan biri gerçek █ ve yerine geçmedi. Muhahaha.

10. konumdaki boşluk aslında bir NUL bayttır. NUL sembolü eski VGA yazı tipindeki boşluk ile aynıdır.

Swift 4 , puan 26/170 ≈ 0.153, güvenli

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}

Çevrimiçi deneyin!

Amaçlanan Çatlak

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 bayt (skor: 0.06851) ( Çatlak Nitrodon tarafından)

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

Çevrimiçi deneyin!

Birincil ise "asal", kompozitse "asal" olarak yazdırır. Teknik olarak rastgele tamsayılar için çalışır, ancak 6000'in üzerindeki sayılar için TIO'da zaman aşımına uğrar

Mathematica, 97 bayt, skor 0.2989690722 ( Çatlak )

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

Teller! Regex! Asal sayılar?

Orada olan regex kontrol bir asallık diye bir şey, ama burada oluyor whats değil.

Bu kırıldı , ancak istediğim yol oldukça farklıydı, bu yüzden henüz tasarlanan çözümü açıklamayacağım.

Jöle , skor 0. (142857) ( çatlak )

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

Çevrimiçi deneyin!

Diğer cevabımı yeniden yayınla, bu sefer birkaç bayt ile istenmeyen hileleri önlemek için ortaya çıktı.

Oktav , Puan: 0.15 (86 bayt)

Birkaç karakter daha ortaya çıkardım. Kazanan ölçütün en düşük puan değil en yüksek puan olduğunu düşündüm .

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

Çevrimiçi deneyin!

İyi şanslar =)

Python 3, 388 bayt, .155, Çatlak

Son dakika çatlağı. Evet, bu Miller-Rabin testi.

Herhalde olasılıklı testlere izin verilir, belirsizlik 2 ^ -100

Yine de önceki cümlede büyük bir ipucu

Dönüş değeri 0, KOMPOZİT ve 1 Olası PRIME olarak yapılmıştır

* 368> 388: z <4 olduğunda sorun düzeltildi

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

Çözüm:

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 , skor 0.20512820512 [Güvenli]

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

Asalsa 1, kompozitse 0 yazdırır

Çözüm:

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

Düğüm JavaScript, skor: 0.4

İşte burada çalışıyor.İlk komut satırı bağımsız değişkeninden girdi alan ve stdout'a çıktı veren tam program.

Umarım, bunu başlatmak için çok zor olmayan bir çözüm.

Skoru hesaplamak için bu pasajı kullanma .

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

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

Çevrimiçi deneyin!

Komut satırı argümanı alır.

False = 0
True =1

JavaScript, 103 bayt, puan 0.1923

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

Bir boole döndürür.

İstenmeyen çatlak

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

İyi şanslar. : p

kontrol etmek istediğiniz prime f arayın.

Jo <skoru kırılmış skor 0.096

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

Amaçlanan çatlak:

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

Brain-Flak, Puan: 35/134 = 0.2612 ( kırık! )

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

Asal için 1, kompozit için 0 döndürür.

Biçimlendirme o kadar kısıtlı olduğu için bu meydan okumayı denemek çok zor bir dildir, çünkü eksik karakterin ne olduğunu açıklığa kavuşturmamak için çaba harcar.

Bu zorluğu çözmek için çok zor bir dildir, çünkü okumak gülünç derecede zordur.

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

Çevrimiçi deneyin!

Ben çok lol tarafından Java prime check-in gördüm en garip yolu.

Japt, 19 bytes, 0.315789 ... skor, Güvenli

Benden daha fazlasını gizlemem gerekip gerekmediğini bilmiyorum, kendime daha iyi bir puan.

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

View solution (Açıklama yakında)

C, 34/76 = 0.447368, Güvenli

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

Bu kadar boşluğa sahip olmak, istenmeyen bir çatlak alma amacımdan çok daha fazla olacağım anlamına gelir.

Çözüm:

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

açıklama:

esayının asal olup olmadığına ilişkin bir boole değeri vardır (birkaç özel durum istisnası dışında). röğesinin karekökünden küçük veya ona eşit olan tek sayılarla yinelenir n. return e?n>1:n<3;zaman özel davalarına bakan nolduğu 1ya 2.

M , skor: 4/22 = .1818 ..., Dennis tarafından kırıldı

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

Bu istenmeyen bir çatlak ile sonuçlanabilir, görmemiz gerekecek. It did.

Dennis'in çözümleri

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

Çevrimiçi deneyin!

Birinin çatlaması için çözümümü gizli bırakacağım. Soyguncu gönderimi Dennis'e olan ipucum "hayvanat bahçesi" kelimesiydi.

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.

Pyth, score: ~0.(461538) (13 bytes) (Cracked)

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

Try to crack it here!

sh + coreutils, score 19 / 143 ~= 0.1328

cracked

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

TIO

Brain-Flak, score 29 / 140 = 0.207

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

Try it online!

Outputs 1 for prime and 0 for non-prime.

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.

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.

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!

Ruby, 27/73 = 0.369863

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

This should be fun.

Python 3, score: 0.386363, cracked

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.

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.