मनमानी-लम्बाई करी

Question

एक फ़ंक्शन लिखें f, जो एक सकारात्मक पूर्णांक में लेता है और एक फ़ंक्शन देता है।

लौटाए गए नए फ़ंक्शन के समान होना चाहिए f। हालांकि, जब "समाप्ति कॉल" होती है, fतो इसके बजाय पारित किए गए सभी पूर्णांकों का योग वापस करना चाहिए।

उदाहरण के लिए, g=f(4)(यदि fपहला फ़ंक्शन है) gदूसरे फ़ंक्शन पर सेट होना चाहिए । h=g(3)वही करेंगे। हालांकि, जब आप hकोई तर्क नहीं देते हैं (विवरण के लिए नीचे देखें), तो इसे 7 आउटपुट होना चाहिए, क्योंकि यह पिछले फ़ंक्शन तर्क का योग है। , दूसरे शब्दों में f(3)(4)() == 7।

ध्यान दें यह समान नहीं है f(3,4)()।

"समाप्ति कॉल" निम्नलिखित विकल्पों में से एक है (आपकी पसंद):

• कॉल डब्ल्यू / ओ तर्क
• तर्क के रूप में अशक्त
• कोई भी गैर-सकारात्मक मूल्य

फ़ंक्शन कॉल की विपरीत मात्रा का समर्थन किया जाना चाहिए, कोई पूर्वनिर्धारित सीमा नहीं है।

यह गारंटी है कि कुल राशि 1'000 से अधिक नहीं होगी।

हम मान सकते हैं कि "समाप्ति कॉल" से पहले कम से कम एक कॉल किया जाता है।

आपके कोड को स्थिर, प्रति-प्रोग्राम चर का उपयोग नहीं करना चाहिए, इसलिए एक ही रनटाइम में कई बार प्रयोग चलाना संभव है और वास्तव में समान व्यवहार का निरीक्षण करना चाहिए।

उदाहरण:

f(1)() == 1
f(4)(2)(7)() == 13
f(4)(2)(7)(5)(2)() == 20

Comments

@LuisMendo आमतौर पर इसका मतलब है कि f(4)एक नया फ़ंक्शन देता है। यदि उस नए फ़ंक्शन को तर्कों के बिना कॉल किया जाता है, तो वह वापस लौटता है 4, लेकिन अगर उसे किसी अन्य तर्क के साथ बुलाया जाता है, तो वह फिर से उसी शब्दार्थ के साथ एक नया फ़ंक्शन लौटाएगा , लेकिन नए तर्क के साथ और इसी तरह जोड़ा जाएगा 4।

— मार्टिन एंडर

@LuisMendo यह वास्तव में यूजीन पर निर्भर है, लेकिन मुझे लगता है कि बार-बार कॉल करने की अनुमति देना चुनौती से काफी हद तक दूर होगा, क्योंकि दिलचस्प हिस्सा एक स्टेटफुल फ़ंक्शन बनाने के लिए नहीं है, बल्कि एक उच्च-क्रम फ़ंक्शन बनाने के लिए है।

— मार्टिन एंडर

@MartinEnder जो बहुत मायने रखता है। यूजीन, अगर यह इरादा है, तो कृपया चुनौती के शब्दांकन को बदल दें। एक फ़ंक्शन लिखें जिसे असीम रूप से कहा जा सकता है, यह बिल्कुल भी सुझाव नहीं देता है कि फ़ंक्शन एक फ़ंक्शन को वापस लौटाता है

— लुइस मेंडो

क्या हम यह मान सकते हैं कि एक बार में कॉल श्रृंखला का केवल एक उदाहरण होगा? जैसे नहीं q = f(2)(3); b = f(1)(2)(3); q(); b()?

— कॉनर ओ'ब्रायन

अभी हाल ही में हास्केल को लेने के बाद, मुझे दिलचस्पी है कि क्या हास्केल में यह संभव है। मजबूत प्रकार की प्रणाली मुझे लगता है कि यह नहीं हो सकता है।

— CAD97

Answer 1

जावास्क्रिप्ट (ईएस 6), 18 बाइट्स

f=n=>m=>m?f(m+n):n

राशि प्राप्त करने के लिए एक मिथ्या मान पास करें। 2 बाइट की लागत के लिए शून्य की अनुमति दी जा सकती है।

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

Ungolfed:

f = function(n) {
    return function(m) {
        if (m) {
            return f(m+n);
        } else {
            return n;
        }
    }
}

Comments

शानदार प्रस्तुत!

— यूजीन डी। गुबेनकोव

Answer 2

हास्केल (GHC), 118 बाइट्स

यह कोड के लिए 98 बाइट्स और GHC संकलक ध्वज के लिए 20 बाइट्स है -XFlexibleInstances, जो एक प्रकार का सिस्टम एक्सटेंशन सक्षम करता है।

class F a where f::Int->a
instance F(()->Int)where f n()=n
instance F a=>F(Int->a)where f=(f.).(+)

यह एक "फ़ंक्शन" को परिभाषित करता है f, जिसे यूनिट द्वारा पीछा किए गए पूर्णांकों की एक मनमानी संख्या के साथ कहा जा सकता है, जिसके ()बाद यह एक पूर्णांक देता है। टाइप एनोटेशन आवश्यक हैं। इसे ऑनलाइन आज़माएं!

व्याख्या

हास्केल के सख्त प्रकार के सिस्टम को मजबूर करने की अनुमति देने के लिए कुछ जादू की आवश्यकता होती है, अर्थात्, लचीले टाइपकास्ट इंस्टेंस के लिए जीएचसी एक्सटेंशन को सक्षम करना। यह कैसे काम करता है कि fएक प्रकार के वर्ग बाधा द्वारा प्रतिबंधित एक पैरामीट्रिक पॉलीमॉर्फिक फ़ंक्शन है: इसका प्रकार है F a => Int -> a। इसका मतलब यह है कि fएक पूर्णांक लेता है और टाइपकास्ट से संबंधित aकिसी भी प्रकार के लिए एक प्रकार का मान aलौटाता है F। Fकेवल टाइपसेकल्स का नाम है जो फ़ंक्शन प्रदान करता है f; यह पहली पंक्ति में घोषित किया गया है।

अगली दो पंक्तियाँ Fविभिन्न प्रकारों के दो उदाहरण हैं a। दूसरी पंक्ति में कहा गया है कि ()पूर्णांक से फ़ंक्शन का प्रकार F(जहां ()इकाई का प्रकार जिसका एकमात्र सदस्य मूल्य है ()) से संबंधित है, और कार्यान्वयन है f n () = n; फ़ंक्शन अपना पहला तर्क देता है। अंतिम पंक्ति बताती है कि यदि aसंबंधित है F, तो पूर्णांक से कार्यों के प्रकार a: एक फ़ंक्शन से f :: Int -> aहम एक और फ़ंक्शन उत्पन्न कर सकते हैं f :: Int -> Int -> a। कार्यान्वयन है f m n = f (m+n)(कोड कम करने के लिए कोडिनेटर का उपयोग करता है), जहां fबाईं तरफ नया है, और fदाईं ओर पुराना है। यह अनिवार्य रूप से देता हैfएक नया पूर्णांक तर्क, जो अगले एक में जोड़ा जाता है। इस तरह एक साथ कई तर्क प्रस्तुत किए जाते हैं:

  f  a1   a2   a3   a4   a5  ()
= f (a1 + a2)  a3   a4   a5  ()
= f (a1 + a2 + a3)  a4   a5  ()
= f (a1 + a2 + a3 + a4)  a5  ()
= f (a1 + a2 + a3 + a4 + a5) ()
=    a1 + a2 + a3 + a4 + a5

fप्रत्येक पंक्ति पर एक अलग प्रकार का है।

हास्केल फ़ंक्शंस स्वचालित रूप से करी जाती है, इसलिए यदि आप fकेवल पूर्णांक देते हैं, तो आपको एक फ़ंक्शन मिलता है।

Comments

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

— ०४:०५

@ निम्मी यह नहीं कहे जाने वाले दो कार्यों को परिभाषित करता है f, लेकिन असीम रूप से कई फ़ंक्शन कहलाते हैं f। (प्रत्येक संभावित तर्कों के लिए एक।) इन कार्यों (इस अनंत परिवार से) की दो तरह की परिभाषाएं हैं, एक प्रकार जब तर्कों की संख्या शून्य होती है, और दूसरी जब यह नहीं होती है।

— श्रीवत्सआर

@ श्रीवत्सआर: मुझे दो परिभाषाएँ दिखाई देती हैं, f n()=nऔर f=(f.).(+), इसलिए मैं इसे दो कार्यों को परिभाषित करता हूँ।

— निमी

@ निम्मी की दो परिभाषाएँ हैं, लेकिन दो कार्य नहीं। परिभाषाओं की संख्या कार्यों की संख्या नहीं होनी चाहिए। उदाहरण के लिए, आप भाज्य फ़ंक्शन को दो परिभाषाओं के साथ परिभाषित कर सकते हैं g 0 = 1और g n = g (n-1) * n, जहाँ दो परिभाषाएँ हैं, लेकिन सिर्फ एक फ़ंक्शन। यहाँ हमारे पास दो परिभाषाएँ हैं लेकिन असीम रूप से कई कार्य हैं। (प्रत्येक अलग प्रकार का।)

— श्रीवत्सआर २१'१

@nimi BTW ghciऊपर लोड में और कोशिश :t f- यह कहेंगे f :: F a => Int -> a(मतलब है कि अगर aवर्ग का एक उदाहरण है f, तो fएक समारोह है Int -> a)। इसलिए हम इसे एक फ़ंक्शन या असीम रूप से कई के रूप में मान सकते हैं, लेकिन हालांकि इसकी दो प्रकार की परिभाषाएं हैं (बस फैक्टरियल फ़ंक्शन की तरह) मुझे इसे दो कार्यों के लिए विचार करने के लिए कोई अच्छा आधार नहीं दिखता है।

— श्रीवत्सआर

Answer 3

पायथन 2, 42 41 36 बाइट्स

यह समाधान कभी भी अतिप्रवाह नहीं होगा, क्योंकि पायथन मनमाना-सटीक पूर्णांक का समर्थन करता है। शून्य "विशेष मूल्य" है।

f=lambda n:lambda m:m and f(m+n)or n

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

Ungolfed:

def f(n):
    def g(m=''):
        return f(m+n)if m<''else n
    return g

Answer 4

सी, 62 58 बाइट्स, बॉर्डरलाइन प्रतिस्पर्धा

केविन के लिए धन्यवाद 4 बाइट्स बचाए! (फिर भी टाइप किए गए हटाए नहीं जा रहे हैं क्योंकि इसे बुलाया जाने के लिए कुछ आवश्यक है।)

typedef(*(*B)(_))(_);q;f(x,o,_){x=x?(q+=x,f):(x=q,q=0,x);}

कॉल करने का कार्य है f; आप इसे कॉल करना बंद कर देते हैं और इसे गैर-सकारात्मक संख्या के साथ कॉल करके परिणाम प्राप्त करते हैं जैसे 0। ऑनलाइन परीक्षण का प्रयास करें!

इसलिए, जहां तक ​​मैं बता सकता हूं, "करी" फ़ंक्शन का एकमात्र तरीका जिसमें कई रिटर्न प्रकार हैं, उनमें से एक निम्न कार्य करना है:

1. कंपाइलर को फिर से परिणाम कॉल करने की इच्छा बताने के लिए एक फ़ंक्शन के लिए परिणाम कास्ट करें;
2. या एक ऐसा union/ structप्रकार बनाएं जिसमें एक intऔर फ़ंक्शन / सेल्फ-रेफ़रेंशियल उपप्रकार हों।

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

यह "करी" वाक्यविन्यास थोड़ा अजीब लगता है, लेकिन काफी समान है। अनुकरण करने के लिए f(21)(1), एक को लिखना होगा ((B)((B)f(21))(1))(0)। मैंने उस Bप्रकार को परिभाषित किया है जो एक पूर्णांक लेता है और पूर्णांक लेने वाले फ़ंक्शन के लिए एक सूचक लौटाता है। विस्तारित, ऐसा दिखता है:

   ( (B)( (B) f(21) )(1) )(0)
//            f(21)            - call f with 21
//        (B)                  - cast to B, a function pointer
//      (           )(1)       - call with 1
//   (B)                       - cast to a function pointer
// (                     )(0)  - call with 0

Comments

यदि आप कहते हैं कि यह केवल 0 पर समाप्त होता है, तो आपको कास्टिंग की आवश्यकता होती है (जो आप C में करते हैं क्योंकि C किसी फ़ंक्शन को ठीक से परिभाषित नहीं कर सकता है जो स्वयं लौटता है), और आप कॉल करने के लिए रन के बीच वैश्विक को साफ़ करना छोड़ देते हैं (जो मुझे लगता है कि पूरी तरह से उचित है), आप पूरी बात को सरल कर सकते हैं q;f(x){return x?(q+=x,f):q;}।

— केविन

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

— केविन

@ केविन अभी तक, साइट के नियमों के अनुसार, एक फ़ंक्शन को पुन: प्रयोज्य होना चाहिए। यदि मैं qप्रत्येक रन के बाद शून्य नहीं करता , तो फ़ंक्शन अब उपयोग करने योग्य नहीं होगा

— कॉनर ओ'ब्रायन

शायद समारोह संकेत? आप हर बार संदर्भ डी होगा लेकिन बाहर की जाँच के लायक हो सकता है

— Downgoat

@ ConorO'Brien मैंने अभी आपका यूनियन अप्रोच लागू किया है। यह इस से अधिक लंबा है, लेकिन यह बहुत दूर नहीं है।

— जैकब

Answer 5

गणितज्ञ, 25 बाइट्स

f[x_]@y_=f[x+y]
f[x_][]=x

इसे ऑनलाइन आज़माएं! (गणित का उपयोग करना।)

जावास्क्रिप्ट उत्तर को पोर्ट करके तीन बाइट्स कम करना संभव है, लेकिन मैं एक अधिक मुहावरेदार गणितज्ञ समाधान प्रस्तुत करना चाहता था। @बस वाक्यात्मक चीनी, जो बराबर समाधान के लिए बनाता का एक सा है:

f[x_][y_]=f[x+y]
f[x_][]=x

तो हाँ विचार यह है कि मैथेमेटिका में आप केवल एक फ़ंक्शन को परिभाषित नहीं कर सकते हैं, f[x_]लेकिन आप सीधे एक अधिक जटिल अभिव्यक्ति के लिए एक मूल्य संलग्न कर सकते हैं f, जैसे f[x_]कि एक और तर्क पारित किया जा रहा है। इसके लिए दो परिभाषाएँ निर्धारित करके हम वांछित व्यवहार प्राप्त कर सकते हैं:

• पहली परिभाषा एक f[x][y]कॉल को ढहा देती है f[x+y], जिससे एक "कॉल" का उपभोग होता है और अंदर के तर्कों को जोड़ देता है। जब तक हम साथ नहीं रहेंगे तब तक यह नियम लागू होता है f[sum][]।
• दूसरी परिभाषा ने इस अंतिम मामले को मूल्यांकन करने के लिए पूरी बात को परिभाषित करके अनपैक कर दिया sum।

Comments

<3 प्रतीकात्मक प्रोग्रामिंग

— जूलियन वुल्फ

Answer 6

सी ++, 72 बाइट्स

#define O(P)operator()(P){return{P+a};}int
struct F{F O(int(m))O()a;}f;

यह एक प्रकार को परिभाषित करता है Fजो अनुरोधित फ़ंक्शन के रूप में कार्य करता है, और fउस प्रकार के एक चर को लागू करने के लिए। यह C ++ 11 के रूप में मान्य है और GCC, clang, icc और VC ++ के ऑनलाइन संस्करणों के साथ काम करता है।

उपयोग:

int main() {
  return f(1)(2)(3)(); // returns 6
}

स्पष्टीकरण:

प्रीप्रोसेसिंग और रिफॉर्मरेटिंग के बाद, ऐसा दिखता है:

struct F {
  F operator()(int(m)) { return{int(m)+a}; }
  int operator()() { return {+a}; }
  int a;
} f;

यह सामान्य रूप से लिखा जाएगा:

struct F {
  F operator()(int m) { return {m+a}; }
  int operator()() { return a; }
  int a;
} f;

return a;और return {+a};एक ही काम करते हैं, क्योंकि यूनरी +वैल्यू नहीं बदलता है, और रिटर्न वैल्यू के आसपास निरर्थक ब्रेसिज़ की अनुमति है। int mऔर int(m)एक ही काम करते हैं, क्योंकि एक चर नाम के आसपास अनावश्यक कोष्ठक की अनुमति दी जाती है, जिसमें फ़ंक्शन पैरामीटर भी शामिल हैं। return {m+a};और return {int(m)+a};एक ही बात करते हैं, के कलाकारों के रूप में mसे intकरने के लिए intअपने मूल्य नहीं बदलता है। इन परिवर्तनों operator()को सिंटैक्स में दो अधिभार मिलते हैं , जिससे एकल मैक्रो परिभाषा को दो बार लागू किया जा सकता है। तीन सदस्यों के लिए सही क्रम चुनने से अगली पंक्ति ( int) के पहले शब्द को भी स्थूल परिभाषा में शामिल किया जा सकता है।

Comments

सुंदर। और न केवल गोल्फ समाधान ... operator()इस काम को बनाने के लिए अधिभार विशेष रूप से शांत था।

— रे तोल

Answer 7

रूबी, 23 बाइट्स

f=->n{->m{m ?f[n+m]:n}}

उपयोग:

f[1][2][3][nil]
=> 6

Answer 8

सी, 104 96 बाइट्स

#define a(i)s(i)|b
#define b(i)u(i)|c
#define c(i)u(i)|b
b,c,d;s(i){b=c=i;i=d;}u(i){c=b+=i;i=d;}

@JulianWolf द्वारा साझा किए गए लिंक से विधि का उपयोग करता है। अंतिम तर्क 0 होना चाहिए।

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

Comments

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

Answer 9

गणित.जेएस, 38 बाइट्स

f(x)=i(x,0)
i(x,y)=x<0?y:j(z)=i(z,y+x)

इसके साथ बुलाओ f(number_a)(number_b)(...)(negative_number)

यदि हमें प्रारंभिक कॉल निर्दिष्ट करने की अनुमति है, तो 12 बाइट्स ( f(x)=i(x,0)\n) को गिराया जा सकता है, और इसे कहा जा सकता हैi(number_one,0)(number_two)(...)(negative_number)

कोशिश करो!

explination

जैसा कि ऊपर LaTex में दिखाया गया है, f(x)बस कॉल करता है i(x,0), अगर 0 से कम है, या फ़ंक्शन , जो एक तर्क लेता है, जो लूप करता है , i(x,y)का मान लौटाता है । के मूल्य में जोड़ रहा है ।yxj(z)=i(z,x+y)y

Answer 10

सी, 232 206 बाइट्स

#include<string.h>
#include<stdlib.h>
#define f(X)s(""#X)?0:g
#define g(X)u(""#X)?0:h
#define h(X)u(""#X)?0:g
g=0,h=0;s(char*s){g=h=atoi(s);return 0;}u(char*s){char*a=strlen(s)?s:"0";g=h+=atoi(a);return 0;}

यह संभवतः महत्वपूर्ण रूप से गढ़ा जा सकता है, लेकिन एक अवधारणा के प्रमाण के रूप में काम करना चाहिए कि C का उपयोग किसी भी भाषा एक्सटेंशन के बिना * किया जा सकता है, इस समस्या को हल करने के लिए एक जादुई मूल्य के बजाय तर्क के बिना कॉल करके।

* @hvd ने उल्लेख किया है कि, जबकि यह gcc का उपयोग करके बॉक्स से बाहर काम करता है, कुछ व्यवहार C मानक में परिभाषित नहीं है, जिसका अर्थ है कि यह पोर्टेबल नहीं हो सकता है। अपने जोखिम पार इस्तेमाल करें!

Ungolfed:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define f(X) start("" #X) ? 0 : f0
#define f0(X) update("" #X) ? 0 : f1
#define f1(X) update("" #X) ? 0 : f0

long f0 = 0;
long f1 = 0;

int start(const char *s) {
    f0 = f1 = strtol(s, NULL, 10);

    return 0;
}

int update(const char *s) {
    const char *a = strlen(s) ? s : "0";
    f0 = f1 += strtol(a, NULL, 10);

    return 0;
}

int main() {
    printf("f(1)()          -> %ld\n", f(1)());
    printf("f(1)(2)(0)(3)() -> %ld\n", f(1)(2)(0)(3)());
    printf("f(1)(-2)(3)()   -> %ld\n", f(1)(-2)(3)());
    printf("f()             -> %ld\n", f());

    return 0;
}

संकलित करना और gcc arbitrary-length-currying.c -o arbitrary-length-currying && ./arbitrary-length-curryingआउटपुट के साथ चलना (कुछ चेतावनियों के बाद)

f(1)()          -> 1
f(1)(2)(3)(0)() -> 6
f(1)(-2)(3)()   -> 2
f()             -> 0

Comments

"बिना किसी भाषा एक्सटेंशन के" - मैक्रो इनवोकेशन की एक श्रृंखला को जारी रखने gऔर उसके बीच काम hकरने की चाल की गारंटी नहीं है, क्योंकि यह अनिर्दिष्ट है कि अगला gपहले के विस्तार के संदर्भ में दिखाई देता है या नहीं g। C11 ने 6.10.3.4 में एक उदाहरण जोड़ा है कि यह अनिर्दिष्ट है या नहीं। (IIRC, TenDRA का प्रीप्रोसेसर वह है जो इसे आपके इच्छित तरीके का विस्तार नहीं करेगा।) इसके अलावा, भाषा का कोई भी संस्करण खाली मैक्रो तर्कों और निहित इंट दोनों का समर्थन नहीं करता है, इसलिए एक वैध सी प्रोग्राम दोनों का उपयोग नहीं कर सकता है। :) फिर भी, अच्छा जवाब। क्या आप इसे और आगे बढ़ाना चाहते हैं?

— hvd

@hvd: हाँ, शायद दो दिनों में इसे वापस आने वाला हूं और देख सकता हूं कि क्या मैं इसे नीचे कर सकता हूं। आप निश्चित रूप से सही हैं कि यह अनिर्दिष्ट व्यवहार है, लेकिन मुझे लगता है कि यहां पर मानक उपचार यह है कि भाषाओं को उनके कार्यान्वयन द्वारा परिभाषित किया गया है, इसलिए जब तक यह gcc के साथ काम करता है मैं खुश हूं।

— जूलियन वुल्फ

मैं सिर्फ आपके उत्तर में शामिल टिप्पणी को संबोधित कर रहा था कि यह किसी भी भाषा एक्सटेंशन पर निर्भर नहीं करता है। हां, यहां तक ​​कि भाषा एक्सटेंशन के साथ, यह पूरी तरह से यहां एक उत्तर के रूप में मान्य है, अन्यथा सुझाव देने का मतलब नहीं है।

— hvd

आह, यह निश्चित रूप से उचित है। आप सही कह रहे हैं कि मुझे यह निर्धारित करना चाहिए, जबकि अतिरिक्त झंडे की आवश्यकता नहीं है, यह पोर्टेबल नहीं हो सकता है।

— जूलियन वुल्फ

आप *sइसके बजाय खाली स्ट्रिंग के लिए परीक्षण कर सकते हैं strlen(s)। सी स्ट्रिंग्स निहित-लंबाई हैं, एक charमूल्य के साथ समाप्त 0। एक आर्ग के साथ / बिना कॉल करने की अनुमति देने के लिए अच्छा मैक्रो हैक!

— पीटर कॉर्ड्स

Answer 11

8086 मशीन कोड, 27 बाइट्स

00000000  bb 00 00 85 c0 74 13 01  d8 be 00 01 89 e7 47 47  |.....t........GG|
00000010  57 b9 1b 00 f3 a4 5b 89  47 01 c3                 |W.....[.G..|
0000001b

यह मशीन कोड 0x100 पते पर होना चाहिए, और छोटे कोड मॉडल (cs = ds = es = ss) को मानता है। अतिरिक्त बाइट्स की लागत के बिना फ़ंक्शन स्थान को बदला जा सकता है, हालांकि। इसे ऑफ़सेट पर रखने से 0बाइट बच जाएगी ( xor si,siइसके बजाय mov si, 0x100)

आवश्यक कॉलिंग कन्वेंशन

यह मानता है कि कॉलर को स्टैक पर कम से कम 27 बाइट्स पूर्व-आवंटित किए गए हैं। यह एक नंबर लेता है ax, और एक फ़ंक्शन पॉइंटर को वापस लौटाता है bx। इस पॉइंटर को कॉल करने ax=0से श्रृंखला समाप्त हो जाती है, और राशि वापस आ जाती है bx।
तो पहली कॉल के लिए:

mov bp, sp
sub sp, 28
mov ax, number_to_add
call function
; new function pointer in bx

फिर, प्रत्येक बाद की कॉल के लिए:

sub sp, 28
mov ax, number_to_add
call bx
; new function pointer in bx

निष्कासित करना:

mov ax, 0
call bx
; result in bx
mov sp, bp

---

Ungolfed (मशीन कोड की असंतुष्ट टिप्पणी):

00000000  BB0000            mov bx,0x0      ; 0 is replaced after copying
00000003  85C0              test ax,ax
00000005  7413              jz 0x1a         ; if(ax==0) ret (with value in bx)
00000007  01D8              add ax,bx       ; arg += total
00000009  BE0001            mov si,0x100    ; address of the original: ds:0x100
0000000C  89E7              mov di,sp
0000000E  47                inc di
0000000F  47                inc di          ; dst = sp+2 = above return address
00000010  57                push di
00000011  B91B00            mov cx,0x1b
00000014  F3A4              rep movsb         ; copy the function code.
00000016  5B                pop bx            ; bx = start of copy destination
00000017  894701            mov [bx+0x1],ax   ; update total in the copied code
0000001A  C3                ret               ; with bx = function pointer

गैर-शून्य AX के साथ इसे कॉल करने के बाद, bx = spऔर बफर को मशीन कोड की संशोधित प्रतिलिपि से भर दिया जाता है function। पहले निर्देश में 16-बिट तत्काल कुल है। (यह अंतिम निर्देश द्वारा पहले लिखा गया है ret।)

push di/ (पहले ) के pop bxसाथ प्रतिस्थापित किया जा सकता है , इसे सरल बना सकता है लेकिन कोई बचत नहीं।mov bx, direp movsb

कॉल करने वाले को dst बफर में पॉइंटर पास करने के diलिए 4 बाइट्स बचाने की आवश्यकता होती है sp।

फ़ंक्शन प्रारंभ को उसी तरह से संबोधित करना जिससे फ़ंक्शन का आकार बाइट ( mov cx, si) बच जाए ।

Comments

यह एक बेहतर उत्तर होगा यदि आपने मशीन-कोड बाइट्स के डिस्सैम्ड को शामिल किया है। मशीन-कोड के जवाबों को निश्चित रूप से एक ungolfed संस्करण की आवश्यकता होती है। objdump -b binaryइसके बजाय का उपयोग करेंhexdump -C

— पीटर कॉर्ड

टिप्पणी के साथ अद्यतन disassembly। संभावित बचत: di(4 बाइट्स) में dst पॉइंटर पास करने के लिए कॉलर की आवश्यकता होती है । फ़ंक्शन प्रारंभ पता = आकार बनाएं: mov cx, siइसके बजाय mov cx, 0x1b।

— पीटर कॉर्ड्स

Answer 12

सी #, 62 बाइट्स

dynamic f(int n)=>(System.Func<int,dynamic>)(m=>m<0?n:f(n+m));

एक नकारात्मक संख्या में कॉल पास समाप्त करने के लिए जैसे

f(1)(2)(3)(-1) == 6

Comments

मैं इसे nullसमाप्त करने के लिए या कोई मापदंडों को पारित करके काम करना चाहता हूं । हालाँकि, मैंने जितने भी तरीके आज़माए, वे बहुत लंबे थे

— TheLethalCoder

क्या आप अंतिम पैरामीटर के !mबजाय m<0और पास nullया उपयोग कर सकते हैं 0?

— betseg

@betseg नहीं C # में केवल एक के Booleanरूप में इस्तेमाल किया जा सकता है Boolean... मैं के साथ की कोशिश की, nullलेकिन यह सिर्फ लंबे समय तक मिल गया। मैं उपयोग करना चाहता था, ??जिसका मतलब है कि अगर LHS null करते हैं RHS, लेकिन जैसा कि मुझे ज़रूरत है अगर LHS शून्य नहीं है तो इसे RHS करें जो मैं नहीं कर सकता।

— TheLethalCoder

Answer 13

स्काला, 58 वर्ण

case class f(n:Int){def apply(m:Int)=f(n+m)
def apply()=n}

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

Ungolfed:

case class f(n:Int){
  def apply(m:Int)=f(n+m)
  def apply()=n
}

स्पष्टीकरण:

यह कोड case classएक कंस्ट्रक्शन लेने वाले के साथ एक तथाकथित f को परिभाषित करता है । एक केस क्लास निश्चित करें जो समान, हैशकोड, स्ट्रींग और कॉपी करने के तरीकों को उत्पन्न करेगा, और newकीवर्ड के बिना ऑब्जेक्ट निर्माण को सक्षम करने के लिए एक ही नाम के साथ एक साथी ऑब्जेक्ट ।

इस वर्ग में एक अधिभार लागू विधि है: एक और पूर्णांक जोड़ने के लिए एक और पूर्णांक लेता है और अद्यतन राशि के साथ एक नया ऑब्जेक्ट बनाता है, और एक राशि प्राप्त करने के लिए तर्क के बिना।

स्काला में, किसी विधि के साथ किसी वस्तु को विधि की तरह कहा जा सकता है, जिसे o.apply(x)लिखा जा सकता है o(x)। इसका उपयोग सरणियों, सूचियों, नक्शों और Function1अनाम कार्यों द्वारा कार्यान्वित विशेषता के लिए मानक परिवाद में किया जाता है

Answer 14

पायथ, 19 बाइट्स

DhdDebR?bh+dbdR$end

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

मैं प्रभावित हूं कि जावास्क्रिप्ट पाइथ को हरा देता है, लेकिन फिर पाइथ को पासिंग फ़ंक्शंस के लिए डिज़ाइन नहीं किया गया है।

Answer 15

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

sub f{my$n=pop;sub{@_?f($n+pop):$n}}

---

say f(1)->(); # 1
say f(1)->(2)->(3)->(); # 6

Comments

इसके बारे में क्या आवश्यकता है -M5.016? ऐसा लगता है कि आपको ड्रॉप करने में सक्षम होना चाहिए -M5.016और फिर myएक-एक बाइट छोड़ना और बचाना भी चाहिए । यदि यह सिर्फ है say, तो आप -Eइसके बजाय ध्वज का उपयोग कर सकते हैं , जो सक्रिय नहीं करता है use strict, इसलिए आप अभी भी ड्रॉप कर सकते हैं my।

— क्रिस

@ क्रिस आप सही कह रहे हैं, इसे 5.16 की आवश्यकता नहीं है, मेरे प्रारंभिक संशोधन ने (उपयोग करते हुए __SUB__) किया लेकिन मैंने इसे जमा करने से पहले बदल दिया और 5.16 के बारे में कुछ नहीं बताया। मैं उसे हटा दूंगा। मुझे नहीं लगता कि गिराना myसही होगा।

— होब्स

(और नहीं, मैं sayकोड के हिस्से के रूप में नहीं गिन रहा हूं , यह केवल दृष्टांत उद्देश्यों के लिए है)

— हॉब्स

यदि आप myबिना हटाए हैं use strict, तो $nयह एक वैश्विक चर है। यह उचित पर्ल स्क्रिप्ट्स में खराब रूप है, लेकिन यह वन-लाइनर्स में बहुत आम है, और यह यहां काम करने लगता है।

— क्रिस

Answer 16

ब्रेन-फ्लैक , 6 बाइट्स

वास्तव में मैंने सिर्फ यह देखा कि चूंकि TOS एक वैध रिटर्न प्रारूप है, जिसमें 0 को पॉपअप करना वास्तव में आवश्यक नहीं है जो 2 बाइट्स बचाता है:

({{}})

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

मूल जमा (ओं), 8 बाइट्स

0विशेष मूल्य के रूप में उपयोग करता है :

({{}}{})

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

व्याख्या

यह देखते हुए तर्क एक ₁ , एक ₂ , ..., एक _एन , 0 ढेर शुरू में इस तरह दिखता है:

                                                       a _n

                                                       ⋮

                                                       एक _२

                                                       एक _१

                                                       0

कोड तब चलता है, हर एक _{i को} पॉप करता है , उन्हें जमा करता है, 0 को पॉप करता है और उन्हें परिणाम को धक्का देता है:

(      )  -- push the following value:
 {  }     --   while ToS ≠ 0 (sums the runs):
  {}      --     pop 1 element
     {}   --   pop the remaining 0 & add it

---

वैकल्पिक समाधान, 8 बाइट्स

0 को पॉप करने और योग में जोड़ने के बजाय , हम स्टैक को स्वैप कर सकते हैं क्योंकि सही शुरू में खाली है:

({{}}<>)

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

का उपयोग करते हुए -rझंडा 0 ढेर के शीर्ष पर है, इसलिए हमने इसे पहले पॉप कर सकते हैं:

({}{{}})

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

{}({{}})

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

Comments

ओह माय गुडनेस ... शानदार!

— यूजीन डी। गुबेनकोव

Answer 17

सी (जीसीसी), 83 बाइट्स

मेरी पहली सी गोल्फ! वहाँ अन्य सी समाधान के एक जोड़े हैं, लेकिन यह एक अलग सा है। प्रीप्रोसेसर का उपयोग विशुद्ध रूप से कॉस्मेटिक है। इस दृष्टिकोण की चर्चा यहां पहली बार कॉनर ओ'ब्रायन के उत्तर में की गई ।

#define r union r
t=0;r{int v;r(*f)();};r e;r f(a){t+=a;e.v=a?f:t;t*=a>0;return e;}

टर्मिनल मान शून्य है। वापसी मूल्य एक संघ है, इसलिए परिणाम को कॉल करने के लिए, फ़ील्ड का उपयोग करें f, और अंतिम मूल्य तक पहुंचने के लिए, फ़ील्ड का उपयोग करें v, जैसे

f(1).f(2).f(3).f(0).v

यह ऑनलाइन की कोशिश करो

सीमाएं

एक वैश्विक परिवर्तनशील कुल चल रहा है। हालांकि यह स्पष्ट रूप से अस्वीकृत है, सबमिशन बार-बार किए गए इनवोकेशन (टर्मिनल कॉल में कुल रीसेट) का समर्थन करता है, जो वैश्विक राज्य में प्रतिबंध का कारण लगता है।

एक पॉइंटर को सदस्य के fमाध्यम से लौटाए गए संघ में संग्रहीत किया जाता है int, इसलिए यह स्पष्ट रूप से पोर्टेबल नहीं है। मुझे यकीन नहीं है कि यह जीसीसी पर सभी प्लेटफार्मों पर या सिर्फ लिनक्स पर या सिर्फ x86 पर या केवल ईएलएफ के साथ काम करता है या ... यदि किसी को इस बारे में कोई विवरण पता है, तो कृपया टिप्पणी करें या संदेश भेजें!

Answer 18

APL (Dyalog Classic) , 48 47 46 ₄₄ 32 बाइट्स

∇r←(a f)x
r←⍎'(a+x)f'↓⍨-0=x
∇
0f

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

शून्य में पारित करके निर्देश। कॉल सिंटैक्स:((0 f 1) 2) 0

-15 बाइट्स के लिए धन्यवाद @ngn

आवश्यक है ⎕IO←0

किसी भी गोल्फ टिप्स का स्वागत है!

Comments

यदि आप टर्मिनेटर मूल्य के रूप में उपयोग कर सकते हैं 0, बदलने :If x<0के लिए :If×xऔर "अगर" और "बाकी" खंड स्वैप

— NGN

Derp। मैंने यह नहीं देखा कि इसने "गैर-सकारात्मक" कहा है

— ज़ाचारि

क्या आप इस ट्रिक को जानते हैं? r←⍎condition⊃'else' 'then'

— NGN

32 बाइट्स

— ngn

सोचा कि 22 कहा ...> _ <

— Zacharý

Answer 19

पर्ल 6 , 31 बाइट्स

sub f(\n){->$m?{$m??f n+$m!!n}}

Answer 20

Dyvil , 34 बाइट्स

infix int apply(i:int,j:int=0)=i+j

उपयोग :

0() // = 0
0(1)() // = 1
0(1)(2)() // = 3

अनुगामी ()को छोड़ा जा सकता है।

स्पष्टीकरण :

एक juxtaposition ऑपरेटर को परिभाषित करता है जो दो ints लेता है और उन्हें जोड़ता है। तर्क के बिना कॉल का समर्थन करने के लिए पैरामीटर jका डिफ़ॉल्ट मान 0है। 0उदाहरण में ऊपर नाम है, लेकिन एक शाब्दिक नहीं है।

Answer 21

जूलिया v0.5 +, 52 बाइट्स

type F n end
F()=0
(f::F)()=f.n
(f::F)(x)=(f.n+=x;f)

के रूप में बुलाओ F। यह शायद कम OO पद्धति को अपनाकर बहुत छोटा बनाया जा सकता है, लेकिन मुझे हमेशा इस मुहावरे का उपयोग करने का मौका मिलना पसंद है।

यदि यह माना जा सकता है कि "समाप्ति कॉल से पहले कम से कम एक कॉल किया जाएगा", तो दूसरी पंक्ति को 6 बाइट्स को बचाने के लिए हटाया जा सकता है।

Answer 22

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

!n=k->k>0?!(n+k):n

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

Answer 23

आर, 40 बाइट्स

f=function(x)function(y)`if`(y,f(x+y),x)

0 यहां स्टॉप वैल्यू के रूप में कार्य करता है। दो और बाइट्स के लिए, हम इसे छोड़ सकते हैं।

समस्या यह है कि आर में एक संक्षिप्त अंतर्निहित लैम्बडा का अभाव है। लेकिन अगर हम एक जोड़ते हैं , तो हम 26 बाइट्स के लिए कोड प्राप्त कर सकते हैं :

f=x->(y->`if`(y,f(x+y),x))

(हां, यह मान्य आर। यह सिर्फ एक आयात की जरूरत है।)

Answer 24

PHP, 44 बाइट्स

@ User63956 से एक आइडिया

समाप्ति कॉल 0

function f($i){return[$_GET[0]+=$i][$i]?:f;}

ऑनलाइन संस्करण

साथ समापन कॉल NULLएक डाली की जरूरत [$i]के लिए[+$i]

PHP, 47 बाइट्स

function f($i){global$s;return$i?f.!$s+=$i:$s;}

ऑनलाइन संस्करण

PHP, 52 बाइट्स

समाप्ति कॉल NULLया कोई अन्य मान जो PHP में गलत है

function f($i){global$s;$i?$s+=$i:print$s;return f;}

अगर कार्यक्रम आउटपुट के बाद समाप्त करना होगा की जगह print$sके साथ die("$s")+ 2 बाइट्स

ऑनलाइन संस्करण

Comments

मुझे लगता है कि फ़ंक्शन को वापस लौटना चाहिए (प्रिंट नहीं) $s। तो आप return$i?f:$sअंत में कुछ ऐसा कर सकते हैं

— कॉनर ओ'ब्रायन

@ ConorO'Brien मुझे यकीन नहीं है लेकिन अगर आपकी सोच सही है तो यह 5 बाइट्स बचा सकती है धन्यवाद

— Jörg Hülsermann

कुछ बाइट्स को सुपरग्लोबल चर के साथ बचाया जा सकता है function f($i){return[$_GET[0]+=$i][$i]?:f;}:।

— user63956

@ user63956 एक बहुत अच्छा विचार

— 10:00 पर Jörg Hülsermann

Answer 25

पॉवरशेल, 86 बाइट्स

$f={$n=$args[0];$f=(gv f).value;{if($args){&$f($args[0]+$n)}else{$n}}.getnewclosure()}

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

टेस्ट कोड:

&(&(&(&(&(&$f 4)2)7)5)2)

आउटपुट: 20

Comments

बहुत अच्छा। PPCG में आपका स्वागत है! आप $n="$args"इसके बजाय एक बाइट को बचा सकते हैं $n=$args[0]। $args[0]हालांकि, यह दूसरे पर काम नहीं करेगा , क्योंकि तब आपको जोड़ के बजाय स्ट्रिंग संयोजन मिलेगा।

— AdmBorkBork 12

Answer 26

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

f=lambda n,l=[]:n and(l.append(n)or f)or sum(l)*(l.clear()or 1)

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

---

0 के साथ समाप्त होता है

Answer 27

पायथन, 69 बाइट्स

def f(a=0,s=[]):
    if a:
        return lambda b=0:f(b,s+[a])
    return sum(s)

Comments

मैं मान रहा हूँ कि यह अजगर है? आपको अपने उत्तर में प्रयुक्त भाषा को बताना चाहिए।

— corvus_192

क्या आप अपने उत्तर को और अधिक गोल करने की कोशिश कर सकते हैं जैसा कि यह खड़ा है, यह बहुत अच्छी तरह से गोल्फ नहीं है।

— 14:

Answer 28

ऑक्टेव, 39 बाइट्स

function r=f(n)r=@(m)merge(m,f(m+n),n);

* समाप्ति कॉल का तर्क 0 है।

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

* endfunctionकुछ अन्य कोड जोड़ने की आवश्यकता है।

Answer 29

आर, 54 52 बाइट्स

f=function(x){g=function(y='')'if'(y>'',f(x+y),x);g}

2 बाइट्स बचाकर मिकी को धन्यवाद!

अजगर जवाब में से एक के समान है। Ungolfed:

f=function(x){
  g=function(y=''){
    if(y>''){
      f(y+x)
      }
      else{x}
  }
  g
}

के रूप में चलाता है

> f(1)(2)(4)()
[1] 7

Comments

अच्छा काम। आप अगर खंड के आसपास आंतरिक ब्रेसिज़ से छुटकारा पा सकते हैं। f=function(x){g=function(y='')'if'(y>'',f(x+y),x);g}

— मिकी टीटी

मैं थोड़ा हैरान हूं कि आपके "अनगुल्ड" संस्करण में क्यों है return। returnR अन्य भाषाओं की तरह नहीं है, यह समय से पहले गर्भपात करता है। उपयोग नहीं करना returnमुहावरेदार है। दूसरी ओर आपके अनगुल्ड संस्करण में अभी भी गोल्फ है if।

— कोनराड रुडोल्फ

@KonradRudolph गोल्फ ifमें आलस्य था, लेकिन returnयह सिर्फ पठनीयता के लिए है - यह उसी के साथ या बिना परिणाम देता है return।

— बीएलटी

@ बीएलटी एचएम। मुझे दृढ़ता से लगता है कि आर में return ग्रेटिट्यूड पठनीयता कम हो जाती है क्योंकि यह गलत चीज (समय से पहले निकलने) को इंगित करता है और कार्गो पंथ प्रोग्रामिंग का एक उदाहरण है ।

— कोनराड रुडोल्फ

कूल, मैंने फिर से कुछ नया सीखा। यही कारण है कि मैं वापस आती रहती हूं। धन्यवाद @KonradRudolph, यह भी स्टैक ओवरफ्लो प्रश्न दिलचस्प है: stackoverflow.com/questions/11738823/…

— BLT

Answer 30

सी ++ (जीसीसी) , 95 91 बाइट्स

struct f{int s;f(int t):s(t){}int operator()(){return s;}f operator()(int t){return s+t;}};

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