आपकी कंपनी अभी एक परियोजना पर शुरू हो रही है, और पहली बार आपने एक कार्यात्मक प्रोग्रामिंग कोड-शैली का उपयोग करने का फैसला किया है। हालाँकि आपका बॉस वास्तव में अलग है और बिल्ट-इन फ़ंक्शंस का उपयोग नहीं करना चाहता है, और आपको स्वयं को मुख्य फ़ंक्शंस लागू करने की आवश्यकता है। विशेष रूप से आप कार्यों लिखने के लिए की जरूरत है: Map, Nest, Apply, Range, FoldऔरTable अपनी पसंद पर एक भाषा में। बॉस वास्तव में व्यस्त आदमी है, और वह कार्यक्रमों को यथासंभव छोटा करना चाहता है, इसलिए वह पढ़ने में समय बर्बाद नहीं करता है। वह यह भी नहीं चाहेंगे कि आप लूप का उपयोग न करें, इसलिए लूप का उपयोग न करने के लिए आपको बाइट की गिनती में 10% की कमी होगी।

कार्यों की विस्तृत आवश्यकताएं नीचे हैं:

नक्शा

Mapसमारोह दो पैरामीटर लेता है: fऔर listजहां fएक समारोह है और listमूल्यों की एक सूची है। इसे fप्रत्येक तत्व पर लागू होना चाहिए list। इसलिए यह इस तरह काम करेगा:

Map(f,{a,b,c})

रिटर्न

{ f(a), f(b), f(c) }

तथा

Map(f, {{a,b},{b,c}})

रिटर्न

{ f({a,b}), f({b,c})}

घोंसला

Nestसमारोह तीन पैरामीटर के रूप में अच्छी तरह से लेता है: f, arg, timesजहां fएक समारोह है, argइसके शुरू होने वाले तर्क है, और timesकितनी बार समारोह लागू किया जाता है। इसे fलागू timesसमय के साथ एक अभिव्यक्ति लौटानी चाहिए arg। इसलिए यह इस तरह काम करेगा:

Nest(f, x, 3)

रिटर्न

f(f(f(x)))

तथा

Nest(f, {a,b}, 3)

रिटर्न

f(f(f({a,b})))

लागू करें

Applyसमारोह दो पैरामीटर लेता है: fऔर argsजहां fएक समारोह और है argsएक सूची है। यह आवेदन करना चाहिए fकरने के लिए args। इसलिए:

Apply(f, {a,b,c})

रिटर्न

f(a,b,c)

रेंज

Rangeसमारोह एक पूर्णांक लेता है rऔर उस नंबर से ऊपर पूर्णांकों आउटपुट। इसलिए:

Range(5)

रिटर्न

{ 1, 2, 3, 4, 5}

तह

Foldसमारोह तीन पैरामीटर लेता है f, arg, othersजहां fएक समारोह है, argसाधारण पैरामीटर, और है othersएक सूची है। यह इस तरह काम करेगा:

Fold(f, x, {a, b, c, d})

रिटर्न

f(f(f(f(x,a),b),c),d)

तालिका

तालिका फ़ंक्शन को एक फ़ंक्शन fऔर iteratorफॉर्म में बुलाया एक पैरामीटर लेना चाहिए : {iMin, iMax}जहां iMinऔर iMaxपूर्णांक हैं। आपको fनिर्दिष्ट सीमा से अधिक आवेदन करना चाहिए । इसलिए:

Table(f, {0, 5})

रिटर्न

{f(0), f(1), f(2), f(3), f(4), f(5)}

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

मानक Loopholes हमेशा की तरह बंद कर दिए जाते हैं।

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

यह कोड गोल्फ है इसलिए सबसे छोटा कोड जीतता है। सौभाग्य!!!

code-golf functional-programming

— WizardOfMenlo
स्रोत

यह कमाल का है! +1 हालाँकि, मुझे वास्तव में यह नहीं पता कि Tableयहाँ कैसे काम करता है। क्या आपका उदाहरण होना चाहिए Table(f, {x, 0, 5})? मुझे इसका उद्देश्य बिल्कुल भी नहीं मिलता x, क्योंकि यह केवल फंक्शन को रेंज में लागू करता है।

— kirbyfan64sos

@ kirbyfan64sos धन्यवाद! हां, यह एक टाइपो था, मैंने x को गणितज्ञ के संदर्भ के रूप में छोड़ दिया, जो इसे प्रतीकात्मक रूप में इस्तेमाल करता है, हालांकि मुझे लगता है कि मैं इसे बाहर निकाल सकता हूं

— विजार्डऑफमेनो

एक और सवाल: हम कार्यों को कैसे नाम देते हैं? क्या हमें उन्हें ठीक वैसा ही नाम देना होगा? एकल अक्षर का?

— kirbyfan64sos

@ kirbyfan64sos चूंकि यह कोड-गोल्फ है, इसलिए मैं एकल अक्षर नामों की अनुमति दूंगा, हालांकि आपके उत्तर में प्रत्येक फ़ंक्शन पर एक शीर्षक दिया जाएगा ताकि हमें पता चले कि यह कौन सा है। इसके अलावा टकराने वाले पत्रों का उपयोग न करें।

— जादूगरऑफमेलो

क्या आप एक लूप के रूप में गिना जा सकता है?

— 17

9

हास्केल, पिछले कई बाइट्स 127 * 0.9 = 114.3 बाइट्स गिना करते हैं

f#(a:b)=f a:f#b;f#x=x
(f&x)0=x;(f&x)i=f$f&x$i-1
i=id
r x=i%(1,x)
(g?x)(a:b)=g(g?x$b)a;(g?x)y=x
f%(a,b)|a>b=[]|1<2=f a:f%(a+1,b)

नहीं छोरों, बस पुनरावृत्ति।

#नक्शा है: (*2) # [1,2,3]->[2,4,6]

&घोंसला है: ((*2) & 3) 4->48

iलागू होता है: i (*2) 7->14

rरेंज है: r 4->[1,2,3,4]

?गुना है: ((+) ? 0) [1,2,3,4]->10

%तालिका है: (*2) % (2,4)->[4,6,8]

जैसा कि टिप्पणियों के साथ एक ungolfed संस्करण का अनुरोध किया। ध्यान दें, &और ?टर्नरी इन्फिक्स ऑपरेटर हैं, जिन्हें अतिरिक्त कोष्ठकों की आवश्यकता होती है जब बुलाया जाता है या पैटर्न का मिलान होता है।

f # (a:b) = f a : f#b        -- map on a list (a->head, b->tail) is f a in front of mapping f to b
f # x     = x                -- map on the empty list is the empty list
                             -- (non empty lists are caught in the line before) 

(f & x) 0 = x                -- nesting zero times is x
(f & x) i = f $ f&x $ i-1    -- nesting i times is f (nesting one time less)

i=id                         -- apply in Haskell is just the identity function 

r x = i % (1,x)              -- defined via the "table" of the identity function from 1 to x

(g ? x) (a:b) = g (g?x$b) a  -- folding g into a list (a->head, b->tail) is g applied to (folding g into b) and a
(g ? x) y     = x             -- folding the empty list is x
                             --  again, y must be the empty list, else it would have been handled by the previous line

f % (a,b)                    
  |a>b       = []                -- if iMin is greater than iMax, the table is empty
  |otherwise = f a : f%(a+1,b)   --  otherwise f a in front of the table with iMin increased by one

कुछ उपयोगी संकेत के लिए @dfeuer और @Zgarb को धन्यवाद

— nimi
स्रोत

मैं हैस्केल के लिए नया हूं, यह काफी अच्छा लग रहा है, हालांकि क्या आप कृपया एक स्पष्टीकरण जोड़ सकते हैं कि आप क्या कर रहे हैं?

— जादूगरऑफमेनो

1

@WizardOfMenlo: कुछ टिप्पणियां जोड़ी

— nimi

बस एहसास हुआ कि हास्केल कितना सुंदर है, असली अच्छा है!

— जादूगरऑफमेनो सेप

1

अनंत सूचियों और दक्षता की अनदेखी करते हुए m#q=reverse$f((:).m)[]q। यह आपकी लंबाई के समान है, लेकिन पढ़ने में बहुत कठिन है।

— dfeuer

आप छोटा कर सकते हैं !एक ऑपरेटर के बजाय इसे एक नाम बनाने के द्वारा: i f=f।

— dfeuer

5

पायथन 2, 305.1 बाइट्स (-10% 376 369 366 349 339 बाइट्स)

exec'e=eval;q=len;m=@,l:e("["+"f(l.pop()),"*q(l)+"][::-1]");n=@,x,l:e("f("*l+"*x"+")"*l);r=@:e("r(f-1)+"*(f>1)+"[f]");a=@,a:e("f(a["+`r(q(a))`[1:-1]$",","-1],a[")+"-1])");f=@,x,l:e("f("*q(l)+"x,["+`r(q(l))`[1:-1]$",","-1]),l[")+"-1])");t=@,n,x:e("[f("+`r(x)[n-1:]`$",","),f(")[1:-1]+")]")'.replace("@","lambda f").replace("$",".replace(")

जब इसका विस्तार किया गया, तो इसके बराबर:

e=eval;q=len
m=lambda f,l:e("["+"f(l.pop()),"*q(l)+"][::-1]")
n=lambda f,x,l:e("f("*l+"*x"+")"*l)
r=lambda i:e("r(i-1)+"*(i>1)+"[i]")
a=lambda f,a:e("f(a["+`r(q(a))`[1:-1].replace(",","-1],a[")+"-1])")
f=lambda f,x,l:e("f("*q(l)+"x,["+`r(q(l))`[1:-1].replace(",","-1]),l[")+"-1])")
t=lambda f,n,x:e("[f("+`r(x)[n-1:]`.replace(",","),f(")[1:-1]+")]")

नहीं छोरों!

खैर, यह बहुत कुछ करता है eval और यदि आपका बॉस लूप नहीं खड़ा कर सकता है, तो वे घृणा का कारण बनेंगे। लेकिन, वे इसे करने जा रहे हैं

करने का एक तरीका range लंबोदर में सराहा जाता है, इसलिए मुझे कोई कार्य नहीं करना है (शूडर।)।

स्पष्टीकरण:

m=lambda f,l:eval("["+"f(l.pop()),"*len(l)+"][::-1]")
- सूची से तत्वों को पॉप करने वाली एक स्ट्रिंग बनाएं, इसे सूची में लपेटें, इसे उल्टा करें और अंत में इसे खाली करें!
n=lambda f,x,l:eval("f("*l+"*x"+")"*l)
- मैन्युअल रूप से घोंसले के शिकार के साथ स्ट्रिंग बनाएं, और इसे खाली करें!
r=lambda i:e("r(i-1)+"*(i>1)+"[i]")
- एक स्ट्रिंग बनाएँ eval, जब एड, [0]पिछले परिणामों को प्राप्त करने के लिए या तो रिटर्न करता है या पुनरावर्तन का उपयोग करता है , और सूची में वर्तमान सूचकांक जोड़ता है। इसका प्रमाण है।
a=lambda f,a:eval("f(a["+आर (LEN (क))[1:-1].replace(",","-1],a[")+"-1])")
- अनुक्रमित 1-लेन (सूची) प्राप्त करने के लिए रेंज फ़ंक्शन का उपयोग करता है। सूची में कॉमा को प्रतिस्थापित करके सूची के सही सूचकांक प्राप्त करने के तरीके के साथ कड़ा किया जाता है a। इसका सबूत है!
f=lambda f,x,l:eval("f("*len(l)+"x,["+आर (LEN (एल))[1:-1].replace(",","-1]),l[")+"-1])")
- कोष्ठक को छोड़कर, कोमा को बंद करने, अल्पविराम और सूची सूचकांक शुरू करने के साथ लागू होता है।
t=lambda f,n,x:eval("[f("+r (x) [n-1:].replace(",","),f(")[1:-1]+")]")
- फ़ंक्शन को समाप्त करने और नए को कॉल करने के साथ प्रतिस्थापित करने के अलावा लागू करें और मोड़ें। इसका सबूत है!

नक्शा, घोंसला, रेंज, लागू, गुना, टेबल।

रेंज के लिए एक मेमने के लिए @Zgarb धन्यवाद!

— नीला
स्रोत

मेरे मालिक ने अपने डेस्क पर मेरा सिर होगा :) क्या आप कृपया एक संक्षिप्त विवरण जोड़ सकते हैं?

— विजार्डऑफमेनो

कैसे के बारे में r=lambda i:[]if i<1 else r(i-1)+[i]? लूप नहीं, केवल रिक्रिएशन।

— जर्गब

1

यकीन है, मैं इसे अभी के लिए ले जाऊंगा, लेकिन बॉस evalको यह दिखाने के लिए और अधिक की आवश्यकता है कि लूप के लिए कैसे इतना बुरा नहीं है :)

— ब्लू

हा! एक अन्य संस्करण का उपयोग कर e=eval:r=lambda i:e("r(i-1)+"*(i>1)+"[i]")

— ज़गारब

क्या आप इसे 60% बोनस से 10% तक बदल सकते हैं? मैंने प्रश्न विनिर्देश को संशोधित किया, इसलिए इसे उचित बनाने के लिए

— विजार्डऑफमेनो

5

जावास्क्रिप्ट ईएस 6, 197 * 0.9 = 177.3 बाइट्स

M=(f,l)=>F((a,b)=>[...a,f(b)],[],l)
N=(f,x,n)=>f(--n?N(f,x,n):x)
A=(f,l)=>f(...l)
R=n=>n--?[...R(n),n+1]:[]
F=(f,x,l,n=l.length)=>n--?f(F(f,x,l,n),l[n]):x
T=(f,i)=>([n,x]=i,M(q=>f(q+n-1),R(x-n+1)))

नक्शा ( `M=(f,l)=>F((a,b)=>[...a,f(b)],[],l)`):

रिक्त सूची के प्रत्येक सदस्य पर लागू परिणामों को संक्षिप्त करने के लिए फोल्ड का उपयोग करता है । अंतर्निहित कार्यों का उपयोग करने से यह कम हो जाता है (इसका उपयोग नहीं किया क्योंकि यह सस्ता लगता है ...?)।flM=(f,l)=>l.map(f)

घोंसला ( `N=(f,x,n)=>f(--n?N(f,x,n):x)`):

0 fतक अपघटित होने तक पुनरावर्ती लागू करें n।

लागू करें ( `A=(f,l)=>f(...l)`):

पर ...लागू करने के लिए प्रसार ( ) ऑपरेटर का उपयोग करता है ।lf

रेंज (`R=n=>n--?[...R(n),n+1]:[]` ):

Concat nकी पुनरावर्ती कॉल करने के लिएरेंजn 0 तक घटने तक ।

तह ( `F=(f,x,l,n=l.length)=>n--?f(F(f,x,l,n),l[n]):x`):

की पुनरावर्ती कॉल पर लागू होता है फोल्ड और n'की वें तत्व lको fजब तकn 0 पर कम कर रहा है का उपयोग करना बिल्ट-इन कार्य को यह कम कर देता हैF=(f,x,l)=>l.reduce(f,x) (... फिर, लग रहा था सस्ता)।

तालिका (`T=(f,i)=>([n,x]=i,M(q=>f(q+n-1),R(x-n+1)))` ):

सबसे पहले आरंभ nऔर xiMin और IMAX destructuring (उपयोग करने के लिए [n,x]=i), तो का उपयोग करता रेंज आइमैक्स को iMin से मानों की तालिका के निर्माण के लिए। fफिर मानचित्र का उपयोग करके तालिका पर लागू किया जाता है और परिणाम वापस आ जाता है।

— Dendrobium
स्रोत

मेरे दर्शन को जानना चाहते हो? "अगर यह सस्ता है, तो इसे खरीदें।" यह ऐनक में यह नहीं कहता है कि आप बिलिंस (अभी तक) का उपयोग नहीं कर सकते हैं, इसलिए उनका उपयोग करें!

— मामा फन रोल

4

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

अपठनीय संस्करण:

exec("P!:[f(_)for _ in x];Y!,z:Y(f,f(x),z-1)if z else x;T!:f(*x);H!=0:(H(f-1)if~-f else[])+[f];O!,z:O(f,f(x,z[0]),z[1:])if z else x;N!:(N(f,[x[0],x[1]-1])if x[1]-x[0]else[])+[f(x[1])]".replace("!","=lambda f,x"))

(अधिक) पठनीय संस्करण:

P=lambda f,x:[f(_)for _ in x]
Y=lambda f,x,z:Y(f,f(x),z-1)if z else x
T=lambda f,x:f(*x)
H=lambda f,x=0:(H(f-1)if~-f else[])+[f]
O=lambda f,x,z:O(f,f(x,z[0]),z[1:])if z else x
N=lambda f,x:(N(f,[x[0],x[1]-1])if x[1]-x[0]else[])+[f(x[1])]

हालांकि यह एक बार में एक मेमना है:

नक्शा समारोह `P`

P=lambda f,x:[f(_)for _ in x]
बस एक साधारण पुनरावृत्त। यहां कहने के लिए कुछ अधिक नहीं।

घोंसला समारोह `Y`

Y=lambda f,x,z:Y(f,f(x),z-1)if z else x
हर बार zआवेदन करने fपर , शून्य को हिट करने तक दोहराते हुए । यदि अंत में क्लॉन्ज़ क्लंकी लगता है; शायद पुनरावृत्ति को समाप्त करने का एक बेहतर तरीका है।

फ़ंक्शन लागू करें `T`

T=lambda f,x:f(*x)
पायथन के पास मेरे लिए भारी लिफ्टिंग करने के लिए एक अच्छा विस्तार ऑपरेटर है।

सीमा समारोह `H`

H=lambda f,x=0:(H(f-1)if~-f else[])+[f]
यह एक मुश्किल से मैं उम्मीद कर रहा था। एक पुनरावर्ती दृष्टिकोण लेने का समर्थन किया। फिर, अगर-और निर्माण में बहुत सारे बाइट्स लगते हैं, और मुझे लगता है कि इसमें सुधार किया जा सकता है। यह एक डमी क्यों है x=0, आप पूछते हैं? यह ऐसा है कि जब मैं इसके साथ संपीड़ित करता हूंexec हूं, तो मैं =lambda f,xबस के बजाय बदल सकता हूं=lambda f ।

समारोह मोड़ो `O`

O=lambda f,x,z:O(f,f(x,z[0]),z[1:])if z else x
इससे बहुत खुशी हुई। जब तक कुछ भी नहीं बचा है, तब तक हर बार सरणी के पहले तत्व को खो देता है।

तालिका समारोह `N`

N=lambda f,x:(N(f,[x[0],x[1]-1])if x[1]-x[0]else[])+[f(x[1])]
यह एक भयानक है और मुझे यकीन है कि इसमें सुधार की गुंजाइश है। map(f,range(x,y))निर्माण के एक प्रकार के लिए पहले से परिभाषित सीमा और मानचित्र कार्यों का उपयोग करने की कोशिश की , लेकिन बहुत सफलता के बिना। एक भयानक कर समाप्त किया पुनरावर्ती दृष्टिकोण करने के लिए संपन्न हुआ जो रेंज फ़ंक्शन के लिए कुछ समानता साझा करता है।

सभी लैम्ब्डा को बाइट की गिनती को छोटा करने के लिए execएक में लपेटा जाता है replace।

— Tryth
स्रोत

मैं उस टिप्पणी के बारे में था [f(_)for _ in x]जिसे छोटा किया जा सकता था map(f,x), लेकिन फिर मुझे याद आया कि चुनौती क्या थी

— साइओस

4

जूलिया, 181 बाइट्स

मेरे लिए कोई बोनस नहीं; मैंने उदारतापूर्वक छोरों का इस्तेमाल किया। सॉरी बॉस, लेकिन जूलिया में लूप कुशल हैं!

M(f,x)=[f(i...)for i=x]
N(f,x,n)=(for i=1:n x=f(x...)end;x)
A(f,x)=f(x...)
R(n)=(i=0;x={};while i<n push!(x,i+=1)end;x)
F(f,x,a)=(for b=a x=f(x,b)end;x)
T(f,i)=[f(j)for j=i[1]:i[2]]

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

फ़ंक्शन नाम:

नक्शा: M
घोंसला: N
लागू करें: A
रेंज: R
तह: F
तालिका: T

— एलेक्स ए।
स्रोत

4

tinylisp , 325 * 0.9 = 292.5

भाषा सवाल से नई है, लेकिन यह वैसे भी जीतने वाली नहीं है।

(d @(q(a a)))(d Q(q((l)(i l(c(@(q q)(h l))(Q(t l)))l))))(d A(q((f a)(v(c(q f)(Q a))))))(d M(q((f l)(i l(c(A f(@(h l)))(M f(t l)))l))))(d N(q((f a x)(i x(A f(@(N f a(s x 1))))a))))(d ,(q((m a b)(i(l b a)m(,(c b m)a(s b 1))))))(d R(q((a)(,()1 a))))(d T(q((f r)(M f(A ,(c()r))))))(d F(q((f a l)(i l(F f(A f(@ a(h l)))(t l))a))))

कार्यों A(लागू), M(मानचित्र), N(घोंसला), R(श्रेणी), T(तालिका), और को परिभाषित करता हैF (गुना) को एक जोड़े के सहायक कार्यों के साथ । Tअपने दूसरे तर्क के लिए दो पूर्णांकों की सूची की अपेक्षा करता है।

Tinylisp में कोई लूप निर्माण भी नहीं है; सब कुछ पुनरावृत्ति का उपयोग कर पूरा किया है। इनमें से कई कार्य नहीं हैं पूंछ-पुनरावर्ती , इसलिए यदि आप उन्हें बड़ी सूचियों पर कॉल करते हैं तो वे संभवतः कॉल स्टैक को उड़ा देंगे। वे सभी पूंछ पुनरावृत्ति के साथ लागू हो सकते हैं ... लेकिन यह अधिक बाइट्स ले जाएगा, और यह कोड गोल्फ है।

यहां व्हॉट्सएप और नामों के लिए वास्तविक शब्दों के साथ एक विस्तारित संस्करण है, जो कि लिस्प से परिचित होने पर बहुत पठनीय होना चाहिए। (मैंने q(बोली) और i(अगर) को छोड़कर अधिकांश टिनिइल बिल्डिंस को अलियास किया है ।

(d define d)
(define cons c)
(define car h)
(define cdr t)
(define subtract s)
(define less l)
(define eval v)

(define lambda
  (q (()
      (arglist expr)
      (list arglist expr))))

(define list (lambda args args))

(define quote-all
  (lambda (lyst)
    (i lyst
       (cons
         (list (q q) (car lyst))
         (quote-all (cdr lyst)))
       lyst)))

(define Apply
  (lambda (func arglist)
    (eval (cons (q func) (quote-all arglist)))))

(define Map
  (lambda (func lyst)
    (i lyst
       (cons
         (Apply func (list (car lyst)))
         (Map func (cdr lyst)))
       lyst)))

(define Nest
  (lambda (func arg times)
    (i times
       (Apply func
              (list (Nest func arg (subtract times 1))))
       arg)))

(define range*
  (lambda (accumulator a b)
    (i (less b a)
       accumulator
       (range* (cons b accumulator) a (subtract b 1)))))

(define Range
  (lambda (x)
    (range* 1 x)))

(define Table
  (lambda (func iterator)
    (Map func
         (Apply range* (cons () iterator)))))

(define Fold
  (lambda (func arg lyst)
    (i lyst
       (Fold func
             (Apply func (list arg (car lyst)))
             (cdr lyst))
       arg)))

अनुरोध पर और स्पष्टीकरण उपलब्ध है।

नमूना उत्पादन

मेरे संदर्भ कार्यान्वयन से REPL पर्यावरण का उपयोग करता है। मैंने इन उदाहरणों के लिए बाइनरी फ़ंक्शन के रूप qमें एकरी फ़ंक्शन और s(घटाना ) के लिए (उद्धरण) का उपयोग किया , साथ ही फ़ंक्शन @(इस कोड में परिभाषित) जो इसके तर्कों की सूची लौटाता है।

tl> [line of definitions goes here]
@
Q
A
M
N
,
R
T
F
tl> (A s (@ 10 7))
3
tl> (M q (@ 1 2 3 4))
((q 1) (q 2) (q 3) (q 4))
tl> (N q 123 4)
(q (q (q (q 123))))
tl> (R 5)
(1 2 3 4 5)
tl> (T q (@ 3 7))
((q 3) (q 4) (q 5) (q 6) (q 7))
tl> (F s 10 (@ 4 3 2))
1

— DLosc
स्रोत

2

पायथन 2.x: 450.6 बाइट्स (10% छूट से पहले 493 बाइट्स)

गोल्फ का जवाब:

y=len
z=lambda a,b:a.append(b)
_=lambda a:a if a is not None else[]
def M(a,b,c=None):
 c=_(c);d=y(b)
 if d:z(c,A(a,b[0]))
 return M(a,b[1:],c)if d else c
def N(a,b,c):d=A(a,b);return N(a,d,c-1)if c>1 else d
A=lambda a,b:a(*b)if type(b)is list else a(b)
def R(a,b=None):b=_(b);b.insert(0,a);return b if a<=1 else R(a-1,b)
def F(a,b,c):d=a(b,c[0]);return F(a,d,c[1:])if y(c)>1 else d
def T(a,b,c=None,d=None):
 if c is None:c=b[0];d=[]
 z(d,a(c));return T(a,b,c+1,d)if c<b[1]else d

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

नीचे मेरे पास प्रत्येक फ़ंक्शन के लिए अनगॉल्डेड लिस्टिंग है।

Apply:

A = lambda function, arguments: function(*arguments) if type(arguments) is list else function(arguments)

Map:

def M(function, arguments, result=None):
    result = result if result is not None else []
    length = len(arguments)
    if length != 0:
        result.append(A(function, arguments[0]))
    return M(function, arguments[1:], result) if length != 0 else result

Nest:

def N(function, arguments, times):
    result = A(function, arguments)
    return N(function, result, times - 1) if times > 1 else result

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

Range:

def R(ceiling, result=None):
    result = result if result is not None else []
    result.insert(0, ceiling)
    return result if ceiling <= 1 else R(ceiling - 1, result)

Fold:

def F(function, initial, rest):
    result = function(initial, rest[0])
    return F(function, result, rest[1:] if len(rest) > 1 else result

Table:

def T(function, iterator, current=None, result=None):
    if current is None:
        current = iterator[0]
        result = []
    result.append(function(current))
    return T(function, iterator, current + 1, result) if current < iterator[1] else result

यहाँ निम्न सहायक कार्यों का उपयोग करके नमूना आउटपुट दिया गया है:

square = lambda x: x * x
def add(*args):
    addTwo = lambda a, b: a + b
    if len(args) == 1 and type(args[0]) is list:
        return F(addTwo, 0, args[0])
    else:
        return F(addTwo, 0, args)

>>> M(square, R(10))
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> M(add, [R(i) for i in R(10)])
[1, 3, 6, 10, 15, 21, 28, 36, 45, 55]
>>> T(square, [0, 10])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> N(square, 2, 4)
65536
>>> N(lambda *args: F(lambda a, b: a * b, 1, args) if len(args) > 1 else str(args[0]) + 'a', R(5), 10)
'120aaaaaaaaa'

— sadakatsu
स्रोत

वाह, बहुत अच्छा लग रहा है!

— जादूगरऑफमेनो

यह सौंदर्यशास्त्र की तिरछी भावना की तरह लगता है; ) मुझे हमेशा लगता है कि पहली पायथन पुस्तक मैंने पढ़ी थी, के बाद से पायथन को देखने के लिए मनोरंजक है, पायथन ने पठनीयता को कैसे लागू किया।

— सादकात्सु

मैं वास्तव में सौंदर्यशास्त्र की तिरछी भावना रखता हूँ :)

— जादूगरऑफेंलो

मैं अन्य लोगों के स्कोर से भ्रमित हूं। मैंने प्रत्येक आवश्यक फ़ंक्शन के स्कोर का 10% लिया, जिसमें एक लूप का उपयोग नहीं किया गया था (जो उन सभी में से था), लेकिन अन्य लोगों ने प्रत्येक फ़ंक्शन के लिए पूरे स्कोर का 10% लिया जिसमें लूप का उपयोग नहीं किया गया (जो हो सकता है अप करने के लिए 60%)। सही दृष्टिकोण कौन सा है?

— सादकात्सु

तुम्हारा जाने का सही तरीका है, मुझे एक अवास्तविक उम्मीद थी और इसलिए शुरू में मेरे मन में 60% दृष्टिकोण था, लेकिन अब मुझे लगता है कि 10% अधिक उत्तेजक होगा और दोनों के बीच का

— मुकाबला

2

सीलोन, 370 * 0.9 = 333 364 * 0.9 = 327.4

उन कार्यों में से अधिकांश सीलोन के भाषा पैकेज में पहले से ही उपलब्ध हैं (हालांकि कभी-कभी थोड़ा अलग हस्ताक्षर के साथ), लेकिन हम उन्हें यहां परिभाषित कर रहे हैं जैसे प्रश्न में अनुरोध किया गया है।

alias I=>Integer;R[]m<A,R>(R(A)g,A[]l)=>f((R[]x,A y)=>x.append([g(y)]),[],l);A n<A>(A(A)g,A a,I t)=>f((A x,I y)=>g(x),a,r(t));R y<A,R>(Callable<R,A>g,A v)given A satisfies Anything[]=>g(*v);I[]r(I i)=>t((j)=>j,[1,i]);A f<A,O>(A(A,O)g,A a,O[]o)=>if(nonempty o)then f(g,g(a,o[0]),o.rest)else a;R[]t<R>(R(I)g,[I,I]i)=>i[1]<i[0]then[]else[g(i[0]),*t(g,[i[0]+1,i[1]])];

वास्तव में केवल दो फ़ंक्शन ( tऔर f) वास्तव में पुनरावृत्ति (क्रमशः सूचियों और पूर्णांक से अधिक) का उपयोग कर रहे हैं, अन्य इन पर आधारित हैं। (लागू एक सा है, यह वास्तव में दूसरों से संबंधित नहीं है।)

मैं सीलोन के अनुक्रमिक प्रकार के रूप में "सूची" की व्याख्या करता हूं, जो तत्वों का एक अपरिवर्तनीय (संभवतः खाली) अनुक्रम है। [R*]का अर्थ है Sequential<R>- किसी कारण से हम इसे लिख भी सकते हैं R[], जो एक बाइट से छोटा है।

एक फ़ंक्शन प्रकार है Callable<R, A>, जहां Aतर्कों के लिए एक तुच्छ प्रकार है, जैसे [X, Y, Z](अर्थात कुछ उपप्रकार Anything[])। शॉर्टकट के रूप में हम R(X,Y,Z)इसके बजाय लिख सकते हैंCallable<R,[X,Y,Z]> ।

मैं एलियास Integerके रूप में Iकुछ बाइट्स बचाने के लिए।

यहाँ एक स्वरूपित (और थोड़ा टिप्पणी की गई) संस्करण है:

// implement functional paradigms
//
// Question: http://codegolf.stackexchange.com/q/58588/2338
// My Answer: http://codegolf.stackexchange.com/a/64515/2338

alias I => Integer;

// map – based on fold.
R[] m<A, R>(R(A) g, A[] l) =>
        f((R[]x,A y) => x.append([g(y)]), [], l);

// nest – based on fold + range, throwing away the second
//        argument in a proxy function.
A n<A>(A(A) g, A a, I t) =>
        f((A x, I y) => g(x), a, r(t));

// apply – this looks quite heavy due to type safety.
//         This uses the "spread operator" *.
R y<A, R>(Callable<R,A> g, A v)
        given A satisfies Anything[] =>
        g(*v);

// range – based on table (using the identity function)
I[] r(I i) =>
        t((j) => j, [1, i]);

// fold – a plain list recursion.
A f<A, O>(A(A, O) g, A a, O[] o) =>
        if (nonempty o) then f(g, g(a, o[0]), o.rest) else a;

// table – an integer recursion.
//        (Not sure why the min/max parameters need
//         to be passed in one argument.)
R[] t<R>(R(I) g, [I, I] i) =>
        i[1] < i[0] then [] else [g(i[0]), *t(g, [i[0] + 1, i[1]])];

"छोरों" का उपयोग करना

तालिका और मानचित्र को छोरों (वास्तव में, एक अनुक्रम समझ) का उपयोग करके कम कार्यान्वित किया जा सकता है:

// map – using a sequence comprehension:
R[] m<A, R>(R(A) g, A[] l) =>
        [for(a in l) g(a)];

// table – map with an integer range.
//        (Not sure why the min/max parameters need
//         to be passed in one argument.)
R[] t<R>(R(I) g, [I, I] i) =>
        m(g, i[0]..i[1]);

हालांकि मुझे यकीन नहीं है कि पूर्णांक श्रेणी के लिए ..ऑपरेटर का उपयोग एक अंतर्निहित फ़ंक्शन का उपयोग करने के लिए गिना जाता है। यदि इसकी अनुमति है, तो परिणामी कोड यह यहां है, लंबाई 312:

alias I=>Integer;R[]m<A,R>(R(A)g,A[]l)=>[for(a in l)g(a)];A n<A>(A(A)g,A a,I t)=>f((A x,I y)=>g(x),a,r(t));R y<A,R>(Callable<R,A>g,A v)given A satisfies Anything[]=>g(*v);I[]r(I i)=>t((j)=>j,[1,i]);A f<A,O>(A(A,O)g,A a,O[]o)=>if(nonempty o)then f(g,g(a,o[0]),o.rest)else a;R[]t<R>(R(I)g,[I,I]i)=>m(g,i[0]..i[1]);

(इसे परिभाषित करके और भी छोटा बनाया जा सकता है r(I i) => 1..i, जिसके परिणामस्वरूप स्कोर 301 होगा। हालांकि यह धोखा देने के समान है।)

यदि ..अनुमति नहीं है, तो हमें इसे फिर से लागू करना होगा। हम ( rऔर ऊपर के tसाथ m) इन कार्यान्वयनों का उपयोग कर सकते हैं :

// range – based two-limit range 
I[] r(I i) =>
        q(1, i);

// two-limit range implemented recursively
I[] q(I i, I j) =>
        j < i then [] else [i, *q(i + 1, j)];


// table – map with an integer range.
//        (Not sure why the min/max parameters need
//         to be passed in one argument.)
R[] t<R>(R(I) g, [I, I] i) =>
        m(g, q(i[0], i[1]));

यह 348 बाइट्स में परिणाम देता है, पूरी तरह से पुनरावर्ती संस्करण की तुलना में बेहतर है, लेकिन बोनस लागू करने के बाद नहीं।

— पाओलो एबरमन
स्रोत

0

ग्रूवी (146 बाइट्स) (146 * 90% = 131.4)

PS मुझे नहीं पता कि आप इस संदर्भ में 'लूप' के रूप में क्या विचार कर रहे हैं, मैंने ओपी द्वारा टिप्पणियों में बताए जाने के बाद ही बोनस लागू किया और 2-3 अतिरिक्त उपयोगकर्ताओं के इन संग्रह कार्यों और पुनरावृत्तियों को कहने पर हटा देंगे लूप हैं और मैं बोनस के लायक नहीं हूं। इसके अलावा, यदि आप मुझे 1..it के उपयोग के बारे में बताना चाहते हैं, तो कृपया ऐसा करें और मैं इसे फिर से काम करूंगा / मेरे बायटेकाउंट को अपडेट करूंगा।

m={f,l->l.collect{f(it)}}            // Map
n={f,x,n->n.times{x=f(x)};x}         // Nest
a={f,l->f(l)}                        // Apply
r={1..it}                            // Range (Is this cheating?)
f={f,x,l->l.each{x=f(x,it)};x}       // Fold
t={f,l->(l[0]..l[1]).collect{f(it)}} // Table

उदाहरण इनपुट / आउटपुट

f1={2*it}
f2={a,b,c,d,e->a*b*c*d*e}
f3={a,b->a*b}
l=[1,2,3,4,5]
l2=[1,9]
y=5
x=1
println m(f1,l)
println n(f1,x,y)
println a(f2,l)
println r(y)
println f(f3,x,l)
println t(f1,l2)

उत्पादन

MAP:   [2, 4, 6, 8, 10]
NEST:  32
APPLY: 120
RANGE: [1, 2, 3, 4, 5]
FOLD:  120
TABLE: [2, 4, 6, 8, 10, 12, 14, 16, 18]

इसे स्वयं आज़माएँ: https://groovyconsole.appspot.com/edit/5203951758606336

— जादू ऑक्टोपस Urn
स्रोत

यह तकनीकी रूप से छोरों का उपयोग नहीं करता है, इसलिए बोनस याद रखें! महान, महान जवाब!

— विजार्डऑफमेनो

तकनीकी रूप से नहीं छोरों ?! वास्तव में?! .each {} .times {} .collect {} पुनरावृत्तियाँ हैं।

— मैजिक ऑक्टोपस Urn

कार्यात्मक प्रोग्रामिंग प्रतिमानों को लागू करें

नक्शा

घोंसला

लागू करें

रेंज

तह

तालिका

हास्केल, पिछले कई बाइट्स 127 * 0.9 = 114.3 बाइट्स गिना करते हैं

पायथन 2, 305.1 बाइट्स (-10% 376 369 366 349 339 बाइट्स)

जावास्क्रिप्ट ईएस 6, 197 * 0.9 = 177.3 बाइट्स

नक्शा ( M=(f,l)=>F((a,b)=>[...a,f(b)],[],l)):

घोंसला ( N=(f,x,n)=>f(--n?N(f,x,n):x)):

लागू करें ( A=(f,l)=>f(...l)):

रेंज (R=n=>n--?[...R(n),n+1]:[] ):

तह ( F=(f,x,l,n=l.length)=>n--?f(F(f,x,l,n),l[n]):x):

तालिका (T=(f,i)=>([n,x]=i,M(q=>f(q+n-1),R(x-n+1))) ):

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

नक्शा समारोह P

घोंसला समारोह Y

फ़ंक्शन लागू करें T

सीमा समारोह H

समारोह मोड़ो O

तालिका समारोह N

जूलिया, 181 बाइट्स

tinylisp , 325 * 0.9 = 292.5

नमूना उत्पादन

पायथन 2.x: 450.6 बाइट्स (10% छूट से पहले 493 बाइट्स)

सीलोन, 370 * 0.9 = 333 364 * 0.9 = 327.4

"छोरों" का उपयोग करना

ग्रूवी (146 बाइट्स) (146 * 90% = 131.4)

उदाहरण इनपुट / आउटपुट

उत्पादन

नक्शा ( `M=(f,l)=>F((a,b)=>[...a,f(b)],[],l)`):

घोंसला ( `N=(f,x,n)=>f(--n?N(f,x,n):x)`):

लागू करें ( `A=(f,l)=>f(...l)`):

रेंज (`R=n=>n--?[...R(n),n+1]:[]` ):

तह ( `F=(f,x,l,n=l.length)=>n--?f(F(f,x,l,n),l[n]):x`):

तालिका (`T=(f,i)=>([n,x]=i,M(q=>f(q+n-1),R(x-n+1)))` ):

नक्शा समारोह `P`

घोंसला समारोह `Y`

फ़ंक्शन लागू करें `T`

सीमा समारोह `H`

समारोह मोड़ो `O`

तालिका समारोह `N`