एक और आसान चुनौती के लिए समय जिसमें सभी भाग ले सकते हैं!

बहुराष्ट्रीय प्रमेय बताता है:

कोष्ठक में अभिव्यक्ति बहुपद गुणांक है, जिसे इस प्रकार परिभाषित किया गया है:

की अनुमति दे शर्तों k _मैं के सभी पूर्णांक विभाजन से अधिक लेकर n देता n पास्कल की मई के स्तर मीटर -simplex। आपका कार्य इस गुणांक की गणना करना है।

कार्य

एक प्रोग्राम या फंक्शन लिखिए जो m नंबर, n , k ₁ , k ₂ , ..., k _m-1 और आउटपुट को लेता है या संबंधित बहुराष्ट्रीय गुणांक लौटाता है। आपका कार्यक्रम वैकल्पिक रूप से लग सकता है मी एक अतिरिक्त तर्क के रूप में अगर जरूरत हो। ध्यान दें कि k _m इनपुट में नहीं है।

इन नंबरों को किसी भी प्रारूप में इनपुट किया जा सकता है, उदाहरण के लिए, सूचियों में समूहीकृत या एकरी, या कुछ और में एन्कोडेड, जब तक कि बहुराष्ट्रीय गुणांक की वास्तविक गणना आपके कोड द्वारा की जाती है, और एन्कोडिंग प्रक्रिया नहीं।
आउटपुट स्वरूप समान रूप से लचीला है।
सभी कोड n और m के लिए 1000 से एक मिनट से भी कम समय में चलने चाहिए ।
पूर्णांक अतिप्रवाह के बारे में चिंता न करें।
बहु-आयामी गुणांक की गणना करने के लिए डिज़ाइन किए गए अंतर्निर्मित की अनुमति नहीं है।
मानक खामियां लागू होती हैं।

स्कोरिंग

यह कोड गोल्फ है: बाइट्स जीत में सबसे छोटा समाधान।

परीक्षण के मामलों

Input: 3, [2, 0]
Output: 3

Input: 3, [1, 1]
Output: 6

Input: 11, [1, 4, 4]
Output: 34650

Input: 4, [1,2]
Output: 12

Input: 15, [5,4,3,2]
Output: 37837800

Input: 95, [65,4,4]
Output: 1934550571913396675776550070308250

Input: 32, [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
Output: 4015057936610313875842560000000

Input: 15, [3,3,3,3]
Output: 168168000

Input: 1000, [10,10,10,10,10,10,10,10,10,10,100,100,100,100,100,100,100,100]
Output: 1892260836114766064839886173072628322819837473493540916521650371620708316292211493005889278395285403318471457333959691477413845818795311980925098433545057962732816261282589926581281484274178579110373517415585990780259179555579119249444675675971136703240347768185200859583936041679096016595989605569764359198616300820217344233610087468418992008471158382363562679752612394898708988062100932765563185864346460326847538659268068471585720069159997090290904151003744735224635733011050421493330583941651019570222984959183118891461330718594645532241449810403071583062752945668937388999711726969103987467123014208575736645381474142475995771446030088717454857668814925642941036383273459178373839445456712918381796599882439216894107889251444932486362309407245949950539480089149687317762667940531452670088934094510294534762190299611806466111882595667632800995865129329156425174586491525505695534290243513946995156554997365435062121633281021210807821617604582625046557789259061566742237246102255343862644466345335421894369143319723958653232683916869615649006682399919540931573841920000000000000

Input: 33, [17]
Output: 1166803110

Input: 55, [28]
Output: 3824345300380220

code-golf math combinatorics

— quintopia
स्रोत

क्या हममें गलतियाँ हो सकती हैं? यानी, के बजाय 1934550571913396675776550070308250, हम उत्पादन कर सकते हैं 1.9345505719133966e+33?

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

@ C @O'Bʀɪᴇɴ यदि आपने 64-बिट फ़्लोट्स का उपयोग किया है, तो आप इनपुट [1000 {999 ones}]का बिल्कुल भी प्रतिनिधित्व नहीं कर पाएंगे , क्योंकि प्रतिपादक 64-बिट फ़्लोट का प्रतिनिधित्व कर सकता है। (128-बिट फ़्लोट शायद पर्याप्त होगा, लेकिन मैं मान रहा हूं कि आप जावास्क्रिप्ट के मूल संख्या प्रकार का उपयोग करना चाहते हैं?)

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

@ मार्टिनबटनर हां, यह एक सही धारणा है।

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

2

@quintopia "एक और आसान चुनौती के लिए समय जिसमें सभी भाग ले सकते हैं!"। मेरे सिवा सब लोग! (चूंकि मुझे कोई अंदाजा नहीं है कि पास्कल्स सिम्पलेक्स और मल्टीनोमियल डी क्या हैं :) LOL।

— अश्विन गुप्ता

@ अश्विनगुप्त इसके बारे में चिंता न करें। आप बस दूसरी छवि में अभिव्यक्ति की गणना करते हैं और आप जाने के लिए अच्छे हैं! 👍

— quintopia

21

जेली , 7 6 बाइट्स

;_/!:/

देखो माँ, कोई यूनिकोड नहीं! यह कार्यक्रम इनपुट के रूप में एकल सूची लेता है, इसके पहले सूचकांक में n है ।

इसे ऑनलाइन आज़माएं! या एक ही बार में सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

;_/!:/ Input: A (list)

 _/    Reduce A by subtraction. This subtracts all other elements from the first.
;      Concatenate A with the result to the right.
   !   Apply factorial to all numbers in the resulting list.
    :/ Reduce the result by division. This divides the first element by the others.

— डेनिस
स्रोत

यह बहुत आसान एल्गोरिथ्म है जिसे मैंने सबसे सरल होने के रूप में ध्यान में रखा था।

— क्विंटोपिया

9

सीजेएम, 11 बाइट्स

l~_:-+:m!:/

nपहली सूची के साथ एकल सूची के रूप में इनपुट :

[95 65 4 4]

यह बहुत ही तुरंत 1000 nऔर तक के इनपुट को संभालता है m।

इसका परीक्षण यहां करें।

व्याख्या

l~  e# Read a line of input and evaluate it.
_   e# Duplicate.
:-  e# Fold subtraction over the list. A fold is essentially a foreach loop that starts
    e# from the second element. Hence, this subtracts all the k_i from n, giving k_m.
+   e# Append k_m to the list.
:m! e# Compute the factorial of each element in the list.
:/  e# Fold division over the list. Again, this divides n! by each of the k_i!.

— मार्टिन एंडर
स्रोत

ऐसा लग रहा है कि आप वास्तव में बाइट-काउंट प्रतियोगिता को खो देंगे, लेकिन मुझे कहना होगा कि मैं सीजाम की पागल मर्यादा से प्रभावित हूं।

— फॉर्ड

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

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

4

MATL , 21 15 बाइट्स

चलो लॉग-गामा फ़ंक्शन को अच्छे उपयोग के लिए रखें। यह फैक्टरियल के लघुगणकों के साथ काम करके आंतरिक अतिप्रवाह से बचा जाता है, न कि स्वयं फैक्टरियल के साथ।

1+ZgiO$Gs-h1+Zgs-ZeYo

यह भाषा / संकलक के वर्तमान संस्करण (9.2.2) में काम करता है , जो इस चुनौती से पहले है।

इनपुट्स हैं: पहले एक संख्या, फिर एक संख्यात्मक वेक्टर। परिणाम को एक के रूप में उत्पादित किया जाता है double, जो अधिकतम आउटपुट को आसपास कहीं पर सीमित करता है 2^52।

उदाहरण

>> matl 1+ZgiO$Gs-h1+Zgs-ZeYo
> 15
> [5 4 3 2]
37837800

व्याख्या

1+       % implicit input (number). Add 1
Zg       % log-gamma function
i        % input (numeric vector).
0$G      % push both inputs
s-       % sum the second input (vector) and subtract from first
h1+      % append to vector. Add 1
Zg       % log-gamma function, element-wise on extended vector
s        % sum of results
-        % subtract from previous result of log-gamma
Ze       % exponential
Yo       % round. Implicit display

— लुइस मेंडो
स्रोत

4

इसे ऑनलाइन आज़माएं! अब प्रायोगिक MATL सपोर्ट है: matl.tryitonline.net/… सुझावों का स्वागत है।

— डेनिस

1

@ डेनिस हे! क्या आश्चर्य है!!! मैं तुम्हारा धन्यवाद कैसे कर सकता हूं?? मेरे पास एक सुझाव है: यदि आप कभी मैड्रिड आते हैं तो मैं आपको एक अच्छा डिनर और कुछ पेय देता हूं

— लुइस मेंडो

मैं वास्तव में आभारी हूं। इसे ऑनलाइन करना बहुत अच्छा है। हम संशोधन कैसे संभालेंगे? मैं अब भी लगातार भाषा को अपडेट कर रहा हूं, आप जानते हैं ...

— लुइस मेंडो

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

— डेनिस

@ डेनिस ग्रेट! इस तरह हम व्यक्ति में मिल सकते हैं!

— लुइस मेंडो

4

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

_{वू! PPCG पर मेरा 100 वाँ जवाब!}

param($n,$k)(1..$n-join'*'|iex)/(($k|%{$n-=$_;1..$_})+(1..$n)-join'*'|iex)

वाह। शॉर्ट-कोड जीतने के लिए नहीं, यह सुनिश्चित करने के लिए है। पर्वतमाला के साथ कुछ स्वच्छ चाल का उपयोग करता है, यद्यपि। _{और यह शायद पावरबेल से परिचित किसी के लिए भी पूरी तरह से अस्पष्ट है।}

व्याख्या

पहले हम इनपुट लेते हैं param($n,$k)और $kएक सरणी, उदाहरण के लिए उम्मीद करते हैं .\compute-the-multinomial-coefficient.ps1 11 @(1,4,4)।

हम अंश (सब कुछ बाईं ओर /) के साथ शुरू करेंगे । यह बस उसी से एक सीमा है 1..$nजिसे -joinसाथ में संपादित किया गया है *और फिर तथ्य iex(यानी 1*2*3*...*$n) की गणना के साथ मूल्यांकन किया गया है ।

इसके बाद, हम से अधिक पाश $k|%{...}और प्रत्येक पुनरावृत्ति हम वर्तमान मूल्य घटाना $_से $n(जो हम के बारे में अब और कोई परवाह नहीं है) तैयार करने के लिए $k_mबाद में। इसके अतिरिक्त, हम 1..$k_iप्रत्येक पुनरावृत्ति की सीमा उत्पन्न करते हैं , जो पाइपलाइन पर छोड़ दिया जाता है। उन पाइपलाइन ऑब्जेक्ट्स को दूसरी अभिव्यक्ति, श्रेणी 1..$n(जो $k_mइस बिंदु पर है) के साथ सरणी-संक्षिप्त किया जाता है। यह सब अंत में अंश के साथ -joinएक साथ संपादित *और मूल्यांकन किया जाता है iex(यह काम करता है क्योंकि x! * y! = 1*2*3*...*x * 1*2*3*...*y, इसलिए हम व्यक्तिगत आदेश की परवाह नहीं करते हैं)।

अंत में, /होता है, अंश भाजक और आउटपुट से विभाजित होता है।

बड़ी संख्या के लिए आउटपुट को सही ढंग से संभालता है, क्योंकि हम स्पष्ट रूप से किसी भी चर को किसी विशेष डेटाटाइप्स के रूप में नहीं डाल रहे हैं, इसलिए पावरशेल चुपचाप अलग-अलग डेटाटिप्स के रूप में आवश्यकतानुसार मक्खी पर फिर से डाली जाएगी। बड़ी संख्या के लिए, महत्वपूर्ण अंकन को संरक्षित करने के लिए वैज्ञानिक संकेतन के माध्यम से आउटपुट के रूप में डेटाटाइप्स को फिर से कास्ट मिलता है। उदाहरण के लिए, .\compute-the-multinomial-coefficient.ps1 55 @(28)आउटपुट देगा 3.82434530038022E+15। मुझे लगता है कि यह ठीक है "आउटपुट स्वरूप समान रूप से लचीला है" को चुनौती और क्विंटोपिया की टिप्पणियों में निर्दिष्ट किया गया है। यदि अंतिम परिणाम मूल रूप से समर्थित पूर्णांक प्रकारों में फिट हो सकता है, तो परिणाम सटीक होना चाहिए। आउटपुट पर कोई प्रतिबंध नहीं हो सकता है। "

वैकल्पिक रूप से

आउटपुट स्वरूपण निर्णयों के आधार पर, 92 बाइट्स पर निम्नलिखित

param($n,$k)((1..$n-join'*'|iex)/(($k|%{$n-=$_;1..$_})+(1..$n)-join'*'|iex)).ToString('G17')

जो ऊपर के रूप में ही है, बस का उपयोग करता है स्पष्ट उत्पादन स्वरूपण के साथ .ToString('G17')अंक की वांछित संख्या प्राप्त करने के लिए। इसके लिए 55 @(28)आउटपुट देंगे3824345300380220.5

Edit1 - 17 बाइट्स से छुटकारा पाने के लिए $dऔर बस सीधे गणना करके, और $k_mजब हम लूप को 2 से जोड़ते हैं, तब तक इसे स्ट्रिंग करके गणना से छुटकारा पा लिया $k
- स्पष्ट स्वरूपण के साथ वैकल्पिक संस्करण जोड़ा गया

— AdmBorkBork
स्रोत

3

एपीएल (डायलॉग एक्सटेंडेड) , 9 बाइट्स

×/2!/+\⍛,

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

एक अन्य चुनौती पर मेरे एपीएल जवाब से विचार का उपयोग करना जिसमें बहुराष्ट्रीय शामिल हैं ।

एक मौन फ़ंक्शन जिसका बायाँ तर्क k की सूची है, और सही तर्क n है। परीक्षण के मामलों की जाँच करें कि क्या यह एडम के बाएं और दाएं तर्कों के समाधान से सहमत है ।

यह काम किस प्रकार करता है

×/2!/+\⍛,
     +\    ⍝ Cumulative sum of k's (up to m-1'th element)
       ⍛,  ⍝ Append n (sum of k_1 to k_m)
  2!/      ⍝ Binomial of consecutive pairs
×/         ⍝ Product

\frac{(k_{1} + k_{2} + \dots + k_{m})!}{k_{1}! k_{2}! \dots k_{m}!} = \frac{(k_{1} + k_{2})!}{k_{1}! k_{2}!} \times \frac{(k_{1} + k_{2} + \dots + k_{m})!}{(k_{1} + k_{2})! k_{3}! \dots k_{m}!}

$\frac{(k_1 + k_2 + \cdots + k_m)!}{k_1! k_2! \cdots k_m!} = \frac{(k_1 + k_2)!}{k_1! k_2!} \times \frac{(k_1 + k_2 + \cdots + k_m)!}{(k_1 + k_2)! k_3! \cdots k_m!}$

= \frac{(k_{1} + k_{2})!}{k_{1}! k_{2}!} \times \frac{(k_{1} + k_{2} + k_{3})!}{(k_{1} + k_{2})! k_{3}!} \times \frac{(k_{1} + k_{2} + \dots + k_{m})!}{(k_{1} + k_{2} + k_{3})! \dots k_{m}!}

$= \frac{(k_1 + k_2)!}{k_1! k_2!} \times \frac{(k_1 + k_2 + k_3)!}{(k_1 + k_2)! k_3!} \times \frac{(k_1 + k_2 + \cdots + k_m)!}{(k_1 + k_2 + k_3)! \cdots k_m!}$

= \dots = (\binom{k_{1} + k_{2}}{k_{1}}) (\binom{k_{1} + k_{2} + k_{3}}{k_{1} + k_{2}}) \dots (\binom{k_{1} + \dots + k_{m}}{k_{1} + \dots + k_{m - 1}})

$= \cdots = \binom{k_1 + k_2}{k_1} \binom{k_1 + k_2 + k_3}{k_1 + k_2} \cdots \binom{k_1 + \cdots + k_m}{k_1 + \cdots + k_{m-1}}$

— bubbler
स्रोत

2

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

#!/Times@@({#-+##2,##2}!)&

उदाहरण:

In[1]:= #!/Times@@({#-+##2,##2}!)&[95,65,4,4]

Out[1]= 1934550571913396675776550070308250

— alephalpha
स्रोत

2

पायथन 3, 93 91

डेनिस और FryAmTheEggman को धन्यवाद ।

f=lambda x:0**x or x*f(x-1)
def g(n,k):
    r=f(n)
    for i in k:r//=f(i)
    return r//f(n-sum(k))

nपूर्णांक के रूप में, kiterable के रूप में।

Ungolfed:

import functools #cache

@functools.lru_cache(maxsize=None) #cache results to speed up calculations
def factorial(x):
    if x <= 1: return 1
    else: return x * factorial(x-1)

def multinomial(n, k):
    ret = factorial(n)
    for i in k: ret //= factorial(i)
    km = n - sum(k)
    return ret//factorial(km)

— त्रंग ऊल
स्रोत

1

आप डायनामिक व्हॉट्सएप बिट के लिए चार के बजाय एक सिंगल स्पेस का उपयोग कर सकते हैं

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

मैंने टैब का उपयोग किया, उन्हें इस पद पर जगह मिली। बाइट की गिनती ठीक लगती है। मैं फ्लोट परिणाम और संभावित अतिप्रवाह के बारे में निश्चित नहीं हूं।

— त्रिंग ओउल

2

1. यह एक गलत उत्पादन करता है 95, [65, 4, 4]। ध्यान दें कि इनपुट में k_m नहीं है । 2. आप from functools import*सभी का उपयोग नहीं करते हैं ।

— डेनिस

2

1. आपका गोल्फ कोड उपयोग नहीं करता है reduce। 2. import math;f=math.factorialएक बाइट बचाता है। 3. अजगर 2 आपको दूसरे /में छुटकारा पाने की अनुमति देगा //।

— डेनिस

1

परिभाषित fअपने दम पर कुछ बाइट्स की बचत होती है : f=lambda x:0**x or x*f(x-1)।

— FryAmTheEggman

2

एपीएल (Dyalog यूनिकोड) , 16 बाइट्स ^SBCS

मेरे सहयोगी मार्शल के गणितीय कौशल पर आधारित है ।

अनाम शिशु फ़ंक्शन। K को दाएँ तर्क के रूप में और n को बाएँ तर्क के रूप में लेता है।

{×/⍵!⍺-+\¯1↓0,⍵}

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

{… } गुमनाम लंबोदर; ⍺बाएं तर्क है ( n ) और ⍵सही तर्क है ( k )

0,⍵ एक शून्य से k तक बहाना

¯1↓ उस से अंतिम आइटम ड्रॉप

+\ उस का संचयी योग

⍺-n से घटाएँ

⍵! ( ^k ) वह

×/ उस का उत्पाद

— एडम
स्रोत

1

PARI / जीपी, 43 बाइट्स

बहुत सीधा; स्वरूपण से अलग, ungolfed संस्करण अच्छी तरह से समान हो सकता है।

m(n,v)=n!/prod(i=1,#v,v[i]!)/(n-vecsum(v))!

— चार्ल्स
स्रोत

1

मतलाब 48 बाइट्स

आपको उच्च परिशुद्धता प्राप्त करने के लिए अग्रिम में सेट formatकरने की आवश्यकता है long। फिर, यह बिल्कुल सीधा है:

@(n,k)factorial(n)/prod(factorial([k,n-sum(k)]))

ans(95, [65,4,4])
ans =

 1.934550571913395e+33

— brainkz
स्रोत

1

अजगर, 10 बाइट्स

/F.!MaQ-FQ

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

/F.!MaQ-FQ   implicit: Q = input list
       -FQ   reduce Q by subtraction
     aQ      append the result to Q
  .!M        compute the factorial for each number
/F           reduce by division

— Jakube
स्रोत

1

जे, 16 बाइट्स

[(%*/)&:!],(-+/)

प्रयोग

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

   f =: [(%*/)&:!],(-+/)
   11 f 1 4 4
34650
   15x f 5 4 3 2
37837800

व्याख्या

[(%*/)&:!],(-+/)  Input: n on LHS, A on RHS
             +/   Reduce A using addition
            -     Subtract that sum from n, this is the missing term
         ]        Get A
          ,       Append the missing term to A to make A'
[                 Get n
      &:!         Take the factorial of n and each value in A'
   */             Reduce using multiplication the factorials of A'
  %               Divide n! by that product and return

— मील की दूरी पर
स्रोत

1

05AB1E , 8 बाइट्स

Æ¸«!R.«÷

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

Æ           Subtract all the elements from the first
 ¸«         Append to the original list
   !        Take the factorial of all the elements
    R.«÷    Reduce by integer division

मैं चरण 2 या चरण 4 के बेहतर तरीके खोजने के लिए प्रतीत नहीं हो सकता।

— नील
स्रोत

1

एपीएल (डायलॉग यूनिकोड) , 17 बाइट्स

⊢∘!÷(×/∘!⊣,⊢-1⊥⊣)

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

Infix tacit function (2 बाइट्स के लिए @ Adám के लिए धन्यवाद जो इसे बचाता है।)

एपीएल (डायलॉग यूनिकोड) , 19 बाइट्स

{(!⍺)÷×/!(⍺-+/⍵),⍵}

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

Infix Dfn।

ऊपर दिए गए दोनों कार्य दिए गए सूत्र की गणना करते हैं।

— जे। सल्ल
स्रोत

1

हास्केल , 59 58 बाइट्स

f n=product[1..n]
n#k=foldl((.f).div)(f n)k`div`f(n-sum k)

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

1 बाइट बचाने के लिए बीएमओ को धन्यवाद !

— क्रिस्टियन लुपस्कू
स्रोत

0

क्लोजर, 70 बाइट्स

#(let[a apply](a /(map(fn[x](a *(map inc(range x))))(conj %(a - %)))))

एक अनाम सूची के सभी तर्कों को nपहली सूची के साथ एक एकल सूची के रूप में लेता है ।

30 अक्षर सिर्फ लानत फैक्टरियल फंक्शन को परिभाषित करने के लिए "बर्बाद" हैं। ओह अच्छा।

— MattPutnam
स्रोत

0

पर्ल 6 , 52 50 बाइट्स

->\n,\k{[*](1..n)div[*] ([*] 1..$_ for |k,[-] n,|k)}

झसे आज़माओ

->\n,\k{[*](1..n)/[*] ([*] 1..$_ for |k,[-] n,|k)}

इसका परीक्षण करें (परिणाम 1 के हर के साथ एक तर्कसंगत है)

विस्तारित:

->     # pointy block lambda
  \n,
  \k
{
    [*]( 1 .. n )   # factorial of ｢n｣

  /                 # divide (produces Rational)

    [*]             # reduce the following using &infix:«*»

      (
          [*] 1..$_ # the factorial of

        for         # each of the following

          |k,       # the values of ｢k｣ (slipped into list)
          [-] n,|k  # ｢n｣ minus the values in ｢k｣
      )
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

बहुराष्ट्रीय गुणांक की गणना करें

कार्य

स्कोरिंग

परीक्षण के मामलों

जेली , 7 6 बाइट्स

यह काम किस प्रकार करता है

सीजेएम, 11 बाइट्स

व्याख्या

MATL , 21 15 बाइट्स

उदाहरण

व्याख्या

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

व्याख्या

वैकल्पिक रूप से

एपीएल (डायलॉग एक्सटेंडेड) , 9 बाइट्स

यह काम किस प्रकार करता है

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

पायथन 3, 93 91

एपीएल (Dyalog यूनिकोड) , 16 बाइट्स SBCS

PARI / जीपी, 43 बाइट्स

मतलाब 48 बाइट्स

अजगर, 10 बाइट्स

स्पष्टीकरण:

जे, 16 बाइट्स

प्रयोग

व्याख्या

05AB1E , 8 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 17 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 19 बाइट्स

हास्केल , 59 58 बाइट्स

क्लोजर, 70 बाइट्स

पर्ल 6 , 52 50 बाइट्स

विस्तारित:

एपीएल (Dyalog यूनिकोड) , 16 बाइट्स ^SBCS