ब्रेन-फ्लैक में गोल्फिंग के लिए टिप्स


24

ब्रेन-फ्लैक एक स्टैक-आधारित ट्यूरिंग-टारपीट भाषा है, जो मेरे, डीजेमेकमेम और 1000000000 के बीच सहयोगात्मक रूप से लिखी गई है ।

कुछ उपयोगकर्ता ब्रेन-फ्लैक के रहस्यमय तरीके से बहुत अनुभवी हैं। इसलिए मैंने इस प्रश्न को हमारे लिए एक मार्ग के रूप में स्थापित करने के लिए एक अच्छा विचार सोचा, और उम्मीद है कि अन्य लोग भी, समुदाय के साथ हमारे ज्ञान को साझा करने के लिए और इस भाषा में प्रवेश की पट्टी को कम करने के लिए "डिजाइन का उपयोग करने के लिए दर्दनाक"। और शायद हम में से भी कुछ नए ट्रिक्स का अनुभव करते हैं।

तो ब्रेन-फ्लैक में गोल्फ के लिए आपके पास क्या टिप्स हैं? मैं उन विचारों की तलाश कर रहा हूं जो सामान्य रूप से गोल्फ की समस्याओं को कोड करने के लिए लागू हो सकते हैं जो कम से कम कुछ हद तक ब्रेन-फ्लैक के लिए विशिष्ट हैं (उदाहरण के लिए "टिप्पणियां हटाएं" एक उत्तर नहीं है)।

कृपया प्रति उत्तर एक टिप पोस्ट करें।

जवाबों:


22

थर्ड स्टैक का इस्तेमाल करें

यदि आपने शीर्षक पढ़ा है तो आप थोड़ा भ्रमित हो सकते हैं। निश्चित रूप से ब्रेन-फ्लैक में केवल दो ढेर हैं? हालांकि मैं आपको विश्वास दिलाता हूं कि यह मौजूद है और यह सबसे शक्तिशाली में से एक है, अगर यह ब्रेन-फ्लाक लेखन और गोल्फ में सबसे शक्तिशाली उपकरण नहीं है।


"तीसरा स्टैक" क्या है?

हर ब्रेन-फ्लैक प्रोग्राम एक या दूसरे तरीके से तीसरे स्टैक का उपयोग करता है, लेकिन ज्यादातर उपयोग पर्दे के पीछे होता है और यह अक्सर इस तथ्य को अनदेखा करने के लिए उपयोगी होता है कि यह मौजूद है। कार्यक्रम में प्रत्येक कोष्ठक या तो स्टैक से एक आइटम को जोड़ता है या हटाता है। खुले ब्रेसिज़ में से ([<तीन स्टैक में एक आइटम जोड़ते हैं जबकि उनके तीन संयुग्म होते हैं)]> सभी स्टैक से एक आइटम को हटाते हैं। स्टैक पर आइटम का मूल्य कार्यक्रम के वर्तमान दायरे का मूल्य है और निलाड्स का उपयोग करके इस मूल्य को कुछ तरीकों से संशोधित किया जाएगा। करीब कोष्ठक )में तीसरे स्टैक से एक तत्व को चालू स्टैक तक ले जाने का अनूठा कार्य है; एक धक्का।

उम्मीद है कि यह आपके लिए स्पष्ट हो रहा है। थर्ड स्टैक कुछ प्रकार का स्टैक है जो कोड के रिटर्न वैल्यूज को याद करता है जिसे पहले ही निष्पादित किया जा चुका है। चलो दो सामान्य स्टैक और तीसरे स्टैक का ट्रैक रखते हुए एक सरल कार्यक्रम के उदाहरण के माध्यम से चलते हैं।

उदाहरण

हम निम्नलिखित कार्यक्रम के माध्यम से चलेंगे। यह कार्यक्रम -3, 1, -2स्टैक को धक्का देता है।

(([()()()])(()))

हम तीन खुले ब्रेसिज़ के साथ शुरू करते हैं, जो सभी एक शून्य से तीसरे स्टैक तक पहुंचते हैं।

हमारे स्टैक अब इस तरह दिखते हैं, तीसरा स्टैक दाईं ओर है और ^इसके नीचे सक्रिय स्टैक है :

        0
        0
  0  0  0
  ^

(([()()()])(()))
   ^

अब हम तीन ()nilads है। ये सामान्य दो स्टैक के लिए कुछ भी नहीं करते हैं, हालांकि वे तीसरे स्टैक के शीर्ष पर एक जोड़ते हैं जो हमारे स्टैक को लुक देते हैं:

        3
        0
  0  0  0
  ^

(([()()()])(()))
         ^

अब हम ]तीसरे स्टैक से एक आइटम को हटाने से पहले बताए अनुसार सामना करते हैं , लेकिन ]इसमें स्टैक के शीर्ष से हटाए गए तत्व को घटाने का कार्य होता है। इस प्रकार हमारे नए ढेर लगेंगे:

       -3
  0  0  0
  ^

(([()()()])(()))
          ^

यह समझ में आता है; [...]नकार तो ]नीचे की ओर घटाना चाहिए।

अब हमें एक पर अमल करना चाहिए )। जैसा कि आपको याद )है कि कार्यक्रम में वह जगह है जहां सामान स्टैक की ओर धकेल दिया जाता है, इसलिए हम तीसरे स्टैक के शीर्ष को चालू स्टैक पर ले जाएंगे, इसके अलावा हम -3तीसरे स्टैक में अगले तत्व में जोड़ देंगे ।

 -3  0 -3
  ^

(([()()()])(()))
           ^

एक बार फिर हमारा सामना हमारे तीन खुले ब्रेसिज़ से होता है इसलिए हम अपने थर्ड स्टैक में एक और तत्व जोड़ेंगे।

        0
 -3  0 -3
  ^

(([()()()])(()))
            ^

जैसा कि हमने पहले कहा था कि ()हमारे तीसरे स्टैक के शीर्ष में एक के बाद एक वृद्धि होगी।

        1
 -3  0 -3
  ^

(([()()()])(()))
              ^

और )तीसरे स्टैक के शीर्ष को सक्रिय स्टैक पर ले जाएगा और नीचे की तरफ जोड़ देगा

  1
 -3  0 -2
  ^

(([()()()])(()))
               ^

अंतिम )सक्रिय स्टैक पर तीसरा स्टैक ले जाता है और चूंकि इसमें जोड़ने के लिए तीसरे स्टैक पर कोई तत्व नहीं बचा है, और कुछ नहीं करता है।

 -2
  1
 -3  0
  ^

(([()()()])(()))
                ^

कार्यक्रम समाप्त हो गया है इसलिए हम समाप्त करते हैं और आउटपुट देते हैं।


यह उदाहरण आपको थर्ड स्टैक क्या करता है और क्या करता है के लिए एक एहसास देने का इरादा है। इसमें सभी ऑपरेशन शामिल नहीं हैं, लेकिन उम्मीद है कि आप यह पता लगा सकते हैं कि उनमें से प्रत्येक अपने दम पर क्या करता है। यदि आप अभी भी संघर्ष कर रहे हैं तो मैंने इस उत्तर के निचले भाग में एक "चीटशीट" को शामिल किया है ताकि आपकी सहायता की जा सके।

ठीक है तो क्या हुआ?

ठीक है, अब आप तीसरे स्टैक को समझते हैं, लेकिन "तो क्या"? यदि आप इसे "थर्ड स्टैक" नहीं कहते हैं, तब भी आप इसका उपयोग कर रहे थे, थर्ड स्टैक के संदर्भ में सोच आपको गोल्फ में कैसे मदद करेगी?

एक समस्या पर नजर डालते हैं। आप किसी संख्या का त्रिभुज लेना चाहते हैं । यह n से कम सभी संख्याओं का योग है।

एक दृष्टिकोण अपस्टैक पर एक संचायक बनाने और इसे नीचे जोड़ने के रूप में जोड़ सकता है। यह ऐसा कोड बनाता है जो इस तरह दिखता है:

(<>)<>{(({}[()])()<>{})<>}{}<>({}<>)

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

यह कोड बहुत कॉम्पैक्ट है और कोई सोच सकता है कि यह बहुत छोटा नहीं हो सकता। हालाँकि अगर हम इसे तीसरे स्टैक के दृष्टिकोण से देखें तो यह स्पष्ट हो जाता है कि यह स्थूल रूप से अक्षम है। अपने संचायक को ऑफस्टैक पर रखने के बजाय हम इसे तीसरे स्टैक पर रख सकते हैं (और इसे अंत में हम उपयोग करते हैं )। हम एक बार फिर सभी नंबरों के माध्यम से लूप करेंगे, लेकिन इस बार हमें अपने तीसरे स्टैक को बढ़ाने के लिए ज्यादा कुछ नहीं करना है, कार्यक्रम हमारे लिए करता है। ऐसा दिखता है:

({()({}[()])}{})

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

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

मैं तीसरे स्टैक का उपयोग कब करूं?

आदर्श रूप से जब भी आप ब्रेन-फ्लैक में एक नई समस्या पर काम शुरू करते हैं तो आपको खुद से सोचना चाहिए कि मैं थर्ड स्टैक को ध्यान में रखते हुए ऐसा कैसे करूंगा। हालाँकि, अंगूठे के एक सामान्य नियम के रूप में, जब भी आपको किसी प्रकार के संचायक का ध्यान रखना होता है या एक कुल चलना होता है, तो यह एक अच्छा विचार है कि दो असली ढेर के बजाय अपने तीसरे स्टैक पर डाल दें।

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

तीसरे स्टैक की सीमाएं

थर्ड स्टैक बहुत तरीकों से बहुत शक्तिशाली है लेकिन यह अपनी सीमाओं और कमियों के साथ आता है।

सबसे पहले, किसी भी बिंदु पर तीसरे स्टैक के लिए अधिकतम स्टैक की ऊंचाई संकलन समय पर निर्धारित की जाती है। इसका मतलब यह है कि यदि आप स्टैक पर जगह की मात्रा का उपयोग करना चाहते हैं तो आपको उस जगह को आवंटित करना होगा जब आप प्रोग्राम लिख रहे हैं।

दूसरे थर्ड स्टैक रैंडम एक्सेस नहीं है। इसका मतलब यह है कि आप किसी भी मूल्य पर कोई ऑपरेशन नहीं कर सकते हैं लेकिन सबसे ऊपर का मूल्य है। इसके अलावा आप स्टैक पर मानों को स्थानांतरित नहीं कर सकते (कहते हैं कि पहले दो तत्वों को स्वैप करें)।

निष्कर्ष

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

प्रवंचक पत्रक

यहां ऑपरेशन की एक सूची दी गई है और वे तीसरे स्टैक को कैसे प्रभावित करते हैं

 Operation  |                 Action
====================================================
   (,[,<    | Put a zero on top of the Third Stack
----------------------------------------------------
     )      | Add the top of the Third Stack to the
            | second element and move it to the 
            | active stack
----------------------------------------------------
     ]      | Subtract the top of the Third Stack
            | from the second element and pop it
----------------------------------------------------
     >      | Pop the top of the Third Stack
----------------------------------------------------
     ()     | Add one to the top of the Third Stack
----------------------------------------------------
     {}     | Pop the top of the active stack and
            | add it to the top of the Third Stack
----------------------------------------------------
     []     | Add the stack height to the Third
            | Stack
----------------------------------------------------
   <>,{,}   | Nothing

1
वाह, शानदार टिप! मैं वास्तव में यहाँ आ रहा था जब मैंने यह देखा तो ऐसा ही उत्तर लिखने के लिए। +1! मैं इसे Accumulator के रूप में सोचना पसंद करता हूं , लेकिन द थर्ड स्टैक रूपक वास्तव में दिलचस्प है।
DJMcMayhem

मैंने हमेशा इसे "कार्यक्षेत्र" या "कार्यस्थल" कहा।
सागिक्स्प्स

Brainflak के TIO संस्करण पर, {...}सभी पुनरावृत्तियों का योग देता है।
कैलक्यूलेटरफल

@ कैलाकुलरफेलीन हां, यह कुछ बहुत शुरुआती लोगों को छोड़कर ब्रेन-फ्लैक के लगभग सभी संस्करणों पर सच है। हालाँकि मुझे यकीन नहीं है कि आपने इस पोस्ट पर विशेष रूप से टिप्पणी क्यों की है।
गेहूं जादूगर

<>,{,} | Nothing
CalculatorFeline

21

मापांक / शेष खोजना

एन मोडुलो एम ढूँढना मूल अंकगणितीय संचालन में से एक है, जो कई चुनौतियों के लिए महत्वपूर्ण है। मामलों के लिए m> 0 और n> = 0 , निम्नलिखित 46-बाइट स्निपेट का उपयोग किया जा सकता है। यह मानता है कि n अगले एक मीटर m के साथ सक्रिय स्टैक के शीर्ष पर है , और उन्हें n mod m के साथ बदल देता है । यह बाकी के ढेरों को बरकरार रखता है।

({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

यह एनोटेट संस्करण कार्यक्रम में कुछ बिंदुओं पर स्टैक सामग्री दिखाता है। ;दो ढेर को अलग .करता है और सक्रिय स्टैक को चिह्नित करता है।

. n m;
({}(<>))<>
{   . m; r 0   (r = n - km)
    (({}))
    . m m; r 0
    {({}[()])<>}
    {}
}
m-n%m-1 m; . 0
{}<>([{}()]{})
. n%m;

यह समझने में मुझे कुछ समय लगा कि अननोनोटेड पार्ट ने क्या किया ( {({}[()])<>}), लेकिन एक बार मैंने यह पता लगा लिया ... जीनियस :-)
ETHproductions

11

पुश-पॉप अतिरेक

यह बड़ा वाला है। यह भी एक छोटी सी बारीक है।

विचार यह है कि यदि आप किसी चीज़ को धक्का देते हैं और फिर उसे बिना कुछ किए पॉप करते हैं तो आपको इसे बिल्कुल भी धक्का नहीं देना चाहिए।

उदाहरण के लिए, यदि आप किसी चीज़ को ऑफ़स्टैक में ले जाना चाहते हैं और फिर उसमें एक जोड़ें तो आप निम्नलिखित कोड लिख सकते हैं:

({}<>)({}())

यह इस तरह सरल हो सकता है:

({}<>())

पहला प्रोग्राम आइटम को ऊपर उठाता है, इसे घुमाता है, फिर से ऊपर उठाता है और एक जोड़ता है, जबकि दूसरा एक में दोनों गिरता है झपट्टा।

यह उदाहरण सरल था लेकिन यह बहुत अधिक जटिल हो सकता है। उदाहरण के लिए लें:

({}<({}<>)><>)(<((()()()){}[((){}{})])>)

यहां कमी कम स्पष्ट है, लेकिन कार्यक्रम में 4 वें पॉप को 2 पुश के साथ कम किया जा सकता है, जैसे:

(<((()()()){}[((){}<({}<>)><>{})])>)

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


बाद के उदाहरण में, कोष्ठक की पहली जोड़ी के बराबर का हिस्सा नहीं है ({}<{}>)?
फेर्सुम

@ Faersum नहीं यह नहीं है। यह ({}<{}>)पूरी तरह से आइटम को नष्ट कर देता है, जबकि स्टैक पर स्टैक पर दूसरी आइटम की एक प्रति ले जाता है । हालांकि इन कार्यक्रमों को वास्तव में सिर्फ काम पर सिद्धांत को उजागर करने के लिए इष्टतम होने का मतलब नहीं था।
गेहूं जादूगर

6

अपने पूर्णांकों का अनुकूलन करें

ब्रेन-फ्लैक में प्रतिनिधित्व करने के लिए इंटेगर थकाऊ हैं। सौभाग्य से हमारे पास एक सवाल है जो गोल्फ को आपके लिए एक ब्रेन-फ्लैक इंटेगर की मदद करेगा । (ध्यान दें कि प्रश्न को पूर्णांक को स्टैक पर पुश करने के लिए डिज़ाइन किया गया है, इसलिए पुश-पॉप अतिरेक शायद अधिक यथार्थवादी कार्यक्रमों पर लागू होता है।)


ध्यान दें कि हमारे पास brain-flak.github.io/integer/ भी है , जो सुविधा के लिए उन सभी एल्गोरिदम को ऑनलाइन चलाता है।
DJMcMayhem

@DrMcMoylex हम सभी को अब ब्रेन-फ्लैक में पूर्णांक मेटागोलर के कार्यान्वयन की आवश्यकता है!
नील

1
हमारे पास वह है। codegolf.stackexchange.com/a/98054/31716 : डी
DJMcMayhem

5

अतिरिक्त लूप काउंटर को पुश करें

बार-बार, आप कुछ ऐसा करना चाहते हैं

स्टैक में प्रत्येक तत्व पर एक्स ऑपरेशन करें

या

स्टैक में आसन्न तत्वों के हर जोड़े पर एक्स ऑपरेशन करें

जब इनपुट में '0' हो सकता है, या ऑपरेशन X का परिणाम 0 दे सकता है, तो यह वास्तव में असुविधाजनक है। क्योंकि आपको करने की आवश्यकता होगी:

([])
{

  {}

  ({}...<>)
  ([])

}

ऐसा करने के लिए एक्स प्रत्येक तत्व के लिए, और फिर बाद में

<>
([])
{
  {}
  ({}<>)
  <>
  ([])
}
<>

सरणी को फिर से उलटने के लिए।

इससे भी बदतर यह है कि अगर हम आसन्न तत्वों के जोड़े पर operatiing रहे हैं, हम करने की आवश्यकता होगी ([][()])के स्थान पर ([])। यह वास्तव में असुविधाजनक है। यहां यह चाल है: जब आप प्रत्येक तत्व के लिए X कर रहे हैं , तो 1 धक्का दें इसके ठीक ऊपर वैकल्पिक स्टैक पर ओवर काX(element) । फिर, जब आप इसे उलट रहे हैं, तो आप बस कर सकते हैं

<>
{
  {}
  ({}<>)
  <>
}
<>

यह 8 बाइट्स छोटा है, इसलिए जब आप 1 को पुश करने के लिए अतिरिक्त कोड में कारक हैं, तो आप 4-6 बाइट्स बचाएंगे। अधिक ठोस उदाहरण के लिए, किसी सरणी के डेल्टास प्राप्त करने के कार्य की तुलना करें। इस ट्रिक के बिना, आपको आवश्यकता होगी:

([][()]){

    {}

    ([{}]({})<>)<>

    ([][()])

}{}{}<>

([])
{{}({}<>)<>([])}<>

62. इस ट्रिक के साथ, आपके पास होगा

([][()]){

    {}

    ([{}]({})<>)(())<>

    ([][()])

}{}{}<>

{{}({}<>)<>}<>

58 के लिए। यदि सही तरीके से उपयोग किया जाता है (उदाहरण के लिए, पहले उलट, और ([][()])बाद में दो को हटा दिया जाए), तो यह स्थानिक परिदृश्यों में और भी अधिक बचत कर सकता है।


3

'स्टैक-हाइट' निलाद का लाभ उठाएं

विशेष रूप से चुनौतियों में, या चुनौतियां जहां आप हमेशा इनपुट के आकार को जानते हैं, आप 'स्टैक- का लाभ उठा सकते हैं[] पूर्णांक बनाने हैं।

आइए इसके माध्यम से एक काल्पनिक चुनौती के साथ काम करें: आउटपुट CAT। गैर-गोल्फरी रास्ता 67, 65 और 84 को धक्का देने के लिए ऑनलाइन पूर्णांक गोल्फर का उपयोग करना है । यह देता है:

(((((()()()()){}){}){}()){}())

(((((()()()()){}){}){}){}())

((((((()()()){}()){}){})){}{})

(स्पष्टता के लिए नई खबरें)। यह 88 बाइट्स है, और यह बहुत अच्छा नहीं है। यदि हम इसके बजाय मूल्यों के बीच लगातार अंतर को धक्का देते हैं, तो हम बहुत कुछ बचा सकते हैं। इसलिए हम पहले नंबर को एक पुश कॉल में लपेटते हैं, और 2 घटाते हैं:

(   (((((()()()()){}){}){}()){}())  [()()] )

फिर, हम इस कोड को लेते हैं, इसे एक पुश कॉल में लपेटते हैं, और अंत में 19 जोड़ते हैं:

(  ((((((()()()()){}){}){}()){}())[()()])   ((((()()()){})){}{}()) )

यह एक 26 बाइट गोल्फ के लिए 62 बाइट्स है!

अब यहाँ वह जगह है जहाँ हम ढेर-ऊँचाई वाले निलाद का लाभ उठा सकते हैं। जब तक हम 19 को धक्का देना शुरू करते हैं, तब तक हम जानते हैं कि स्टैक पर पहले से ही 2 आइटम मौजूद हैं, इसलिए इसका []मूल्यांकन करेंगे 2। हम इसका उपयोग कम बाइट्स में 19 बनाने के लिए कर सकते हैं। स्पष्ट तरीका यह है कि भीतर ()()()को बदलना है ()[]। हालांकि यह केवल दो बाइट्स बचाता है। कुछ और छेड़छाड़ के साथ, यह पता चला है कि हम 19 के साथ धक्का दे सकते हैं

((([][]){})[]{})

यह हमें 6 बाइट बचाता है। अब हम नीचे 56 पर हैं।

आप इस टिप को इन उत्तरों पर बहुत प्रभावी ढंग से उपयोग कर सकते हैं:


आपका CATकार्यक्रम वास्तव में धक्का देता है TAC: पी
गेहूं जादूगर


2
मुझे पता है कि यह एक टिप है, लेकिन मैं खुद की मदद नहीं कर सकता, 50 बाइट्स
गेहूं जादूगर 19

1
दुर्व्यवहार में मदद करने के लिए एक और अजीब लेकिन कभी-कभी प्रभावी टिप []: आपके कोड से पहले 0एस के साथ प्रीपेडिंग एस (<>)। यह वास्तव में तभी काम करता है जब आप कोड को किसी भी तरह रिवर्स करने की योजना बना रहे हों, लेकिन यदि आप सही संख्या में आते हैं तो आप अपने कोड को काफी कम कर सकते हैं। एक अत्यधिक चरम उदाहरण जहां मैं 6 0एस को जोड़ देता हूं, जो मुझे सिर्फ उतना ही []एस का उपयोग करने की अनुमति देता है()
जो राजा

2

विकि का उपयोग करें

हमारे पास एक विकी है ! इसमें कुछ लघु चित्रण हैं, लेकिन यह सहायक संसाधन है। इसमें उपयोगी, अच्छी तरह से गोल्फ, स्टैक स्वच्छ कार्यक्रमों की सूची है जिन्हें आप अपने कोड में पेस्ट कर सकते हैं। यदि आप कुछ ऐसा करना चाहते हैं जो आपको लगता है कि किसी ने किया हो सकता है इससे पहले कि विकी पर एक अच्छा मौका है।


2

बेहतर लूपिंग

यहाँ एक आसान है:

एक काफी सामान्य निर्माण है:

(({})<{({}[()]<...>)}{}>)

जहाँ आप n को लूप करना चाहते हैं लेकिन फिर भी n को बनाए रखें। हालाँकि इसे इस प्रकार लिखा जा सकता है:

({<({}[()]<...>)>()}{})

2 बाइट बचाने के लिए।

एक और काफी सामान्य प्रतिमान है

([])({<{}>...<([])>}{})

जो पूरे स्टैक को लूप और संचित करेगा। कुछ फैंसी गणित के कारण यह इस प्रकार है:

(([]){[{}]...([])}{})

1

अपने नकारात्मक की जाँच करें

कभी-कभी आप रणनीतिक रूप से चुनने के लिए कुछ बाइट्स को गोल कर सकते हैं कि इसके साथ क्या करना है [...]

एक सरल उदाहरण नेस्टेड [...]एस में है। उदाहरण के लिए[()()()[()()]] बस हो सकता है[()()()]()()

मान लें कि आप जांचना चाहते हैं कि क्या कोई मूल्य प्रारंभ कोष्ठक है (<{[। प्रारंभिक प्रयास प्रत्येक चरित्र और लूप के बीच के अंतर को घटाना है

({}<(((((       #Push the differences between start bracket characters
(((()()()()){}){}){})   #Push 32
[()])                   #Push 31
[((()()())()){}{}])     #Push 20
){})><>)                #Push 40
<>({<(([{}]<>{}))>(){[()](<{}>)}<>})

हालांकि, आप इसके बजाय मतभेदों के नकारात्मक संस्करणों को धक्का देकर 4bytes बचा सकते हैं!

({}<(((((       #Push the differences between start bracket characters
((([()()()()]){}){}){}) #Push -32
())                     #Push -31
((()()())()){}{})       #Push -20
){})><>)                #Push -40
<>({<(({}<>{}))>(){[()](<{}>)}<>})

आम तौर पर, यह आपको बहुत बचाता नहीं है, लेकिन यह जो आसपास है उसे बदलने के लिए बहुत कम प्रयास खर्च [...]होता है। उन स्थितियों की तलाश में रहें, जहां आप बाद में घटने के बजाय कई बार वेतन वृद्धि पर बचाने के लिए सकारात्मक के बजाय एक काउंटर के नकारात्मक को धक्का दे सकते हैं। या बाहर गमागमन (a[b])के साथ ([a]b)दो नंबर नकारात्मक के बजाय सकारात्मक के बीच अंतर कर सकते हैं।


1
इसी तरह की चीजें शून्य <a<b>c>-> <abc>और <a[b]c>-> के साथ की जा सकती हैं <abc>
गेहूं जादूगर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.