Bozulmamış bir programı, kendi başına bir hata içermeyen bir program olarak tanımlayalım, ancak N karakterinin bitişik alt dizgisini kaldırarak değiştirirseniz hata verir 1 <= N < program length.

Örneğin, üç karakterli Python 2 programı

`8`

bozulmamış bir programdır ^{( teşekkürler, Sp )} çünkü uzunluk 1'in alt dizgilerinin çıkarılmasından kaynaklanan tüm programlar hatalara neden olur (aslında sözdizimi hataları, ancak herhangi bir hata yapacaktır):

8`
``
`8

ve ayrıca uzunluk 2'nin alt dizelerinin çıkarılmasından kaynaklanan tüm programlar hatalara neden olur:

`
`

Örneğin, `8hata yapmayan bir program `8`olsaydı, o zaman bozulmamış olmazdı, çünkü alt zeminin kaldırılmasının tüm sonuçları hata vermeli.

Bu zorluğun içindeki göreviniz, hiçbir girdi gerektirmeyen ancak aşağıdaki beş kelimeden herhangi birini çıkaran mümkün olan en kısa bozulmamış programı yazmaktır:

world
earth
globe
planet
sphere

Hangi kelimeyi seçtiğiniz tamamen size kalmış. Tek kelime ve isteğe bağlı son bir satırsonu stdout'a (veya dilinizin en yakın alternatifi) basılmalıdır. Bayt cinsinden en kısa program kazanır.

Notlar:

• Bir fonksiyon değil, bağımsız bir program gereklidir.
• Kelimeler büyük / küçük harf duyarlıdır; çıkış Worldveya EARTHizin verilmiyor.
• Derleyici uyarıları hata olarak sayılmaz.
• Hata yapan alt programlar her zaman hata yaptıkları sürece girdi alabilir veya çıktı verebilir veya başka bir şey yapabilir.

İşte potansiyel olarak bozulmamış bir program verildiğinde hangi programların hata yapması gerektiğini listeleyen bir yığın pasajı:

<script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>function go() { var s = $('#i').val(), e = []; for (var i = 1; i < s.length; i++) { for (var j = 0; j <= s.length - i; j++) { e.push(s.substring(0, j) + s.substring(j + i)); } } $('#o').val(e.join('\n---\n')); }</script>Program:<br><textarea id='i' rows='16' cols='80'>`8`</textarea><br><button onclick='go()' type='button'>Go</button><br><br>Programs that should error: (--- separated)<br><textarea id='o' rows='16' cols='80'></textarea><br>

Demiryolu , 24 bayt

$'main'    #
 -[world]o/

Ben düşünüyorum bu çalışır. Ve hem kısa hem de okunabilir (Demiryoluna kadar).

• Çıkarılan alt dize $'main'aldığımız herhangi bir parçayı içeriyorsa Internal Error: Crash: No 'main' function found.
• Kaldırılan alt dize içerirse #, programın temiz bir şekilde çıkması için bir yol yoktur, bu nedenle her zaman sonlandırılır Crash: No valid move. Parça geçerli bir (sonsuz) bir döngü oluşturacak şekilde bir alt dizginin silinmesinin mümkün olmadığına inanıyorum.
• Kaldırılan alt dize önünde ise, #parçanın sonundan bağlantısı kesilecektir, böylece tren çarpacaktır (yukarıdaki ile aynı hatayla).
• Kaldırıldı alt dize sonra ise #, aynı zamanda kesilir #(potansiyel ve giriş noktasından parçanın bile başlangıcı parçanın ucundan $). Yani yine aynı hata.

Asıl programa gelince: Her Demiryolu programının bir $'main'(veya daha uzun bir değişkene sahip olması gerekiyor , ancak burada golf oynuyoruz) işleve bir giriş noktası olarak geliyor ve tren $Güney-Doğu'ya gidiyor. Bu ilk satırdaki her şey olsa parçanın bir parçası olabilir, bu yüzden 'main'parçanın çıkarılması :

$          #
 -[world]o/

-Ve /basitçe tren olanlar 45 ° sırayla izin vermelisiniz ray parçalarıdır.

[world]ipi iter worldve oyazdırır. #Bir Ray programını güvenli bir şekilde sonlandırmanın tek yolu izin sonunu işaretler.

İlginçtir, bu çözüm ancak Rail'in rayların mainhattan geçmesine izin verdiği için mümkündür - eğer mümkün değilse #ilk yeni satırdan sonra olur ve kod her zaman için kısaltılabilir

$'main'
 #

bu hiçbir şey yapmadan geçerli bir programdır. (Aradaki boşluk olmayan karakterler 've #bunu etkilemez.)

Ayrıca oldukça ilginç: Baskı işini yeni başlatmış olsaydımworld daha kısa ya da basit olmazdı:

$'main'
 -[world]o#

Funciton ( UTF-16'da 186 136 bayt)

╔══════════════╗
║19342823075080╟
║88037380718711║
╚══════════════╝

Bu program “dünya” yazıyor.

Bundan çıkardığınız alt dizgelerin çoğu, çözümleyicinin şikayet edeceği eksiksiz bir kutu olmasını engeller. Komple bir kutu bırakan olası kaldırmalar şunlardır:

 ╔══════════════╗
|║19342823075080╟  (remove this whole line)
|║88037380718711║
 ╚══════════════╝
 ╔══════════════╗
 ║|19342823075080╟   ← substring starts at | here
 ║|88037380718711║   ← substring ends at | here
 ╚══════════════╝
... ↕ or anything in between these that removes a whole line’s worth ↕ ...
 ╔══════════════╗
 ║19342823075080|╟   ← substring starts at | here
 ║88037380718711|║   ← substring ends at | here
 ╚══════════════╝
 ╔══════════════╗
|║19342823075080╟
 ║88037380718711║  (both lines entirely)
|╚══════════════╝
 ╔══════════════╗
 ║19342823075080╟
|║88037380718711║  (remove this whole line)
|╚══════════════╝

Bunların çoğu, çıkış konektörü olan kutunun sağ üstündeki sarkan ucu çıkarır. Bu gevşek son olmadan, kutu sadece bir yorumdur:

╔══════════════╗
║88037380718711║
╚══════════════╝

Bu artık geçerli bir program değil, çünkü çözümleyici tam olarak bir çıktılı bir program bekliyor:

Hata: Kaynak dosyalar bir program içermiyor (programın bir çıktısı olması gerekir).

Bir çıkış konektörü bırakan tek olasılık, bunu bırakan yukarıdakilerin sonuncusudur:

╔══════════════╗
║19342823075080╟
╚══════════════╝

Ancak, bu numara Funciton'un ezoterik UTF-21'deki geçerli bir Unicode dizesini kodlamaz. Bunu çalıştırmayı dene.

İşlenmeyen İstisna: System.ArgumentOutOfRangeException: Geçerli bir UTF32 değeri, 0x000000 ve 0x10ffff arasında, dahil olup, yedek kod noktası değerleri (0x00d800 ~ 0x00dfff) içermemelidir.

Bu nedenle, bu program bozulmamış.

Visual C ++ - 96 95 bayt

#include<iostream>
#define I(a,b)a<<b
int main()I({std::cout,I('w',I('o',I('r',I('l','d';)))))}

Özellikleri:

1. int main()Derleme hatası olmadan hiçbir bölümünü kaldıramazsınız .
2. Kaldırıyorsunuz, HER değiştirmek makro genişleme kaldıramazsınız aelbette en main()geçmez {, çıkarmadan bbütün adresindeki satır bitmeyen demektir ;çıkarmadan, <araç std::cout<'w'hataya neden oluyor ve çıkarma <<nedenleri std::cout'w', 'w''o'vb
3. Makro tanımından veya başlatmadan parametreleri kaldıramazsınız, tanım için yalnızca geçerli adlar I(a), I(b)hiçbir zaman eşleşmeyen ve Iöncekine genişleyen (; Öte yandan I(,nedenleri kullanır <<<<ve ,)yarı-kolonu bırakır (diğer hataları engeller).
4. Tümünün bir bölümünü std::coutbir başlıkla karşılaşmadan <<kaldıramazsınız ve bu nedenle #include<iostream>başlangıçta hiçbirini derleme hatası yapmadan kaldıramazsınız .
5. Tek bir karakterin hiçbir bölümünü kaldıramazsınız, ''boş bir karakter hatası vardır 'w,, vb. Her şeyi bir karakter haline getirmeye çalışın.
6. Bir makronun sol / sağ tarafını çok fazla )veya (diğer tarafa bırakmadan kaldıramazsınız , örneğin gibi şeyler yapamazsınız I('w',I('r'.

Visual C ++ kullanarak çevrimiçi derler .

Bir kez daha bu ayrıntılı bir kanıt değil. Eğer çok çalışmadan alabileceğinizi düşünüyorsanız, bana bildirdiğinizden emin olun.

Önceki versiyonlar oldukça farklı bir yaklaşım kullandılar ve bozulmamış olmadıkları kanıtlandı, bu yüzden bu puanları kaldırdım.

Doğrulama:

Aşağıdaki program, bu sürümün clVisual C ++ 2010'dan derleyici kullanılarak bozulmamış olduğunu onaylamıştır . Bunu daha önce yazmak için can atıyordum:

#include <fstream>
#include <iostream>
char *S = "#include<iostream>\n#define I(a,b)a<<b\nint main()I({std::cout,I('w',I('o',I('r',I('l','d';)))))}";
//uncomment to print source code before compile
// #define prints
int main(){
   for(int i=0; i<95; i++)
      for(int j=i; j<95; j++){
         std::fstream fs;
         fs.open ("tmptst.cpp",std::fstream::out);
         for(int k=0; k<95; k++)
         if(k<i || k>j){
            fs << S[k];
            #ifdef prints
               std::cout<<S[k];
            #endif
         }
         fs.close();
         #ifdef prints
            std::cout<<'\n';
         #endif
         //Compile and surpress/pipe all output
         //if it doesn't compile we get a nonzero errorlevel (i.e.true) from system.
         if(!system("cl -nologo tmptst.cpp >x"))
            return 0;
      }
      std::cout<<"PRISTINE!";
}

Python 3, 79 33

if 5-open(1,'w').write('world'):a

open(1,'w')standart çıktıyı açar, sonra dizgeyi yazdırırız. writeYazılan karakter sayısını döndürür. Bu, alt tabaka çıkarma işlemine karşı sertleştirmek için kullanılır: İpin bir kısmını çıkarmak, 5'den başka bir şeyin geri dönmesine neden olur ve bu değer 5 eksi sonra doğru olarak değerlendirilir. Ancak bu, ifkimsenin idam edilmesine ve atanımlanmamasına neden olur .

Bu Anders Kaseorg akıllıcaymış bozulmamış Quine'ın dayanmaktadır burada .

Yalnızca tek bir ifadenin doğrulanması gerektiğinden, bu eski çözümden çok daha kısadır, fakat daha az geneldir.

Eski çözüm:

try:
 q="print('world');r=None"
 if exec('e=q')==eval(q[17:]):exec(e)
finally:r

Gerçekten bozulmamış bir program olduğunu doğrulamak için:

w=r'''try:
 q="print('world');r=None"
 if exec('e=q')==eval(q[17:]):exec(e)
finally:r'''
exec(w)
for j in range(1,len(w)):
 for i in range(len(w)+1-j):
  e=w[:i]+w[i+j:]
  try:exec(e,{});print('WORKED',e)
  except:pass

Bazı önemli noktalar:

• Yürütülen her ifade silinebilir. Bunun qyürütüldüğünü doğrulamak dışında bir ifade gerektiriyor q. Güzel bir tryşekilde, hiçbiri tamamen silinemeyen en az iki ifade gerektirerek çözer.
• Bunun gerçekleştirildiğini doğrulamak sonunda qdeğerlendirerek rgerçekleşir.
• Doğrulayarak qile elde edilir değiştirilmediğini eval(q[17:])değerlendirmek için olan, Noneiçin qyürütülecek.
• Durum ifdoğru almak için biraz zor. Değerlendirilmesini sağlamak için, eayarlanması gereken ayarın hoş bir yan etkisi vardır r. (Bu, Python 3'ü kullanmamın nedeni, exprbir işlev ifade düzeyindeki yan etkiler için harikalar yaratıyor.)

Haskell, 61

x=uncurry(:)
main=putStr$x('w',x('o',x('r',x('l',x('d',[])))))

Herhangi bir hata türü tamam mı? Bu durumda:

Haskell, 39

main=putStr$take 5$(++)"world"undefined

JavaScript, 74 73 35 bayt

if((alert(a="world")?x:a)[4]!="d")x

Anlaşılan cevabım düşündüğümden daha basitti ...

açıklama

if(
  (
    alert(a="world") // throws a is not defined if '="world"' is removed
        ?x           // throws x is not defined if 'alert' or '(a="world")' is removed
        :a           // throws a is not defined if 'a="world"' or 'a=' is removed
  )
  [4]!="d"           // if "world" is altered fifth character will not be "d"
                     // if 'd' is removed it will compare "world"[4] ("d") with ""
                     // if '[4]' is removed it will compare "world" with "d"
                     // if '(alert(a="world")?x:a)' is removed it will compare [4] with "d"
                     // if '?x:a' is removed [4] on alert result (undefined[4]) will error
                     // if '[4]!="d"' is removed the if will evaluate "world" (true)
                     // if '!', '!="d"' or '(alert...[4]!=' is removed the if will
                     //     evaluate "d" (true)
)x                   // throws x is not defined if reached

// any other combination of removing substrings results in a syntax error

Java 8, 301 bayt

Çünkü her sorunun bir Java cevabı gerekiyor.

class C{static{System.out.print(((((w='w')))));System.out.print((((o='o'))));System.out.print(((r='r')));System.out.print((l='l'));System.out.print(d='d');e=(char)((f=1)/((g=8)-C.class.getDeclaredFields()[h=0].getModifiers()));}public static void main(String[]a){}static final char w,o,r,l,d,e,f,g,h;}

Expanded

class C {
    static {
        System.out.print(((((w = 'w')))));
        System.out.print((((o = 'o'))));
        System.out.print(((r = 'r')));
        System.out.print((l = 'l'));
        System.out.print(d = 'd');
        e = (char) ((f = 1) / ((g = 8) - C.class.getDeclaredFields()[h = 0].getModifiers()));
    }

    public static void main(String[] a) { }

    static final char w, o, r, l, d, e, f, g, h;
}

açıklama

• public static main(String[]a){} gerekli.
• Alan bildirimleri kaldırılırsa (veya statik değilse), ilk statik blok bunları bulamaz.
• Statik blok kaldırılırsa (veya statik değilse), alanlar başlatılmaz.

En zor kısım:

• Eğer finalanahtar kelime kaldırılır, ikinci satır olarak değerlendirilen 1/(8-8)bir neden / by zeroistisna.

Funciton , 143 142 136 bayt

Skor UTF-8'de olduğu gibi UTF-16 iki byte daha büyük olacaktır (BOM nedeniyle).

╔══════════╗
║1934282307║╔╗
║5080880373╟╚╝
║80718711  ║
╚══════════╝

Bu yüzden bir süredir bir Funciton cevabını düşünmüştüm ve her zaman tam bir çizgiyi kaldırabileceğiniz ve kodun hala geçerli bir blok oluşturacağı için imkansız olacağını düşündüm. Sonra bu konuda Timwi konuştum ve o anladım sadece bunu kaldırılırken bir çıkış konektörü yetersizliğinden programı kıracak şekilde, tek bir satırda numaranın tamamını koyabilirsiniz.

Ama tek bir satırda değişmezleri herkesin bildiği, hem çünkü büyük karakter sayımı pahalıdır ve çünkü ASCII olmayan karakterler daha büyük sayıda. Ve "boş yorum" bloğundan bahsetmesi beni düşündürdü ...

Bu yüzden, değişmez bloğu inceliğe sokacak herhangi bir şeyi çıkarmaya çalıştığınızda kırılan ek bir boş yorum bloğu kullanan bu daha etkili çözüm buldum:

• Üçüncü satırı çıkaramayız çünkü çıkış konektörünü kaldırırız.
• İkinci satırı kaldırırsak, yorum bloğu üst kenarını kaybeder ve kesilir.

Bu iki seçenek bırakır (bunu işaret ettiği için Steve'e teşekkürler ):

• Dördüncü çizgiyi çıkarın. Bu iki kutuyu da inceliğe bırakıyor. Ancak, ortaya çıkan tamsayı 19342823075080880373çözüldüğü zaman, karşılık gelen dize 0x18D53Bgeçerli bir Unicode karakteri olmayan kod noktasını içerecek ve bir System.Char.ConvertFromUtf32ile çarpışacaktır ArgumentOutOfRangeException.
• Sağ üst köşeden başlayarak başlayan tam bir çizgi kaldırın. Yine, her iki kutu da dokunuşta bırakılır, ancak ortaya çıkan tam sayı 508088037380718711iki geçersiz kod noktası içerir 0x1B0635ve 0x140077aynı istisnaya yol açar.

Boş yorum bloğu olmasa bile, ikinci satırın kaldırılmasının geçersiz bir kod noktasına neden olacağını unutmayın. Ancak yorum bloğu , örneğin bir hataya yol açmayacak bir tamsayı elde etmek için ikinci satırın içinden bir satır çekmemizi önler 193428037380718711.

Ruby, 36

eval(*[(s="planet")[$>.write(s)^6]])

Atarız s="planet", sonra bu dizgiyi STDOUT'a yazarız. Bu yazılı karakter sayısını döndürür. 6 ile x veya x karakterden başka bir şey yazılmışsa sıfır olmayan bir tamsayı elde edeceğimiz için xorlar. Sonra sbu endeks ile kesilir. Yalnızca s"p" nin 0ncı karakteri geçerli bir kod dizesidir (no-op). Bunu , bir yöntem çağrısının dışında geçerli olmaması dışında , eşdeğerde evalolan (*[argument])sözdizimini kullanarak aktarıyoruz (argument).

Gerçeklik programlı olarak Ruby 1.9.3 ve 2.2'de doğrulandı

C #, 128 118 101 bayt

Bitişik alt dize kuralını kötüye kullanma düşüncesi.

Kod

class h{static void Main()=>System.Console.Write(new char[1
#if!i
*5]{'w','o','r','l','d'
#endif
});}

Neden Çalışıyor?

1. class hve static void Main()gereklidir.
2. İçindeki karakterlerden herhangi birinin çıkarılması 'w','o','r','l','d'bir hataya neden olur çünkü karakter dizisi uzunluğu ile başlatılmıştır 1*5.
3. Main () içindeki içerikleri, parçaların ön bilgisayarlar tarafından ayrılmasından dolayı bitişik karakter kuralını ihlal etmeden kaldıramazsınız. (Aşağıya bakınız)

Golf ve Ayrılmadan Önce

class h
{
    static void Main() =>
        System.Console.Write(new char[1 * 5]{'w','o','r','l','d'});
}

Doğrulandı

https://ideone.com/wEdB54

DÜZENLE:

• #if !xBunun yerine bazı baytlar kaydedildi #if x #else.
• Kullanılan =>func sözdizimi. #if!xyerine #if !x. @JohnBot’a verilen krediler.
• =>Func sözdizimi nedeniyle , ekstra preproc durumu kaldırılabilir.

MATLAB, 37 36 33 bayt

feval(@disp,reshape('world',1,5))

Ayrıca , ans = çıktısına izin verilip verilmediğinden emin olamadığımdan , düzgün bir şekilde çıktı almak için biraz uğraş bulmam gerekti. Fprintf'i kendi başına kullanmak işe yaramadı, çünkü ne denedim olursa olsun, hata yapmayı reddetti. Disp'i tek başına kullanmak bir seçenek değildi, çünkü sadece 1 argümanı alacaktı ve bu argümanın kendisi de hatasız olarak yürütülebilecekti.

Çıktıya ans = eklenmesi de sorun değilse , MATLAB 20 bayt ile yapılabilir :

reshape('world',1,5)

> <> , 17 bayt

e"ooooo7-c0pBhtra

Çevrimiçi deneyin!

"Dünya" yı yazdırır.

Bir ><>programın hatasız ;çıkmasının tek yolu karakteri çalıştırmaktır; bu, bundan önce tüm karakterleri kaldırabileceğiniz bir sorundur, böylece ;ilk çalıştırılan karakter bu olur. Bunun yerine yürütme sırasında piçerecek programı değiştirmek için komutu kullanarak bu sorunu çözebilirsiniz ;. Kodun herhangi bir bölümünü çıkarma nedenleri ;geçersiz talimatlar aracılığıyla hatalara neden üretilecek asla B, hve t, Yetersizlik yığını ve sonsuz döngüler sonunda bellek tükendi yapma. Sadece tüm sonsuz döngülerin yığını doldurmaya devam etmesini sağlamak zorunda kaldım.

Tüm değişkenler bu piton snippet'i kullanılarak test edildi:

code = 'e"ooooo7-c0pBhtra'
count = {"invalid":0, "underflow":0, "memory":0}
for l in range(1, len(code)):
    for x in range(0, len(code)-l+1):
        print(code[:x] + code[x+l:], "\t\t", end='')
        try:
            interp = Interpreter(code[:x]+code[x+l:])
            for _ in range(0,1000):
                interp.move()
            print(len(interp._stack), "< ", end='')
            interp2 = Interpreter(code[:x]+code[x+l:])
            for _ in range(0,2000):
                interp2.move()
            print(len(interp2._stack))
            count["memory"] += 1
        except Exception as e:
            print(e)
            if str(e) == "pop from empty list": count["underflow"] += 1
            else: count["invalid"] += 1
print(count) 
#don't judge me

resmi <.> yaratıcısı tarafından resmi fish.py yorumlayıcısına (biraz değiştirilmiş versiyonu) eklendi . 152 olası alt programdan 92'si geçersiz komutlardan, 18'inin yığın altından ve 42'sinin bellek yetersiz kaldığından hatalı.

Komik gerçekler, bunun ilk versiyonunda , geçersiz komut yerine, yığını temizlemek için e"ooooo6-c0pAhtraput komutunu kullanmayı başaran birkaç ucube alt program vardı . Ayrıca, "dünya" bu yöntemle çalışacak ifadelerden yalnızca biridir, çünkü ilk harf geçerli bir komuttur . Aksi halde komut programın önüne yerleştirilmelidir ve geçerli bir alt program kendi başına olabilir.[Ae><>""

Ruby, 34

eval(*[($>.write("world")-1).chr])

Bunun birkaç bileşeni var:

eval(*[ İfade ]) ödünç histocrat cevabı ve bozulmamış yanı sıra dönüş değeri doğrulayarak olduğunu expre hatası değil, geçerli bir yakut programıdır. argüman olarak değerleri method(*arr)çağıran bir yakut sözdizimidir . Bunun gerekli olmasının nedeni, yalnızca bir yöntemin parametreleri olarak geçerli olması , eğer kaldırılırsa bir sözdizimi hatası olması. Eğer expr kaldırılır, hakkında yeterli argümanlar olmaması şikayetmethodarreval(*[expr])eval

$>.write("world")-1dizi içinde ve çıkarma dışında karıştırılamaz. $>.write("world")"dünya" yı STDOUT'a yazar ve yazılan karakter sayısını döndürür, sonra 1'i çıkarır. Bunun için program ayarsız ise değer tam olarak 4 olacaktır . Karıştırılırsa ( -1kaldırılır veya kısaltılır) daha sonra -1,0,1,2,3 veya 5'ten birini döndürür . Başka herhangi bir işlem sözdizimi hatasıyla sonuçlanır.

chrBir numarayı çağırmak , o numara ile gösterilen karakteri döndürür. Bu nedenle, yukarıdaki örneğin sonucu çağrıldığında -1'de hata yapar ve aksi takdirde tek karakterli bir dize döndürür.

Bunun neden böyle olduğundan emin değilim, ama görünüşe göre yakut \x04beyaz boşluk karakteri olarak yorumlanıyor , yani ifade geçerli (boş yakut programları hiçbir şey yapmıyor) anlamına geliyor. Ancak, diğer karakterlerin ( \x00- \x03ve \x05) herhangi biriyle sonuçlanır Invalid char '\x01' in expression. Bunu, basitçe, verilen sayıya yapabileceğim bir matematiği tekrar ederek buldum. Daha önce kullanmıştım

$>.write("planet
")*16

"gezegen" artı bir yeni satırın 7 karakter olduğu, zaman zaman 16'yı 112'ye pçıkardığı, yakuttaki tek tek harfli fonksiyonun varsayılan olarak tanımladığı bir karakter. Hiçbir argüman verilmediğinde, etkili bir şekilde hayır operasyonu

Onurlu söz: $><<"%c"*5%%w(w o r l d)çok yakın ama bozulmamış. Çıkarma "%c"*5%hatasız sonuçları. Mini açıklama:

$>stdout ve <<üzerinde çağrılan bir fonksiyondur. daha sonra kısa bir sürüm olan bir dizi tarafından biçimlendirilecek olan ( ) "%c"*5dizgesini oluşturur . Dizide, biçim dizgisine uymayacak şekilde çok az veya çok fazla öğe varsa, bir hata düşünülür. Aşil topuğu olduğunu ve her iki İndependantly var olabilir ve sadece birinin bir argüman gerekiyor. Dolayısıyla bu programı hata yapmayan kuzenlere dönüştürmenin birkaç farklı yolu var."%c%c%c%c%c"%%w(w o r l d)['w','o','r','l','d']"%c"*5%w(w o r l d)$><<

Bunu kullanarak doğrulandı:

s = 'eval(*[($>.write("world")-1).chr])'
puts s.size
(1...s.length).each do |len| #how much to remove
  (0...len).each do |i| #where to remove from
    to_test = s.dup
    to_test.slice!(i,len)
    begin #Feels so backwards; I want it to error and I'm sad when it works.
      eval(to_test)
      puts to_test
      puts "WORKED :("
      exit
    rescue SyntaxError
      #Have to have a separate rescue since syntax errors
      #are not in the same category as most other errors
      #in ruby, and so are not caught by default with 
      #a plain rescue
    rescue
      #this is good
    end
  end
end

Python 3 , 43 bayt

for[]in{5:[]}[open(1,"w").write("world")]:a

Çevrimiçi deneyin!

Nasıl çalışır

Alt silme silmelerine karşı korumak için open(1,"w").writeyerine kullanırız print. Python 3'te, dizenin hiçbir bölümünün silinmediğinden emin olmak için writedoğrulayacağımız yazılı karakter sayısını döndürür 5. Bunu, sözlükteki dönüş değerini arayarak {5:[]}ve sonucu for[]in…:ayineleyen, boş bir yinelenebilir elde edemediğimizde veya forifade silindiğinde başarısız olacak şekilde yaparız .

Javascript (Node.js), 93 95 bayt

if(l=arguments.callee.toString().length,l!=158)throw l;console.log("world");if(g=l!=158)throw g

Herhangi bir karakter eksikse, bir hata atılırsa, kendi boyutunu iki kez kontrol edin. Uzunluk 156, çünkü Node.js function (exports, require, module, __filename, __dirname) {çalışma zamanındaki koda hazırlar .

Hata bildirdiğiniz için teşekkürler Martin Büttner. Şimdi düzeltildi.

Perl 5.10+, 71 63 bayt

(${open 0;@{\(read(0,$a,63)!=63?die:@_)};say"world"});{$a//die}

worldSondaki yeni satır ile yazdırır . Bu şekilde koş:

perl -M5.010 file

Bu, kaynak kodun bayt sayısına dayanır, bu nedenle fileyukarıdaki kodu içermeli ve başka bir şey içermemelidir (shebang, izleyen yeni satır yok). sayTanımlanan veya işleç için 5.10+ Perl gerekir //.

Perl ile bozulmamış bir program yapmak inanılmaz derecede zor, çünkü:

• Herhangi bareword tanıtıcısı (örn foo, a, _) ile geçerli bir ifadedir no strict 'subs';(varsayılan). Bu, programın bir harf, sayı veya alt çizgi ile başlayamayacağı veya bitemeyeceği anlamına gelir.

• Gibi tchrist açıklıyor , "Sembolik dereferencing aracılığıyla belirlenen tanımlayıcılar sahip olursa olsun kesinlikle hiçbir kısıtlama adlarına." Bu Sigils herhangi biriyle başlayamaz programı anlamı $, @, %, veya *, ilk ve son karakteri bütün kaldırarak beri hep geçerli bir değişken adı bırakacaktı.

• Birçok yerleşik işlev (çıktı üretebilen çoğu işlev dahil) $_varsayılan olarak çalışır; bu nedenle, bağımsız değişkenleri kaldırsanız bile (örneğin, say"world"vs. say) çağrılar çalışır .

Nasıl çalışır

Bu çözüm, karakterlerin kaldırılmadığından emin olmak için kendi uzunluğunu kontrol eden Naouak'ın Node.js yanıtından ilham aldı .

Programın biri parantez içinde diğeri blok halinde olmak üzere iki bölümü vardır:

(...);{...}

İlk bölüm kaynak dosyayı okur ve 63 karakterden uzunsa ölür. İkinci bölüm, readbaşarıyla yürütüldüğünü kontrol eder . Her iki bölüm de kaldırılırsa (ekteki parantezler veya küme parantezleri olsun veya olmasın), diğer bölüm bir istisna atar.

Programın ortasını veya solunu veya sağını kaldırmak, parantezleri ve / veya kıvrımlı parantezleri dengesiz hale getirerek bir sözdizimi hatasına neden olur.

İlk Eğer diedeğiştirildiğinde (için d, e, di, de, veya ie, tüm geçerli tanımlayıcılardır olan), uzunluk denetimini sağlar:

@{\(read(0,$a,63)!=63?di:@_)};

hangi değerlendirir:

@{\'di'};

Bu bir dizgiye referans alır ve onu bir dizge olarak kaldırmaya çalışır, bir hata üretir:

Not an ARRAY reference

Başka bir ifade değişirse, uzunluk kontrolü başarısız olur ve program ölür.

Aşağıdaki programla onaylanmış bozulmamış:

#!/usr/bin/perl

use strict;
use warnings;
use 5.010;

use File::Temp;
use List::MoreUtils qw(uniq);

sub delete_substr {
    my ($str, $offset, $len) = @_;

    my $tmp = $str;
    substr($tmp, $offset, $len) = '';

    return $tmp;
}

sub generate_subprograms {
    my ($source) = @_;

    my $tot_len = length $source;
    my @subprograms;                                             

    foreach my $len (1 .. $tot_len - 1) { 
        foreach my $offset (0 .. $tot_len - $len) {
            push @subprograms, delete_substr($source, $offset, $len);
        }                                                        
    }                                                            

    return uniq @subprograms;                                    
}                                                                

chomp(my $source = <DATA>);                                                                                                       
my $temp = File::Temp->new;                                                                                        

foreach my $subprogram ( generate_subprograms($source) ) {       
    print $temp $subprogram;

    my $ret = system(qq{/usr/bin/perl -M5.010 $temp > /dev/null 2>&1});
    say($subprogram), last if $ret == 0;

    truncate $temp, 0;
    seek $temp, 0, 0;
}

__DATA__
(${open 0;@{\(read(0,$a,63)!=63?die:@_)};say"world"});{$a//die}

Ruby + coreutils, 33 27 26 bayt

`base#{$>.write"world
"}4`

Çevrimiçi deneyin!

Yakuttaki geri tepmeler, içlerindeki komutu uygular ve programın STDOUT'a dizge olarak ne koyduğunu döndürür. #{expr}Sözdizimi dizeleri ve ters tırnakların içinde ifadelerin gömme izin verir. Bu program şu şekilde yazılabilir (el değmeden):

system("base" + (STDOUT.write("world\n")).to_s + "4")

IO#writeYazılan bayt sayısını döndürür, bu nedenle dize kısaltılırsa doğru sayı olmaz. #{}gömmek, numarayı otomatik olarak dizgeye dönüştürür. Bazı parça kaldırılırsa ve sözdizimi hatasıyla sonuçlanmazsa, yanlış komut çalıştırılır. Bir kısmı "world"kaldırılırsa base04içinden birinden base54kaçmaya çalışır.

Dizginin içinde veya dışında olan yeni satır gereklidir. Aksi halde, ilk 5 karakter ( `base) kaldırılabilir ve tüm satırı yorum yapabilir. Ayrıca, ilk geri tepme çizgisi arasında bir veya daha fazla karakter bulunmalıdır #, aksi takdirde {her şeyi kabuklu bir yorum haline getirmek için kaldırılabilir .

exec(*[(s="ec%co earth")%s[10]])

execGeçerli yakut işlemini belirtilen komutla değiştirir. Sözdizimin bir açıklaması ve bunun gerekliliği için diğer cevabımı görün meth(*[]).

(s="ec%co earth")değişkene "ec% co earth" dizesini atar s. Atamalar atananları döndürür, böylece dize de döndürülür.

"format string %d" % 5sözdizimi şekeridir sprintf("format string %d",5), ancak etrafındaki boşluklar %zorunlu değildir.

s[10]dizgede 10 karakterindeki karakteri alır. Karıştırılmadığında, bu karakter dizgideki son harf olan "h" olur. Ancak, dizedeki herhangi bir karakterin kaldırılması, dizenin daha kısa olduğu anlamına gelir, bu nedenle 10. dizinde karakter yoktur, bu nedenle s[10]döndürür nilve "%c" % nilbir hataya neden olur.

eğer %s[10]kaldırılır, ardından yakut komutu çalıştırmak çalışır ec%co earthçalışmaz.

Bunun 10yerine 1veya 0aynı zamanda bilinmeyen bir komutla (veya eceoveya ecco) sonuçlanır . Tamamen kaldırılması, teknik olarak bir sözdizimi hatası değildir, çünkü #[]dizedeki yöntemi çağırır , ancak daha sonra yeterli argüman olmadığından şikayet eder.

Bunu genel olarak çözme ile ilgili bir not: El değmemiş olurken içindeki soyut kodu doğrulayan bir paketleyiciye sahip olmalısınız. Örneğin, ( blablabla/somevar) sonunda bölünen bir program hiçbir zaman çalışmaz çünkü bir bölünme her zaman kaldırılabilir ( blablabla). Bunlar, şu ana kadar kullandığım bazı paketleyiciler:

• eval(*[])histocrat tarafından kullanılan kod ve ilk cevabımda. Çıktının geçerli bir yakut programı olduğunu doğrular
• exec(*[])Yukarıda kullanılan kod , yanıtın geçerli bir komut olduğunu doğrular.
• `#{ kod }`

Ters çevirme sözdizimi de bir komut çalıştırır (ve bunun geçerli bir komut olduğunu doğrular), ancak STDOUT üst işlem olarak çıkarılmak yerine bir dize olarak yakalanır '(Ruby'nin) STDOUT. Bundan dolayı bu cevap için kullanamadım, EDIT: Çalışmasını sağladım. Yukarıda belirtilen sınırlamalar.

Düzenleme: Bazı kusurları işaret için @ histokrat sayesinde

PowerShell, (program adı için 97 bayt + 5) = 102 bayt

"$(try{if(($a=(gc .\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a

Kendini batırmadan önce kendini kontrol eder ... iki defa.

Beklediği gibi kaydedilmesini c.ps1ve bu şekilde yerel dizinden çalıştırılır:
PS C:\Tools\Scripts\Golfing\> .\c.ps1.

Diğer ad gckısadır Get-Contentve catbir dosyayı okumakla aynıdır (bu durumda bizim yürütme yolumuz .\c.ps1). .LengthDosyayı alıyoruz , ayarlıyoruz $ave 97 ile eşit olup olmadığını kontrol ediyoruz -eq97. Eşitse (yani program değiştirilmedi), ile yazdırır "world"ve geçersiz komut yürütürüz a. Bu catch, kendimizi tekrar kontrol etmemize izin veren etkili olmaya zorlar . Kodumuz 97'ye eşit değilse, bu kez geçersiz bir komut atarız, böylece programımız hata verdi ve hata metnini çıktıya yazdırdı. Biz o clear()zaman hata ve exitnormalde.

Her iki ififadede de değişiklik yapılması durumunda diğerinin bir hatayla karşılaşacağı açıktır . Herhangi bir kısmı "world";tahrif edilmişse , ilk ifhataya neden olacaktır. Bitişik olması gerektiğinden, her iki ififadeyi de kaldıramayız . Ortadaki dizgiler eşleşmeyen parantezler ile sonuçlanacak veya ikinci işlem yapılmasına neden olacaktır {a}. try/ catchBirinciden hatayı yakalamak için ifo kadar biz düzgün berrak açıklamada. Dış "$( )"dize iplerin iki ucundan kopmasını önler. Nihai ;a(örneğin geçerli programlara neden olacağını snipped alma orta kısımlarını önlemektir "it}a)";ayazdırmak hangi it}a)ardından hatası).

Birkaç özel durum var:

• Eğer gc, gc<space>ya gc .\da kaldırılırsa, program sonunda yetersiz bellek hatasının bir tadıyla (tekrarlanan kendi kendine yürütme çağrıları nedeniyle) bir hatayla sonuçlanacak ve muhtemelen kabuğu (ve belki de bilgisayarı) çökertecektir. Test edilmedi.
• Eğer <space>.\c.ps1veya .\c.ps1kaldırılır program durdurma ve kullanıcı girişi isteyecektir. Kullanıcının ne girdiği önemli değil, boyut yanlış olacağından program hala hata verecektir.
• En baştan başlamadan $önce biten ve biten bir "altsaç, program ne kalırsa çıkacak ve hata ageçerli olmayacağından çıkacaktır .

Aşağıdakilerle doğrulandı:

$x='"$(try{if(($a=(gc .\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'
$yy='"$(try{if(($a=( .\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'
$yyy='"$(try{if(($a=(.\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'
$yyyy='"$(try{if(($a=(c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'

for($i=1;$i-lt$x.Length;$i++){
  for($j=0;$j-lt($x.Length-$i);$j++){
    $y=($x[0..$j]+$x[($i+$j+1)..$x.Length])-join''
    $y>.\c.ps1
    $error.clear()
    if(!($y-in($yy,$yyy,$yyyy))){try{.\c.ps1}catch{};if(!($error)){exit}}
    $q++;
    write-host -n "."
    if(!($q%150)){""}
  }
}
"No success."

(Kapsamlı yardımları için Martin'e teşekkürler!)

C (gcc) (Linux, -Werror=undef), 66 bayt

main(a){a
=
1
/
(puts("world")/
6);
#if(7^__LINE__)
#else
}
#endif

Çevrimiçi deneyin!

Büyük zorluk! Bu aldatıcı bir şekilde zordu, ama şimdi geçerli bir programım olduğuna eminim!

Önişlemci komutunu kullanır, böylece yeni satırlar kaldırılamaz, çünkü kapatma braketi mainyalnızca eğer dahil edilmişse __LINE__==6. Aynı zamanda sizi maintamamen temizlemekten alıkoyuyor, çünkü bu #endifyüzer halde kalıyor (bunun #endifdışında olması önemlidir main).

Kullandığım #elseOrada hiçbir versiyonu oldukça ikna oldum çünkü __LINE__==6bir alt dize kaldırılmasını ve hala hem beri, gerçek olamayacağı 6ve __LINE__kendileri truthy vardır tarafından. Aynı zamanda, -Werror=undefböyle bir şeyin #ifdef(LINE__)yanlış olarak değerlendirilmemesi için bir hata yapması için kullanır .

Gcc ile (en azından Linux'ta), putsbasılan karakter sayısını (izleyen satırsonu dahil) puts("...")/6döndürür 0, böylece dizginin herhangi bir kısmını kaldırmak geri dönüş yapar , böylece 1/0bir kayan nokta istisnasına neden olur. Bu istisnaya, bir 1/0şey için atanmadıkça neden olmadığına dikkat edin , bu nedenle a=gereklidir.

Herhangi bir satırın başka hiçbir kısmı bir hata, genellikle bir sözdizimi hatası veya bir bağlantı hatası oluşturmadan kaldırılamaz.

Bir avantaj olarak, bu oldukça trivially, sadece eklemek C ++ için bir 86 bayt çözümünü verir #include <cstdio>ve beyan abir şekilde int. Çevrimiçi deneyin! (C ++)

PHP, 73 bayt

<?=call_user_func(($p='ns')|(($f="u{$p}erialize"))?$f:'','s:5:"world"');

explination

Varsayılan php.ini yapılandırmasını kabul ediyorum. Yani short_tags devre dışı bırakıldı. Bu =, açılış etiketinden kaldıramayacağınız anlamına gelir .

Bu temelde <?=unserialize('s:5:"world"');.

Serileştirilmiş dizenin herhangi bir bölümünü kaldırırsanız hata alırsınız.

Sadece kaldırabilirsiniz unserializeve script sadece serileştirilmiş dizgenin çıktısını alır. Bunun üstesinden gelmek için kullanıyorum call_user_func. Paramlardan birini çıkarmak bir hataya neden olur.

'<?=call_user_func('unserialize','s:5:"world"');

Ancak un, serializeişlevi çağırmak için kaldırabilirsiniz . Yani biz 'ns` çıkarıyoruz. Herhangi bir karakterin kaldırılması yanlış bir fonksiyon ismine sebep olmaz.

<?=call_user_func(($p='ns')&&($f="u{$p}erialize")?$f:'','s:5:"world"');

Çıktı etiketiyle değişken atama kullanıyorsanız bir satır içi kullanacağız. Kullanmak yerine &&'|' kullanıyoruz Birini çıkarmayı &veya $födevi kaldırmayı önlemek için

Kaldırabilir ='ns')&&($f="u{$p}erialize"ve sona erebilirsin ($p)?$f:''. Bunun üzerine fazladan parantez eklerim $f="u{$p}erialize".

Not

Teknik olarak, açılış etiketlerini bir hata oluşturmadan kaldırabilirsiniz. Ancak bu artık bir PHP betiği değil, sadece düz bir metin dosyasıdır.

Matlab (77)

bsxfun(@(c,b)arrayfun(@(x)getfield(c,{x}),conv(b,ismember(4,b))),'world',1:5)

dene

Not:

@ Optimiser’in bir CPR veya başka bir şey tasarlama tavsiyesini takiben, kaldırıldığında herhangi bir derleme hatasına neden olmayan öngörülemeyen alt tabakalarla karşı karşıya kaldım, örneğin: arrayfun(@(x)a(x),prod(b,ismember(4,1:5))),bu önceki düzenlemeden kaldırmak feval(@(a)arrayfun(@(x)a(x),prod(b,ismember(4,1:5))),'world')herhangi bir hata üretmedi! Ayrıca, son aynı baskı için vardı bsxfun(@(a,b)arrayfun(@(x)(x),prod(b,ismember(4,b))),'world',1:5)ve bsxfun(@(a,b)a,'world',1:5)onları çıkış konsolumda bulduğumda nasıl olduğumu sorduysanız, bebek gibi ağladım, işte program:

b=0;string='bsxfun(@(c,b)arrayfun(@(x)getfield(c,{x}),conv(b,ismember(4,b))),''world'',1:5)'
for u=1:numel(string),for j=u:numel(string)-2,try a=eval([string(1:u) string(j+2:end)]);catch(b); a=0;end; if a~=0, ['here is it : ' string(1:u) string(j+2:end)],end;end;end

Bozulmamış bir program örneği

Düzenle:

@Martin dışındaki herkese önceki kodumu (hataları değil) işaret ettiğim için teşekkürler.

SmileBASIC, 63 bayt

REPEAT
A=1/(PRGSIZE(0,1)==63)?"world
UNTIL 1/(PRGSIZE(0,1)==63)

Bir Armut Ağacı , 17 bayt

Bu program, yüksek bit kümesine sahip baytları içerir (bu, UTF-8 geçerli değildir ve bu nedenle TIO'ya gönderilemez), işte xxdgeri dönüşümlü bir hexdump:

00000000: 7072 696e 7427 776f 726c 6427 23cd 4290  print'world'#.B.
00000010: bf                                       .

açıklama

Bu sadece print'world'eklenmiş bir sağlama toplamı ile. Muhtemel silme işlemlerinin hiçbirinin geçerli bir sağlama toplamı olan bir program vermediğini kaba kuvvetle doğruladım, bu yüzden olası bir silme işleminden sonra bir hata alıyorsunuz.

Oldukça sıkıcı, ama şu anki lideri bağlıyor, ben de göndermeye değer olduğunu hissettim.