अंडरलोड , 56 52 बाइट्स
(~!)(!)((~)~*):((!)~^)*(:^)(~(!)~^(~)~*)(()~(~)~^~*)
इसे ऑनलाइन आज़माएं! (कार्यक्रम के कुछ हिस्सों की जाँच और पाठ की पहचान करना शामिल है)
यह आश्चर्यजनक रूप से बहुत कम स्तर के एसोलंग के लिए आश्चर्यजनक है। (चर्च अंक, चर्च बूलियन, इत्यादि का उपयोग आमतौर पर अंडरलोड में इस कारण से किया जाता है; भाषा में नंबर और बूलियन नहीं बने होते हैं, और यह उन्हें अनुकरण करने के आसान तरीकों में से एक है। उन्होंने कहा, यह भी आम है। चर्च संख्या 0 और 1. के रूप में बूलियन को सांकेतिक शब्दों में बदलना)
किसी के लिए जो उलझन में है: अंडरलोड आपको पुन: प्रयोज्य कार्यों को परिभाषित करने देता है, लेकिन आपको उन्हें सामान्य तरीके से नाम नहीं देता है, वे सिर्फ तर्क स्टैक पर चारों ओर तैरते हैं (इसलिए यदि आप पांच कार्यों को परिभाषित करते हैं और फिर पहले कॉल करना चाहते हैं आपने परिभाषित किया है, आपको एक नया फ़ंक्शन लिखने की ज़रूरत है जो पांच तर्क लेता है और उनमें से पांचवां कॉल करता है, फिर इसे अपर्याप्त रूप से कई तर्कों के साथ कॉल करें ताकि यह उपयोग करने के लिए अतिरिक्त तर्कों की तलाश करे)। उन्हें कॉल करना डिफ़ॉल्ट रूप से उन्हें नष्ट कर देता है, लेकिन आप इसे गैर-विनाशकारी बनाने के लिए कॉल को संशोधित कर सकते हैं (सरल मामलों में, आपको कॉल में कॉलोन जोड़ने की आवश्यकता है, हालांकि जटिल मामले अधिक सामान्य हैं क्योंकि आपको यह सुनिश्चित करने की आवश्यकता है कि प्रतियां स्टैक पर आपके रास्ते में नहीं मिलता है), इसलिए अंडरलोड के फंक्शन सपोर्ट में वे सभी आवश्यकताएं हैं जो हमें सवाल से चाहिए होंगी।
व्याख्या
सच
(~!)
( ) Define function:
~ Swap arguments
! Delete new first argument (original second argument)
यह काफी सीधा है; हम उस तर्क से मुक्त हो जाते हैं जो हम नहीं चाहते हैं और हम जो तर्क चाहते हैं वह सिर्फ वहीं रहता है, जो रिटर्न मान के रूप में कार्य करता है।
असत्य
(!)
( ) Define function:
! Delete first argument
यह एक और भी सीधा है।
नहीं
((~)~*)
( ) Define function:
~* Modify first argument by pre-composing it with:
(~) Swap arguments
यह एक मजेदार है: notअपने तर्क को बिल्कुल भी नहीं कहता है, यह सिर्फ एक फ़ंक्शन संरचना का उपयोग करता है। यह अंडरलोड में एक सामान्य ट्रिक है, जिसमें आप अपने डेटा का बिल्कुल भी निरीक्षण नहीं करते हैं, आप बस यह बदलते हैं कि यह कैसे पूर्व और इसके बाद की चीजों की रचना करता है। इस मामले में, हम चलने से पहले इसके तर्कों को स्वैप करने के लिए फ़ंक्शन को संशोधित करते हैं, जो स्पष्ट रूप से एक चर्च अंक को नकारता है।
तथा
:((!)~^)*
( ) Define function:
~^ Execute its first argument with:
(!) false
{and implicitly, our second argument}
* Edit the newly defined function by pre-composing it with:
: {the most recently defined function}, without destroying it
प्रश्न अन्य कार्यों के संदर्भ में कार्यों को परिभाषित करने की अनुमति देता है। हम "और" अगला परिभाषित करते हैं क्योंकि हाल ही में "नहीं" परिभाषित किया गया है, इसका उपयोग करना जितना आसान है। (यह हमारे स्कोर से घटाना नहीं है, क्योंकि हम "नहीं" का नामकरण नहीं कर रहे हैं, लेकिन यह परिभाषा को फिर से लिखने से बाइट्स बचाता है। यह केवल एक बार है कि एक फ़ंक्शन दूसरे को संदर्भित करता है, क्योंकि किसी भी फ़ंक्शन का जिक्र है। लेकिन सबसे हाल ही में परिभाषित बहुत सारे बाइट्स खर्च होंगे।)
यहां परिभाषा है and x y = (not x) false y। दूसरे शब्दों में, अगर not x, फिर हम लौटते हैं false; अन्यथा, हम लौट जाते हैं y।
या
(:^)
( ) Define function:
: Copy the first argument
^ Execute the copy, with arguments
{implicitly, the original first argument}
{and implicitly, our second argument}
@ निट्रोडन ने उन टिप्पणियों में बताया जो or x y = x x yसामान्य रूप से कम है or x y = x true y, और जो अंडरलोड में भी सही है। इसका एक निष्प्रभावी कार्यान्वयन होगा (:~^), लेकिन हम एक अतिरिक्त बाइट को ध्यान में रखते हुए यह कह सकते हैं कि इससे कोई फर्क नहीं पड़ता कि हम मूल प्रथम तर्क को चलाते हैं या उसकी प्रति, परिणाम भी उसी तरह है।
अंडरलोड वास्तव में सामान्य अर्थों में करी का समर्थन नहीं करता है, लेकिन इस तरह की परिभाषाएं इसे वैसा ही दिखती हैं जैसा कि यह करती है! (चाल यह है कि गैर-खपत वाले तर्क बस चारों ओर चिपक जाते हैं, इसलिए आप जिस फ़ंक्शन को कॉल करते हैं, वह उन्हें अपने स्वयं के तर्कों के रूप में व्याख्या करेगा।)
का तात्पर्य
(~(!)~^(~)~*)
( ) Define function:
~ Swap arguments
~^ Execute the new first (original second) argument, with argument:
(!) false
{and implicitly, our second argument}
(~)~* Run "not" on the result
यहां इस्तेमाल की गई परिभाषा है implies x y = not (y false x) । यदि y सत्य है, तो यह सरल हो जाता है not false, अर्थात true। यदि y गलत है, तो यह सरल हो जाता है not x, इस प्रकार हमें वह सत्य तालिका प्रदान करता है जो हम चाहते हैं।
इस मामले में, हम notइस बार फिर से उपयोग कर रहे हैं , इसके कोड को फिर से संदर्भित करने के बजाय इसे फिर से लिखना। यह सीधे (~)~*चारों ओर कोष्ठक के बिना के रूप में लिखा है, इसलिए इसे परिभाषित करने के बजाय कहा जाता है।
XOR
(()~(~)~^~*)
( ) Define function:
~ ~^ Execute the first argument, with arguments:
(~) "swap arguments"
() identity function
~* Precompose the second argument with {the result}
इस बार, हम अपने दो तर्कों में से केवल एक का मूल्यांकन कर रहे हैं, और इसका उपयोग यह निर्धारित करने के लिए करते हैं कि दूसरे तर्क पर क्या लिखें। अंडरलोड आपको तेजी से और ढीलेपन से खेलने देता है, इसलिए हम पहले तर्क का उपयोग दो दो-तर्क दो-रिटर्न कार्यों के बीच चयन करने के लिए कर रहे हैं; तर्क स्वैप करता है जो उन दोनों को वापस करता है, लेकिन विपरीत क्रम में, और पहचान फ़ंक्शन जो उन दोनों को उसी क्रम में वापस करता है।
जब पहला तर्क सत्य होता है, तो इसलिए हम दूसरे तर्क का एक संपादित संस्करण तैयार करते हैं, जो चलने से पहले अपने तर्कों को स्वैप कर देता है, अर्थात "स्वैप तर्क" के साथ प्रस्तावना not। इसलिए एक सच्चा पहला तर्क का अर्थ है कि हम notदूसरा तर्क लौटाते हैं । दूसरी ओर, एक गलत पहला तर्क का मतलब है कि हम पहचान समारोह के साथ रचना करते हैं, अर्थात कुछ भी नहीं करते हैं। परिणाम का कार्यान्वयन है xor।