Bu yorumdan ilham alan ...

Kullanıcılara, adım önce göndermeden önce bu zorluğun özelliklerini sağlamlaştırmama yardımcı oldukları için Adım Tavuk , Buğday Sihirbazı ve Dennis'i sağlayın!

Bu, Polislerin konusu. Robbers'ın ipliği için buraya gidin

Gelen bu meydan , kendi dil artık bir programlama dili olma bizim ölçütlerini karşılayan böylece yapan bazı kod çalıştıran görevli bulunmaktadır. Bu zorlukta, bu dilin artık yapamayacağı şekilde yapmak anlamına gelir ...

• Sayısal giriş ve çıkış al

• Birlikte iki sayı ekle

• Belirli bir sayının asal olup olmadığını sınayın.

Bu, iki farklı amaç için iki farklı zorluğun olduğu polisler ve soyguncular mücadelesidir: Polisler , dili çoğunlukla kullanılmaz kılan bazı kodlar yazmaya çalışacak ve soyguncular , polislere izin veren gizli geçici çözümü bulmaya çalışacaklardır. dillerini kurtarmak için.

Bir polis olarak iki kod snippet'i yazmalısınız:

1. Dilinizi çoğunlukla kullanılamaz hale getiren, örneğin giriş / çıkış ve sayısal işlemleri yapmak için yerleşik işlevleri kaldırarak. Ne kadar çok özellik çıkarırsanız, o kadar iyidir. Bu kod edilir değil çökmesine veya çıkış izin verdi. Bu snippet'in sonuna kod eklemek mümkün olmalı ve bu kod değerlendirilecektir . Ve...

2. ... iki negatif olmayan tam sayıyı girdi olarak alan, bunları bir araya getiren ve toplamlarını veren bir kod snippet'i. Bu pasajın, birinci pasajı çalıştırdıktan sonra bile hala doğru çalışması gerekir. İki snippet birlikte kullanıldığında, iki sayı ekleyen tam bir program oluşturmaları veya iki sayı ekleyen bir işlev tanımlamaları gerekir. İdeal olarak, bu pasajın bulunması daha zor olması için çok belirsiz davranışlara dayanmalıdır.

Herhangi bir standart giriş ve çıkış yöntemini seçebilirsiniz . Ancak, tam olarak hangi formatı (giriş ve çıkış) kullandığınızı göstermelisiniz. Bir hırsız, seninle aynı biçimi kullanmadıkça cevabını kıramaz.

Bu iki parçacığın her ikisini de yazdıktan sonra, ikincisini açıklamadan ilkini cevap olarak göndermelisiniz. Cevabınız aşağıdaki bilgilerin tümünü içermelidir:

• Birinci kısmı (tabii ki ikinci değil).

• Dil (küçük sürümler de dahil olmak üzere, çoğu başvuru muhtemelen garip kenar davalarına dayanacaktır)

• Bir fonksiyon mu yoksa tam program mı olduğu dahil olmak üzere IO formatı. Soyguncular , çatlaklarının geçerli olması için aynı formatı kullanmalıdır.

• Cevabınızın çalışması için gereken garip kenar durumları. Örneğin, sadece Linux üzerinde çalışır veya bir İnternet bağlantısı gerektirir . Açıkçası, bu biraz subjektiftir, ancak bir polisin çatlamasını önleyen bazı aşırı uç vakalara sahipse, ve o zaman bunu yalnızca güvende olduktan sonra ortaya çıkarırsa, bu zayıf sporculuğu düşünüyorum. Potansiyel bir soyguncu, cevabınızı kırılmadan önce kırmak için gerekli tüm bilgilere sahip olmalıdır .

Cevabınız güvende olana kadar bayt sayınızı açıklamanıza gerek yoktur.

İşte bir örnek. İlk snippet için aşağıdaki Python 3 programını gönderebilirsiniz:

Python 3

print=None

STDIN'den girdi alır ve STDOUT'dan çıktı alır

Ve sonra ikinci snippet'iniz olarak şunları yazabilirsiniz:

import sys
a,b=int(input()),int(input())
sys.stdout.write(a+b)

Bu geçerlidir, çünkü giriş olarak iki sayı alacaktır ve iki parçacığı birleştirseniz bile toplamlarının çıktısını alacaktır, örn.

print=None
import sys
a,b=int(input()),int(input())
sys.stdout.write(a+b)

Ancak, bir soyguncunun çözüm bulması son derece kolay olacaktır. Bu, çözülmesi çok kolay olacağından, bu özel yaklaşımı şu şekilde düzeltmeye çalışabilirsiniz:

import sys
sys.stdout=None
print=None

Bununla birlikte, bunun bile çok kolay bir çözümü vardır:

del print
a,b=int(input()),int(input())
print(a+b)

Bir polis olarak amacınız, soyguncuların onu bulmasını engellemek için gizli geçici çözümü mümkün olduğunca belirsiz hale getirmektir.

Soyguncular cevaplar biri bakmak ve onu kırmak için çalışacaktır. Snippet 2 olarak çalışabilecek herhangi bir geçerli snippet yazarak kırabilir (dil çoğunlukla kullanılamaz hale getirildikten sonra iki sayı ekleyerek). Bu, başlangıçta tasarladığınız aynı snippet olmak zorunda değildir . Bir soyguncunun cevabını kırması durumunda, cevabınıza bir yorum bırakacaklardır ve daha sonra kırıldığını belirtmek için düzenlemelisiniz. Yayınınız çatlamışsa, cevabınızı, orijinal olarak tasarladığınız çözümü (pasaj 2) göstermek için düzenlemelisiniz. Bu başlı başına bir kural değildir , sadece oyunu eğlenceli kılmak için dostane bir öneri. Zorunda değilsin.

Bir hafta boyunca bir cevap hala açık kalırsa, ikinci snippet'inizde düzenleme yapabilir ve cevabınızın şimdi güvenli olduğunu belirtebilirsiniz . Hafta bittikten sonra düzenleme yapmazsanız, diğer kullanıcılar siz bunu yapana kadar hala başarabilirler. İkinci snippet'inizi açığa çıkarmazsanız, cevabınız için puan talep edemez veya güvenli olarak arayamazsınız.

Polislerin iplik kazanan kısa güvenli cevaptır hem snippet'ların da byte olarak sayılır ve bu cevap olacak yeterli süre geçtikten sonra kabul edilmeyecektir. Sen do not cevap güvende olana kadar bayt sayısı puanınıza alakasız beri Cevabınız, güvenlidir kadar bayt sayısını ortaya çıkarmak gerekir. Yeterli zamanın geçmesi ve hiçbir cevabın kırılmaması durumunda, kazanan en uzun süre boyunca çatlak olarak kalmamış olan cevap olacaktır.

İyi eğlenceler!

Kural açıklamaları

• İlk snippet, herhangi bir giriş yapmadan düzgün şekilde çalışmalıdır . İstediğiniz şekilde çıktı verebilir ve bu çıktı yoksayılır - snippet yapıldıktan sonra, ikinci snippet düzgün çalışır.

• Cevabınızın geçerli olması için ikinci pasajın gerçekten yürütülmesi gerekiyor. Bu gibi bir cevap anlamına gelir

  import sys
  sys.exit()
  

  geçerli değil çünkü dili bozmuyor. Bu sadece sonlandırılıyor. Benzer şekilde, sonsuz bir döngüye girmek geçerli değildir, çünkü ikinci snippet hiçbir zaman yürütülmeyecektir.

• Güvende olduktan sonra, puanınız her iki snippet'in bayt sayısıdır .

• Bu kadar uzanır çalışmak Cevabınız için gerekli her türlü garip sınır durumları ortaya Lütfen Gönderdiğiniz yeterli bilgi içermesi gerekir ... önce tekrarlanabilir olması açığa çıkmalarını sonra gün ışığına çıkarılıyor. Bu, cevabınız güvende olursa ve sonra da düzenlemeyi yaptığınız anlamına gelir: İşte cevabım. Oh, BTW bu sadece Solaris'te çalıştırıyorsanız çalışır, şaka size! Cevabınız geçersiz ve silinecek ve kazanmaya uygun kabul edilmeyecektir.

• İkinci snippet toplamı çıkardıktan sonra çökmesine izin verilir - çıkış hala doğru olduğu sürece (örneğin, STDERR'ye çıkış yapmayı seçerseniz ve sonra bir sürü çökme bilgisi alırsanız, bu geçersizdir).

• Bir cevap gönderdikten sonra kodunuzu düzenleyemezsiniz.

• Şifreleme, karma işlevler, CSPRNG'ler vb. Gibi şifreleme işlevlerine güvenemeyebilirsiniz.

Tıklanmamış gönderileri bulmak için snippet:

<script>site='meta.codegolf';postID=5686;isAnswer=false;QUESTION_ID=133174;</script><script src='//ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='//api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

Gforth 0.7.3 (TIO) , 231 bayt [GÜVENLİ]

Bu kod, bazı gerekli çıktı yöntemlerinin yanı sıra ekleme ve işlevleri bildirmek için çok önemli olan bir şeyi de işe yaramaz olarak yeniden tanımlıyor. İyi şanslar!

: . ;
: dec. ;
: u. ;
: .r ;
: u.r ;
: d. ;
: ud. ;
: d.r ;
: ud.r ;
: emit ;
: type ;
: + postpone 2drop ;
: ; + + + postpone exit reveal postpone [ ;

Giriş, yığının tepesinden fonksiyon parametreleri olarak alınan iki işaretli tam sayı olacaktır. STDOUT çıkışına.

Öyleyse, verilen hasarı düzeltmeli ve en üst iki değeri yığından alarak bir sonuç tanımlamalı (sonucu float değil) ek çıktı olmadan (iz bırakmadan boşluk olmadan) STDOUT'a yazdırmalısınız.

Hedef işleviniz adlandırılmışsa, burada bir şablon var f.

Çözüm:

79 bayt Anahtar sözcüğü yeniden tanımlamanın sonundan

kaldırdım , bu nedenle bir cevabın başlangıcına dahil edilmesi gerekiyordu. Tanımladığım işlev çoğunlukla iç tanımına eşdeğerdir , ancak sonunda boşluğu yazdırmaz ve sayılar kayan nokta yığınına geri hareket ettirilerek ilk önce toplama yapılır. Çevrimiçi deneyinimmediate;.

immediate : f s>f s>f f+ f>d swap over dabs <<# #s rot sign #> (type) #>> 0 0 ;

Christian Sievers tarafından kırık Haskell

import Prelude(getLine,print)
a=a

Tam program, iki tamsayının (negatif olanlar dahil) stdin'den okunması ve stdout'a yazılması.

Ben sadece Prelüdü devre dışı bıraktım, yani neredeyse hiçbir şey kapsam dahilinde değildi ve sonra bir tanım ekledi; daha fazla ithalat sözdizimsel olarak geçersiz. Sana getLineve printolsa verdim .

Orijinal çözümümü eklemek için düzenlendi. Christian'ın çatlağı farklıydı, ancak aynı temel özellikleri kullanıyor (doğrudan yerleşik bir şeyi çağıramasanız veya dahil olanları bile isimlendirmeseniz bile, sözdizimsel şekere sahip işlevlere erişerek şaşırtıcı miktarda hesaplama elde edebilirsiniz).

import Prelude(getLine,print)
a=a
(x:l)!0=x
(x:l)!n=l!d[0..n]
d[x,y]=x
d(x:l)=d l
x^y=[x..]!y
x+y=f[0..y](x^y)(-((-x)^(-y)))
f[]x y=y
f _ x y=x
f.g= \x->f(g x)
f&0= \x->x
f&n=f.(f&d[0..n])
x*y=((+x)&y)0
x%[]=x
x%('-':s)= -(x%s)
x%(c:s)=x*10+i c%s
i c=l['1'..c]
l[]=0
l(x:s)=1+l s
main=do
 x<-getLine
 y<-getLine
 print((0%x)+(0%y))

Muhtemelen zaten süper golf değil, ama burada daha kolay:

import Prelude(getLine,print)
a=a

-- List indexing
(x : _) !! 0 = x
(_ : xs) !! n = xs !! (sndLast [0..n])

-- sndLast [0..n] lets us decrement a positive integer
sndLast [x, _] = x
sndLast (_ : xs) = sndLast xs

-- Pseudo-addition: right-operator must be non-negative
x +~ y = [x..] !! y

-- Generalised addition by sign-flipping if y is negative
x + y = switch [0..y] (x +~ y) (-((-x) +~ (-y)))
  where switch [] _ empty = empty   -- [0..y] is null if y is negative
        switch _ nonempty _ = nonempty

f . g = \x -> f (g x)

-- compose a function with itself N times
composeN f 0 = \x -> x
composeN f n = f . (composeN f (sndLast [0..n]))

-- multiplication is chained addition
x * y = composeN (+x) y 0

strToNat acc [] = acc
strToNat acc ('-' : cs) = -(strToNat acc cs)
strToNat acc (c : cs) = strToNat (acc * 10 + charToDigit c) cs

charToDigit c = length ['1'..c]

length [] = 0
length (_ : xs) = 1 + length xs

main = do
  x <- getLine
  y <- getLine
  print (strToNat 0 x + strToNat 0 y)

Python 2 , Kırık

Adlandırılmış bir işlev olarak eklemeyi uygular

import sys
c="".join(open(__file__).read().split('\n')[4:])
if set(c)-set(' &)(,.:[]a`cdfijmonrt~')or"import"in c:sys.setrecursionlimit(1)
f=lambda\

Çevrimiçi deneyin!

Bu ne işe yarıyor?

Size biraz yardım etmek amacıyla bunun ne yaptığını açıklayacağım. Bu kod kaynak dosyayı açar ve kodun geri kalanının aşağıdaki kriterlere uyup uymadığını kontrol eder:

• Dize içermiyor import
• Sadece karakterlerden oluşur &)(,.:[]a`cdfijmonrt~

Her iki kriteri de başarısız olursa, özyineleme sınırı 1yazdığınız kodların özyineleme sınırına ulaşacağı anlamına gelir.

Burada hile yok, sadece bu karakterleri kullanan ve ithalat olmayan bir çözüm yazdım, yıkıcı bir şey yapmıyorum, ancak bunun çatlamasının oldukça zor olacağını düşünüyorum.

Burada size biraz zaman kazandırmak için bu kısıtlama ile yapamayacağınız faydalı şeylerin kısa bir listesi

• + peki ya

• evalBundan execkurtulmana izin vermeyecekti

• Sayılar, Düşündüğünüzden daha faydalı olabilirler

• Dize değişmezleri

• len

• =, Atama değişkenleri yok

• >, <, ==. . . Karşılaştırma yapmadan seni terk ettim

• *, -, /, %, ^, |, >>, << Yalnızca operatörler vardır ~ve&

• __foo__, Bu süslü çift alt çizgi yöntemlerinden hiçbirine izin verilmiyor.

Python 2 , Kırık

Bu, bu cevabın dördüncü tekrarıdır. Son cevapların her biri özyineleme derinliğini sıfırlayarak kırıldı.

Adlandırılmış bir işlev olarak eklemeyi uygular

import sys
if set("".join(open(__file__).read().split('\n')[4:]))-set(' &)(,.:[]a`cdfijmonrt~'):sys.setrecursionlimit(1)
for m in sys.modules:sys.modules[m]=None
del sys;f=lambda\

Çevrimiçi deneyin!

Bu ne işe yarıyor?

Size biraz yardım etmek amacıyla bunun ne yaptığını açıklayacağım. Bu kod kaynak dosyayı açar ve kodun geri kalanının yalnızca karakterlerden yapılmış olup olmadığını kontrol eder. &)(,.:[]a`cdfijmonrt~

Başarısız olursa, özyineleme sınırı 1yazdığınız kodların özyineleme sınırına ulaşacağı anlamına gelir.

Ayrıca tüm modülleri devre dışı bıraktım, böylece hiçbir şey alamazsınız.

Burada hile yok, sadece bu karakterleri kullanan ve ithalat olmayan bir çözüm yazdım, yıkıcı bir şey yapmıyorum, ancak bunun çatlamasının oldukça zor olacağını düşünüyorum.

Burada size biraz zaman kazandırmak için bu kısıtlama ile yapamayacağınız faydalı şeylerin kısa bir listesi

• + peki ya

• evalBundan execkurtulmana izin vermeyecekti

• Sayılar, Düşündüğünüzden daha faydalı olabilirler

• Dize değişmezleri

• len

• =, Atama değişkenleri yok

• >, <, ==. . . Karşılaştırma yapmadan seni terk ettim

• *, -, /, %, ^, |, >>, << Yalnızca operatörler vardır ~ve&

• __foo__, Bu süslü çift alt çizgi yöntemlerinden hiçbirine izin verilmiyor.

Çözümüm

Bu yüzden şimdi xnor bunu yeterince tatmin ettiğim bir şekilde kırdı, çözümümü ortaya koyacağım

r,o:(o and f(~(~r&~o)&~(r&o),int(`r`[:r&~r].join([`dict()`[r&~r],`r&~r`,`dict([(r&~r,r&~r)])`[int(`~([]in[[]])`[[]in[[]]:])],`min`[[]in[[]]],`dict()`[~(r&~r)],`r&~r`]).format(r&o),int(`~([]in[[]])`[[]in[[]]:]))))or r

Sürpriz, sürpriz onun engebeli bir saçmalık yığını. Bunu yıkmak yerine, bunu nasıl yaptığım sürecinden geçeceğim.

Oldukça standart bir ekleme algoritması ile başladım

r,o:(o and f(r^o,r&o<<1))or r

Sonra temsil arasında ikilik numara kullanılmaktadır ^ile |, &, ~.

r,o:(o and f((r|o)&~(r&o),r&o<<1))or r

Kurtulmak için başka bir bit numarası yaptım |

r,o:(o and f(~(~r&~o)&~(r&o),r&o<<1))or r

Şimdi kalan tek şey, <<çok zor olmamalı, değil mi? Engebeli bir yolculuk için hazır olun. Bitshift'i değiştirmek için, ikili gösteriminin sonuna bir sıfır eklemek için dizeleri kullandım.

r,o:(o and f(~(~r&~o)&~(r&o),int(bin(r&o)[2:]+"0",2)))or r

Bunun birkaç sorunu var, ancak birincil olanı ekleme kullanıyor , bunun yerine bunun yerine bir format kullanarak çalıştım.

r,o:(o and f(~(~r&~o)&~(r&o),int("{}0".format(bin(r&o)[2:]),2)))or r

Bin kullanmamıza izin verilmedi, ben de binary formatına dönüştürmek için string format kullandım.

r,o:(o and f(~(~r&~o)&~(r&o),int("{0:b}0".format(r&o),2)))or r

Dizi değişmezleri yasaklandığından, ipi {0:b}0arka keneler ve joinbirlikte yapılan parçalardan oluşturmalıyım.

r,o:(o and f(~(~r&~o)&~(r&o),int("".join(["{","0",":","b","}","0"]).format(r&o),2)))or r

Boş dize oldukça kolaydır, sadece yapabilirsiniz

`r`[:0]

Sıfırlar

`0`

ve {:}hepsi sözlükten alındı.

r,o:(o and f(~(~r&~o)&~(r&o),int("".join([`dict()`[0],`0`,`dict([(0,0)])`[2],"b",`dict()`[-1],`0`]).format(r&o),2)))or r

bBizim karakter setinde onun değil, almak oldukça zor görünüyor, bu nedenle nasıl bir olan bir nesne elde etmek gerekiyor bonun içinde repr? Peki işte nasıl: Bir repryerleşik işlevi kullandığınızda , benzeyen bir şey elde edersiniz

<built-in function name>

Ve bu bizim alacağımız yerden b.

r,o:(o and f(~(~r&~o)&~(r&o),int("".join([`dict()`[0],`0`,`dict([(0,0)])`[2],`min`[1],`dict()`[-1],`0`]).format(r&o),2)))or r

Şimdi geriye kalanların hepsi sayı, sadece -1, 0, 1 ve 2'ye ihtiyacım var.

-1 = ~(r&~r)
 0 = r&~r
 1 = []in[[]]
 2 = `~([]in[[]])`[[]in[[]]:]

2 aslında bir bayt daha kısa olabilir

```r&~r```.find(`r&~r`)

@ Blender'ın yorumlarındaki önerisine dayanarak, ancak gerçeğe kadar bunu düşünmedim.

Yani biz bu sayıları yerine

r,o:(o and f(~(~r&~o)&~(r&o),int(`r`[:r&~r].join([`dict()`[r&~r],`r&~r`,`dict([(r&~r,r&~r)])`[int(`~([]in[[]])`[[]in[[]]:])],`min`[[]in[[]]],`dict()`[~(r&~r)],`r&~r`]).format(r&o),int(`~([]in[[]])`[[]in[[]]:]))))or r

Ve bu çatlak.

C (gcc) Çatlak!

#define D(f)void f(void);
D(printf)D(fprintf)D(putc)D(puts)D(getchar)D(putc)D(fputc)D(ferror)D(feof)D(read)D(fclose)D(fread)D(wr1te)D(fgets)D(fgetc)D(popem)D(gets)D(read)D(scanf)D(setbuf)D(execl)D(execlp)D(putchar)D(execle)D(execv)D(malloc)D(execvp)D(execvpe)D(exec)D(system)D(close)D(fwrite)D(open)D(free)
int stdin;
int main(){
//your code goes here...hehe
}

Çevrimiçi deneyin!

STDIN'den giriş yapın ve STDOUT'ya çıkış yapın.

Bu hatasız çalışır. Hahaha bu oldukça kötü. Sadece TIO’nun gcc’si üzerinde test ettim. Her zamanki, çalışması için bu kod parçasından sonra kodunuzu eklemelisiniz :) Yorum, ortalama bir koddur, onu dinlemeyin.

Üzerinde test edildi gcc (GCC) 6.3.1 20161221 (Red Hat 6.3.1-1). Herhangi bir linux sistem üzerinde çalışması gerekir.

Orijinal çözüm

#define D(f)void f(void);
D(printf)D(fprintf)D(putc)D(puts)D(getchar)D(putc)D(fputc)D(ferror)D(feof)D(read)D(fclose)D(fread)D(wr1te)D(fgets)D(fgetc)D(popem)D(gets)D(read)D(scanf)D(setbuf)D(execl)D(execlp)D(putchar)D(execle)D(execv)D(malloc)D(execvp)D(execvpe)D(exec)D(system)D(close)D(fwrite)D(open)D(free)
int stdin;
int main(){
//your code goes here...hehe
}
void __attribute__ ((destructor)) dtor() {
    int a,b,c,d;a=b=c=0;
    struct FILE* z = popen("cat", "r");
#define q(x)for(;(c=getc(z))^32&&c^-1;)x=10*x+c-48;
q(a);q(b);
    char*y=calloc(c=a+b,1);
    for(a=0;c;){y[a++]=(48+(c%10));c=c/10;}
    for(b=0;b<a/2;b++){d=y[b];y[b]=y[a-b-1];y[a-b-1]=d;}
    write(1,y,a);
}

Haskell , Ben tarafından kırık

main=main--

Çevrimiçi deneyin! Bu, stdin'den iki sayı okuyan ve toplamı stdout'a çıkaran tam bir program olmalıdır.

Her tam program mainişlevi çalıştırarak başlar , ancak burada mainkendini çağırır ve sonsuz bir döngüye neden olur. Sorunları daha kötü hale getirmek için --, özyinelemeli çağrının tam arkasında, örneğin olarak değiştirilmesini önlemek main2ve sonra bunu toplamanın yapılması için tanımlamak üzere bir satır yorumu başlatılır .

Amaçlanan çözüm:

main=main--$()
_ --$ _ = do
     x <- readLn
     y <- readLn
     print $ x+y

Çevrimiçi deneyin!

--Bir operatörün parçası olarak ayrıştırılamadığı sürece bir satır yorumu başlatır . (Sözdizimi vurgusu bu gerçeğin farkında değil gibi görünüyor.) İlk argüman ve bazı kukla ikinci argüman olarak --$alan geçerli bir infix operatörü . Ardından, her iki argümanı da görmezden gelmek ve bunun yerine gerekli görevi gerçekleştirmek için tanımlanır.main()

C (Linux'ta GCC) (çatlak)

Aptal dosya okuma sanallaştırma teknikleri kullanmak yerine, bunu doğru şekilde yaparız - SECCOMP beyaz listesi ile!

Göreviniz: STDIN'den giriş ve STDOUT'ya çıkış eklenmesi.

#include <stdlib.h>
#include <unistd.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
#include <syscall.h>
#include <stdio.h>
void sandbox();
__attribute__ ((constructor(0))) int s() {
    close(0);
    close(1);
    close(2);
    prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
}
int main() {
    sandbox();
    syscall(SYS_exit, EXIT_SUCCESS);
}
void sandbox() {
    // Your code here!
}

Çevrimiçi deneyin!

Buda ne böyle!?

Aşılmaz işinizde size yardımcı olmak için bu kodun ne yaptığını açıklayacağım.

__attribute__ ((constructor(0)))sişlevin önce çalıştırılmasını sağlar . Fonksiyon STDIN, STDOUT ve STDERR için tüm açık dosya tanımlayıcılarını kapatır. Ardından program, sisteminizin aşağıdakileri çağırmasını sınırlayan katı bir SECCOMP beyaz listesi ile kendisini kısıtlar:

read(2)
write(2)
_exit(2)
sigreturn(2)

Bu nedenle, herhangi bir yeni dosyayı açamazsınız (veya temel olarak herhangi bir şey yapamazsınız). Daha sonra ana sandboxfonksiyona geliriz ve kodunuzu çağırırız, fonksiyona güzelce sarılırlar .

syscall(SYS_exit, EXIT_SUCCESS);Varsayılan GCC tarafından birlikte çıkılacak - sonunda sadece temiz çıkar programı sağlamaktır exit_group(2)Seccomp beyaz liste ile izin verilmez hangi. Bu çıkış işlevi kodunuz çalıştırıldıktan sonra çağrılır .

Açık dosya tanımlayıcınız yok ve yeni bir şey açamazsınız. İmkansız değil mi? ;)

x86 16 bit gerçek mod Montaj ( Çatlak )

_main:
    call l
    cli
    hlt
l:  pop si
    xor ax, ax
    mov bp, cs
    mov es, ax
    mov di, 12
    mov [di], si
    mov [di + 2], bp
    pushf
    mov bp, sp
    or word [bp], 256
    popf

Hile biliyorsan kolay.

Javascript, Kırık

Bu zorluk Grant Davis'ten kaynaklanıyor , ancak aklındaki çözümü düzeltir (iframe oluşturur ve iframe'i kullanır window). Çözüm, chrome'ların üzerinde javascript konsolunda çalışır about:blank pageve iki input()saniyeyi alır , bunları bir araya getirir ve console.logsonuçtur. Kodunuzu sonra girin:

d=prompt=console=document;new MutationObserver(s=>s.forEach(e=>{t=e.target;t.parentNode.removeChild(t)})).observe(d,{"childList":d, "subtree":d})

İlk önce, clobber promptve consolekısayolu belirleriz d. Ardından, mutasyonu yapılan her hedefi kaldıran bir geri çağırma ile bir mutasyon gözlemcisi oluşturuyoruz. Bu mutasyon gözlemcisini dokümanı gözlemlemek, bildirmek childListve subtreedeğişiklikleri yapmak için belirledik . Bunun yerine literal true, biz truthy değere bizim kısayolunu kullanın document( Spec buna izin vermez, ancak krom yapar).

Bunu gönderdikten sonra çok daha şık bir pelerin farkettim. Amaçladığım çözüm hala çalışıyor, ancak yayınlanan çatlak çalışmıyor:

 h=document.querySelector("html");h.parentNode.removeChild(h);

Perl 5, Ilmari Karonen tarafından kırık

$_=<DATA>;
s/[+'{dPz|K.UD!_ iJ;o}e6tjWb7253k@%&Iq4l0AN:?\$8B`Yywn9^pfmZQTF"M#-]//g;
eval;
print@_,$!,pop,shift,<>,eval"@>",$\,@ARGV,eval"@$",$@,eval"@@",$,,eval"@,",$/
__DATA__

Giriş, ayrı satırlara alınır STDINve çıktısı yazdırılır STDOUT.

Tüm kod __DATA__işaretleyiciden sonra gider . Bu, @ WheatWizard'ın çözümüne benzer bir yöntem kullanarak , kodun ayrıştırılması ve kullanılamaz karakterlerin kaldırılmasıdır.

Bu, 5.8, 5.10 ve 5.16 sürümlerinde test edilmiştir ve komut satırı bayrakları gerektirmez.

Çevrimiçi deneyin!

Python 3, zbw tarafından kırık

import sys
for mod in sys.modules.values():mod.__dict__.clear()
1+1

Tüm modlu dosyalar silindi; bu da yerleşik yapı yok ve başka bir şey yapılamayacağı anlamına geliyor. STDOUT'ya çıkış, STDIN'den giriş. Bu, önceki cevabın bir break ifadesi ekleyerek önemsiz bir çatlaktan kırılmasından sonraki ikinci tekrarıdır.

APL (ngn-apl) , ngn tarafından çatlak

Meslektaşım Marshall ile işbirliği içinde yapıldı .

Sol ve sağ argümanlarla giriş yapın +. Yani hedefiniz aşağıdakilerden sonra kod eklemek, böylece son satırınız STDOUT'a okuyor ⎕←3+2ve çıkıyor 5.

+←-←−←⍴←≢←≡←⊥←⊤←⍟←○←⍳←⌹←~←∈←∊←⍷←<←≤←=←≥←>←≠←,←⍪←⌷←⌽←⍉←⊖←{}⋄⍣←∘

Çevrimiçi deneyin!

{}Bir veya iki argüman alan ve boş bir sayısal liste döndüren tüm faydalı işlevleri ayarlayarak çalışır . Ayrıca ⍣sadece işlevleri oluşturmak için ayarlar .

çatlak

+←{⌈/⍋⍺⍵1/0}

⍺⍵1/0 0'ı sol argümanla ve sağ argümanla ve 1

⍋ Bunu sıralayacak endeksleri al (tüm öğeler sıfır olduğundan, 0 1 2… (a + b) verir

⌈/ maksimum değer (a + b)

Python 2 , Kırık

Bu beklenmedik bir yöntemle @HyperNuetrino tarafından bir kez kırılmış bir cevabın ikinci tekrarıdır. Şimdi onu o kadar ekledim ki, geriye kalan tek çözümün istediğim kısıtlamalara uyması gerekecek.

Adlandırılmış bir işlev olarak eklemeyi uygular

import sys
c="".join(open(__file__).read().split('\n')[4:])
if set(c)-set(' &)(,.:[]a`cdfijmonrt~')or"import"in c:sys.setrecursionlimit(1)
sys.modules['sys'],sys.modules['os']=None,None;del sys;f=lambda\

Çevrimiçi deneyin!

Java 8, @ OlivierGrégoire tarafından Cracked

İşte benim denemem. Hemen hemen, fikir sadece çıktı almak için kullanabileceğiniz tüm ad alanlarını aşırı yüklemektir (ve yansıtırım, umarım). Çıktı sdout (System.out) için tasarlanmıştır.

class java {
    public static void main(String[]s){
       //there is no executable code in snippet one.
       //your code here.
    }
    class Class{}
    class Method{}
    class System{}
    class FileDescriptor{}
    class Logger{}
    class Runtime{}
    class Scanner{}
}

Kara listeleme, genellikle beyaz listeye göre daha kötü bir yaklaşımdır, bu nedenle birinin göz önünde bulundurmadığım bir yaklaşımla ortaya çıkmasından önce zaman meselesi olduğundan eminim.

Mayube tarafından kırılmış cQuents

#|1,1:A

Bu oldukça kolay olmalı, ama asla bilemezsin.

"Sorun", Ckodunuzda olmadan , bir hatayla karşılaşmanızdı.

Mayube'un çözümü:

#|1,1:A+BC

Dizideki her öğe ilk girdi artı üçüncü kez ikinci kezdir (aka 1).

Çözümlerim:

#1,1:A+B,C

Sıra, ilk giriş artı ikinci giriş ve üçüncü giriş (1) arasında geçiş yapar. İkincisi ilk öğedir A+B.

#1,1:A+B+C-C

Mayube'un çözümüne benzer şekilde - çarpmak yerine B*C, sadece ekler Cve çıkarır.

Çevrimiçi deneyin!

açıklama

#|1,1      Append 1 and 1 to the end of the user's input
     :     Set mode to : (sequence 1: if given n, output nth term in sequence; if given no n, output whole sequence)
      A    Each item in the sequence equals the first input

Şu anda, bu program çıktı 1çünkü kullanıcı girişi olmadığından, ilk girdi 1varsayılan girdideki ilk girdi ( #).

Node.JS versiyon 7.3.0 (Dom Hastings tarafından Cracked)

var p=process,f;(_=>{var w=p.stdout.write,n='f'+(Math.random()*1e7|0),l=1
f=p.stdout.write=a=>eval(`(function ${n}(a){while(l&&((typeof a)[0]!='s'||'f'+a!=n));a=l?l="":a;w.apply(p.stdout,arguments);})`)(a)})();

İlk koddan sonra ikinci kod bloğunu yerleştirin.

Feragatname: ikinci kod bloğu kendi kendine çalışmayacaktır (ilkinden sonra yerleştirilmeden). Buna izin verilmezse, ikinci snippet'i değiştirebilirim.

Bu tam bir programdır. Çıktı process.stdout(STDOUT), girdi process.argv(komut satırı argümanları)

Bu benim ilk polislerim ve hırsızlarım, umarım bu iyi bir meydan okumadır :)

Çevrimiçi deneyin!

Meydan açıkladı

n0 ile 1e7 arasında rastgele bir değişken oluşturur . Doğru yazmayı çağırırsanız n, hiçbir şey yazdırmaz, ancak lyazma işlevini "kilidini" açan ve hiçbir şey yazdırmanıza olanak tanıyan 0 değerine ayarlar . Eğer string olmayan bir yazı ile yazmaya çalışırsanız, sizi sonsuz bir döngüye gönderir. nYazma "kilitli" iken doğru dışında herhangi bir şeyle yazmaya çalışırsanız, tahminde bulunmamak için sizi sonsuz bir döngüye gönderir.

Amaçlanan çözüm

Sadece s ile başlayan bir Symbol (Sembol) kullanarak dizeleri kontrol eden tipin dışına gizlice girer. Bu, eval çağrısından kaynaklanan işlevde bir hata atar; çünkü "f" dizesini bir Sembole ekleyemezsiniz. Hatayı yakalar ve nfonksiyon adının bulunduğu yığın izinden kurtarmak için regex kullanırız . Sonra nherhangi bir şey yazmayan, ancak "kilit" değişkenini lyazma işlevini "kilidi açmak" için 0 olarak ayarlamaya çalışıyoruz. Şimdi yazma işlevi kilitli değil, sadece toplamı basıyoruz.

try{f(Symbol())}catch(e){f(e.stack.match(/f(\d+)/)[1])
f(+p.argv[2]+ +p.argv[3]+"")}

RProgN2 , Arnold Palmer tarafından Çatlak

"+-/*÷^"{²[[\=};

Onları geri yüklemek mümkün olmayan tüm matematik işleçlerine yazar. Özellikle, onları yığındaki ilk iki öğeyi kaldıran bir işlevle değiştirir.

Çevrimiçi deneyin!

Orijinal çözüm

{S]‘[L}`d={0RL}`i=«x=y=x{xd`x=yi`y=x}:y»`+=

{S]‘[L}`d={0RL}`i=«x=y=x{xd`x=yi`y=x}:y»`+=
{     }`d=                                  #Define a function, "d", which returns n-1
 S                                          #Convert the input to a stack, which, as a number, makes a stack of 1 - n.
  ]‘                                        #Duplicate the stack, and pop the top value off it.
    [                                       #Discard the popped'd value.
     L                                      #Get the length of the stack, which now is n-1.
          {   }`i=                          #Define a function, "i", which returns n+1
           0R                               #Get the range of numbers between 0 and n.
             L                              #Get the length of that stack, which is n+1
                  «                    »`+= #Define a function, "+", which takes two numbers, and outputs their sum. We use «» here, because it localises references, instead of globalising them.
                   x=                       #Set the first input to the value of "x", which by default, is x.
                     y=                     #Ditto for y.
                       x{          x}:      #While x is truthy, which in this case, is non-zero.
                         xd                 #Get x - 1
                           `x=              #Set x to it.
                              yi`y=         #And set y to y + 1
                                      y     #Push y to the output. And we're done.

Çevrimiçi deneyin!

Haskell, 161 144 bayt, BlackCap tarafından Cracked

{-#OPTIONS_GHC -fth -w#-}
module M where

STDIN girişi, STDERR çıkışı. Programın sonuna ekleyin.

Düzenleme: Fazladan GHC argümanı olmadan derlenecek, sadece normal ghc --make prog.hs.

Bayt sayısını azaltmak için tekrar düzenlenir.

İyi eğlenceler!

Mascarpone , Ilmari Karonen tarafından kırık

[ Make 'i' and 'z' print 'q' ]$
v ['q.]v* 'i<^
v ['q.]v* 'z<^

[ Disable some standard commands ]$
v[]v*   '1<^
v[]v*   '$<^
v[]v*   '@<^
v[]v*   '{<^
v[]v*   '}<^
v[<:]v* '<<^
v[]v*   'v<^$

Girdi, stdio'daki kilise sayılarıdır, iartış için ve zsıfır için kullanılır. Örneğin, 2 + 3 şöyle olur:

iiziiiz

Takip eden bir newline ile

Çıkış, stdout'ta, stdio'daki gibi bir sayı olmalıdır. Örneğin, cevap beş ise çıktı vermelisiniz:

iiiiiz

(mascarpone'da sayı kavramı yoktur)

Amaçlanan çözüm:

: '[/''/'i/'./' /':/',/'>/'!/']/* 'i<^
: '[/':/',/'>/'!/']/* 'z<^
: ,>!
'z.

Dokümantasyondan hemen anlaşılmadı, ama çatlağında @ IlmariKaronen belirtildiği gibi, Mascarpone'deki sicim harfleri, karakter dizisini zorlamak için aslında sözdizimsel şeker.

Kasten [this]$bir ip geçirip hemen sonra patlattığım gibi görünmesini sağlayacak yorumlar yazdım . Saf bir kraker [:,>!]/*bir ipi itmek, tercümanla değiştirmek ve yorumlamak gibi bir şey denemiş olabilir .

Ayrıca yığında bıraktığım tercümanı patlatıyormuş gibi yaptım $, ama $zaten bir NOP için yeniden tanımlandı. Yığın üzerinde bu tercümana bırakıldı ve tüm program boyunca yanınızda bulundurmanız gerekiyor; Her dize her karakter yalak.

Ilmari Karonen tarafından C # (.NET Core) Cracked

Ayrıca Joshua tarafından çatladı .

namespace System
{
    class Console
    {
        static void Main()
        {
            //Your code goes here
        }
    }
}

İki değeri stdin'den okur ve sonucu stdout'a yazar. Windows'ta Framework Sürüm 3, 4.6 ve TIO'da test edilmiştir .

İşte istediğim tam program.

namespace System
{
    class Console
    {
        static void Main()
        {
            var t = Reflection.Assembly.Load("mscorlib").GetType("System.Console");
            var r = t.GetMethod("ReadLine");
            int a = int.Parse((string)r.Invoke(null, null));
            int b = int.Parse((string)r.Invoke(null, null));
            var w = t.GetMethod("WriteLine", new[] { typeof(int) });
            w.Invoke(null, new object[] { a + b });
        }
    }
}

Çevrimiçi deneyin!

GolfScript , Dennis tarafından çatlamış

{}' !$%&()*+,-./<=>?@[\]^`|~'':'*~;

Çevrimiçi deneyin!

Bu ise bir kod golf sonuçta, meydan okuma, öyleyse neden GolfScript denemiyorsunuz?

Geçerli bir çözüm, yığından iki tam sayı okuyan, bunları birbirine ekleyen ve sonucu yığına geri döndüren bir snippet olmalıdır. Yakalama, yukarıdaki kodun, yerleşik GolfScript operatörlerinin neredeyse tamamını, hiçbir şey yapmamaları için yeniden tanımladıktan sonra bile çalışması gerekir . En azından ;dokunulmamış olarak bıraktım , böylece hala yığından değerler alabilirsiniz. ;-) Kodunuz, örneğin TIO'da olduğu gibi standart GolfScript yorumlayıcısı üzerinde çalışmalıdır (yukarıdaki bağlantıya bakın).

Dennis'in çözümü de benimki gibi , çift tırnaklı dizelerde enterpolasyonlu Ruby koduna izin veren nadir kullanılan GolfScript özelliğine güveniyor . Bu özelliği, tam olarak yerleşik +operatöre benzeyen yeni bir ekleme operatörü tanımlamak için kullanırız ve sonra bunu çağırırız.

(GolfScript'teki Ruby enterpolasyon özelliğinin bu kadar nadir kullanılmasının bir nedeni, beceriksiz bir şekilde enterpolasyonlu Ruby kodunun ayrıştırma sırasında çalıştırılması ve çıktısının GolfScript yorumlayıcısı tarafından önbelleğe alınmasıdır. Bir döngüde, kod , gerçek program başlamadan önce sadece bir kez çalışır ve daha sonra her zaman döngünün her yinelemesinde aynı değeri döndürür .. Ayrıştırmayı ertelemek için eval dizesini kullanarak bunun üzerinde çalışabilirsiniz , ancak bu zaten garip sözdizimini daha da fazla yapar. çirkin ve ayrıntılı ve her halükarda, bu zorluk için, eval operatörünü ~de devre dışı bıraktım , ancak, yeni yerleşik GolfScript operatörlerini tanımlamanın ortaya çıktığını Bu özellik aslında oldukça güzel ve temiz bir şey.)

Node.js v8.2.0, Dom Hastings tarafından Cracked

let mess = ctx => f => new Proxy (f, {
  has: (t, p) => p in t || p in ctx
, get: (t, p) => {
    let k = p in t? t[p]: ctx[p];

    if (k instanceof Function) return (
      function fetch (_k) {
        return mess (ctx) ( x => ( q => q instanceof Function
                                      ? fetch (q)
                                      : t (q)
                                  ) ( _k(x) )
                          )
      })(k);

    return k;
  }
});

with (mess (global) (x => x)) {
  dot   = f => a => b => f(a(b))
  ap    = f => g => x => f (x) (g (x))
  flip  = f => x => y => f (y) (x)
  Const = a => b => a
  id    = x => x
  num   = n => n (x => x + 1) (0)
  log   = console.log

  let x = flip (Const . id . id)
    , y = flip (Const . id . id . id)
  for (let i = 0; i < process.argv[2]; i++) x = ap (dot) (x)
  for (let i = 0; i < process.argv[3]; i++) y = ap (dot) (y)
  process.argv = [];

  logic = x => y => /* Your code here */;

  log . id . num ( logic (ap (dot) (x))
                         (f => z => (( y(flip (id) . id . flip (dot (id)) (f)) ) (Const (z))) (id) )
                 );
}

logicİşlevi uygulayacaksınız . Girdi, sağlanan argümanlardır (stdin'den), çıktı, işleviniz ne olursa olsun (stdout'a basılır) olur.

Benim kod kilisem , girdideki sayıları kodlar . Kodun geri kalanı seni korkutmak için orada. Mess işlevi , rasgele yerlere eklemek için kullandığım , hiçbir şey yapmayan, ancak işlevsel programlamaya aşina olmayan herkesi karıştıracak olan nokta içermeyen notasyonu ( )
uygulamak için bazı hileler yapar. Onlara fonksiyona geçmeden önce sayılara uygulanan dönüşüm şudur ve 0'a kadar eklenir, bu yüzden belirsizliğe eklemek için başka bir NOP'dir.a . b == dot (a) (b). id .
logicx+1y-1

Amaçlanan çözüm şuydu:

logic = x => y => f => z => x (f) (y (f) (z))

Bilgilendirme 7 , ppperry ile çatlak

For reading a command: rule fails.

[Your code here.]

Giriş interaktif komutu, örneğin olarak oyuncu tarafından yazılmalıdır add 17 to 25veya sum 17 25. İki sayı içerdiği sürece girilmesi gereken komutun tam biçimini seçmekte özgürsünüz. Sayıların toplamı (örn. 42) Komuta cevaben yazdırılmalıdır.

Tabii ki, buradaki zorluk, “bir emir okumak” aktivitesinin tamamı işlemesiz olarak değiştirilirken yapmaktır. Muhtemelen bu problemi çözmenin birkaç yolu vardır, fakat en azından dilin aşina olmasını gerektirir. Geldiğimde biraz beklenmedik bir durum varsa, oldukça basit.

Çözümümü Ubuntu Linux'ta GNOME Inform 7 IDE, sürüm 6L38'de test ettim . Amaçlanan çözüm hem Glulx hem de Z-makine arka uçlarında çalışır ve Inform 7'nin diğer yeni sürümlerinde de çalışması gerekir. (Uygun bir çözüm olmadan) yukarıdaki kodun bir komutu okumaya çalıştığında tercümanın meşgul döngüsüne neden olacağını unutmayın; Z-makine yorumlayıcısı bu olduğunda tamamen tepkisiz görünüyor ve IDE içinden durdurulamıyor, bu yüzden test için Glulx kullanmanızı tavsiye ediyorum.

CPython 3 (yine), Sisifos tarafından çatlak

import sys,os,functools
def p(f,e,a,_=os._exit):
 if e == "c_call":_(1)
sys.setprofile(p)

İstediğiniz her şeyi yapabilirsiniz - C'ye uygulanmadığı sürece, bu demek ki hayır print, hayır input- hepsi _(1)çizgiye varacak ve sona erecektir. İki ayrı satırdaki sayılarla STDIN'den giriş yapın, STDOUT'a çıkış yapın. Bunun ne kadar süreceğini merak ediyorum ... Bu engelleyici numarayı bulduktan sonra çalışan ikinci parçacığı bulmak biraz zaman aldı. Sys.setprofile dosyasının alternatif olmayan bir uygulamasına dayanarak kırılmaması için açıkça Cpython belirtilmesi.

Java 8 ( Kırık )

İkinci deneme. Bu sefer iki dakikalık testlere yatırım yaptım.

static {

    try {

        System.setIn(null);
        System.setOut(null);
        System.setErr(null);

        for (Method m : System.class.getMethods()) {

            m.setAccessible(false);

        }

        System.class.getMethod("getSecurityManager", new Class[0]).setAccessible(false);

        for (Method m : Class.class.getMethods()) {

            m.setAccessible(false);

        }

        SecurityManager mngr = new SecurityManager() {

            @Override
            public void checkPermission(Permission p) {

                if (p.getName().equals("createSecurityManager")) throw new SecurityException();
                if (p.getActions().startsWith("read")) throw new SecurityException();

            }

        };

        System.setSecurityManager(mngr);

        // Your code goes here.

    } catch (Throwable t) {

    }

}

Çoğu şey shouuuld karşılanacaktır.

Python 2 kırık

import sys,hashlib
c=open(__file__).read().split()[-1]
if c!='#'and hashlib.sha256(c).hexdigest()!='e6400dd63733d10ec042e3c28033cfa85e1d25fbef80020810c354d7c942e843':sys.exit() #

Çevrimiçi deneyin!

Bu cevabın alt sınırda bir cevap olarak tasarlanan bir sarsıntı hamlesi olduğunu söyleyerek bunu ön planlayacağım.

Buğday Sihirbazı'ndan ilham alan ve HyperNeutrino en cevapları.

Metin parçacığı kaynak dosyayı okur ve boşlukla ayrılmış son kod öbekinin içine sığmazsa devam etmeyi reddeder. e6400dd63733d10ec042e3c28033cfa85e1d25fbef80020810c354d7c942e843 .

EDIT : Bu yoruma yanıt olarak hafifçe düzenlendi . Çekirdek sorunu değişmez, herhangi bir çatlak girişimi geçersiz değildir.

Java 8 @ OlivierGrégoire tarafından Cracked

Olabildiğince zorlaştırmaya çalıştım! :) Ve, şimdiye kadarki diğer Java cevabından farklı olarak, tüm bu snippet’ten sonra (yani hayır, kodunuzu koymayın;public static void main(String[] args) metoda koymuyorsunuz, . tüm dersten sonra. :) İyi şanslar!

Neyin kısıtlandığını göstermek için yorumlar ekledim.
( Cevabım için kullanabileceğim aynı yaklaşımla daha az kısıtlayıcı ve çırpıcı olan bu yazıdan ilham alınmıştır. )

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileDescriptor;
import java.io.FilePermission;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Main {

  // Put everything in a static block so it is run before the static main method 
  // and any trailing (static) initializer-blocks:
  static {
    try {
      initializing();
    } catch (final Exception e) {
    }
  }

  static void initializing() throws Exception {
    // Overwrite System.out, System.err and System.in:
    System.setOut(new PrintStream(new ByteArrayOutputStream()));
    System.setErr(new PrintStream(new ByteArrayOutputStream()));
    System.setIn(new ByteArrayInputStream(new byte[0]));

    // Enable reflection for System.out, System.err and System.in:
    final Field modifiersField = Field.class.getDeclaredField("modifiers");
    modifiersField.setAccessible(true);
    final Class<?> fdClass = java.io.FileDescriptor.class;
    final Field outField = fdClass.getDeclaredField("out");
    outField.setAccessible(true);
    modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
    final Field errField = fdClass.getDeclaredField("err");
    errField.setAccessible(true);
    modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL);
    final Field inField = fdClass.getDeclaredField("in");
    inField.setAccessible(true);
    modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL);

    // Replace existing System.out FileDescriptor with a new (useless) one:
    outField.set(null, new FileDescriptor());
    // Replace existing System.err FileDescriptor with a new (useless) one:
    errField.set(null, new FileDescriptor());
    // Replace existing System.in FileDescriptor with a new (useless) one:
    inField.set(null, new FileDescriptor());

    // Disable reflection for System.out, System.err, System.in again:
    modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
    modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL);
    modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL);
    inField.setAccessible(false);
    errField.setAccessible(false);
    outField.setAccessible(false);
    modifiersField.setAccessible(false);

    // Overwrite the SecurityManager:
    System.setSecurityManager(new SecurityManager() {

      private boolean exitAllowed = false;

      @Override
      public void checkExec(final String cmd) {
        throw new SecurityException();
      }

      @Override
      public void checkPermission(final java.security.Permission perm) {
        final String name = perm.getName();
        // You're not allowed to read/write files:
        if (name.equals("setIO") || name.equals("writeFileDescriptor")
            || name.equals("readFileDescriptor")
            || ((perm instanceof FilePermission) && name.startsWith("/proc/self/fd/"))) {
          throw new SecurityException();
        }
        // You're not allowed to overwrite the Security settings:
        if (name.equals("setSecurityManager") || name.equals("suppressAccessChecks")) {
          throw new SecurityException();
        }
        // You're not allowed to use reflection anymore:
        if (name.equals("getModifiers") || name.equals("get") || name.equals("set")
            || name.equals("setBoolean") || name.equals("setByte")
            || name.equals("setChar") || name.equals("setShort") || name.equals("setInt")
            || name.equals("setLong") || name.equals("setFloat") || name.equals("setDouble")
            || name.equals("setFieldAccessor") || name.equals("setFieldAccessor")) {
          throw new SecurityException();
        }
        // When you try to leave the current VM it will stop the program:
        if (name.startsWith("exitVM") && !this.exitAllowed) {
          this.exitAllowed = true;
          System.exit(0);
        }

        // You know what, nothing is allowed!
        throw new SecurityException("Mhuahahahaha!");
      }
    });
  }

  public static void main(String[] args) {
    // Overwritting all given arguments:
    args = new String[0];

    // Exit the program before you can do anything!
    System.exit(0);
  }
}

// Your code goes below:

Burada dene. (TIO yerine ideone.com, orada iş görünmüyor çünkü Eclipse IDE'de testler yapıldı, ancak ideone.com kullanıyorsanız amaçlanan çözümüm işe yarıyor)

Jöle: KIRIKLI

Buğday Büyücüsü'nün muhteşem Python cevabına göre bu delicesine kolay olacak, ama işte başlıyoruz: P

“for c in code_page:
 if c in atoms:atoms[c].call=None”ŒVø<insert code snippet here>

İlk snippet dahil, geçici çözümümün sha256 onaltılık bölümüdür cfeb1e193ad77f66f039c0d6a792a3e4c311490f6412698e019ca1fae10c0e0a.

Not

Kodda dizgiler dışında herhangi bir yeni satırınız olmayabilir, aksi takdirde bu kod çalıştırılmayacak, bu zorluğun amacını yendi.

DJMcMayhem tarafından Cracked

Adil olmak gerekirse, bu yeni bir satır kullanır, bu yüzden yeni satır kullanmayan bir çözüm görmek isterim.

Ayrıca Jonathan Allan tarafından bir çözüm

Bu yeni bir satır kullanmaz, bu yüzden kırıldı. : P

Benim çözümüm bu:

“for c in code_page:
 if c in atoms:atoms[c].call=None”ŒVø“print(int(input())+int(input()))”ŒV

İlk kod parçası yalnızca tek karakterli atomları siler, bu da Python eval'ün hala çalıştığı anlamına gelir :)))

JavaScript, Kırık

Giriş: prompt()iki kez

Çıktı: console.log()

Benim çözümüm jsfiddle'da çalışmıyor. Hakkında çalışır: Google chrome'un JS konsolunda boş sayfa.

prompt=console=0

Çözümüm:

x=document.createElement("iframe")
x.src="data:text/html,<script>console.log(prompt()-0+(prompt()-0))</script>"
document.body.appendChild(x)

Açıklama:

0'a eşit ayarlayarak istemi ve konsolu kaldırdım.

Benim çözümümde, bir sanal alan oluşturan bir iframe ve hızlı ve konsolun düzgün çalıştığı yeni bir pencere örneği yaratıyorum.

Java, Kırık

import java.lang.reflect.*;
public class Main{
  public static void main(String... args){
    System.setOut(null);
    System.setErr(null);
    /*Your code here*/
  }
}

Bu çatlamak için çok kolay olmalıydı .

Amaçlanan çözüm

import java.lang.reflect.*;
public class Main{
public static void main(String... args){
  System.setOut(null);
  System.setErr(null);
  try{
    Class<?> cistream = Class.forName("java.io.InputStream");
    Class<?> cfostream = Class.forName("java.io.FileOutputStream");
    Class<?> costream = Class.forName("java.io.OutputStream");
    Class<?> cfdescriptor = Class.forName("java.io.FileDescriptor");
    Object sout = cfostream.getConstructor(cfdescriptor).newInstance(cfdescriptor.getField("out").get(null));
    Class<?> csys = Class.forName("java.lang.System");
    Field mod = Field.class.getDeclaredField("modifiers");
    mod.setAccessible(true);
    Field stdout = csys.getField("out");
    mod.set(stdout,Integer.class.cast(mod.get(stdout) )&~ Modifier.FINAL);
    stdout.set(null,Class.forName("java.io.PrintStream").getConstructor(costream).newInstance(sout));
    Class<?> cscanner = Class.forName("java.util.Scanner");
    Object scanner = cscanner.getConstructor(cistream).newInstance(System.in);
    Method nextInt = cscanner.getMethod("nextInt");
    int f = Integer.class.cast(nextInt.invoke(scanner));
    int s = Integer.class.cast(nextInt.invoke(scanner));
    int sum = s + f;
    System.out.println(sum);
  }catch(Throwable t){t.printStackTrace();}
  }
}

Çevrimiçi deneyin