संक्षेप? यह मेरी बाइट है!

Question

परिचय

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

उदाहरण के लिए, LET 2=4-1अब से निष्पादित करने के बाद 2मान लेता है 3, जिसका अर्थ है कि जब भी 2किसी अभिव्यक्ति में मूल्य आता है, तो इसके बजाय इसे "प्रतिस्थापित" किया जाता है 3। (1+1)*2अब अभिव्यक्ति का मूल्यांकन होगा 9।

फॉरेस्ट में यह निर्देश स्टोरिंग सूचना के लिए और प्रवाह नियंत्रण के लिए दोनों का उपयोग किया जाता है (लाइनें क्रमांकित हैं और उनकी संख्या के मूल्य को बदलकर आप उनके निष्पादन का क्रम निर्धारित कर सकते हैं)। इस चुनौती में हम इस दूसरे पहलू से नहीं निपटेंगे।

चुनौती

आपको फोर्ट के LETभावों के सरलीकृत सबसेट के लिए एक दुभाषिया लिखना आवश्यक है ।

आपको इस व्याकरण के बाद लाइनों की एक श्रृंखला इनपुट के रूप में प्राप्त होगी:

<line>::= <number>=<expression>

<expression>::= <number>|<expression>+<number>

_{नोट: यह व्याकरण मान्य Forte नहीं है क्योंकि इसमें लाइन नंबर, LET और कोष्ठक का अभाव है (जो हमेशा अनिवार्य होते हैं)}

यही है, आपको केवल कंप्यूटिंग योगों और संख्याओं को मान असाइन करने की आवश्यकता होगी। कोष्ठक इनपुट में मौजूद नहीं होगा, और प्रत्येक अभिव्यक्ति को बाएं से दाएं का मूल्यांकन करने की आवश्यकता होगी: सावधान रहें कि आंशिक परिणाम पुनर्वितरण से प्रभावित होते हैं!

नंबर हमेशा गैर-नकारात्मक पूर्णांक होंगे, आपकी भाषा के मूल पूर्णांक प्रकार (या 2 ^ 32, जो भी अधिक हो) की सीमा तक।

प्रत्येक पंक्ति के लिए आपको अभिव्यक्ति के परिणाम का उत्पादन करना चाहिए और इस परिणाम को पहले नंबर के (संभवतः पुन: असाइन किए गए) मान पर असाइन करना चाहिए, जो प्रभावित करेगा कि निम्नलिखित पंक्तियों की व्याख्या कैसे की जाएगी।

यह कोड-गोल्फ है , सबसे छोटा कोड (बाइट्स में) जीतता है!

अन्य नियम

• इनपुट प्रारूप लचीला है, उदाहरण के लिए आप एक ही स्ट्रिंग को ले सकते हैं newlines, तार की एक सूची, संख्याओं की सूची की सूची ... यह आउटपुट के लिए जाता है, जब तक यह स्पष्ट है कि प्रत्येक अभिव्यक्ति का परिणाम क्या है इनपुट।
• आप प्रत्येक पंक्ति के लिए एक बार कॉल करके एक फ़ंक्शन, एक पूर्ण प्रोग्राम, या एक REPL वातावरण में चलाने के लिए एक समाधान प्रस्तुत कर सकते हैं।
• मानक कमियां निषिद्ध हैं, विशेष रूप से आप अपने कोड में एक बाहरी फोर्ट इंटरप्रेटर को नहीं बुला सकते हैं।

उदाहरण

ये सभी एक ही इनपुट के भाग हैं। प्रत्येक पंक्ति के बाद उस पंक्ति के सापेक्ष अपेक्षित आउटपुट दिखाया जाता है, कभी-कभी एक टिप्पणी के साथ प्रासंगिक पुनर्मूल्यांकन (आवश्यक आउटपुट का हिस्सा नहीं) का संकेत देता है।

5=4
4
6=5
4        # 5 -> 4
7=1+2+5
7
7=5+2+1
4        # Order of operations matters! 5+2 -> 4+2 -> 6 -> 4
18=5+6+7
12
5=3
3        # Remember: 5 -> 4
10=6+4
3        # 6 -> 4 -> 3, 3+3 = 6 -> 3

Comments

है 0कोई मान्य संख्या?

— orlp

@orlp 0वैध है ("संख्या हमेशा गैर-नकारात्मक पूर्णांक होगी")

— सिंह

क्या हमें किसी अंकगणित संचालक को स्वीकार करना चाहिए?

— bacchusbeale

@bacchusbeale नहीं, बस सारांश।

— सिंह

क्या कोई विशेष अधिकतम संख्या है, या यह भाषा के मूल पूर्णांक प्रकार जितना बड़ा है? इसके अलावा, संख्याओं की सूची वापस करने के लिए यह अमान्य आउटपुट होगा, जिनमें से एक परिणाम है, है ना? (जैसे कि शब्दकोश / मैप को प्रिंट करने के लिए किस नंबर पर किस नंबर पर जाता है)

— zgrep

Answer 1

जेली , 28 बाइट्स

®y$ÐL
ṪÇ+Ç¥/Ṅ;®⁸Ǥ;©
⁸©ḷƓÇ€¤

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

यह उन कुछ जैली कार्यक्रमों में से एक है, जहाँ मानक इनपुट से इनपुट लेना टेस्टर लगता है। यह एक पूर्ण कार्यक्रम है (एक फ़ंक्शन लिखना कम होता है लेकिन पीपीसीजी नियमों द्वारा प्रतिबंधित है, क्योंकि यह दूसरी बार सही तरीके से नहीं चलेगा)। इनपुट प्रारूप इस तरह दिखता है:

[[5,[4]],[6,[5]],[7,[1,2,5]],[7,[5,2,1]],[18,[5,6,7]],[5,[3]],[10,[6,4]]]

व्याख्या

हेल्पर फ़ंक्शन 1Ŀ (इसके मूल्य के लिए पूर्णांक का अनुवाद करें)

®y$ÐL
   ÐL   Repeatedly, until there are no further changes,
  $       apply the following unary function to {the input}:
 y          replace values using the mapping table
®             stored in the register.
        {Then return the eventual result.}

आसानी से, बल्कि यह सहायक फ़ंक्शन सही तरीके से या तो एकल मान, या मूल्यों की एक सूची पर काम करेगा, जिस तरह yसे परिभाषित किया गया है। यदि एकल मान के लिए एक से अधिक मैपिंग दी जाती है, तो हम तालिका से पहली मैपिंग लेते हैं। मैपिंग टेबल को रजिस्टर में संग्रहीत किया जाता है (जो मूल रूप से सिर्फ एक चर है; जेली में केवल एक चर है)।

हेल्पर फ़ंक्शन 2Ŀ (एक एलईटी निर्देश का मूल्यांकन करें)

ṪÇ+Ç¥/Ṅ;®⁸Ǥ;©
Ṫ               On the last element of {the input},
 Ç              Run 1Ŀ,
     /          left fold it via
    ¥             the following binary function:
  +                 add {the two arguments}
   Ç                and run 1Ŀ on {the result},
      Ṅ         write {the result} (and a newline) to standard output,
       ;®       append the value of the register,
            ;   prepend
           ¤      the following value:
         ⁸          {the input, without its last element}
          Ç         with 1Ŀ run on it
             ©  and store that value in the register {and return it}.

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

मुख्य कार्यक्रम

⁸©ḷƓÇ€¤
 ©       Initialize the mapping table
⁸        with the empty string (which is also the empty list)
  ḷ      then evaluate and discard
      ¤  the following value:
   Ɠ       a line from standard input, parsed into a data structure
    Ç€     with each element transformed via 2Ŀ
         {and leave the empty string to be printed implicitly}

आम तौर पर, ⁸इस संदर्भ में चलने पर हमें पहली कमांड-लाइन तर्क देगा, लेकिन कोई भी नहीं है (हम मानक इनपुट से इनपुट ले रहे हैं), इसलिए यह एक वैकल्पिक मोड में चलता है जो हमें अशक्त स्ट्रिंग देता है। रजिस्टर को शुरू करने की आवश्यकता (इसके डिफ़ॉल्ट मान से 0, जो क्रैश हो जाती है y) का अर्थ है कि हम उपयोगकर्ता के इनपुट का स्पष्ट रूप से उल्लेख नहीं कर सकते हैं, जिसका अर्थ है कि इसे मानक इनपुट ( Ɠ) से लेना उतना ही सस्ता है, क्योंकि इसे किसी से लेना होगा कमांड लाइन तर्क ( ³या ⁸), और ⁸इनपुट के असामान्य (जेली के लिए) रूप का वैकल्पिक उपयोग करने में सक्षम होने के नाते वास्तव में एक बाइट कम है।

यह संभव है कि यह कामचलाऊ है। मुझे अभी तक यह पता नहीं चला है कि दूसरी पंक्ति को ⁸Ǥ;सिर्फ कहने की ज़रूरत क्यों है ;@Ç- दोनों को बराबर होना चाहिए, जहाँ तक मैं जेली को समझता हूं, µ/ ð/ के उपयोग की कमी को देखते हुए, øलेकिन बाद में किसी कारण से दुर्घटनाग्रस्त हो जाता है। इसी तरह, बाइट्स को खोए बिना कार्यक्रम को पुनर्व्यवस्थित करने के लिए कई अन्य तरीके हैं, इसलिए यह संभव है कि मैंने चीजों को थोड़ा कम करने का एक तरीका याद किया है।

संयोग से, ḷअंतिम पंक्ति में परिवर्तन ;आपको कार्यक्रम के आंतरिक कामकाज में एक दिलचस्प रूप देता है, क्योंकि यह "रजिस्टर का इतिहास" का उत्पादन करेगा, जो कि वापसी के मूल्यों द्वारा अनुमानित रूप से आउटपुट है 2Ḷ।

Answer 2

पर्ल 5 , 92 बाइट्स

कोड + -plझंडे के 90 बाइट्स ।

sub f{($b=$h{$a=pop}//$a)!=$a?f($b):$a}s%(\d+)\+(\d+)%f($1)+f$2%e&&redo;/=/;$_=$h{f$`}=f$'

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

मैं %hसंख्याओं के बीच मैपिंग को संग्रहीत करने के लिए हैशटेबल का उपयोग करता हूं ।
फ़ंक्शन ( sub) fउस नंबर को लौटाता है जिसका इनपुट मैप (या उसका इनपुट अगर यह बिना नंबर के मैप किया जाता है): $h{$a=pop}उस नंबर को फिर से प्राप्त करता है जिस ओर इनपुट मैप्स करता है। यदि यह कोई नहीं है, तो धन्यवाद //$a, ($b=$h{$a=pop}//$a)इनपुट का मूल्य ( $a) है। हम यह सुनिश्चित करते हैं कि यह मान स्वयं इनपुट नहीं है कि अनन्त रूप से लूप न करें ( !=$a)। फिर, हम या तो पुनरावर्ती कॉल करते हैं fया इनपुट वापस करते हैं।
मुख्य कार्यक्रम में दो चरण होते हैं:
- s%(\d+)\+(\d+)%f($1)+f$2%e&&redoदाईं ओर पहले जोड़ का मूल्यांकन करता है, जबकि अभी भी एक अतिरिक्त है: यह x+yमूल्यांकन के परिणाम से बदल जाता है f(x)+f(y)।
- /=/;$_=$h{f$`}=f$'काम करता है:/=/के साथ बाईं ओर $`और दाईं ओर का उपयोग करने की अनुमति देता है $', फिर $h{f$`}=f$'असाइनमेंट करता है। और हम यह भी निर्दिष्ट करते हैं $_कि प्रत्येक पंक्ति के बाद स्पष्ट रूप से मुद्रित किया जाता है।

Answer 3

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

v=x=>(v[x]=v[x]||x,v[x]-x?v(v[x]):x)
f=x=>l=>v[v(x)]=l.reduce((p,x)=>v(v(x)+p),0)

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

असाइन करने के लिए मान के साथ f कॉल करके इनपुट प्राप्त करता है, फिर एक साथ जोड़ने के लिए मानों की एक सरणी के साथ उस का परिणाम कॉलिंग। (यानी f(5)([4])) कई लाइनों के लिए दोहराएँ।

vएक संख्या के वास्तविक वर्तमान मूल्य की गणना करने के लिए एक फ़ंक्शन के रूप में उपयोग किया जाता है, और वास्तविक मूल्यों को संग्रहीत करने के लिए एक वस्तु के रूप में भी। पहले v[x]=v[x]||xसुनिश्चित करता है कि v[x]परिभाषित किया गया है। v[x]-xयह निर्धारित करने के लिए तुलना करता है कि यह वास्तविक संख्या है या नहीं। यदि संख्या खुद से मैप नहीं होती है, तो v(v[x])पुन: पुन: प्रयास करता है, अन्यथा वापस लौटाएं x।

f गणना और असाइनमेंट करता है, एक बाइट को बचाने के लिए, जहां दूसरी कॉल परिकलित मान लौटाता है।

Answer 4

हास्केल , 116 113 108 106 बाइट्स

(#)=until=<<((==)=<<)
e?((n,s):r)|m<-foldl1(\a b->e#(e#a+e#b))s=m:(\x->last$m:[e#x|x/=e#n])?r
e?r=[]
(id?)

इसे ऑनलाइन आज़माएं! प्रत्येक समीकरण 4=3+1+5टपल के रूप में नहीं देखा गया है (4,[3,1,5])। अनाम फ़ंक्शन (id?)ऐसे ट्यूपल्स की एक सूची लेता है और सभी मध्यवर्ती परिणामों की सूची देता है।

#किसी दिए गए फ़ंक्शन का एक फ़िक्सप्वाइंट eऔर एक स्टार्ट वैल्यू खोजने के लिए एक फ़ंक्शन है x।

फ़ंक्शन ?एक मूल्यांकन फ़ंक्शन लेता है eऔर प्रत्येक समीकरण को पुनरावृत्ति करता है। foldl1(\a b->e#(e#a+e#b))sएक समीकरण के दाहिने हाथ की ओर का मूल्यांकन करता है और परिणाम को बचाता है m, उदाहरण के लिए 4=3+1+5यह गणना करता है eval(eval(eval 3 + eval 1) + eval 5), जहां प्रत्येक evalका एक फिक्स पॉइंट एप्लिकेशन है e। तब के नए कार्यभार को लेने के लिए eval फ़ंक्शन को संशोधित किया गया हैn को खाते गया है: (\x->last$m:[e#x|x/=e#n])जो कि जैसा है वैसा ही है \x -> if x == eval n then m else eval x।

प्रारंभिक मूल्यांकन कार्य है id जो प्रत्येक पूर्णांक को अपने आप में मैप करता है।

---

2 बाइट्स की बचत के लिए अर्जन जोहानसेन को धन्यवाद!

Comments

अच्छी नौकरी! वैसे आपको सभी मध्यवर्ती परिणाम वापस करने की आवश्यकता होती है, इसलिए आप ड्रॉप कर सकते हैंlast.

— लियो

(#)e=until((==)=<<e)eया (#)=until=<<((==)=<<)कम है।

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

@ !RjanJohansen बहुत बहुत धन्यवाद!

— लकोनी

Answer 5

ओके, 48 बाइट्स

a:[];s:{*(a@x;x)^0N}/;f:{a[s@x]:y:{s@x+y}/s'y;y}

उपयोग: f[5;1 2 3] / 5=1+2+3

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

---

आप इस तरह के केवल नंबर का उपयोग कर के रूप में जो नंबर आप उपयोग कर सकते हैं, के लिए एक ऊपरी सीमा होने पर आपत्ति नहीं है 0के माध्यम से 998निम्नलिखित suffices, तो ( 41 बाइट्स में कुछ अधिकतम के आधार पर ±):

a:!999;s:(a@)/;f:{a[s@x]:y:{s@x+y}/s'y;y}

---

स्पष्टीकरण:

; तीन परिभाषाओं को अलग करता है।

aसंख्याओं का शब्दकोश / मानचित्र है। पहले मामले में, यह एक वास्तविक, खाली शब्दकोश है [], दूसरे मामले में यह संख्याओं की एक सूची 0है 998।

sएक फ़ंक्शन है जो एक नंबर दिए जाने पर "परिणामी" संख्या पाता है। /समारोह का मतलब है कि यह जब तक उत्पादन बदल रहा बंद हो जाता है अपने स्वयं के उत्पादन के लिए ही लागू होगी के अंत पर।

अंतिम बिट f, इसका मतलब है कि:

f:{                      } /function called f, input number x, list y
                    s'y    /apply s to every number in the list
                   /       /fold through the list
            {s@x+y}        /    sum the two numbers, apply s
   a[s@x]:                 /set the s(x) to map to the final sum
          y:           ;y  /redefine y to be the final sum, then return it

Answer 6

पायथन 3, 146 132 130 बाइट्स

14 बाइट्स ने
@ धन्यवाद का धन्यवाद बचाया 2 बाइट्स ने @ mbomb007 को धन्यवाद दिया

d={}
g=lambda x:d.get(x)and x!=d[x]and g(d[x])or x
def f(t):
 for n,(s,*r)in t:
  for b in r:s=g(g(s)+g(b))
  d[g(n)]=s;yield g(n)

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

समीकरणों के ट्यूपल्स के रूप में इनपुट प्राप्त करता है [के x = y + z + wरूप में (x, (y, z, w))], जनरेटर के माध्यम से आउटपुट।

Comments

क्या आप एक मंगलाचरण दिखा सकते हैं ताकि इसका परीक्षण किया जा सके?

— सिंह

@LIO ने TIO को जोड़ा।

— ऊरीएल

gशायद लिखा जा सकता है g=lambda x:d.get(x)and d[x]!=x and g(d[x])or x। और मुझे लगता है कि आप 2 के बजाय इंडेंट करने के लिए 1 स्थान का उपयोग कर सकते हैं। यह आपको [132 बाइट्स] तक पहुंचाना चाहिए ( ऑनलाइन इसे आज़माएं! )।

— दादा

@ दादा धन्यवाद! बहुत बुरा वे आधा स्थान इंडेंट नहीं है: पी

— यूरिल

कोई आधा-स्थान इंडेंट नहीं है, लेकिन एक और साफ चाल दो स्थानों के बजाय एक टैब का उपयोग कर रही है। जब तक इंडेंटेशन अलग हैं, पायथन खुश है (आप उदाहरण के लिए अतिरिक्त नेस्टेड स्तरों पर इंडेंटेशन के रूप में स्पेस-टैब और टैब-स्पेस का उपयोग कर सकते हैं)। यह आपको दो बाइट्स बचा सकता है :)

— लियो