क्विंट ए प्रिस्टिन वर्ल्ड

Question

यह चुनौती हेल्का होम्बा के सवाल पर आधारित है जो प्रिस्टिन वर्ल्ड प्रोग्रामिंग है । उस सवाल से, एक प्राचीन कार्यक्रम की परिभाषा है:

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

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

`8`

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

8`
``
`8

और यह भी सभी कार्यक्रमों की वजह से 2 की त्रुटियों को दूर करने के कारण त्रुटियों:

`
`

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

टिप्पणियाँ:

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

आपका कार्य गैर-शून्य लंबाई का एक कार्यक्रम बनाना है जो अपने स्वयं के स्रोत कोड को बिल्कुल प्रिंट करता है, एक उचित क्वीन के लिए नियमों का पालन ​​करता है , और प्राचीन है।

प्रत्येक भाषा के लिए बाइट्स में सबसे छोटा उत्तर जीतता है।

Comments

मैं ऐसी भाषाएं ग्रहण कर रहा हूं जो त्रुटि नहीं कर सकती हैं?

— ATaco

@ATaco दुर्भाग्य से हाँ। अन्य भाषाएं, जैसे कि लिस्प, ने वाक्य रचना को इस तरह से संरचित किया है कि एक उपयोगी प्राचीन कार्यक्रम बनाना असंभव है।

— शेल्वैकू

RIP वास्तव में / गंभीरता से

— ATaco

'प्रत्येक भाषा के लिए बाइट्स में सबसे छोटा उत्तर जीतता है।' मैं एक प्राचीन कार्यक्रम के लिए सबसे अच्छा उपाय होने के बारे में निश्चित नहीं हूं।

— पी। सेहर

@ P.iehr इसके बजाय आप क्या करेंगे?

— शेल्वैकू

Answer 1

हास्केल , 132 बाइट्स

q x=if length x==132then putStr x else fail[];main=q$(++)<*>show$"q x=if length x==132then putStr x else fail[];main=q$(++)<*>show$"

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

यह क्वीन का विस्तार है

main=putStr$(++)<*>show$"main=putStr$(++)<*>show$"

जो showस्वयं के उद्धृत (संस्करण का उपयोग करके ) और परिणाम को प्रिंट करके डेटा स्ट्रिंग को संक्षिप्त करके काम करता है । हालाँकि, यह प्राचीन नहीं है क्योंकि डेटा स्ट्रिंग के किसी भी वर्ण को विफल किए बिना हटाया जा सकता है और साथ ही कार्यक्रम को तोड़ने के बिना $(++)<*>show$या (++)<*>भाग को गिराया जा सकता है।

इसे ठीक करने के लिए एक कस्टम प्रिंट समारोह qपरिभाषित किया गया है जो चेक दिए गए स्ट्रिंग और कॉल की लंबाई failअगर यह कम से 132. यह कैच डेटा स्ट्रिंग से किसी भी दृश्य के हटाने और भी को हटाया जाना है $(++)<*>show$या (++)<*>, दोनों ही मामलों जिसके परिणामस्वरूप में के रूप में स्ट्रिंग qको छोटा कर दिया गया ।

में qसंख्या 132के लिए छोटा किया जा सकता है 1, 13, 32या 2, लेकिन प्रत्येक मामले में फिर से failकहा जाता है।

जहां तक ​​मैं बता सकता हूं, किसी भी अन्य सबस्ट्रिंग को हटाने से एक सिंटैक्स या टाइप त्रुटि होती है, इसलिए प्रोग्राम पहले स्थान पर भी संकलन नहीं करता है। (हास्केल का सख्त टाइप सिस्टम यहाँ काम आता है।)

संपादित करें: एक दोष को इंगित करने के लिए अर्जन जोहान्सन और शेल्वैकु को धन्यवाद!

Comments

मुझे डर है fail[]|length x/=122कि हटाया जा सकता है। fail[]:[putStr x|length x==122]बेहतर काम कर सकते हैं।

— अर्जन जोहान्सन

अर्घ, नहीं, तो |length x==122हटाया जा सकता है। if length x==122 then putStr x else fail[]शायद?

— अर्जन जोहान्सन

@ HadrrrJohansen अच्छा कैच, मेरे पास if then elseपहले था लेकिन मुझे लगा कि मैं इसे छोटा कर सकता हूं।

— लकोनी

putStr xबन सकता है p x, जो कि जब मैंने अपने सिस्टम पर कोशिश की, तो उसे मारने से पहले बहुत लंबे समय तक चला, मुझे संदेह है कि पूंछ कॉल पुनरावृत्ति को अनुकूलित किया गया था, इसलिए यह एक अनंत लूप है। मैं इसे ठीक करने के बारे में कोई सुझाव देने के लिए पर्याप्त हैस्केल नहीं जानता।

— शेल्वकु जू

@ शल्वकु वूप्स। ठीक pकरने के लिए नाम बदलना q।

— अर्जन जोहान्सन

Answer 2

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

for[]in{113:[]}[open(1,"w").write((lambda s:s%s)('for[]in{113:[]}[open(1,"w").write((lambda s:s%%s)(%r))]:a'))]:a

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

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

हम आसानी से एक से अधिक कथनों का उपयोग नहीं कर सकते हैं क्योंकि दूसरे को हटाया जा सकता है, इसलिए हम एक एकल-अभिव्यक्ति के साथ शुरू करते हैं:

print((lambda s:s%s)('print((lambda s:s%%s)(%r))'))

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

Comments

क्या आप बता सकते हैं कि आपका कोड कैसे काम करता है?

— शेल्वैकु

@ शाल्वेषु हाँ, जोड़ा।

— एंडर्स कासोर्ग

Answer 3

रूबी, 78 बाइट्स

eval(*[($>.write((s=%{eval(*[($>.write((s=%%{%s})%%s)-78).chr])})%s)-78).chr])

मैंने यह तब लिखा जब मैंने यह सुनिश्चित करने की चुनौती के बारे में सोचा कि यह संभव है। यह मूल उत्तरवादी चुनौती के लिए मेरे उत्तरों में से एक ही "आवरण" का उपयोग करता है ।

स्पष्टीकरण:

• eval(*[ expr ])

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

  "स्प्लैट" ऑपरेटर *आपको किसी फ़ंक्शन के तर्क के रूप में एक सरणी का उपयोग करने की अनुमति देता है। इसका मतलब यह भी है कि यदि evalहटा दिया जाता है, तो परिणामी कार्यक्रम (*[ expr है ]) , जो वैध रूबी नहीं है।

• ($>.write( str )-78).chr

  $> STDOUT के लिए एक छोटा चर है।

  $>.write(foo) इस कोड के लिए महत्वपूर्ण रूप से STDOUT को फू लिखते हैं, और लिखी गई बाइट्स की संख्या लौटाते हैं।

  $>.write(foo)-78: यहां 78प्रोग्राम की लंबाई है, और इसलिए यदि प्रोग्राम को मंगली नहीं किया गया है, तो बाइट्स की संख्या भी लिखी जाएगी। इसके बाद, असंगठित मामले में, यह शून्य वापस आ जाएगा।

  num.chrएक पात्र के रूप में संख्या लौटाता है, जैसे 0.chrएक एकल नल बाइट युक्त स्ट्रिंग लौटाएगा। अनमैंगल्ड प्रोग्राम में, यह सिंगल नल बाइट के साथ एक स्ट्रिंग देगा eval, जो कि एक वैध रूबी प्रोग्राम है जो एक नो-ऑप है।

  इसके अलावा, प्रोग्राम में एक विकल्प निकाला जा सकता है जैसे कि यह सिर्फ eval(*[(78).chr])या eval(*[(8).chr]), जिसका अर्थ है कि संख्यात्मक स्थिर संख्याओं में से किसी के साथ समाप्त नहीं हो सकता है (0, 4, 9, 10, 11, 12, 13, 26, 32, 35, 48 , 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 64, 95) क्योंकि वे वैध एकल-वर्ण रूबी कार्यक्रमों के लिए एएससीआई कोड हैं।

• %{ str }

  यह माणिक में स्ट्रिंग शाब्दिक के लिए एक कम ज्ञात वाक्यविन्यास है। यहां इसका उपयोग करने का कारण यह है कि संतुलित जोड़ियों का {}उपयोग स्ट्रिंग के भीतर किया जा सकता है, जिसका अर्थ है कि इस वाक्यविन्यास में स्वयं शामिल हो सकता है। उदाहरण के लिए, %{foo{bar}}जैसा है वैसा ही है "foo{bar}"।

• (s=%{ डेटा })%s

  यह वैरिएबल को परिभाषित करता है sजो कि इस क्वीन का डेटा है, प्रिंटफ स्ट्रिंग के रूप में।

  माणिक रिटर्न में असाइनमेंट जो सौंपा गया था, इसलिए यह पहले असाइन करने sऔर फिर चलने के समान हैs%s

  %एक स्ट्रिंग पर स्प्रिंट के बराबर रूबी के लिए सिंथेटिक चीनी है। %sप्रतीक जहां डाटा के भीतर डेटा ही एम्बेडेड किया जाना चाहिए।

  कोड का यह बिट क्वीन के डेटा भाग को परिभाषित करता है और पूर्ण कोड बनाने के लिए इसे अपने भीतर एम्बेड करता है।

Answer 4

मानक एमएल (एमएलटन) , 204 182 189 बाइट्स

val()=hd[(fn s=>let val$ =s^"\""^String.toString s^"\"]"val(189,%)=(size$,$)in print%end)"val()=hd[(fn s=>let val$ =s^\"\\\"\"^String.toString s^\"\\\")\"val(189,%)=(size$,$)in print%end)"]

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

MLton के लिए, पूर्ण SML प्रोग्राम या तो अभिव्यक्त किए जाते हैं और ;(जैसे print"Hello";print"World";) varऔर fun( और var _=print"Hello"var _=print"World") और कीवर्ड (जैसे ) के साथ घोषणाओं को समाप्त कर दिया जाता है जहां _एक वाइल्ड कार्ड होता है जिसे किसी भी चर नाम से बदला जा सकता है।

पहला विकल्प प्राचीन प्रोग्रामिंग के लिए बेकार है क्योंकि ;अपने आप ही एक वैध कार्यक्रम है (जो कुछ भी नहीं करता है, लेकिन त्रुटि भी नहीं करता है)। दूसरे दृष्टिकोण के साथ समस्या यह है कि इस तरह की घोषणाओं var _=print"Hello"को सिर्फ var _="Hello"(या सम var _=print) तक छोटा किया जा सकता है क्योंकि varजब तक दाएं हाथ से काम करने की घोषणा वैध SML अभिव्यक्ति या मूल्य नहीं है (SML एक कार्यात्मक भाषा है, इसलिए फ़ंक्शन हो सकते हैं मूल्यों के रूप में भी उपयोग किया जाता है)।

इस बिंदु पर, मैं SML असंभव में प्राचीन प्रोग्रामिंग की घोषणा करने के लिए तैयार था, जब संयोग से मैं पैटर्न- इन- valसेक्लेरेशन से मेल खाता था । यह पता चला है कि घोषणाओं के लिए वाक्यविन्यास नहीं है , val <variable_name> = <expression>लेकिन val <pattern> = <expression>जहां एक पैटर्न में चर नाम, स्थिरांक और निर्माता शामिल हो सकते हैं। जैसा कि printफ़ंक्शन का प्रकार होता है string -> unit, हम यह लागू करने के लिए unit-value पर एक पैटर्न मैच का उपयोग कर सकते हैं ()कि प्रिंट फ़ंक्शन वास्तव में स्ट्रिंग पर लागू होता है val()=print"Hey":। इस दृष्टिकोण के साथ, printया तो हटाने या "Hey"परिणाम में Pattern and expression disagree।

हाथ में प्राचीन मुद्रण के इस तरीके के साथ, अगला कदम एक क्वीन लिखना है, इससे पहले अंत में कुछ और बचत-रक्षक को जोड़ना होगा। मैंने पहले एक आसान एसएमएल क्वीन तकनीक का इस्तेमाल किया था ( संशोधन इतिहास देखें ), लेकिन एंडर्स केसेर्ग ने एक अलग दृष्टिकोण बताया जो उनके मामले में कुछ बाइट्स को बचा सकता है। यह String.toStringस्ट्रिंग से बचने के लिए अंतर्निहित फ़ंक्शन का उपयोग करता है और सामान्य रूप का होता है <code>"<data>", जहां पहले से "<data>"बचा हुआ स्ट्रिंग है code:

val()=(fn s=>print(s^"\""^String.toString s^"\""))"val()=(fn s=>print(s^\"\\\"\"^String.toString s^\"\\\"\"))"

यह एक काम कर रहा है लेकिन अभी तक प्राचीन नहीं है। सबसे पहले एंडर्स कासोर्ग ने पाया कि MLton "त्रुटियों के उत्पादन के बिना कोड के रूप में एक एकल उद्धरण को स्वीकार करता है , जिसका अर्थ है कि हम ऊपर के रूप में एक उद्धरण में कोड को समाप्त नहीं कर सकते हैं। इसे रोकने का सबसे छोटा तरीका यह होगा कि val()=कोष्ठक की एक जोड़ी के बाद सब कुछ लपेट दिया जाए , हालांकि तब कोड को कम किया जा सकता है val()=()। दूसरा सबसे छोटा तरीका जो मैंने पाया है val()=hd[ ... ], वह है कि हम हर चीज को एक सूची में लपेटते हैं और टाइप चेकर को खुश करने के लिए अपना पहला तत्व वापस करते हैं।

यह सुनिश्चित करने के लिए कि डेटा स्ट्रिंग के किसी भी हिस्से को बिना देखे हटाया नहीं जा सकता है, पैटर्न-मिलान इन- valडिक्लेरेशन फिर से काम में आता है: अंतिम स्ट्रिंग की लंबाई मुद्रित होने के लिए (और इस प्रकार प्रोग्राम की लंबाई) 195 के बराबर होनी चाहिए, इसलिए हम इसके बजाय अमूर्त let val t=... val 195=size t in print t endके शरीर में लिख सकते fnहैं print(...)। स्ट्रिंग के एक हिस्से को हटाने से 189 से कम लंबाई होती है, इस प्रकार एक Bindअपवाद को फेंक दिया जाता है।

अभी भी एक मुद्दा बाकी है: पूरी val 195=size tजाँच को केवल गिराया जा सकता है। हम चैक पर मिलान के लिए चेक का विस्तार करके इसे रोक सकते हैं: val t=... val(216,u)=(n+size t,t)in print u endजैसे कि एक अनबाउंड वैरिएबल में चेक रिजल्ट निकालना u।

कुल मिलाकर, यह निम्नलिखित 195 बाइट समाधान का उत्पादन करता है:

val()=hd[(fn s=>let val t=s^"\""^String.toString s^"\")"val(195,u)=(size t,t)in print u end)"val()=hd[(fn s=>let val t=s^\"\\\"\"^String.toString s^\"\\\")\"val(195,u)=(size t,t)in print u end)"]

जैसे ऑपरेटर चर नाम का उपयोग करने का गोल्फ चाल को लागू करने !, $और %के बजाय n, tऔर uआदेश कुछ सफेद स्थान को बचाने के लिए (देखें इस टिप अंतिम 182 बाइट संस्करण के लिए) की ओर जाता है।

अन्य सभी स्थानापन्न-निष्कासन, जहां स्पष्टीकरण में स्पष्ट रूप से नहीं कहा गया है, एक सिंटैक्स या टाइप त्रुटि में परिणाम होना चाहिए।

संपादित करें 1: length(explode t) बस है size t।
संपादित करें 2: एक अलग रानी दृष्टिकोण के लिए एंडर्स कासोर्ग के लिए धन्यवाद और "भेद्यता" को इंगित करता है।

Comments

Directly2 बाइट्स"\"" सीधे लिखकर और String.toStringभागने के लिए उपयोग करते हैं।

— एंडर्स केसॉर्ग

रुको, यह भयानक है: एमएलटन कार्यक्रम को स्वीकार करने लगता है ", खाली उत्पादन ( टीआईओ ) का उत्पादन करता है ।

— एंडर्स केसरग

@AndersKaseorg हुह, यह अजीब है। हालांकि इस मुद्दे को दूसरे का उपयोग करके ठीक करना संभव होना चाहिए let ... in ... end।

— लकोनी

@AndersKaseorg मैंने नई "कमजोरियों" को पेश किए बिना, उम्मीद को मुद्दा बनाया।

— लिकोनी

वास्तव में मैंने MLton "को एक कार्यक्रम के रूप में स्वीकार करते हुए देखा , और ऐसा लगता है कि इस कमिट में बग को ठीक कर दिया गया था , इसलिए हो सकता है कि आपका 182 या मेरा 180 तब तक ठीक हो जब तक आप MLton के अनट्रिज्ड गिट संस्करण को निर्दिष्ट नहीं करते।

— एंडर्स कासोर्ग