पॉइंटफ्री को पॉइंटफुल में बदलें

Question

हास्केल हैकर होने के नाते, मैं पॉइंटफ्री नोटिफिकेशन ऑन पॉइंटफुल पसंद करता हूं। दुर्भाग्य से कुछ लोगों को पॉइंटफ्री नोटेशन पढ़ने में मुश्किल लगता है, और जब मैं पॉइंटफुल में लिखता हूं तो मुझे सही संख्या में कोष्ठक प्राप्त करने में मुश्किल होती है। मुझे पॉइंटफ्री में लिखे कोड को पॉइंटफुल नोटेशन में बदलने में मदद करें!

के बारे में

पॉइंटफ्री नोटेशन में हम एक फंक्शन के आउटपुट को दूसरे में फीड करने के लिए पॉइंट्स (हाँ, वास्तव में) का उपयोग करते हैं। कहो, अगर आपके पास एक फ़ंक्शन था जो succएक संख्या लेता है और इसमें 1 जोड़ता है, और आप एक ऐसा फ़ंक्शन बनाना चाहते थे जो ऐसा करने के बजाय एक संख्या में 3 जोड़ता है:

\x -> succ(succ(succ(x)))

आप ऐसा कर सकते हैं:

succ.succ.succ

पॉइंटफ्री केवल उन फंक्शंस के साथ काम करता है जो सिंगल पैरामीटर लेते हैं (वैसे भी इस चैलेंज में), इसलिए यदि हमारा फंक्शन नहीं था succ, बल्कि addजो 2 नंबर लेते हैं और उन्हें एक साथ जोड़ते हैं, तो हमें इसे तब तक फीड करना होगा जब तक कि केवल एक ही बचा हो:

pointful:  \x -> add 1(add 1(add 1 x)) 
pointfree: add 1 . add 1 . add 1

अंत में, कार्य तर्कों के रूप में अन्य कार्य कर सकते हैं:

Pointfree: map (f a . f b) . id
Pointful:  \x -> map (\x -> f a (f b x)) (id x)

Javascript equivalent: x => map (x => f(a,f(b,x)), id(x))

इनपुट और अपेक्षित आउटपुट

f . f . f
\x -> f (f (f x))

f a . f b . f c
\x -> f a (f b (f c x))

f (f a . f b) . f c
\x -> f (\x -> f a (f b x)) (f c x)

a b c . d e . f g h i . j k l . m
\x -> a b c (d e (f g h i (j k l (m x))))

a.b(c.d)e.f g(h)(i j.k).l(m(n.o).p)
\x->a(b(\y->c(d y))e(f g h(\z->i j(k z))(l(\q->m(\w->n(o w))(p q))x)))

नियम

• आपके आउटपुट में आवश्यकता से अधिक स्थान या कोष्ठक हो सकते हैं, जब तक कि वे संतुलित हों
• आपको यह सुनिश्चित करने की ज़रूरत नहीं है कि आपके द्वारा बनाए गए चर का नाम \xपहले से ही कोड में कहीं और उपयोग नहीं किया गया है
• यह आपकी पसंद है कि कोई फ़ंक्शन या पूर्ण प्रोग्राम बनाना है या नहीं
• यह codegolf, बाइट्स जीत में सबसे छोटा कोड है!

आपको कुंद उपयोगी मिल सकता है, यह दो नोटेशनों के बीच परिवर्तित होता है (लेकिन जब संभव हो तो कोड को भी कारक करता है): https://blunt.herokokuapp.com

Comments

पॉइंटफ्री नोटेशन में हम एक फ़ंक्शन के आउटपुट को दूसरे में फीड करने के लिए पॉइंट्स का उपयोग करते हैं, यह स्पष्ट रूप से यह साबित करने का प्रयास है कि पॉइंटफ्री बेकार नहीं है

— लुइस

"पॉइंटफ्री केवल उन कार्यों के साथ काम करता है जो एकल पैरामीटर लेते हैं"। यह सच नहीं है: (+).(*3)जैसे ही है\x y->3*x+y

— डेमियन

@ डैमियन मैं चुनौती को अधिक सुलभ बनाने की कोशिश कर रहा था। आप उल्लू जैसी चीजें भी कर सकते हैं: (.).(.)जो कि धर्मान्तरित होती है\i b c f -> i (b c f)

— BlackCap

तो उन लोगों के लिए स्पष्टता के लिए जो दिल से हास्केल के वाक्यविन्यास को नहीं जानते हैं: हमें पहले इनपुट में कोष्ठक से मेल खाना चाहिए और प्रत्येक शीर्ष-स्तरीय कोष्ठक अभिव्यक्ति पर पुनरावृत्ति करना चाहिए; और फिर प्रत्येक .को एक के साथ बदलें (, एक को प्रीपेन्ड करें \xऔर एक संबंधित को जोड़ दें xऔर जितने की )आवश्यकता हो? या यह उससे अधिक जटिल है?

— पीटर टेलर

@ लिनुस \ d->f(\k->f(f d k)), लेकिन आप यह मान सकते हैं कि सभी बिंदुओं को इस चुनौती में दो तर्क दिए गए हैं

— BlackCap

Answer 1

हास्केल, 163 142 133 बाइट्स

p(x:r)|[a,b]<-p r=case[x]of"("->["(\\x->"++a++p b!!0,""];"."->['(':a++")",b];")"->[" x)",r];_->[x:a,b]
p r=[r,r]
f s=p('(':s++")")!!0

Ideone पर इसे आज़माएं।

Ungolfed:

p('(':r)|(a,b)<-p r = ("(\\x->"++a++(fst(p b)),"")
p('.':r)|(a,b)<-p r = ('(':a++")",              b)
p(')':r)            = (" x)",                   r)
p(x  :r)|(a,b)<-p r = (x:a,                     b)
p _                 = ("",                     "")

f s=fst(p('(':s++")"))

Answer 2

हास्केल, 402 289 बाइट्स

काफी लंबा है, लेकिन मुझे लगता है कि यह काम करता है ।।

(!)=elem
n%'('=n+1
n%')'=n-1
n%_=n
a?n=a!"."&&n<1
a#n=a!" ("&&n<1||a!")"&&n<2
q a='(':a++")"
p s o n[]=[s]
p s o n(a:b)|o a n=[t|t@(q:r)<-s:p""o(n%a)b]|0<1=p(s++[a])o(n%a)b
k=foldr((++).(++" ").f)"".p""(#)0
f t|not$any(!"(. ")t=t|l@(x:r)<-p""(?)0t=q$"\\x->"++foldr((.q).(++).k)"x"l|0<1=k t