87

आइए एक प्राचीन कार्यक्रम को एक ऐसे प्रोग्राम के रूप में परिभाषित करें जिसमें स्वयं कोई त्रुटि नहीं है, लेकिन यदि आप इसे N वर्णों के किसी भी सन्निहित विकल्प को हटाकर संशोधित करेंगे, जहां 1 <= N < program length।

उदाहरण के लिए, तीन चरित्र पायथन 2 कार्यक्रम

`8`

एक प्राचीन कार्यक्रम है ^{( धन्यवाद, Sp )} क्योंकि लंबाई 1 के सबस्ट्रिंग को हटाने के परिणामस्वरूप होने वाले सभी कार्यक्रम त्रुटियों का कारण बनते हैं (लेकिन वास्तव में किसी भी प्रकार की त्रुटि होगी):

8`
``
`8

और यह भी सभी कार्यक्रमों की वजह से लंबाई 2 की substrings को हटाने से त्रुटियों का कारण बनता है:

`
`

यदि, उदाहरण के लिए, `8एक गैर- `8`गलत कार्यक्रम था, तो वह प्राचीन नहीं होगा क्योंकि प्रतिस्थापन हटाने के सभी परिणामों में त्रुटि होनी चाहिए।

इस चुनौती में आपका काम सबसे छोटा प्राचीन कार्यक्रम संभव लिखना है जो कोई इनपुट नहीं लेता है, लेकिन निम्नलिखित पाँच शब्दों में से किसी एक को आउटपुट करता है:

world
earth
globe
planet
sphere

आप कौन सा शब्द चुनते हैं यह पूरी तरह आप पर निर्भर करता है। एकमात्र शब्द प्लस एक वैकल्पिक अनुगामी न्यूलाइन को stdout (या आपकी भाषा के निकटतम विकल्प) के लिए मुद्रित किया जाना चाहिए। बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है।

टिप्पणियाँ:

एक स्टैंडअलोन प्रोग्राम की आवश्यकता है, एक फ़ंक्शन की नहीं।
शब्द संवेदनशील हैं; उत्पादन Worldया EARTHअनुमति नहीं है।
कंपाइलर चेतावनियाँ त्रुटियों के रूप में नहीं गिनी जाती हैं।
अनियमित उपप्रोग्राम इनपुट ले सकते हैं या आउटपुट दे सकते हैं या कुछ भी कर सकते हैं जब तक कि वे हमेशा त्रुटि करते हैं।

यहां एक स्टैक स्निपेट दिया गया है, जो यह बताएगा कि संभावित प्रीस्टाइन प्रोग्राम को दिए गए प्रोग्राम को क्या त्रुटि की आवश्यकता है:

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

स्निपेट का विस्तार करें

code-golf restricted-source pristine-programming

— केल्विन के शौक
स्रोत

1

@geokavel हाँ। अपवाद को पकड़ने का मतलब है कि यह अब कोई त्रुटि नहीं है।

— केल्विन के शौक

33

दो बार गैर-हटाए गए उत्तर के रूप में हटाए गए। यह एक उपलब्धि है!

— DLosc

1

क्या कोई प्रोग्राम अपना स्वयं का सोर्स कोड पढ़ सकता है?

— शेल्वैकु

2

"नज़दीकी लेकिन सिगार नहीं" और उनकी टिप्पणियों के कब्रिस्तान को देखने के लिए कहाँ?

— वि।

1

@Vi। 2,000 प्रतिनिधि प्राप्त करें ताकि आप हटाए गए पोस्ट देख सकें ।

— ThisSuitIsBlackNot 16

46

रेल , 24 बाइट्स

$'main'    #
 -[world]o/

मुझे लगता है कि यह काम करता है। और यह छोटा और पठनीय है (जहां तक रेल जाती है)।

यदि हटाए गए सबस्ट्रिंग में $'main'हम में से कोई भी हिस्सा शामिल है Internal Error: Crash: No 'main' function found।
यदि हटाए गए सबस्ट्रिंग में शामिल है #, तो प्रोग्राम को सफाई से बाहर निकलने का कोई रास्ता नहीं है, इसलिए यह हमेशा के लिए समाप्त हो जाएगा Crash: No valid move। मेरा मानना है कि एक विकल्प को हटाना संभव नहीं है, जैसे कि ट्रैक एक वैध (अनंत) लूप बनाता है।
यदि हटाए गए सबस्ट्रिंग सामने हैं #, तो यह ट्रैक के अंत से डिस्कनेक्ट हो जाएगा, इसलिए ट्रेन दुर्घटनाग्रस्त हो जाएगी (ऊपर के रूप में एक ही त्रुटि के साथ)।
यदि हटाए गए सबस्ट्रिंग के बाद है #, तो यह #ट्रैक के अंत से भी डिस्कनेक्ट हो जाएगा (और संभवतः प्रवेश बिंदु से ट्रैक की शुरुआत भी $)। तो फिर से वही त्रुटि।

वास्तविक कार्यक्रम के लिए: प्रत्येक रेल कार्यक्रम के $'main'लिए फ़ंक्शन में प्रवेश बिंदु के रूप में एक (या एक लंबा संस्करण है, लेकिन हम यहां गोल्फ कर रहे हैं) और ट्रेन $दक्षिण-पूर्व में शुरू होती है । उस पहली लाइन पर सब कुछ ट्रैक का हिस्सा हो सकता है, इसलिए 'main'ट्रैक को हटाना है:

$          #
 -[world]o/

-और /बस रेल के टुकड़े जो हम ट्रेन उन 45 डिग्री बारी-बारी से जाने की जरूरत है।

[world]स्ट्रिंग को धकेलता है worldऔर उसे oप्रिंट करता है। #ट्रैक के अंत को चिह्नित करता है - एक रेल कार्यक्रम को सुरक्षित रूप से समाप्त करने का एकमात्र तरीका।

दिलचस्प है, यह समाधान केवल संभव है क्योंकि रेल पटरियों को mainलाइन से गुजरने की अनुमति देता है - यदि यह संभव नहीं था #तो पहली नई लाइन के बाद होगा और कोड को हमेशा छोटा किया जा सकता है

$'main'
 #

जो एक वैध कार्यक्रम है जो कुछ भी नहीं करता है। (बीच में गैर-स्थान वर्ण 'और #वह प्रभावित नहीं करेगा।)

इसके अलावा काफी रोचक: अगर मैं था golfed मुद्रण कार्य worldयह बहुत कम या सरल नहीं होता:

$'main'
 -[world]o#

— मार्टिन एंडर
स्रोत

4

क्या होगा अगर मैं [और] के बीच कोई चार हटा दूं?

— मार्टिन लुत्के

@ MartinLütke यह डिस्कनेक्ट हो जाएगा /से #।

— मार्टिन एंडर

2

@ MartinLütke आप केवल कोष्ठकों को हटा नहीं सकते क्योंकि वे सन्निहित नहीं हैं।

— केल्विन के शौक

क्या होगा अगर दो लाइनों के बीच की नई रेखा को हटा दें?

— वि।

1

@Vi। यह $ट्रैक के शुरू होने से डिस्कनेक्ट होता है , इसलिए ट्रेन तुरंत दुर्घटनाग्रस्त हो जाती है (रेल को उम्मीद है कि ट्रैक दक्षिण-पूर्व को जारी रखेगा $)।

— मार्टिन एंडर

43

Funciton ( 186 136 बाइट्स UTF-16 में)

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

यह कार्यक्रम "दुनिया" छापता है।

इससे जो भी सबस्ट्रिंग आप निकालते हैं, वह इसे एक पूर्ण बॉक्स होने से रोक देगा, जिसके बारे में पार्सर शिकायत करेगा। एकमात्र संभव निष्कासन जो एक पूर्ण बॉक्स छोड़ते हैं:

 ╔══════════════╗
|║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)
|╚══════════════╝

इनमें से अधिकांश बॉक्स के शीर्ष दाईं ओर झूलने वाले छोर को हटा देते हैं, जो आउटपुट कनेक्टर है। इस ढीले अंत के बिना, बॉक्स सिर्फ एक टिप्पणी है:

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

यह अब एक वैध कार्यक्रम नहीं है क्योंकि पार्सर बिल्कुल एक आउटपुट के साथ एक कार्यक्रम की उम्मीद करता है:

त्रुटि: स्रोत फ़ाइलों में प्रोग्राम नहीं होता है (प्रोग्राम में आउटपुट होना चाहिए)।

एकमात्र संभावना जो आउटपुट कनेक्टर को छोड़ती है, उपरोक्त में से अंतिम एक है, जो इसे छोड़ देती है:

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

हालाँकि, यह संख्या फ़नसिटॉन के गूढ़ UTF-21 में एक वैध यूनिकोड स्ट्रिंग को एनकोड नहीं करती है। इसे चलाने का प्रयास करें, आपको मिलता है:

अखंडित अपवाद: System.ArgumentOutOfRangeException: एक मान्य UTF32 मान 0x000000 और 0x10ffff, समावेशी के बीच है, और इसमें सरोगेट कोडपॉइंट मान (0x00x800 / 0x00dfff) शामिल नहीं होने चाहिए।

इसलिए, यह कार्यक्रम प्राचीन है।

— Timwi
स्रोत

3

मुझे लगता है कि आप पिछले मामले पर भाग्यशाली हो गए (ऐसा नहीं है कि यह गलती से एक वैध यूनिकोड अनुक्रम प्राप्त करना आसान है, लेकिन फिर भी ...)

— फल

34

दृश्य C ++ - 96 95 बाइट्स

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

गुण:

आप int main()संकलित त्रुटि के बिना किसी भी भाग को नहीं निकाल सकते ।
आप मैक्रो के विस्तार को संशोधित नहीं कर सकते हैं aसब पर, सभी साधनों को हटाने से main()कभी नहीं मिलता है {, bसभी साधनों को हटाने से हमारी लाइन समाप्त नहीं होती है ;, हटाने का <मतलब है कि std::cout<'w'एक त्रुटि होती है, और <<कारणों को दूर करनाstd::cout'w' , 'w''o'आदि
आप मैक्रो परिभाषा या इनवोकेशन से मापदंडों को नहीं हटा सकते हैं, परिभाषा के लिए एकमात्र वैध नाम होगा I(a), I(b)जो कभी मेल नहीं खाता और Iजो पहले फैलता है (; दूसरी ओर I(,कारणों का उपयोग करते हुए<<<< , और ,)अर्ध-बृहदान्त्र (किसी अन्य त्रुटि को छोड़कर) को गिरा देता है।
आप std::coutबिना किसी अग्रणी भाग के सभी का हिस्सा नहीं निकाल सकते<< , और इसलिए #include<iostream>संकलन त्रुटि के बिना शुरुआत में किसी को भी हटा नहीं सकते हैं ।
आप किसी एकल वर्ण का कोई भाग नहीं निकाल सकते, '' एक खाली चरित्र त्रुटि है और 'w,, आदि ... एक चरित्र में सब कुछ बनाने की कोशिश करें।
आप बहुत सारे )या (दूसरी तरफ जाने के बिना किसी मैक्रो के बाईं / दाईं ओर को हटा नहीं सकते हैं , जैसे आप चीजों को नहीं कर सकतेI('w',I('r' ।

विजुअल C ++ का उपयोग करके ऑनलाइन संकलित करें ।

एक बार फिर यह एक संपूर्ण प्रमाण नहीं है। अगर आपको लगता है कि आप इसे प्राप्त कर सकते हैं तो बिना सेक्शन के भी काम कर सकते हैं।

पिछले संस्करणों ने काफी अलग दृष्टिकोण का उपयोग किया था और साबित नहीं किया गया था कि मैं प्राचीन नहीं था इसलिए मैंने उन अंकों को हटा दिया है।

सत्यापन:

निम्न प्रोग्राम ने पुष्टि की है कि यह संस्करण clविजुअल C ++ 2010 से संकलक का उपयोग करने वाला प्राचीन है । इच्छा थी कि मैं जल्द ही इसे लिखने के लिए परेशान हो:

#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!";
}

— लीनुस
स्रोत

1

हम ध्यान दें कि जबकि यह इस संकलक पर प्राचीन है, सभी संकलक पर ऐसा नहीं है।

— जोशुआ

1

कृपया एक उदाहरण दें ....

— Linus

3

कुछ संकलक पर खाली C ++ प्रोग्राम एक प्रोग्राम देता है जो कुछ भी नहीं करता है। Iostream के कार्यान्वयन के आधार पर, #include <iostream> भी संकलित हो सकता है।

— जोशुआ

5

@ जोशुआ केवल 1 या उससे अधिक लंबाई के सबप्रोग्राम हैं, इसलिए यह अप्रासंगिक है कि खाली कार्यक्रम क्या करता है।

— ThisSuitIsBlackNot

2

@Comintern, वास्तव में नहीं। यदि आप निष्पादन योग्य को चलाने के लिए बॉक्स की जांच नहीं करते हैं, तो /cविकल्प स्वचालित रूप से शामिल है और यह संकलन करता है (जैसे कि एक पुस्तकालय बना रहा है और एक कार्यक्रम नहीं)। यदि आप रन बॉक्स की जांच करते हैं कि साइट में शामिल नहीं है /c, तो आपको एक सफलता संदेश नहीं मिलेगा, और इसके बजाय प्राकृतिक "लिंक: घातक त्रुटि LNK1561: प्रवेश बिंदु को परिभाषित करना होगा"।

— लाइनस

32

पायथन 3, 79 33

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

open(1,'w')मानक आउटपुट खोलता है, फिर हम स्ट्रिंग प्रिंट करते हैं। writeलिखे गए वर्णों की संख्या लौटाता है। यह सबस्ट्रिंग हटाने के खिलाफ सख्त करने के लिए उपयोग किया जाता है: स्ट्रिंग के हिस्से को हटाने से 5 के अलावा कुछ और वापस आ जाता है, और 5 माइनस उस मूल्य का सही मूल्यांकन करता है। लेकिन इसका कारण है कि ifसभी को निष्पादित किया जाता है और aअपरिभाषित होता है।

यह एंडर्स कासोर्ग की चतुर प्राचीन रानी पर आधारित है ।

जैसा कि केवल एक बयान को सत्यापित करने की आवश्यकता है यह पुराने समाधान की तुलना में बहुत कम है, लेकिन सामान्य रूप से भी कम है।

पुराना समाधान:

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

यह सत्यापित करने के लिए कि यह वास्तव में एक प्राचीन कार्यक्रम है:

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

कुछ मुख्य बिंदु:

प्रत्येक निष्पादित विवरण को हटाया जा सकता है। जिसे सत्यापित qकिया गया है, उसके बाहर एक बयान की आवश्यकता है q। tryहल करती है कि अच्छी तरह से, कम से कम दो बयान, की आवश्यकता के द्वारा न तो जिनमें से पूरी तरह से नष्ट कर दिया जा सकता है।
जो सत्यापन qकिया गया है rवह अंत में मूल्यांकन करके होता है ।
यह सत्यापित करना कि qसंशोधित नहीं किया गया था eval(q[17:]), जिसे निष्पादित करने के Noneलिए मूल्यांकन करना है q।
ifहालत थोड़ी सूझबूझ से काम सही पाने के लिए है। यह सुनिश्चित करने के लिए कि इसका मूल्यांकन किया गया था e, इसमें सेटिंग का अच्छा दुष्प्रभाव है , जिसे सेट करने की आवश्यकता है r। (यही कारण है कि मैंने पायथन 3 का उपयोग किया, exprएक फ़ंक्शन अभिव्यक्ति-स्तर के साइड इफेक्ट्स के लिए चमत्कार करता है।)

— फिलिप
स्रोत

इस चुनौती को दूर करने के लिए कोई वाक्यविन्यास त्रुटि नहीं होगी? आप रनटाइम त्रुटियों को भड़काने लगते हैं।

— मार्टिन लुत्के 22

5

@ मार्टिनल्यूके किसी भी प्रकार की त्रुटियां ठीक हैं।

— केल्विन के शौक

1

उम, यह 79 बाइट्स नहीं है?

— मैट

@ TheMatt हाँ? मैंने उन्हें फिर से गिना और आप सही लग रहे हैं। शायद पास्ट-मी ने CRLF की नई सूचियाँ गिनाईं ... कितना शर्मनाक। धन्यवाद!

— फिलिप

25

हास्केल, 61

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

किसी भी प्रकार की त्रुटि ठीक है? उस स्तिथि में:

हास्केल, 39

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

— मार्टिन लुटके
स्रोत

यदि आप एक अक्षर को हटाते हैं तो क्या यह काम करता है?

— रात

यह निष्पादन के दौरान दुर्घटनाग्रस्त हो जाएगा। क्योंकि यह अपरिभाषित का मूल्यांकन करने की कोशिश करेगा।

— मार्टिन लुत्के

यह उत्कृष्ट है। आलसी मूल्यांकन FTW, ऐसा प्रतीत होता है!

— DLosc

1

मैं चाहता हूँ कि 'इनिट्स' प्रस्तावना में था :(। फिर: मुख्य = पुस्ट्र $ $ इनिट्स "वर्ल्ड" !! 5 (27 बाइट्स)

— मार्टिन लुत्के

16

जावास्क्रिप्ट, 74 73 35 बाइट्स

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

यह पता चला है कि जितना मैंने सोचा था उसका उत्तर बहुत सरल था ...

व्याख्या

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

— user81655
स्रोत

को छोड़कर सब कुछ हटा दें a="world", त्रुटि नहीं करता है

— aoksquirrel

3

@anOKsquirrel केवल एक एकल प्रतिस्थापन को हटाया जा सकता है।

— डेनिस

4

मैं इस तरह के माध्यम से चला गया "क्या मैं इसे हटा सकता हूं? नहीं, यह त्रुटि उत्पन्न होगी। क्या इसे हटाया जा सकता है? ठीक है, मुझे लगता है कि यह इस अन्य त्रुटि का कारण होगा। अहा! उन वर्णों को हटाया जा सकता है! ओह प्रतीक्षा करें ..." +1

— ETHproductions

if(a="world")["bol"+a[4]]त्रुटि नहीं करता है।

— anoksquirrel

4

पवित्र गाय, यह अब दुगना प्रभावशाली है! काश मैं फिर से +1 कर

— पाता

15

जावा 8, 301 बाइट्स

क्योंकि हर प्रश्न के लिए जावा उत्तर की आवश्यकता होती है।

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

विस्तारित

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

व्याख्या

public static main(String[]a){} आवश्यक है।
यदि फ़ील्ड घोषणाएँ हटा दी जाती हैं (या गैर-स्थिर बनाई जाती हैं), तो पहला स्थिर ब्लॉक उन्हें नहीं मिल सकता है।
यदि स्थैतिक ब्लॉक को हटा दिया जाता है (या गैर-स्थिर बनाया जाता है), तो फ़ील्ड को आरंभीकृत नहीं किया जाता है।

कठोर हिस्सा:

यदि finalकीवर्ड हटा दिया जाता है, तो दूसरी पंक्ति इसका मूल्यांकन करती है 1/(8-8), जिससे / by zeroअपवाद होता है।

— Ypnypn
स्रोत

आप किसी भी प्रिंट स्टेटमेंट के इनसाइड को क्यों नहीं हटा सकते?

— निक हार्टले

2

@QPaysTaxes कोई रिक्त System.out.print()पद्धति नहीं है। के लिए है println(), लेकिन के लिए नहीं है print()। इसलिए यदि आप हटाएंगे तो d='d'यह The method print(boolean) in the type PrintStream is not applicable for the arguments ()त्रुटि के रूप में देगा (और यदि आप इसे हटा d=देंगे तो यह The blank final field d may not have been initializedत्रुटि के रूप में होगा )।

— केविन क्रूज़सेन

15

फंकिटॉन , 143 142 136 बाइट्स

स्कोर हमेशा की तरह UTF-8 में है, क्योंकि UTF-16 दो बाइट्स (BOM के कारण) बड़ा होगा।

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

इसलिए, मैं कुछ समय के लिए एक फंसीटॉन जवाब पर विचार कर रहा हूं और मुझे लगा कि यह असंभव होगा, क्योंकि आप हमेशा एक पूरी लाइन निकाल सकते हैं और कोड अभी भी एक वैध ब्लॉक बनाएगा। फिर मैंने इसके बारे में टिमवी से बात की, और वह समझ गया कि आप पूरे नंबर को एक ही लाइन में रख सकते हैं, जैसे कि इसे हटाने से आउटपुट कनेक्टर की कमी के कारण प्रोग्राम टूट जाएगा।

लेकिन एक ही लाइन पर शाब्दिक रूप से काफी महंगे हैं, क्योंकि दोनों बड़े वर्ण गणना के कारण और गैर-ASIIII वर्णों की बड़ी संख्या के कारण। और "खाली टिप्पणी" ब्लॉक के उनके उल्लेख ने मुझे सोच में डाल दिया ...

इसलिए मैं इस और अधिक कुशल समाधान के साथ आया, जो एक अतिरिक्त खाली टिप्पणी ब्लॉक का उपयोग करता है, जो तब टूट जाता है जब आप कुछ भी हटाने की कोशिश करते हैं जो कि शाब्दिक ब्लॉक को छोड़ देगा:

हम संभवतः तीसरी पंक्ति नहीं निकाल सकते, क्योंकि तब हम आउटपुट कनेक्टर को हटा देंगे।
यदि हम दूसरी पंक्ति को हटाते हैं, तो टिप्पणी ब्लॉक अपनी शीर्ष बढ़त खो देता है और टूट जाता है।

यह दो विकल्प छोड़ता है ( स्टीव को धन्यवाद कि बाहर इशारा करने के लिए):

चौथी लाइन निकालें। जो दोनों बक्सों को चातुर्य में छोड़ देता है। हालाँकि, जब परिणामी पूर्णांक 19342823075080880373विघटित हो जाता है, तो संबंधित स्ट्रिंग में कोड बिंदु होगा 0x18D53Bजो कि एक वैध यूनिकोड वर्ण नहीं है, System.Char.ConvertFromUtf32एक के साथ क्रैश होता है ArgumentOutOfRangeException।
ऊपरी-दाएँ कोने के बाद शुरू होने वाली एक पूरी लाइन निकालें। फिर से, दोनों बॉक्सों को चातुर्य में छोड़ दिया जाता है, लेकिन परिणामी पूर्णांक 508088037380718711में दो अमान्य कोड बिंदु होंगे 0x1B0635और 0x140077, एक ही अपवाद के लिए अग्रणी होंगे।

ध्यान दें कि खाली टिप्पणी ब्लॉक के बिना भी, दूसरी पंक्ति को हटाने से अमान्य कोड बिंदु बन जाएगा। लेकिन टिप्पणी ब्लॉक रोकता है कि हम दूसरी पंक्ति के अंदर से एक लाइन ले रहे हैं , 193428037380718711उदाहरण के लिए एक पूर्णांक प्राप्त करने के लिए, जो त्रुटि का कारण नहीं होगा।

— मार्टिन एंडर
स्रोत

क्या होता है अगर आप आउटपुट कनेक्टर के बाद कैरेक्टर से शुरू होने वाली सबस्ट्रिंग को हटा देते हैं और ठीक 1 लाइन बाद में खत्म करते हैं? यानी टिप्पणी ब्लॉक की मध्य रेखा और मुख्य ब्लॉक में "80718711" वाली लाइन को हटाना, लेकिन दोनों बक्से के कोनों को बरकरार रखना।

— स्टीव

@ मैं उस मामले को कवर करने के लिए उत्तर में संशोधन कर चुका हूं। इसे थोड़ा और देखने के बाद, इसने मुझे वास्तव में दो वर्णों / छह बाइट्स को बचाने की अनुमति दी।

— मार्टिन एंडर

10

रूबी, ३६

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

हम असाइन करते हैं s="planet", फिर उस स्ट्रिंग को STDOUT पर लिखते हैं। यह लिखे गए वर्णों की संख्या लौटाता है। हम 6 के साथ xor करते हैं, ताकि यदि 6 वर्णों के अलावा कुछ भी लिखा गया हो, तो हमें एक नॉनजरो पूर्णांक मिलेगा। फिर हम sउस इंडेक्स के साथ स्लाइस करते हैं । s"पी" का केवल 0 वां वर्ण , एक मान्य कोड स्ट्रिंग (एक नो-ऑप) है। हम सिंटैक्स evalका उपयोग करते हुए उसे पास करते हैं , (*[argument])जो कि बस के बराबर है(argument) इसके सिवाय इसके कि यह एक विधि कॉल के बाहर मान्य नहीं है।

रूबी 1.9.3 और 2.2 पर प्राचीनता ने प्रोग्रामेटिक रूप से सत्यापित किया

— histocrat
स्रोत

बकवास। ये अद्भुत है।

— क्लैप

यदि आप हटा दें तो क्या होगा *?

— लीजनमोनमाल 978

तब आप एक स्ट्रिंग के बजाय एक सरणी से गुजर रहे हैं, जो एक तर्क है।

— हिस्टोक्रेट

9

सी #, 128 118 101 बाइट्स

नियम के स्थानापन्न नियम का दुरुपयोग करने की बात कही।

कोड

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

क्यों यह काम करता है

class hऔर static void Main()आवश्यक हैं।
किसी भी वर्ण को हटाने से 'w','o','r','l','d'त्रुटि हो जाती है क्योंकि वर्ण सरणी लंबाई के साथ प्रारंभ होती है 1*5।
आप मुख्य () के अंदर की सामग्री को सन्निहित चरित्र नियम का उल्लंघन किए बिना हटा नहीं सकते क्योंकि भागों को प्रीप्रोक द्वारा अलग किया जाता है। (निचे देखो)

गोल्फ और जुदाई से पहले

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

के साथ सत्यापित

https://ideone.com/wEdB54

संपादित करें:

के #if !xबजाय का उपयोग करके कुछ बाइट्स बचाता है #if x #else।
प्रयुक्त =>फंक सिंटैक्स। #if!xके बजाय #if !x। क्रेडिट @JohnBot को।
=>फंक सिंटैक्स के कारण , अतिरिक्त प्रीप्रोक स्थिति को हटाया जा सकता है।

— हेलिक्स क्वार
स्रोत

हाय हेलिक्स! क्या आपको लगता है कि आप समझा सकते हैं कि आपका उत्तर कैसे और क्यों थोड़ा अधिक काम करता है?

— isaacg

@ आइसाकग संपादित अनुसरण करने का प्रमाण।

— हेलिक्स क्वार

मैं इसे बिना staticपर चलने के लिए प्राप्त नहीं कर सकता Main।

— जॉनबोट

@ जॉनहॉट यस। गर्भपात होना चाहिए। फिक्स्ड।

— हेलिक्स क्वार

आप बनाकर एक चरित्र को बचा सकता है Mainएक अभिव्यक्ति शरीर समारोह सदस्य पूर्वप्रक्रमक हालत से पहले रिक्त स्थानों को हटाकर और 2 अधिक:

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

। वह मेरी गिनती से 115 है।

— जॉनबोट

9

MATLAB, 37 36 33 बाइट्स

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

चूँकि मुझे यकीन नहीं है कि अगर हमें ans = को भी आउटपुट करने की अनुमति है , तो मुझे उचित तरीके से आउटपुट के लिए कुछ काम-काज खोजने होंगे। अपने आप से fprintf का उपयोग करने से काम नहीं चला, क्योंकि कोई बात नहीं मैंने जो भी कोशिश की उसे बस त्रुटि से इनकार कर दिया। का उपयोग करते हुए disp ही एक विकल्प नहीं था द्वारा, के रूप में यह केवल 1 तर्क ले जाएगा और उस कथन की ही स्पष्ट रूप से भी त्रुटियों के बिना निष्पादित होगा।

यदि इसे an = = आउटपुट में शामिल करने में कोई समस्या नहीं है , तो MATLAB को 20 बाइट्स के साथ किया जा सकता है :

reshape('world',1,5)

— slvrbld
स्रोत

मुझे वास्तव में बिल्ट-इन फ़ंक्शंस (+1) // के बारे में अधिक जानकारी प्राप्त करनी चाहिए। btw आपके कार्यक्रम को 20 रन दिए गए हैं

— Abr001am

2

यह वास्तव में इस बात पर निर्भर करता है कि नियम कितने सख्त हैं। वे कहते हैं कि केवल 'दुनिया' (+ वैकल्पिक अनुगामी न्यूलाइन) को मुद्रित किया जाना चाहिए, इसलिए यह 33 बाइट्स है।

— slvrbld

हाँ, हम इसे 33 के रूप में गिनेंगे। समझ के लिए धन्यवाद :)

— केल्विन के शौक

9

> <> , 17 बाइट्स

e"ooooo7-c0pBhtra

इसे ऑनलाइन आज़माएं!

प्रिंट "पृथ्वी"।

जिस तरह से एक ><>प्रोग्राम एक त्रुटि के बिना बाहर निकलता है वह ;चरित्र निष्पादित कर रहा है, जो एक समस्या है क्योंकि आप उससे पहले सभी पात्रों को हटा सकते हैं, इसलिए यह ;पहला चरित्र निष्पादित है। आप इसके बजाय निष्पादन के दौरान pशामिल करने के लिए प्रोग्राम को संशोधित करने के लिए कमांड का उपयोग करके चारों ओर प्राप्त कर सकते हैं ;। कोड के किसी भी भाग को हटाने का कारण बनता है कि ;कभी भी अवैध निर्देशों के कारण त्रुटियों का उत्पादन नहीं किया जाना चाहिए B, hऔर t, स्टैक अंडरफ्लो, और अनंत लूप यह अंततः स्मृति से बाहर निकलते हैं। मुझे केवल यह सुनिश्चित करना था कि सभी अनंत लूप ढेर को भरते रहें।

इस अजगर स्निपेट के उपयोग से सभी प्रकारों का परीक्षण किया गया:

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

को जोड़ा गया (थोड़ा संशोधित संस्करण) > <> के निर्माता द्वारा आधिकारिक फिशडैम इंटरप्रेटर। 152 संभावित उप-कार्यक्रमों में से 92, अवैध निर्देशों से गलत, 18 स्टैक अंडरफ्लो से, और 42 मेमोरी से बाहर चलने से।

मजेदार तथ्य, इस के पहले संस्करण में e"ooooo6-c0pAhtraकुछ फ्रीक उप-प्रोग्राम थे जो कि पुट कमांड का उपयोग करने में कामयाब रहे [, जो कि अमान्य निर्देश के स्थान पर स्टैक को साफ कर देगा A। इसके अलावा, "पृथ्वी" केवल वाक्यांशों में से एक है जो इस पद्धति के साथ काम करेगा, क्योंकि पहला अक्षर, eएक मान्य निर्देश है ><>। अन्यथा "कमांड को कार्यक्रम के सामने रखा जाना चाहिए, और एक वैध उपप्रोग्राम सिर्फ "अपने आप से हो सकता है।

— मजाक कर रहा है
स्रोत

8

रूबी, ३४

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

इसके कुछ घटक हैं:

eval(*[ expr ]) को histocrat के उत्तर से उधार लिया जाता है , और यह प्राचीन होने के साथ-साथ expr के रिटर्न मूल्य की पुष्टि करने वाला एक वैध रूबी प्रोग्राम है जो त्रुटि नहीं करता है। method(*arr)एक रूबी सिंटैक्स है जो तर्कों methodके मूल्यों के साथ कहता arrहै। यहां इसकी आवश्यकता इसलिए है क्योंकि यह केवल एक विधि के लिए मापदंडों के रूप में मान्य है, ताकि यदि evalहटा दिया जाए, तो (*[expr])एक सिंटैक्स त्रुटि है। अगर एक्सपायर को हटा दिया जाता है, तो evalपर्याप्त तर्क नहीं होने की शिकायत करता है

$>.write("world")-1स्ट्रिंग और घटाव के अंदर के अलावा मंगाई नहीं जा सकती। $>.write("world")STDOUT में "दुनिया" लिखता है और लिखे गए वर्णों की संख्या लौटाता है, फिर घटाता है। 1. इसके अलावा अगर कार्यक्रम संयुक्त राष्ट्र का है तो मान बिल्कुल 4 होगा । यदि इसे मंगवाया गया -1है (या तो हटा दिया गया है या स्ट्रिंग छोटा कर दिया गया है) तो यह -1,0,1,2,3, या 5 में से एक को लौटाएगा । सिंटैक्स त्रुटि में कोई भी अन्य मैनलिंग परिणाम।

chrकिसी नंबर पर कॉल करना उस नंबर द्वारा दर्शाए गए वर्ण को वापस करता है। इसलिए, जब उपरोक्त उदाहरण के परिणाम पर कहा जाता है, तो यह -1 पर त्रुटियां करता है, और अन्यथा एकल-वर्ण स्ट्रिंग लौटाता है।

मुझे वास्तव में यकीन नहीं है कि ऐसा क्यों है, लेकिन ऐसा लगता है कि रूबी \x04एक व्हाट्सएप चरित्र के रूप में व्याख्या करता है, जिसका अर्थ है कि अभिव्यक्ति वैध है (खाली रूबी कार्यक्रम कुछ भी नहीं करते हैं)। हालाँकि, किसी भी अन्य वर्ण ( \x00- \x03और \x05) में परिणाम है Invalid char '\x01' in expression। मुझे लगता है कि यह संभव गणित पर पुनरावृत्ति करके मैंने पाया कि मैं लौट आए नंबर पर कर सकता हूं। पहले मैंने इस्तेमाल किया था

$>.write("planet
")*16

जहां "ग्रह" प्लस एक नई पंक्ति 7 वर्ण, 16 बार 112 प्राप्त करने के लिए था p, डिफ़ॉल्ट रूप से परिभाषित रूबी में एकमात्र एकल-अक्षर फ़ंक्शन। जब कोई तर्क नहीं दिया जाता है, तो यह प्रभावी रूप से एक विकल्प नहीं है

माननीय उल्लेख: $><<"%c"*5%%w(w o r l d)बहुत करीब है, लेकिन प्राचीन नहीं है। "%c"*5%बिना किसी त्रुटि के परिणाम निकालना । मिनी स्पष्टीकरण:

$>स्टडआउट है, और इस <<पर एक फ़ंक्शन कहा जा रहा है। "%c"*5स्वरूप स्ट्रिंग उत्पन्न करता है "%c%c%c%c%c", जो तब %एक सरणी द्वारा स्वरूपित ( ) करने की कोशिश %w(w o r l d)करता है : जो कि एक छोटा संस्करण है ['w','o','r','l','d']। यदि सरणी में बहुत कम या बहुत सारे तत्व हैं जैसे कि यह प्रारूप स्ट्रिंग से मेल नहीं खाता है, तो एक त्रुटि है। एच्लीस हील वह है "%c"*5, और %w(w o r l d)दोनों स्वतंत्र रूप से मौजूद हो सकते हैं, और $><<केवल एक तर्क की आवश्यकता है। इसलिए इस कार्यक्रम को गैर-गलत तरीके से चचेरे भाई में करने के कुछ अलग तरीके हैं।

इसका उपयोग करके मान्य:

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

— Shelvacu
स्रोत

हिस्टोक्रेट के उत्तर की तर्ज पर एक स्पष्टीकरण अच्छा होगा। ऐसा लगता है कि आप एक ही मूल दृष्टिकोण का उपयोग कर रहे हैं, लेकिन जब से मैं रूबी को नहीं जानता, मैं विवरण नहीं समझ सकता।

— ThisSuitIsBlackNot

@ThisSuitIsBlackNot मेरा सबसे अच्छा, कुछ भी आप समझ में नहीं आया?

— शेल्वैकु

बहुत बढ़िया स्पष्टीकरण, धन्यवाद!

— ThisSuitIsBlackNot 20

6

पायथन 3 , 43 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

सबस्ट्रिंग विलोपन से बचाने के लिए, हम open(1,"w").writeइसके बजाय उपयोग करते हैं print। पायथन 3 में, writeलिखित वर्णों की संख्या लौटाता है, जिसे हम सत्यापित करेंगे 5कि यह सुनिश्चित करना है कि स्ट्रिंग का कोई भी हिस्सा हटाया नहीं गया था। हम इसे शब्दकोश में वापसी मान को देखते हुए करते हैं {5:[]}, और परिणाम के साथ लूपिंग करते हैं for[]in…:a, जो विफल हो जाएगा अगर हमें खाली चलने योग्य नहीं मिला या यदि forकथन हटा दिया गया है।

— एंडर्स कसीर्ग
स्रोत

4

जावास्क्रिप्ट (Node.js), 93 95 बाइट्स

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

जाँच करें कि यह दो बार अपने आकार का है, यदि कोई चार्ट गायब है तो कोई त्रुटि है। लंबाई 156 है क्योंकि Node.js function (exports, require, module, __filename, __dirname) {रनटाइम पर कोड के लिए प्रस्तुत करता है।

एक त्रुटि की ओर इशारा करने के लिए धन्यवाद मार्टिन बटनर। अब तय हो गया।

— Naouak
स्रोत

4

पर्ल 5.10+, 71 63 बाइट्स

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

worldएक अनुगामी newline के साथ प्रिंट । इस तरह से चलाएं:

perl -M5.010 file

यह स्रोत कोड के बाइट काउंट पर निर्भर करता है, इसलिए fileइसमें उपरोक्त कोड और कुछ नहीं होना चाहिए (कोई शेबंग, कोई अनुवर्ती रेखा नहीं)। पर्ल 5.10+ के लिए sayऔर परिभाषित या ऑपरेटर के लिए आवश्यक है //।

पर्ल के साथ एक प्राचीन कार्यक्रम बनाना अविश्वसनीय रूप से कठिन है, क्योंकि:

किसी भी bareword पहचानकर्ता (जैसे foo, a, _) के साथ एक मान्य बयान है no strict 'subs';(डिफ़ॉल्ट)। इसका मतलब यह है कि कार्यक्रम एक पत्र, संख्या, या अंडरस्कोर के साथ न तो शुरू हो सकता है और न ही समाप्त हो सकता है।
के रूप में tchrist बताते हैं , "प्रतीकात्मक dereferencing के माध्यम से निर्दिष्ट पहचानकर्ताओं को उनके नामों पर कोई प्रतिबंध नहीं है ।" इसका मतलब यह है कार्यक्रम sigils से किसी के साथ शुरू नहीं कर सकते $, @, %, या *, लेकिन पहली और आखिरी चरित्र सब को दूर करने के बाद हमेशा के लिए एक वैध चर नाम छोड़ना होगा।
कई अंतर्निहित फ़ंक्शंस (आउटपुट को बनाने में सक्षम अधिकांश फ़ंक्शंस सहित) $_डिफ़ॉल्ट रूप से काम करते हैं , इसलिए कॉल अक्सर काम करेंगे भले ही आप तर्क को हटा दें (जैसे say"world"बनाम say।)।

यह काम किस प्रकार करता है

यह समाधान Naouak के Node.js उत्तर से प्रेरित था , जो यह सुनिश्चित करने के लिए अपनी स्वयं की लंबाई की जाँच करता है कि वर्ण हटाए नहीं गए हैं।

कार्यक्रम में दो खंड होते हैं, एक कोष्ठक के अंदर और दूसरा एक खंड के अंदर:

(...);{...}

पहला खंड स्रोत फ़ाइल पढ़ता है और मर जाता है अगर यह 63 वर्णों से कम लंबा हो। दूसरा खंड जांचता है कि readसफलतापूर्वक निष्पादित। यदि या तो अनुभाग हटा दिया जाता है (कोष्ठक या घुंघराले ब्रेसिज़ के साथ या इसके बिना), तो दूसरा खंड अपवाद फेंक देगा।

कार्यक्रम के मध्य या बाएँ या दाएँ पक्ष को हटाने से कोष्ठक और / या घुंघराले ब्रेस असंतुलित हो जाएगा, जिससे वाक्य रचना त्रुटि हो जाएगी।

पहले तो dieबदल दिया जाता है (करने के लिए d, e, di, de, या ieहै, जो सभी वैध पहचानकर्ता हैं), लंबाई की जांच हो जाता है:

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

जो इसका मूल्यांकन करता है:

@{\'di'};

यह एक स्ट्रिंग का संदर्भ लेता है और एक त्रुटि के रूप में इसे सरणी के रूप में संक्षिप्त करने की कोशिश करता है:

Not an ARRAY reference

यदि कोई अन्य बयान बदल दिया जाता है, तो लंबाई की जांच विफल हो जाएगी और कार्यक्रम मर जाएगा।

निम्नलिखित कार्यक्रम के साथ सत्यापित प्राचीन:

#!/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}

— ThisSuitIsBlackNot
स्रोत

4

रूबी + कोरुटिल्स, 33 27 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

रूबी में बैकटिक्स उनके अंदर कमांड को निष्पादित करता है और जो भी प्रोग्राम एक स्ट्रिंग के रूप में STDOUT में वापस आता है। #{expr}वाक्य रचना तार और बैकटिक में अभिव्यक्ति की embedding अनुमति देता है। इस कार्यक्रम को फिर से लिखा जा सकता है (गैर-प्रमुख रूप से):

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

IO#writeलिखित बाइट्स की संख्या लौटाता है, इसलिए यदि स्ट्रिंग को छोटा किया जाता है तो यह सही संख्या नहीं होगी। #{}स्वचालित रूप से एम्बेड करना एक स्ट्रिंग में संख्या बनाता है। यदि कुछ टुकड़ा हटा दिया जाता है, और इसका सिंटैक्स त्रुटि नहीं होता है, तो गलत कमांड चलाया जाएगा। यदि "world"के base04माध्यम से हटाया जाता है के माध्यम base54से चलाने की कोशिश करेंगे।

नई पंक्ति, चाहे वह स्ट्रिंग के अंदर हो या बाहर, आवश्यक है। अन्यथा पहले 5 अक्षरों ( `base) को हटाया जा सकता है, जिससे पूरी पंक्ति एक टिप्पणी बन जाती है। इसके अलावा वहां पहले बैकटिक और के बीच एक या अधिक अक्षरों का होना चाहिए #, अन्यथा {पूरी बात एक बनाने के लिए भी निकल जाते हैं कर सकते हैं खोल टिप्पणी।

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

execनिर्दिष्ट आदेश के साथ वर्तमान रूबी प्रक्रिया को बदलता है। वाक्यविन्यास की व्याख्या और इसकी विशिष्टता के लिए मेरा अन्य उत्तर देखें meth(*[])।

(s="ec%co earth") चर के लिए स्ट्रिंग "एक्% सह पृथ्वी" प्रदान करता है s । असाइनमेंट लौट आए जो असाइन किया गया था, इसलिए स्ट्रिंग भी लौटा दी गई है।

"format string %d" % 5के लिए sprintf("format string %d",5), लेकिन चारों ओर रिक्त स्थान के लिए सिंथेटिक चीनी है% neccesary नहीं हैं।

s[10]इंडेक्स में स्ट्रिंग में कैरेक्टर मिलता है। 10. अन-मैंगल्ड होने पर, यह कैरेक्टर "h" है, स्ट्रिंग में आखिरी अक्षर है। हालांकि, स्ट्रिंग में किसी भी वर्ण को हटाने का मतलब है कि स्ट्रिंग कम है, इसलिए सूचकांक 10 पर कोई चरित्र नहीं है, इसलिए s[10]रिटर्न nilऔर"%c" % nil त्रुटि का कारण बनता है।

यदि %s[10]हटा दिया जाता है, तो रूबी कमांड चलाने की कोशिश करता है ec%co earthजो काम नहीं करता है।

बदलने 10के लिए 1या 0भी एक अज्ञात आदेश में परिणाम है (या तो eceoया ecco)। इसे पूरी तरह से निकालना तकनीकी रूप से एक वाक्यविन्यास त्रुटि नहीं है क्योंकि यह #[]स्ट्रिंग पर विधि को कॉल करता है , लेकिन फिर यह पर्याप्त तर्क नहीं होने के बारे में शिकायत करता है।

इसे सामान्य रूप से हल करने पर एक नोट: आपके पास कुछ आवरण होने चाहिए जो अपने आप में प्राचीन होने के दौरान एक सार अर्थ में कोड की पुष्टि करता है। उदाहरण के लिए, अंत में विभाजन वाला एक कार्यक्रम ( blablabla/somevar) कभी काम नहीं करेगा क्योंकि एक विभाजन हमेशा हटाया जा सकता है ( blablabla)। ये कुछ ऐसे रैपर हैं जिनका मैंने अब तक इस्तेमाल किया है:

eval(*[कोड का ])उपयोग हिस्टोक्रेट द्वारा और मेरे पहले उत्तर में किया गया था। पुष्टि करता है कि आउटपुट एक वैध रूबी प्रोग्राम है
exec(*[])ऊपर उपयोग किया गया कोड , पुष्टि करता है कि प्रतिक्रिया एक मान्य कमांड है
`#{ कोड }`

बैकटिक सिंटैक्स एक कमांड भी चलाता है (और इसके लिए मान्य है कि यह एक वैध है), हालांकि STDOUT को मूल प्रक्रिया के रूप में आउटपुट होने के बजाय एक स्ट्रिंग के रूप में कैप्चर किया गया है '(Ruby's) STDOUT। ~~इसके कारण मैं इस उत्तर के लिए इसका उपयोग नहीं कर पा रहा था,~~ EDIT: मैंने इसे काम किया। ऊपर उल्लिखित सीमाएँ।

संपादित करें: कुछ खामियों को इंगित करने के लिए @histocrat का धन्यवाद

— Shelvacu
स्रोत

शांत दृष्टिकोण! आप (और इसलिए) writeस्ट्रिंग की शुरुआत और बीच की जगह को हटा सकते हैं , लेकिन मुझे नहीं लगता कि यह प्रभाव को प्रभावित करता है। इसके अलावा, मेरी मशीन पर base64इनपुट की प्रतीक्षा की जाएगी, जो नियमों के विरुद्ध हो सकता है।

— हिस्टोक्रैट

@histocrat वाह, मैं आश्चर्यचकित हूं कि $>.write"world"काम करता है, धन्यवाद! बेस 64 इनपुट की प्रतीक्षा कर रहा है, यह सिस्टम द्वारा भिन्न होता है। TIO ठीक काम करता है। यह इसे और भी अधिक अस्पष्ट बनाता है कि क्या यह नियमों का पालन करता है।

— शेल्वैकू

3

PowerShell, (97 बाइट्स + 5 प्रोग्राम के नाम के लिए) = 102 बाइट्स

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

इससे पहले कि वह खुद को मिटाए ... दो बार चेक करता है।

c.ps1स्थानीय निर्देशिका से इस तरह के रूप में सहेजे जाने और निष्पादित होने की उम्मीद है
PS C:\Tools\Scripts\Golfing\> .\c.ps1:।

उपनाम अन्य के gcलिए छोटा है Get-Contentऔर catएक फ़ाइल को पढ़ने के समान है (इस मामले में, हमारा निष्पादन पथ .\c.ps1)। हमें .Lengthफ़ाइल मिलती है , इसे सेट $aकरें और जांचें कि क्या यह 97 के बराबर नहीं है -eq97। यदि यह बराबर है (यानी, प्रोग्राम को संशोधित नहीं किया गया है), तो हम "world"अमान्य कमांड के साथ प्रिंट करते हैं , और निष्पादित करते हैं a। यह catchप्रभावी होने के लिए मजबूर करता है, जो हमें फिर से खुद को जांचने की अनुमति देता है। इस बार, यदि हमारा कोड 97 के बराबर नहीं है, तो हम एक अमान्य कमांड को फेंक देते हैं ताकि हमारे प्रोग्राम में आउटपुट के लिए त्रुटिपूर्ण और मुद्रित त्रुटि पाठ हो। हम फिर clear()त्रुटि और exitसामान्य रूप से।

यह स्पष्ट है कि यदि या तो ifबयान के साथ छेड़छाड़ की जाती है, तो दूसरे में त्रुटि होगी। यदि किसी भी हिस्से के "world";साथ छेड़छाड़ की जाती है, तो पहले ifएक त्रुटि होगी। चूँकि इसे सन्निहित होना चाहिए, हम दोनों ifकथनों को हटा नहीं सकते । मध्य में स्ट्रिंग्स के परिणामस्वरूप बेमेल कोष्ठक होंगे, या दूसरे के परिणामस्वरूप {a}निष्पादित होंगे। try/ catchपहले से त्रुटि को पकड़ने के लिए है ifबयान तो हम ठीक से साफ कर सकते हैं यह। बाहरी "$( )"छोर के तार या तो खत्म होने से छीन जाते हैं। फाइनल ;aबीच के हिस्से को छीनने से रोकने के लिए है "it}a)";a, जिसके परिणामस्वरूप वैध कार्यक्रम (जैसे , जो प्रिंट होगा it}a)और फिर त्रुटि) होगा।

कई विशेष परिस्थितियां हैं:

यदि gc, gc<space>या gc .\हटा दिया जाता है, तो कार्यक्रम अंततः मेमोरी त्रुटि के कुछ स्वाद (बार-बार आत्म-निष्पादन कॉल के कारण) के साथ त्रुटि करेगा और शेल (और शायद कंप्यूटर) को क्रैश कर देगा। टेस्ट नहीं हुआ।
यदि <space>.\c.ps1या .\c.ps1हटा दिया जाता है, तो प्रोग्राम बंद हो जाएगा और उपयोगकर्ता इनपुट के लिए संकेत देगा। कोई फर्क नहीं पड़ता कि उपयोगकर्ता क्या दर्ज करता है, फिर भी कार्यक्रम में त्रुटि होगी क्योंकि आकार की गणना गलत होगी।
यदि $अंतिम "स्थान छोड़े जाने से पहले और अंत में शुरू होने वाला एक विकल्प , प्रोग्राम जो कुछ भी रहता है उसे आउटपुट करेगा और फिर त्रुटि क्योंकि aमान्य नहीं है।

निम्नलिखित के साथ सत्यापित:

$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."

(उनकी व्यापक सहायता के लिए मार्टिन को धन्यवाद!)

— AdmBorkBork
स्रोत

3

सी (जीसीसी) (लिनक्स `-Werror=undef`), 66 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बड़ी चुनौती! यह भ्रामक रूप से कठिन था, लेकिन मुझे पूरा यकीन है कि अब मेरे पास एक वैध कार्यक्रम है!

प्रीप्रोसेसर कमांड का उपयोग करता है ताकि कोई भी नईलाइन न हटाई जा सके, क्योंकि क्लोजिंग ब्रैकेट को mainकेवल तभी शामिल किया जाता है __LINE__==6। यह आपको mainपूरी तरह से साफ करने से भी रोकता है , क्योंकि यह #endifतैरता है (इसलिए यह महत्वपूर्ण है कि #endifबाहर है main)।

मैंने इस्तेमाल किया #elseक्योंकि मैं काफी हद तक आश्वस्त हो गया हूं __LINE__==6कि इसका कोई भी संस्करण नहीं हो सकता है कि एक सबस्ट्रिंग हटा दिया जाए और अभी भी सच हो, क्योंकि दोनों 6और __LINE__खुद से सत्य हैं। यह -Werror=undefइसलिए भी उपयोग करता है कि कुछ #ifdef(LINE__)ऐसा नहीं है जो गलत का मूल्यांकन नहीं करता है, लेकिन एक त्रुटि है।

जीसीसी (लिनक्स पर, कम से कम), putsमुद्रित किए गए वर्णों की संख्या (अनुगामी न्यूलाइन सहित) puts("...")/6लौटाता है 0, इसलिए स्ट्रिंग के किसी भी हिस्से को हटाने से वापसी होती है , जिससे 1/0फ्लोटिंग पॉइंट अपवाद होता है। ध्यान दें कि यह अपवाद तब तक नहीं है जब तक 1/0कि किसी चीज़ को असाइन नहीं किया जाता है, इसलिए a=इसकी आवश्यकता है।

किसी भी लाइन के किसी अन्य भाग को त्रुटि पैदा किए बिना नहीं हटाया जा सकता है, आमतौर पर एक सिंटैक्स त्रुटि या लिंकिंग त्रुटि।

एक बोनस के रूप में, यह C ++ के लिए 86 बाइट सॉल्यूशन देता है बहुत ही मामूली, बस जोड़ें #include <cstdio>और aएक के रूप में घोषित करें int। इसे ऑनलाइन आज़माएं! (C ++)

— क्रिस
स्रोत

जब तक मैं गलत नहीं हूं, आप 1/न्यूलाइन छोड़ते समय हटा सकते हैं और यह अभी भी चलेगा ।

— गैस्ट्रोपनर

@gastropner सही आप हैं। 1मुझे विश्वास है कि पिछली लाइन पर था।

— क्रिस

दुख की बात है कि एक ही चीज धारण की जाती है। आप तब हटा सकते हैं =1। मुझे लगता है कि आपको 1 को एक लाइन पर रखने की आवश्यकता है।

— गैस्ट्रोपनर

@gastropner मुझे लगता है कि आप सही हैं। मैं बाद में और देखूंगा। धन्यवाद!

— क्रिस

2

PHP, 73 बाइट्स

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

explination

मैं डिफ़ॉल्ट php.ini कॉन्फ़िगरेशन को मानता हूं। इसलिए short_tags अक्षम है। इसका मतलब है कि आप =शुरुआती टैग से नहीं हटा सकते ।

यह मूल रूप से है <?=unserialize('s:5:"world"');।

यदि आप क्रमबद्ध स्ट्रिंग के किसी भी भाग को निकालते हैं तो आपको एक त्रुटि मिलेगी।

आप बस निकाल सकते हैं unserializeऔर स्क्रिप्ट सिर्फ क्रमबद्ध स्ट्रिंग का उत्पादन करेगी। इसे दूर करने के लिए मैं उपयोग करता हूं call_user_func। Params में से किसी एक को निकालने से कोई त्रुटि होगी।

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

हालाँकि, आप फ़ंक्शन unको कॉल करने के लिए निकाल सकते हैं serialize। तो हम 'ns` निकाल लेते हैं। किसी भी वर्ण को हटाने से कोई गलत फ़ंक्शन नाम नहीं होगा।

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

यदि हम आउटपुट टैग के साथ चर असाइनमेंट का उपयोग करने के लिए इनलाइन का उपयोग करेंगे। उपयोग करने के बजाय &&हम उपयोग करते हैं '|' एकल &को हटाने या $fअसाइनमेंट को हटाने के लिए

आप निकाल सकते हैं ='ns')&&($f="u{$p}erialize"और समाप्त कर सकते हैं ($p)?$f:''। वहाँ मैं अतिरिक्त कोष्ठक के आसपास जोड़ें $f="u{$p}erialize"।

ध्यान दें

तकनीकी रूप से आप एक त्रुटि उत्पन्न किए बिना शुरुआती टैग हटा सकते हैं। हालाँकि यह अब PHP लिपि नहीं है, बल्कि एक सादा पाठ फ़ाइल है।

— जैनी - अर्नोल्ड डेनियल
स्रोत

2

अपने अंतिम नोट के बारे में, सादा पाठ फ़ाइल अभी भी एक वैध PHP प्रोग्राम होगा, है ना? इसलिए मुझे यकीन नहीं है कि यह वैध है।

— केल्विन के शौक 5

यह अब PHP नहीं है, लेकिन प्लेनटेक्स्ट / html, इस प्रकार अब

— वैध-

1

मैटलैब (77)

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

कोशिश करो

ध्यान दें:

@ CPR या किसी चीज़ को डिज़ाइन करने के @ ऑप्टिमाइज़र की सलाह के बाद, मुझे अप्रत्याशित विकल्प का सामना करना पड़ा, जिसे हटाए जाने पर कोई संकलन त्रुटि नहीं हुई, उदाहरण: arrayfun(@(x)a(x),prod(b,ismember(4,1:5))),इस पिछले एडिट को हटाने से feval(@(a)arrayfun(@(x)a(x),prod(b,ismember(4,1:5))),'world')कोई बग उत्पन्न नहीं होता है! इसके अलावा, हाल ही के एक ही संस्करण के लिए, वहाँ थे bsxfun(@(a,b)arrayfun(@(x)(x),prod(b,ismember(4,b))),'world',1:5)और bsxfun(@(a,b)a,'world',1:5), अगर आपने पूछा कि मेरे आउटपुट कंसोल में उन्हें खोजने के दौरान मैं कैसा था, तो मैं एक बच्चे की तरह रोया, इसलिए यहां कार्यक्रम है:

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

एक गैर-कार्यक्रम का एक उदाहरण

संपादित करें:

मेरे पिछले कोड (न-त्रुटियों) को इंगित करने के लिए @Martin के पास सभी का धन्यवाद।

— Abr001am
स्रोत

1

स्माइलबासिक, 63 बाइट्स

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

— 12Me21
स्रोत

1

एक नाशपाती का पेड़ , 17 बाइट्स

इस कार्यक्रम में उच्च बिट सेट के साथ बाइट्स शामिल हैं (जो मान्य UTF-8 नहीं हैं और इस प्रकार TIO पर पोस्ट नहीं किया जा सकता है), इसलिए यहां एक xxdप्रतिवर्ती हेक्सडंप है:

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

व्याख्या

यह सिर्फ print'world'एक चेकसम संलग्न है। मैंने पाशविक बल द्वारा सत्यापित किया है कि कोई भी संभावित विलोपन एक मान्य चेकसम के साथ कोई प्रोग्राम नहीं देता है, इसलिए आपको किसी भी संभावित विलोपन के बाद त्रुटि मिलती है।

काफी उबाऊ है, लेकिन वर्तमान नेता को बाँधता है, इसलिए मुझे लगा कि यह पोस्ट करने लायक है।

— ais523
स्रोत

एक प्राचीन दुनिया प्रोग्रामिंग

रेल , 24 बाइट्स

Funciton ( 186 136 बाइट्स UTF-16 में)

दृश्य C ++ - 96 95 बाइट्स

पायथन 3, 79 33

पुराना समाधान:

हास्केल, 61

हास्केल, 39

जावास्क्रिप्ट, 74 73 35 बाइट्स

व्याख्या

जावा 8, 301 बाइट्स

विस्तारित

व्याख्या

कठोर हिस्सा:

फंकिटॉन , 143 142 136 बाइट्स

रूबी, ३६

सी #, 128 118 101 बाइट्स

MATLAB, 37 36 33 बाइट्स

> <> , 17 बाइट्स

रूबी, ३४

पायथन 3 , 43 बाइट्स

यह काम किस प्रकार करता है

जावास्क्रिप्ट (Node.js), 93 95 बाइट्स

पर्ल 5.10+, 71 63 बाइट्स

यह काम किस प्रकार करता है

रूबी + कोरुटिल्स, 33 27 26 बाइट्स

PowerShell, (97 बाइट्स + 5 प्रोग्राम के नाम के लिए) = 102 बाइट्स

सी (जीसीसी) (लिनक्स -Werror=undef), 66 बाइट्स

PHP, 73 बाइट्स

explination

ध्यान दें

मैटलैब (77)

कोशिश करो

स्माइलबासिक, 63 बाइट्स

एक नाशपाती का पेड़ , 17 बाइट्स

व्याख्या

सी (जीसीसी) (लिनक्स `-Werror=undef`), 66 बाइट्स