33

अपनी पसंद की भाषा का उपयोग करते हुए, एक फ़ंक्शन लिखें जो तर्कों की एक चर संख्या लेता है और उन तर्कों की संख्या लौटाता है जिनके साथ इसे बुलाया गया था।

सुनिश्चित वर्णन:

आपकी भाषा को वैरिएड तर्क कार्यों का समर्थन करने की आवश्यकता है: कुछ कॉल करने योग्य जो मनमाने ढंग से तर्कों को लेता है और एक मान लौटाता है।
पैरामीटर को व्यक्तिगत रूप से पारित करने में सक्षम होना चाहिए। इसका मतलब यह है कि एक सरणी पास करना केवल एक पैरामीटर के लिए गिना जाएगा। यदि आपकी भाषा इसका समर्थन करती है, तो आप "सभी पारित तर्क" सरणी का उपयोग कर सकते हैं; प्रतिबंध इस बात पर है कि फ़ंक्शन को कैसे कहा जाता है।
इस फ़ंक्शन को कॉल करने वाले कोड को इसके स्रोत में तर्कों की संख्या को पास करने की आवश्यकता नहीं होनी चाहिए । यदि एक संकलक एक कॉलिंग सम्मेलन के भाग के रूप में तर्कों की संख्या सम्मिलित करता है, तो इसकी अनुमति है।
तर्क आपके इच्छित किसी भी प्रकार के हो सकते हैं। आप केवल एक ही प्रकार का समर्थन कर सकते हैं (जैसे केवल समर्थन intअभी भी मान्य है), मनमाने प्रकार (किसी भी प्रकार के तर्क की अनुमति है), या तर्क के किसी भी प्रकार के संयोजन (जैसे पहले arg है int, बाकी तार हैं)।
आपके फ़ंक्शन में अधिकतम संख्या में तर्क हो सकते हैं (विशेषकर चूंकि संसाधन परिमित हैं), लेकिन कम से कम 2 तर्कों का समर्थन करना चाहिए ।

नमूने:

f() रिटर्न 0
f(1)या f("a")लौटता है1
f([1, 2, 3])रिटर्न के 1रूप में यह एक सरणी है, 3 तर्क नहीं
f(1, 10)या f(1, "a")लौटता है2

जैसा कि यह कोड-गोल्फ है, जीतने वाला समाधान वह है जो सबसे कम संख्या में बाइट्स का उपयोग करता है।

code-golf function

— ग्लेन स्मिथ
स्रोत

4

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

— user202729 5

24

@ user202729 यदि आपकी भाषा फ़ंक्शंस का समर्थन नहीं करती है, तो किसी अन्य भाषा का उपयोग करें। यह कोई आवश्यकता नहीं है कि सभी भाषाएं प्रतिस्पर्धा कर सकती हैं, कोड गोल्फिंग का हिस्सा नौकरी के लिए सही उपकरण ढूंढ रहा है।

— Sanchises

5

@ user202729 मुझे पारंपरिक / उच्च-स्तरीय भाषाओं के लिए कभी-कभार चुनौती के साथ कोई समस्या नहीं है, जैसे हमारे पास कभी-कभार चुनौती है जो केवल असामान्य भाषाओं में संभव है।

— संचित्स

6

एक स्पष्ट चुनौती के लिए हमें नहीं पता था कि हमें भाषा की विशेषताओं की हल करने की समस्या को हल करना था ....

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

5

यदि आपकी भाषा में तर्कों / कॉलिंग कन्वेंशन की अवधारणा नहीं है, तो यह मनमानी संख्या के तर्कों का समर्थन करने के मानदंड के अनुकूल नहीं है।

— ग्लेन स्मिथ

15

बेसिक से Amstrad CPC Z80 बाइनरी कॉल, 1 बाइट, हेक्स एन्कोडेड

C9          : RET

(इसके अलावा 2 और 5 बाइट संस्करण, नीचे देखें)

कॉल में प्रवेश करने पर, पारित किए गए मापदंडों की संख्या Aरजिस्टर में होगी । कोड बस तुरंत लौटता है। Z80 में वापसी मूल्यों की कोई अवधारणा नहीं है, बस प्रवेश और निकास राज्य हैं। मूल्य सिर्फ "वहाँ" रजिस्टर में सुलभ है क्योंकि कोड कोई इनपुट स्थिति नहीं बदलता है, केवल PC(प्रोग्राम काउंटर) और SP(स्टैक पॉइंटर) को छोड़कर । हालांकि, मूल्य में ABASIC तक पहुंच नहीं है और लगभग तुरंत ही ओवरराइट हो जाता है।

उदाहरण:

CALL &8000, "Hello", "World"

A = २

CALL &8000, 42

A = 1

CALL &8000

A = 0

अनुरोध के अनुसार, यहाँ कुछ कोड है जो मूल्य को BASIC में सुलभ बनाता है। मुझे यह देखकर बहुत आश्चर्य हुआ कि यह केवल 5 बाइट्स में किया जा सकता है!

मशीन कोड:

12          : LD   (DE), A
13          : INC  DE
AF          : XOR  A
12          : LD   (DE), A
C9          : RET

प्रवेश पर:

AF - संचायक और झंडे रजिस्टर (दो 8-बिट रजिस्टरों के रूप में माना जाता है)
- A इसमें दिए गए मापदंडों की संख्या, अधिकतम 32 मापदंडों तक है
- मुझे यकीन है कि क्या में है नहीं कर रहा हूँ F। ऐसा लगता है कि सभी अपरिवर्तित झंडे को 0छोड़कर सभी झंडे RESET हैं , जो दोनों हैं 1। Zझंडा (शून्य) पर सेट है 1वहाँ में पारित कोई पैरामीटर थे
BC
- B- 32 माइनस पैरामीटर की संख्या ( A+ B= 32)
- C - &FF
DE - अंतिम पैरामीटर का पता, या कॉलिंग पता यदि कोई पैरामीटर पारित नहीं हुआ था
HL - वर्तमान में निष्पादित किए जा रहे बेसिक कमांड के बाद पहली बाइट का पता (या तो प्रोग्राम या तत्काल कमांड मोड में)
IX - पिछले पैरामीटर को पॉइंटर का स्टैक पता
IY - &0000

कोड

Lमें दिए गए मान के साथ Dइंगित किया गया oa sDEA
INCrements DE
XORs A(साथ A), दे रहे हैं&00
Lद्वारा बताए गए पते पर oa Dका मानADE
RETकलश

बाहर निकलने पर:

Aनष्ट हो गया है (यह हमेशा है &00)
DE नष्ट हो गया है (यह हमेशा प्रवेश पर एक से अधिक है)
अन्य सभी रजिस्टर संरक्षित हैं

बुनियादी

Amstrad बुनियादी में केवल तीन डेटा प्रकार हैं, साथ ही सरल सरणियाँ भी हैं। डिफ़ॉल्ट रूप से, सभी बुनियादी चर वास्तविक (हस्ताक्षरित, 32 बिट मंटिसा, 8 बिट घातांक) हैं, जिनके साथ स्पष्ट किया जा सकता है !। एक INTEGER के लिए (हस्ताक्षरित, 16 बिट) का उपयोग करें %और एक STRING के लिए (1 बाइट स्ट्रिंग लंबाई, 255 बाइट्स वर्ण डेटा, बाइनरी सुरक्षित) का उपयोग करें $:

x - वास्तविक (निहित)
x! - वास्तविक (स्पष्ट)
x% - INTEGER
x$ - STRING

तुम भी उपयोग कर सकते हैं DEFINT, DEFREALऔर DEFSTRएक भी पत्र, या दो सिंगल पत्र की एक सीमा के साथ कि पत्र, FORTRAN के लिए इसी तरह के साथ शुरू सभी चर के लिए डिफ़ॉल्ट प्रकार को निर्दिष्ट करने के लिए।

DEFSTR a
DEFINT x-z

अभी व:

a - STRING (निहित)
i - वास्तविक (निहित)
x - INTEGER (निहित)
x$ - STRING (स्पष्ट)

साथ काम करने का सबसे आसान प्रकार पूर्णांक है। मशीन कोड पता से अंतिम पैरामीटर की उम्मीद करता है, मान से नहीं, यही वजह @है कि चर के लिए उपसर्ग किया गया है। रिटर्न चर को CALLएस मापदंडों में से एक के रूप में गिना जाता है ।

मशीन कोड को बेसिक से निम्नानुसार कहा जाता है (यह मानते हुए कि यह पते पर मेमोरी में लोड है &8000):

CALL &8000, "Hello", "World", 42, @n%

n% = 4

प्रारंभिक मूल्य की परवाह किए बिना, यह हमेशा सही परिणाम देगा n%।

2-बाइट संस्करण के लिए जो सभी इनपुट रजिस्टरों को संरक्षित करता है:

CALL &8003, "Hello", "World", 42, @n%

n% = 4

यह पहले तीन बाइट्स को छोड़ देता है, और केवल सही परिणाम देता है यदि प्रारंभिक मूल्य n%है 0- 255। यह काम करता है क्योंकि Z80 थोड़ा-सा एंडियन है।

पारित होने से पहले रिटर्न पैरामीटर को आरंभीकृत किया जाना चाहिए, अन्यथा BASIC एक Improper argumentत्रुटि फेंक देगा । नीचे की छवि में, मैं ?मूल्य बदल रहा दिखाने के लिए कॉल के तुरंत पहले और बाद में रिटर्न मानों को प्रदर्शित कर रहा हूं (शॉर्टकट के साथ) मैं मुद्रण कर रहा हूं। मैं मान का उपयोग कर रहा हूं &FFFFक्योंकि -1हस्ताक्षरित पूर्णांक के लिए द्विआधारी प्रतिनिधित्व है । यह दर्शाता है कि 5-बाइट प्रोग्राम दोनों बाइट्स को सही ढंग से लिखता है, जबकि 2-बाइट प्रोग्राम केवल कम बाइट लिखता है और मानता है कि उच्च बाइट पहले से ही है &00।

— सीजे डेनिस
स्रोत

तो कॉलिंग कन्वेंशन आप रिटर्न वैल्यू का उपयोग कैसे कर रहे हैं? यदि यह उन्हें संचायक, या बिल्कुल भी वापस नहीं करता है, तो आपका जवाब मूल रूप से एक कस्टम कॉलिंग आविष्कार का आविष्कार कर रहा है जो आपके लिए समस्या को हल करता है (एक रिटर्न रजिस्टर जोड़कर, एक पॉइंटर को पारित करने के बजाय जहां आप स्टोर कर सकते हैं A, यदि वह है आप वास्तव में इसे BASIC से कैसे कर सकते हैं)। ऐसा नहीं है कि इसमें कुछ भी गलत है, लेकिन मौजूदा कॉलिंग कन्वेंशन का अनुसरण करने के लिए यह अधिक दिलचस्प जवाब हो सकता है।

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

@PeterCordes न तो Amstrad BASIC और न ही Z80 में स्कोप की अवधारणा है। सभी मूल्य वैश्विक हैं और नष्ट होने तक तुरंत सुलभ हैं। निर्देश के Aतुरंत बाद का मूल्य समान है RET। मूल्य का जीवनकाल Aबहुत कम है क्योंकि यह संचायक है। जैसी कोई बात नहीं है x = CALL &8000, 42। यह होगा CALL &8000, x, 42, और अतिरिक्त Z80 कोड होगा, लेकिन तब xहोगा 2, नहीं 1।

— सीजे डेनिस

मुझे लगता है कि यदि आप आउटपुट arg को गिनती में शामिल करते हैं, तो यह ठीक है, अन्यथा 1-बाइट डिक्रीमेंट निर्देश नहीं है? मैं एक ऐसे संस्करण को देखना चाहूंगा जो वास्तव में तुच्छ होने के बजाय बेसिक से उपयोग करने योग्य हो।

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

1

@PeterCordes हो गया! ओह, वैसे, मैं इसे किसी भी पैरामीटर के साथ नहीं कॉल करने का उल्लेख करना भूल गया क्योंकि यह &00एस - NOPनो-ऑप्स के साथ अपने स्वयं के पहले दो निर्देशों को अधिलेखित कर देगा । इसे सुरक्षित बनाने के लिए एक और बाइट जोड़ी जा सकती है, लेकिन निश्चित रूप से बिना रिटर्न पैरामीटर के यह कुछ भी सेट नहीं कर सकता है।

— सीजे डेनिस

32

जावा (JDK 10) , 11 बाइट्स

a->a.length

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

— ओलिवियर ग्रेजायर
स्रोत

29

जावा पिटाई जावास्क्रिप्ट दुर्लभ है पर गौर किया जाना चाहिए

— यादृच्छिक आदमी

3

@Therandomguy को interface x{void f(Object...a);}परिभाषित करने के लिए कुछ इस तरह की आवश्यकता होती है , और इस लैम्ब्डा को या तो उस इंटरफ़ेस प्रकार के एक चर में संग्रहित किया जाना चाहिए, या उस इंटरफ़ेस प्रकार की अपेक्षा करने वाले तरीके से पारित किया जाना चाहिए, इसलिए मुझे यकीन नहीं है कि यह इस चुनौती के लिए भी मायने रखता है (यहां तक कि हालांकि आमतौर पर जावा लैम्ब्डा को कोडगॉल्फ चुनौतियों में अनुमति दी जाती है)

— सैम्योनू

3

@SamYonnou अन्य लैम्ब्डा के साथ कोई अंतर नहीं है, और जैसा कि आपने उल्लेख किया है, लैम्ब्डा ठीक हैं ।

— ओलिवियर ग्रेजायर

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

— सैम्योनू

@ ओलिवियरग्रेयर: मैं कुछ जावा को जानता हूं, लेकिन इसके साथ बिल्कुल नहीं रखा है। मैं सैम की टिप्पणी को देखने के लिए इच्छुक था कि बॉयलरप्लेट को एक जावा उत्तर में गलीचा के नीचे क्या बह रहा है जो वास्तव में कम होने देता है। मैं मानता हूं कि इसे अनुमति दी जानी चाहिए (भले ही यह आपको कुछ ऐसा देता है जो आपको सामान्य रूप से जावा फ़ंक्शन के साथ नहीं मिलता है, ठीक है, इसलिए यह केवल बॉयलरप्लेट की कमी नहीं है जो आपको आरजी-काउंटिंग में अंतर्निहित है)। इसके अलावा, यह "जावा बीटिंग जेएस" के उत्तर के रूप में अभी भी दिलचस्प है।

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

25

जावास्क्रिप्ट, 15 बाइट्स

[].push.bind(0)

Array.prototype.pushसमारोह तर्क के किसी भी संख्या लेता है, उन्हें अपने सरणी के लिए कहते हैं, और सरणी के आकार देता है। इसलिए, pushखाली सरणी पर उपयोग किया जाने वाला फ़ंक्शन , आपूर्ति किए गए तर्कों की संख्या देता है push।

f = [].push.bind(0)

f(10,2,65,7)
> 4

f()
> 0

.bind(0)बस देता pushसमारोह एक निश्चित thisइतना है कि यह एक चर में संग्रहीत किया जा सकता मूल्य। वास्तव में, 7-बाइट पहचानकर्ता [].pushका उपयोग शाब्दिक रूप से किया जा सकता है (लेकिन सौंपा नहीं गया) bind:

[].push(10,2,65,7)
> 4

[].push()
> 0

— apsillers
स्रोत

19

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

(...a)=>a.length

कोड स्निपेट दिखाएं

f=
(...a)=>a.length

console.log(f())
console.log(f(1))
console.log(f(1,2))
console.log(f(1,2,3))
console.log(f(1,2,3,4))

स्निपेट का विस्तार करें

— TSH
स्रोत

18

हास्केल , 108 107 95 94 बाइट्स

class T r where z::Int->r
instance T Int where z=id
instance T r=>T(a->r)where z n _=z$n+1
z 0

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

यह काम करने के लिए आश्चर्यजनक रूप से कठिन था, लेकिन मुझे यह पता लगाने की कोशिश करने में मज़ा आया कि कुछ को अनिवार्य भाषाओं में कैसे लागू किया जाए।

— user9549915
स्रोत

लानत है, तुमने इसके लिए मुझे हराया। fवैकल्पिक है यदि आप कहते हैं कि z 0बंधन के बिना फ़ंक्शन है, तो main = print $ ((z 0) pi 0 () [] :: Int)काम करता है।

— Angs

और इसके द्वारा मेरा मतलब है कि प्रकार काम करते हैं जब एक अनाम फ़ंक्शन के रूप में उपयोग किया जाता है ताकि आप वास्तव में आखिरी दो पंक्तियों से सब कुछ हटा z 0

— सकें

अच्छा धन्यवाद! जब मैं अनाम फ़ंक्शन का परीक्षण कर रहा था, तो मैं कुछ गलत कर रहा था। अपने उदाहरण की कोशिश की और यह ठीक काम किया।

— user9549915

मुझे लगता ::Intहै कि बाइट की गिनती में गिना जाना चाहिए, क्योंकि उत्तर का प्रकार जल्द या बाद में घोषित किया जाना चाहिए, जैसे main = print $ ((z 0 :: Double -> Integer -> () -> [a] -> (Int->Int->Int) -> IO () -> Int) pi 0 () [] (+) main)। मुझे भी लगता है कि यह केवल संकलन समय के दौरान काम करता है, इसलिए कुछ foldl(\a b->a b) (z 0) $ [1..5])::Intकाम नहीं कर सकता है। किसी भी तरह से, यह महान सामान है।

— आंग्स

2

s/imperative/non-curry/

— user202729

16

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

lambda*a:len(a)

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

— लीक नन
स्रोत

4

इसके अलावा, पायथन 2 :)

— चास ब्राउन

यह बिल्कुल आश्चर्यजनक नहीं है कि यह पहला जवाब था। ;)

— jpmc26

12

Zsh , 7 5 बाइट्स

<<<$#

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

— पावेल
स्रोत

हालांकि इसे संभवतः लपेटा जाना चाहिए:f(){ echo $#; }

— मूरू

8

@ मूरू मुझे एक पूर्ण कार्यक्रम के रूप में ठीक लग रहा है।

— नील

हालाँकि, अब मैं देख रहा हूँ कि ओपी केवल एक फंक्शन चाहता है ...

— नील

2

@ नील शैल लिपियाँ बिल्कुल कार्यों की तरह काम करती हैं। ओपी यह स्पष्ट नहीं करता है कि एक फ़ंक्शन क्या है, मैं दावा करता हूं कि मेरा सबमिशन डिस्क पर सहेजी गई फ़ंक्शन है।

— पावेल

9

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

मेरा पहला ब्रेन-फ्लैक समाधान योग्य पोस्टिंग है, मुझे लगता है कि यह इस काम के लिए सही उपकरण है:

([]<>)

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

व्याख्या

ब्रेन-फ्लैक प्रोग्राम निष्पादित करते समय, शुरू में बाएं स्टैक में सभी तर्क होते हैं। वहाँ से यह बस की बात है:

(      -- push the following..
 []    --   height of the stack (ie. # of arguments)
   <>  -- ..to the other stack  (toggles to the other stack)
)      --
       -- the right stack now contains the # of arguments which
       -- gets printed implicitly

— ბიმო
स्रोत

7

वोल्फ्राम भाषा (गणितज्ञ) , 11 बाइट्स

Tr[1^{##}]&

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

JungHwan Min द्वारा सुझाया गया। कुछ प्रतिबंध (इनपुट आयताकार होना चाहिए) लेकिन हमें मनमाना इनपुट संभालने की आवश्यकता नहीं है।

11 बाइट्स

Length@!##&

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

मार्टिन एंडर द्वारा सुझाया गया एक और 11 बाइट समाधान। यह तब लगता है जब एक इनपुट नहीं है, लेकिन यह अभी भी सभी मामलों में सही मूल्य देता है।

12 बाइट्स

Length@{##}&

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

मेरा मूल समाधान।

Mathematica ##में एक फ़ंक्शन में कई प्रकार के तर्क होते हैं। {और }उन्हें एक सूची में लपेटता है और Length@इस सूची की लंबाई लेता है। &अंत में यह एक वास्तविक समारोह में बदल जाता है।

— dylnan
स्रोत

7

आर , 30 बाइट्स

function(...)length(list(...))

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

— JAD
स्रोत

1

function(...)nargs()20 बाइट्स है, लेकिन length(...)जब तक मैं एक nargsतरह का फ़ंक्शन नहीं करता तब तक मेरा प्रारंभिक दृष्टिकोण था ।

— ग्यूसेप

@Giuseppe हम्म, मैंने list(...)एक तार्किक को परिवर्तित करने की कोशिश की ताकि sum()इसका इस्तेमाल किया जा सके, लेकिन यह मुश्किल है: /

— JAD

1

हाहा, कोशिश मत करो और मुझे उस तर्क में

— फंसाओ

1

@ RoryT ओह वास्तव में, आर डॉक्स कहते हैं कि गठबंधन करें। कोई बात नहीं: D

— JAD

2

...length() does the same thing as length(list(...))

— Giuseppe

7

Bash, 12 bytes (thanks to paxdiablo for saving 4)

n()(echo $#)

Copy and paste at a bash prompt. Then run the n function from the prompt:

$ n
0
$ n 46 gr 3443 dad
4
$ n 4fwj23 wrw jdwj 00998 34 eyt q3 vg wq j qw
11

— Wastrel
स्रोत

2

Welcome to PPCG!

— Martin Ender

can you just say it is a script "./n" and not a function? then it is just: echo $#, 7 bytes. (will be then any shell you use to launch the "./n" script with. ie, you run bash? then when you: ./n arg1 ... argn it will be interpreted by bash.)

— Olivier Dulac

@Olivier Dulac The challenge clearly says a function.

— Wastrel

7

C++14 (gcc), 34 bytes

As generic variadic lambda function (C++14 required):

[](auto...p){return sizeof...(p);}

Try it online!

Previous (incorrect) answer: 32 bytes

It was missing the template<class...T> and (p)

int f(T...p){return sizeof...p;}

— Bierpfurz
स्रोत

6

C++14, C++11 has no generic lambdas.

— Quentin

1

You could add the permissive flag to be able to remove the parenthesis around p (and -w to turn off the warning).

— nwp

@nwp: wouldn't -fpermissive cost you the 12 bytes for that option, though? If it's not standard ISO C++ or GNU C++.

— Peter Cordes

@PeterCordes It probably does and is intended to avoid having a trivial 0-byte solution for everything by passing the program via command line. I just didn't think about that here because it seems to not be abusive.

— nwp

@Quentin fixed -> C++14

— Bierpfurz

5

Ruby, 12 bytes

->*a{a.size}

Try it online!

*a is a splat of the arguments, making a consume all arguments passed to the Proc. a.size obtains its size.

— Conor O'Brien
स्रोत

5

Octave, 9 bytes

@()nargin

Try it online!

Anonymous function taking any number of arguments (and silently discarding the lot), and outputs the number of arguments through the built-in nargin. This does not work in MATLAB, where you would need varargin to allow for arbitrary many arguments.

— Sanchises
स्रोत

5

Perl 6, 5 bytes

Thanks @Joshua for -5 bytes

{+@_}

Try it online!

— ASCII-only
स्रोत

You could just do {+@_}

— Joshua

@Joshua >_> true, thanks

— ASCII-only

You can remove the sub in Perl 6 (not in Perl 5, though).

— nwellnhof

@nwellnhof Oh, TIL. Perl 6 is so different from Perl 5 >_>

— ASCII-only

4

Perl 5, 9 bytes

sub{~~@_}

Try it online!

— Chris
स्रोत

A quick sitewide search of answers seems to indicate that you can leave out the sub

— ASCII-only

2

Protip: TIO let's you copy in PPCG post format (ESC, S, G)

— ASCII-only

@ASCII-only Oh nice, thanks! :) As for leaving out the sub, I don't think so. It's not a function without it.

— Chris

@ASCII-only I'd consider answers without sub invalid since the result isn't something you can call or assign to a variable

— Ton Hospel

4

PHP, 34 bytes

function(...$a){return count($a);}

— Jarno
स्रोत

Nice one! The alternative, for PHP 5.6 and older, is function(){return func_num_args();} (35 bytes, posted below).

— Ismael Miguel

@IsmaelMiguel This one also works in PHP 5.6.

— axiac

1

You should mention this works only in PHP 5.6 and newer.

— axiac

@axiac You're right, my bad. Was thinking about PHP5.5

— Ismael Miguel

4

C# .NET, 11 bytes

a=>a.Length

Try it online.

Explanation:

C # .NET objectमें बहु-प्रकार के तर्कों के लिए उपयोग किया जाता है, जिससे एक पूर्णांक, स्ट्रिंग, वर्ण, आदि को संभव इनपुट के रूप में पारित किया जा सकता है। उदाहरण के लिए:

// Can be called like: `F(2)`, `F("test")`, `F('a')`, etc.
void F(object arg){ ... }

C # .NET में वैकल्पिक तर्कों का एक निश्चित आकार भी हो सकता है। उदाहरण के लिए:

// Can be called like: `F()`, `F(2)`, `F("test")`, `F('a')`, etc.
void F(object arg = null){ ... }

और वहाँ भी varargs, जो वैकल्पिक तर्कों की एक अपरिभाषित राशि है (जो कि मैंने इस उत्तर में उपयोग किया है)। उदाहरण के लिए:

// Can be called like: `F()`, `F(2)`, `F(2, "test", 'a')`, etc.
void F(params object[] args){ ... }

आमतौर पर मेमने इस तरह बनाए जाते हैं:

System.Func<object[], int> F f = a=>a.Length;
// A call like `f(new object[]{2, "test", 'a'))` will return 3 (size of the input array)

लेकिन दुर्भाग्य से varargs का System.Funcसमर्थन नहीं करता है params, इसलिए मुझे delegateइसके बजाय बनाना होगा:

delegate int F(params object[] args);
F f = a=>a.Length;
// A call like `f()` will return 0, and `f(2, "test", 'a')` will return 3

इस चुनौती के लिए मेरा जवाब क्या है, और लिंक किए गए TIO टेस्ट कोड में पाया जा सकता है।

केवल सीमा यह है कि वास्तविक की object[]तरह इनपुट f(new object[]{1,2,3})1 के बजाय 3 में परिणाम f(new int[]{1,2,3})देगा, फिर भी 1 में परिणाम होगा, क्योंकि यह int[]एकल के रूप में व्याख्या करता है object। object[]पैरामीटर को एकल ऑब्जेक्ट के रूप में व्याख्या करने के लिए और साथ ही इसे इस तरह ऑब्जेक्ट पर डाला जा सकता है f((object)new object[]{1,2,3}):।

— Kevin Cruijssen
स्रोत

I have to say, if there were ever an answer that made me support including lambda-related boilerplate in C# answers it would be this one... but it is definitely a valid solution.

— Kamil Drakari

@KamilDrakari शायद यह वास्तव में बहुत स्पष्ट नहीं था कि मैंने टीआईओ-लिंक को खोले बिना क्या किया है, इसलिए मैंने एक स्पष्टीकरण जोड़ा है।

— केविन क्रूज़सेन

1

@Taemyr मैंने एक समाधान खोजने की कोशिश की, लेकिन दुर्भाग्य से C # .NET के लिए कोई भी नहीं है, सिवाय इसके किसी भी object[]पैरामीटर को कास्टिंग करने के लिए object, जैसे f((object)new object[]{1,2,3});:। मेरे f(new object[]{1,2,3});और f(1,2,3);जहाँ तक मुझे मिल सके, में अंतर करने का कोई तरीका नहीं है ।

— केविन क्रूज़सेन

1

यह बाइट्स के भारी जुर्माना के लिए सही ढंग से सरणी मापदंडों को संभालता है। एक अधिक संक्षिप्त संरचना हो सकती है जो इसे संभाल सकती है, लेकिन यह मेरे परीक्षण में काम करती है।

— कामिल दकरी

1

@KamilDrakari हम्म, लेकिन यह f(1, new object[]{1,2,3})फिर से विफल रहता है । यकीन नहीं होता कि इस व्यवहार का कोई हल मिल सकता है।

— केविन क्रूज़सेन

4

डोडोस , 32 31 बाइट्स

f
	dot i f dab
i
	
	dip dot dab

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

डेनिस वेतन वृद्धि समारोह का उपयोग करता है।

व्याख्या

f                     # definition of f - target function
        dot i f dab   # sum of j(f(all args but first)). recurses until it has 0 args
i                     # definition of i - returns (arg, 1) given 1 arg
                      # arg
        dip dot dab   # 1 (dot dab on list of length 1 returns 0, dip returns |0 - 1|)

वैकल्पिक रूप से, लक्ष्य समारोह में पुनरावृत्ति के बिना 32 बाइट्स (धन्यवाद @Leo )

	dot i
i
	dip dot dab dot
	i dab

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

व्याख्या

        dot i             # anonymous function: sum of i(args)
                          # here this becomes implicit main
i                         # definition of i - returns a list with all arguments replaced with 1
        dip dot dab dot   # 1 (dab dot returns empty list, dot returns 0, dip returns |0 - 1|
        i dab             # list concatenated with i(all args but first)

— ASCII-केवल
स्रोत

यहां एक और समान-लंबाई समाधान है इसे ऑनलाइन आज़माएं! मुझे समझ में नहीं आ रहा है कि आपका काम क्यों होता है, क्या आप कृपया स्पष्टीकरण जोड़ सकते हैं?

— सिंह

अरे, आपने मेरे समाधान के लिए एक स्पष्टीकरण जोड़ा! मैं तुम्हारे लिए एक चाहता था, मुझे पता है कि मेरा काम एक्सडी कैसे होता है

— लियो

1

@ देर से जवाब के लिए खेद है, मैं क्या कर रहा हूँ, सिर्फ डेनिस समारोह की नकल की है, asap को समझने की कोशिश करेंगे। मुझे पता नहीं था कि डोडो कैसे काम करता है, इसलिए मैंने पता लगाया कि तुम्हारा पहला क्या था

— केवल

कोई चिंता नहीं, यह सिर्फ एक अजीब स्थिति थी :)

— सिंह

@ ठीक है, तो मेरे स्पष्टीकरण का कोई मतलब नहीं है? (नोट: मैं मोबाइल पर हूं इसलिए इसे बेहतर बनाने के लिए इसे संपादित करने के लिए स्वतंत्र महसूस कर रहा हूं)

— ASCII-only

3

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

int f(){return 0;}template<class...P>int f(int,P...p){return f(p...)+1;}

केवल बट्स के साथ काम करके बाइट्स बचाता है।

— bridgerrholt
स्रोत

आप उपयोग कर सकते हैं sizeof...।

— एलएफ

3

जंग, 57 बाइट्स

macro_rules!f{()=>{0};($($x:expr),+)=>{[$($x),+].len()};}

स्पष्टीकरण:

macro_rules! f {         // define a macro called f
    () => {0};           // when called without arguments, expand to 0
    ($($x:expr),+) => {  // when called with 1 or more comma seperated arguments
        [                // rust uses [a, b, c] to make an array
            $($x),+      // expand to the arguments seperated with a comma
        ]                
        .len()           // take the length of that.
    };
}

परीक्षा:

fn main() {
    println!("{:?}", f!());                // prints 0
    println!("{:?}", f!(4));               // prints 1
    println!("{:?}", f!(5, 2));            // prints 2
    // works with anything, as long as you dont mix things
    println!("{}", f!("", "a", "hello"));  // prints 3
}

— corvus_192
स्रोत

2

PHP, 35 बाइट्स

function(){return func_num_args();}

हस्त प्रविष्टि

— टाइटस
स्रोत

2

आम लिस्प , 28 बाइट्स

(defun f(&rest a)(length a))

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

— ASCII-केवल
स्रोत

2

++ , 3 बाइट्स जोड़ें

L,L

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

— केर्ड सिक्काहिरिंग
स्रोत

2

PHP, 11 बाइट्स

<?=$argc-1;

इसे ऑनलाइन आज़माएँ: 1 इनपुट | 3 इनपुट

— झबरा
स्रोत

मैं इस बारे में इतना निश्चित नहीं हूं (और यह वैधता है) क्योंकि यह PHP को कॉल करने के लिए पारित तर्कों की गिनती है।

— इस्माइल मिगुएल

@IsmaelMiguel, यह आम सहमति देखें ।

— झबरा

1

The question explicitly requires a function that returns the number, does not display it: "...write a function that takes a variable number of arguments and returns the number of arguments."

— axiac

1

Re-quoting the question: "Using your language of choice, write a function that takes a variable number of arguments and returns the number of arguments it was called with.". Your code doesn't contain functions.

— Ismael Miguel

@IsmaelMiguel, अगर वास्तव में ऐसा होता तो कई अन्य समाधान भी अमान्य हो जाते। मानदंड समाधान को कार्यक्रम या कार्य करने की अनुमति देता है।

— झबरा

2

बैच, 50 49 बाइट्स

set n=0
for %%a in (%*)do set/an+=1
exit/b%n%

बैच में कोई भी भवन नहीं है, इसलिए हमें पुराने स्कूल जाना होगा। @IsmaelMiguel को 1 बाइट धन्यवाद दिया गया। यदि वैश्विक वैरिएबल के माध्यम से आउटपुट मान्य है, तो एक्ज़िट कोड के माध्यम से आउटपुट, या 3 बाइट्स बचाएं। एक पूर्ण कार्यक्रम में उपयोग का उदाहरण:

@echo off
call:c %*
echo %ERRORLEVEL%
exit/b
:c
set n=0
for %%a in (%*)do set/an+=1
exit/b%n%

— नील
स्रोत

I believe that this answer is answer goes (somewhat) against the rules. Batch has something somewhat close to functions. You can do something similar to :a|set r=0&for %%a in (%*)do set/ar+=1 (| = windows-style newline). This solution is 38 bytes. To execute it, do call :a <args> with a goto :eof before the function, being the value available inside the variable r. If you want to keep your solution, remove the /a on the first set, and remove those @.

— Ismael Miguel

@IsmaelMiguel Like this? (Note: I didn't include the function name in the byte count, but I did include the function return, which seems reasonable, as there needs to be one somewhere.)

— Neil

हाँ, बिलकुल ऐसा ही है। एग्जिट कोड के साथ अच्छी पकड़! मुझे यह देखकर आश्चर्य हुआ कि एग्जिटकोड 255 से अधिक हो सकते हैं। एक उदाहरण सिमेंटेक द्वारा प्रदान की गई सूची है: symantec.com/connect/articles/…

— Ismael Miguel

2

x86 32-bit (i386) machine code function, 13 bytes

कॉलिंग कन्वेंशन: i386 सिस्टम V (स्टैक args), NULL पॉइंटर के साथ एक सेंटिनल / टर्मिनेटर के रूप में एंड-ऑफ-आर्ग-लिस्ट के लिए. (Clobbers EDI, otherwise complies with SysV).

सी (और एएसएम) प्रकार की जानकारी को चर कार्यों के लिए पारित नहीं करते हैं, इसलिए बिना किसी स्पष्ट प्रकार की जानकारी के पूर्णांक या सरणियों को पास करने का ओपी विवरण केवल एक सम्मेलन में लागू किया जा सकता है जो किसी प्रकार की संरचना / वर्ग वस्तु (या बिंदुओं को पारित करता है) ), ढेर पर नंगे पूर्णांक नहीं। इसलिए मैंने यह मानने का फैसला किया कि सभी आर्ग गैर-पूर्ण बिंदु थे, और कॉल करने वाला एक पूर्ण टर्मिनेटर से गुजरता है।

POSIX जैसे कार्यों के लिए C की वास्तव में एक पूर्ण-समाप्ति सूचक सूची C में उपयोग की जाती हैexecl(3) : int execl(const char *path, const char *arg, ... /* (char *) NULL */);

C int foo(...);कोई निश्चित arg वाले प्रोटोटाइप की अनुमति नहीं देता है , लेकिन int foo();इसका मतलब समान है: अनिर्दिष्ट args। (C ++ के विपरीत जहां इसका मतलब हैint foo(void) )। किसी भी मामले में, यह एक जवाब है। इस फ़ंक्शन को सीधे कॉल करने के लिए एक सी कंपाइलर कोअक्सिंग करना दिलचस्प है लेकिन आवश्यक नहीं है।

nasm -felf32 -l/dev/stdout arg-count.asm कुछ टिप्पणी लाइनों के साथ हटा दिया गया।

24                       global argcount_pointer_loop
25                       argcount_pointer_loop:
26                               .entry:
28 00000000 31C0             xor   eax, eax  ; search pattern = NULL
29 00000002 99               cdq             ; counter = 0
30 00000003 89E7             mov   edi, esp
31                       ;    scasd           ; edi+=4; skip retaddr
32                       .scan_args:
33 00000005 42               inc   edx
34 00000006 AF               scasd            ; cmp eax,[edi] / edi+=4
35 00000007 75FC             jne  .scan_args
36                       ;    dec   edx       ; correct for overshoot: don't count terminator
37                       ;    xchg  eax,edx
38 00000009 8D42FE           lea   eax, [edx-2]    ; terminator + ret addr
40 0000000C C3               ret

size = 0D               db $ - .entry

प्रश्न दिखाता है कि फ़ंक्शन 0 को वापस करने में सक्षम होना चाहिए, और मैंने उस आवश्यकता का पालन करने का फैसला किया जिसमें Arg गिनती में NULL पॉइंटर को समाप्त नहीं किया गया था। हालांकि यह 1 बाइट खर्च करता है। (12-बाइट संस्करण के लिए, एलईए को हटा दें और scasdलूप और ए के बाहर को अनकम्प्लिमेंट करें xchg, लेकिन नहींdec edx मैंने । मैंने एलईए का उपयोग किया क्योंकि यह उन तीनों निर्देशों को एक साथ रखने के समान है, लेकिन अधिक कुशल है, इसलिए फ़ंक्शन कम है UOPs।)

परीक्षण के लिए सी कॉलर :

इसके साथ निर्मित:

nasm -felf32 -l /dev/stdout arg-count.asm | cut -b -28,$((28+12))- &&
 gcc -Wall -O3 -g -std=gnu11 -m32 -fcall-used-edi arg-count.c arg-count.o -o ac &&
 ./ac

-fcall-used-ediयह भी आवश्यक है कि -O0 को यह बताने के लिए कि फ़ंक्शन ediको बचाने / बहाल करने के बिना उस फ़ंक्शन क्लोबर को gcc बताने के लिए , क्योंकि मैंने एक सी स्टेटमेंट ( printfकॉल) में इतने कॉल -O0का उपयोग किया था कि यहां तक कि ईडीआई का उपयोग कर रहा था। यह mainglibc के साथ लिनक्स पर अपने स्वयं के कॉलर (CRT कोड में) से cccbber EDI के लिए gcc के लिए सुरक्षित प्रतीत होता है , लेकिन अन्यथा यह विभिन्न के साथ संकलित / मैच कोड को मिलाने के लिए पूरी तरह से फर्जी है -fcall-used-reg। __attribute__इसका कोई संस्करण नहीं है कि हम सामान्य कॉलिंग रिवाज़ों के साथ ऐश कार्यों को सामान्य से अलग घोषित करें।

#include <stdio.h>

int argcount_rep_scas();       // not (...): ISO C requires at least one fixed arg
int argcount_pointer_loop();   // if you declare args at all
int argcount_loopne();

#define TEST(...) printf("count=%d = %d = %d   (scasd/jne) | (rep scas) | (scas/loopne)\n", \
        argcount_pointer_loop(__VA_ARGS__), argcount_rep_scas(__VA_ARGS__), \
        argcount_loopne(__VA_ARGS__))

int main(void) {
    TEST("abc", 0);
    TEST(1, 1, 1, 1, 1, 1, 1, 0);
    TEST(0);
}

13 बाइट्स में दो अन्य संस्करण भी आए: यह एक loopneरिटर्न पर आधारित है जो 1 से बहुत अधिक है।

45                       global argcount_loopne
46                       argcount_loopne:
47                           .entry:
49 00000010 31C0             xor   eax, eax  ; search pattern = NULL
50 00000012 31C9             xor   ecx, ecx  ; counter = 0
51 00000014 89E7             mov   edi, esp
52 00000016 AF               scasd           ; edi+=4; skip retaddr
53                       .scan_args:
54 00000017 AF               scasd
55 00000018 E0FD             loopne  .scan_args
56 0000001A 29C8             sub   eax, ecx
58 0000001C C3               ret

size = 0D = 13 bytes               db $ - .entry

यह संस्करण एक लूप के बजाय रेप स्कैड का उपयोग करता है, लेकिन आर्ग काउंट मॉडुलो 256 लेता है। (या 256 पर छाया हुआ यदि ऊपरी बाइट्स ecxप्रवेश पर 0 हैं!)

63                       ; return int8_t maybe?
64                       global argcount_rep_scas
65                       argcount_rep_scas:
66                               .entry:
67 00000020 31C0             xor   eax, eax
68                           ;    lea   ecx, [eax-1]
69 00000022 B1FF             mov   cl, -1
70 00000024 89E7             mov   edi, esp
71                       ;    scasd              ; skip retaddr
72 00000026 F2AF             repne scasd        ; ecx = -len - 2 (including retaddr)
73 00000028 B0FD             mov   al, -3
74 0000002A 28C8             sub   al, cl       ; eax = -3 +len + 2
75                       ;    dec   eax
76                       ;    dec   eax
77 0000002C C3               ret

size =  0D = 13 bytes         db $ - .entry

जाहिर है, अभी तक 13 / बाइट्स पर आधारित inc eax/ pop edx/ पर एक और संस्करण आया था। यह एक कैली-पोप सम्मेलन है, जिसका उपयोग चर कार्यों के लिए सी कार्यान्वयन द्वारा कभी नहीं किया जाता है। (मैंने रिट एडियर को एक्सएक्सएक्स, और जेएमपी एक्सएक्सएक्स में रेट के बजाय पॉप किया। (या रिटर्न-एड्रेस प्रेडिक्टर स्टैक को नहीं तोड़ने के लिए पुश / रिट)।test edx,edxjnz

— पीटर कॉर्डेस
स्रोत

2

आर , 20 बाइट्स

function(...)nargs()

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

R के पास इसके लिए एक फंक्शन है ।

— Jayce
स्रोत

1

जावास्क्रिप्ट, 35 बाइट्स

f=
function(){return arguments.length}

console.log(f(2,5,4))

स्निपेट का विस्तार करें

— l4m2
स्रोत

1

फूलगोभी , 16 बाइट्स

(\((@a))(len@a))

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

— ASCII-केवल
स्रोत

कितने तर्क पारित किए गए?

बेसिक से Amstrad CPC Z80 बाइनरी कॉल, 1 बाइट, हेक्स एन्कोडेड

मशीन कोड:

बुनियादी

जावा (JDK 10) , 11 बाइट्स

जावास्क्रिप्ट, 15 बाइट्स

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

हास्केल , 108 107 95 94 बाइट्स

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

Zsh , 7 5 बाइट्स

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

व्याख्या

वोल्फ्राम भाषा (गणितज्ञ) , 11 बाइट्स

आर , 30 बाइट्स

Bash, 12 bytes (thanks to paxdiablo for saving 4)

C++14 (gcc), 34 bytes

Previous (incorrect) answer: 32 bytes

Ruby, 12 bytes

Octave, 9 bytes

Perl 6, 5 bytes

Perl 5, 9 bytes

PHP, 34 bytes

C# .NET, 11 bytes

डोडोस , 32 31 बाइट्स

व्याख्या

व्याख्या

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

जंग, 57 बाइट्स

PHP, 35 बाइट्स

आम लिस्प , 28 बाइट्स

++ , 3 बाइट्स जोड़ें

PHP, 11 बाइट्स

बैच, 50 49 बाइट्स

x86 32-bit (i386) machine code function, 13 bytes

आर , 20 बाइट्स

जावास्क्रिप्ट, 35 बाइट्स

फूलगोभी , 16 बाइट्स