18

0.0 और 1.0 के बीच संभाव्यता वाली घटनाओं के अनुक्रम को देखते हुए, उत्पन्न होने वाले प्रत्येक संयोजन की संभावना उत्पन्न और प्राप्त करते हैं। आप यह मान सकते हैं कि आपकी चुनी हुई भाषा जो भी प्रदान करती है उसमें संख्याओं का एक क्रम प्रदान किया जाता है।

यहाँ एक उदाहरण है; आप यह मान सकते हैं कि अनुक्रम के संयोजन की लंबाई स्मृति में फिट होती है:

{ 0.55, 0.67, 0.13 }

कार्यक्रम प्रत्येक संयोजन और उस अनुक्रम के होने की सम्भावना को प्रिंट करेगा। एक 1 यह बताएगा कि इनपुट अनुक्रम के उस सूचकांक में घटना हुई थी और 0 यह दर्शाता है कि घटना नहीं हुई थी। वांछित आउटपुट नीचे है (मैं काम को प्रिंट करने के बारे में परवाह नहीं करता, यह सिर्फ एल्गोरिदम के सूचनात्मक उद्देश्यों के लिए है):

[0,0,0] = (1 - 0.55) * (1-0.67) * (1-0.13) = 0.129195
[0,0,1] = (1 - 0.55) * (1-0.67) * (0.13)   = 0.019305
[0,1,0] = (1 - 0.55) * (0.67)   * (1-0.13) = 0.262305
[0,1,1] = (1 - 0.55) * (0.67)   * (0.13)   = 0.039195
[1,0,0] = (0.55)     * (1-0.67) * (1-0.13) = 0.157905
[1,0,1] = (0.55)     * (1-0.67) * (0.13)   = 0.023595
[1,1,0] = (0.55)     * (0.67)   * (1-0.13) = 0.320595
[1,1,1] = (0.55)     * (0.67)   * (0.13)   = 0.047905

यह समस्या "कार्टेशियन उत्पाद" की गणना से संबंधित है।

याद रखें, यह कोड-गोल्फ है, इसलिए सबसे कम संख्या में बाइट्स जीतता है।

code-golf probability-theory

— मार्क जॉनसन
स्रोत

3

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है, और अच्छी पहली चुनौती!

— दरवाज़े

[0.129195, 0.019305, 0.262305, ..., 0.047905]आउटपुट के रूप में पर्याप्त होगा या [0,0,0], [0,0,1], ...आवश्यक हैं?

— लकोनी

@ लिकोनी वह आउटपुट ठीक है। आउटपुट भाग समस्या का मांस नहीं है।

— मार्क जॉनसन

क्या आउटपुट रिवर्स ऑर्डर में हो सकता है?

— लुइस मेंडो

@LuisMendo ज़रूर, क्यों नहीं।

— मार्क जॉनसन

8

हास्केल, 86 बाइट्स

unlines.map(\p->show(fst<$>p)++" = "++show(product$snd<$>p)).mapM(\x->[(0,1-x),(1,x)])

उपयोग उदाहरण:

Prelude> putStrLn $ unlines.map(\p->show(fst<$>p)++" = "++show(product$snd<$>p)).mapM(\x->[(0,1-x),(1,x)]) $ [0.55, 0.67, 0.13]
[0,0,0] = 0.12919499999999998
[0,0,1] = 1.9304999999999996e-2
[0,1,0] = 0.262305
[0,1,1] = 3.9195e-2
[1,0,0] = 0.157905
[1,0,1] = 2.3595e-2
[1,1,0] = 0.320595
[1,1,1] = 4.790500000000001e-2

अधिकांश बाइट्स आउटपुट स्वरूपण के लिए खर्च किए जाते हैं। यदि आप केवल संभावना वेक्टर में रुचि रखते हैं तो यह केवल 29 बाइट्स हैं:

map product.mapM(\x->[1-x,x])

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

                    mapM(\x->[(0,1-x),(1,x)])   -- for each number x in the input
                                                -- list make either the pair (0,1-x)
                                                -- or (1,x). Build a list with
                                                -- all combinations

    map(\p->                    )               -- for each such combination p
          show(fst<$>p)                         -- print the first elements
          ++" = "++                             -- then the string " = "
          show(product$snd<$>p)                 -- then the product of the second
                                                -- elements

unlines                                         -- joins with newlines

— nimi
स्रोत

यह साफ-सुथरा है; मैं उत्सुक था कि क्या ऐसा करने का वास्तव में एक छोटा विशुद्ध रूप से कार्यात्मक तरीका होने जा रहा था। क्या आपको C # या F # पता है? मैं उत्सुक हूं कि उन भाषाओं में वही एल्गोरिथ्म दिखाई देगा जैसे मैं हास्केल सिंटैक्स के साथ पूरी तरह से अपरिचित हूं।

— मार्क जॉनसन

@MarkJohnson: नहीं, माफ करना, मैं न तो C # और न ही F # जानता हूं।

— nimi

5

गणितज्ञ, ४६ 45 बाइट्स

(s=#;1##&@@Abs[#-s]&/@{1,0}~Tuples~Length@s)&

एक सूची लेता है। यहां तक कि खाली सूची के लिए भी काम करता है{} , जिसके लिए आउटपुट है {1}।

परीक्षण का मामला:

%[{0.55, 0.67, 0.13}]
{0.129195, 0.019305, 0.262305, 0.039195, 0.157905, 0.023595, 0.320595, 0.047905}

व्याख्या

संभावनाओं की एक सूची को देखते हुए sऔर बिट्स की एक सूची bके साथ 0दर्शाने "नहीं होती है" और 1संभावनाओं की सूची को संकेतित "अवश्य हुआ है", करने के लिए किया जा बढ़ी द्वारा दिया जाता है

1 - b - s

साइन अप करना। यदि इसके बजाय 0"घटित हुआ" और 1"नहीं हुआ", तो यह सरल हो जाता है

b - s

सो हम्:

                      {1,0}~Tuples~Length@s   (* Generate all possible bit combinations *)
              (#-s)&/@{1,0}~Tuples~Length@s   (* Generate probabilities to be multiplied
                                                  up to sign *)
     1##&@@Abs[#-s]&/@{1,0}~Tuples~Length@s   (* Correct sign and multiply;
                                                 1##& is short for Times *)
(s=#;1##&@@Abs[#-s]&/@{1,0}~Tuples~Length@s)& (* Assign s to first argument of function,
                                                 done separately to avoid clash
                                                 with inner function *)

— u54112
स्रोत

4

पर्ल, 42 40 बाइट्स

के लिए +1 शामिल है -a

STDIN पर नंबर दें:

perl -M5.010 combi.pl <<< "0.55 0.67 0.13"

आउटपुट

combi.pl:

#!/usr/bin/perl -a
$"=")\\*({1-,}";say eval for<({1-,}@F)>

— टन हास्पेल
स्रोत

4

MATL , 12 11 बाइट्स

TF-|Z}&Z*!p

इनपुट एक कॉलम वेक्टर है, प्रारूप के साथ [0.55; 0.67; 0.13]

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

TF    % Push [1, 0]
-     % Subtract from implicit input (column array), with broadcast. Gives a 2-col
      % matrix where the first column is the input minus 1 and the second is the input
|     % Absolute value
Z}    % Split the matrix into its rows
&Z*   % Cartesian product of all resulting. This gives a matrix as result, with each
      % "combination" on a different row
!p    % Product of each row. Implicitly display

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

3

पर्ल, 116 बाइट्स

for(glob"{0,1}"x(@a=split/ /,<>)){@c=split//;$d=1;$d*=@c[$_]?$a[$_]:1-$a[$_]for 0..$#a;say"[".join(",",@c)."] = $d"}

पठनीय:

for(glob"{0,1}"x(@a=split/ /,<>)){
    @c=split//;
    $d=1;$d*=@c[$_]?$a[$_]:1-$a[$_]for 0..$#a;
    say"[".join(",",@c)."] = $d"
}

इनपुट मापदंडों की संख्या के बराबर 0s और 1s लंबाई के सभी संभावित संयोजनों की एक सूची बनाता है (उदाहरण के लिए, ऊपर दिए गए उदाहरण के लिए, यह लंबाई 3 का होगा), फिर प्रत्येक संभावना की गणना करता है।

मुझे यह दिखाने के लिए @Dada के लिए धन्यवाद कि globफ़ंक्शन क्या कर सकता है, भले ही मैं 100% सुनिश्चित नहीं हूं कि मुझे समझ में कैसे आया यह करता है।

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

[0,0,0] = 0.129195
[0,0,1] = 0.019305
[0,1,0] = 0.262305
[0,1,1] = 0.039195
[1,0,0] = 0.157905
[1,0,1] = 0.023595
[1,1,0] = 0.320595
[1,1,1] = 0.047905

— गेब्रियल बेनामी
स्रोत

1

-aइसके बजाय (@a=split/ /,<>)...

— दादा

3

आर, 72 69 बाइट्स

स्टडिन से इनपुट लेता है और संभावनाओं का एक आर-वेक्टर लौटाता है।

apply(abs(t(expand.grid(rep(list(1:0),length(x<-scan())))-x)),1,prod)

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

[1] 0.129195 0.157905 0.262305 0.320595 0.019305 0.023595 0.039195 0.047905

ध्यान दें कि संभाव्यताएं इस तथ्य के कारण एक अलग क्रम में हैं कि उत्पन्न expand.gridहोने वाला पर्मुटेशन -मैट्रिक्स निम्नलिखित उत्पन्न करता है (इस मैट्रिक्स की पीढ़ी शायद बाहरी पैकेजों का उपयोग करके गोल्फ हो सकती है):

1    1    1    1
2    0    1    1
3    1    0    1
4    0    0    1
5    1    1    0
6    0    1    0
7    1    0    0
8    0    0    0

पहली संभावना उपरोक्त मैट्रिक्स में पहली पंक्ति के उल्टे परिणाम और दूसरी उल्टे दूसरी पंक्ति आदि से मेल खाती है। इसे और भी स्पष्ट रूप से देखने के लिए आउटपुट स्वरूपण कार्यक्रम को लंबा बनाता है (164 बाइट्स):

m=expand.grid(rep(list(1:0),length(x<-scan())))
cat(paste0("[",apply(abs(m-1),1,function(x)paste0(x,collapse=",")),"] = ",apply(abs(t(t(m)-x)),1,prod),"\n"),sep="")

जो इसके बजाय पैदा करता है:

[0,0,0] = 0.129195
[1,0,0] = 0.157905
[0,1,0] = 0.262305
[1,1,0] = 0.320595
[0,0,1] = 0.019305
[1,0,1] = 0.023595
[0,1,1] = 0.039195
[1,1,1] = 0.047905

— Billywob
स्रोत

मैं इस पर अपने जवाब पर काम कर रहा था, लेकिन मैं एक साफ समाधान के साथ नहीं आ सका। के महान उपयोग expand.grid! मुझे लगता है कि applyडेटा फ़्रेम के साथ-साथ मैट्रिसेस पर भी काम कर सकता है, इसलिए आपका कोड बिना काम करना चाहिए t(t(...)), जो आपको 6 बाइट्स बचाएगा।

— rturnbull

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

— बिलीवॉब

2

जेली , 9 बाइट्स

ż@C×þF¥@/

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

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

2

जे, 14 बाइट्स

-.([:,*/)/@,.]

प्रयोग

   f =: -.([:,*/)/@,.]
   f 0.55 0.67 0.13
0.129195 0.019305 0.262305 0.039195 0.157905 0.023595 0.320595 0.047905

व्याख्या

-.([:,*/)/@,.]  Input: array P
-.              Complement (1-x) for each x in P
             ]  Identity, get P
           ,.   Interleave to make pairs [(1-x), x]
  (     )/@     Reduce from right-to-left by
      */          Forming the multiplication table
   [:,            Flattening the result

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

आप |*//0.55 0.67 0.13-/0 1एक ट्रेन में कर सकते हैं ?

— 1

2

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

*MaVLQ^U2l

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

स्पष्टीकरण:

*MaVLQ^U2lQ   implicit Q at the end (Q = input list)
      ^U2lQ   repeated Cartesian product of [0, 1] with itself length(Q)-times
              this gives all combinations of 0s and 1s
  aVLQ        absolute difference between these 0-1-vectors with Q
*M            fold the vectors by multiplication

— Jakube
स्रोत

1

सी, 110 बाइट्स

i,k;f(float* a,int n){for(k=0;k<1<<n;++k){float p=1;for(i=0;i<n;++i)p*=k&(1<<i)?a[i]:1-a[i];printf("%f,",p);}}

Ungolfed:

i,k;f(float* a,int n){ 
 for(k=0; k<1<<n; ++k){
  float p=1;
  for (i=0; i<n; ++i)
   p*=k&(1<<i)?a[i]:1-a[i];
  printf("%f,",p);
 }
}

32 वस्तुओं तक काम करता है, 64 वस्तुओं के लिए + 5 + 1 बाइट्स ( पहले लूप में घोषित करें long k;और जोड़ें Lताकि k<1L<<N)।

— कार्ल नेफ
स्रोत

1

> 32 आइटम के लिए, C को "L" शाब्दिक की आवश्यकता होती है *1*<<nया क्या यह सिर्फ C ++ की चीज है?

— मार्क जॉनसन

@MarkJohnson हाँ मुझे लगता है कि इसकी आवश्यकता होगी।

— कार्ल नेफ

1

05AB1E , 8 बाइट्स

<Äæ¹æR+P

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

 <Äæ¹æR+P  # Main link (Input is [.1,.2])
 ###########
 <Ä        # Invert input, take the abs value.
           # Stack is [.9,.8]
   æ¹æ     # Powerset of both inverted and original arrays.
           # Stack is [[],[.1],[.2],[.1,.2]],[[],[.9],[.8],[.9,.8]]
      R+   # Reverse original array, add arrays together.
           # Stack is [.9,.8],[.1,.8],[.2,.9],[.1,.2]
        P  # For each sub array, push product.
           # Final Result: [0.02, 0.18, 0.08, 0.72]
           # E.G.          [  11,   10,   01,   00]

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

1

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 57 बाइट्स

f=([p,...a])=>1/p?[for(q of[1-p,p])for(b of f(a))q*b]:[1]

सभी संभावनाओं की एक सरणी देता है। यदि आप भी घटनाओं की सरणी चाहते हैं, तो 86 बाइट्स के लिए:

f=([p,...a])=>1/p?[for(e of'01')for(b of f(a))[[+e,...b[0]],(+e?p:1-p)*b[1]]]:[[[],1]]

यदि आपको एक स्ट्रिंग के रूप में घटनाओं की अनुमति है, तो यह केवल 80 बाइट्स है:

f=([p,...a])=>1/p?[for(e of'01')for(b of f(a))[e+b[0],(+e?p:1-p)*b[1]]]:[['',1]]

1/प्रत्येक समाधान के लिए दो बाइट्स घटाएँ यदि संभावना कभी शून्य न हो।

— नील
स्रोत

आप इसे एक <script></script>ब्लॉक में कैसे चलाएंगे ? मैं "अनपेक्षित" होने के लिए पहले "मुद्दों" के साथ मिल रहा हूं?

— मार्क जॉनसन

@MarkJohnson जब तक आप फ़ायरफ़ॉक्स 30 या उसके बाद का उपयोग कर रहे हैं, तब तक यह काम करना चाहिए।

— नील

0

पर्ल 6, 24 1 लैटिन -1 के बाइट्स

{[*] 1 «-»@_ «|»@_}

पुराना कोड:

{[*] map {1-$^a|$^a},@_}

यह एक फंक्शन है। इसे इस तरह उपयोग करें:

{[*] 1 «-»@_ «|»@_}(0.55, 0.67, 0.13)

लेना:

any(any(any(0.129195, 0.019305), any(0.262305, 0.039195)), any(any(0.157905, 0.023595), any(0.320595, 0.047905)))

पुराने कोड की व्याख्या:

[*]          multiply together all array elements
map          but first transform each element via
{1-$^a|$^a}  considering both 1 minus the value and the value
,@_          of the function input

नया कोड मूल रूप से एक ही है, बस terser सिंटैक्स का उपयोग कर:

[*]          multiply together all array elements
1 «-»@_      of the array formed by subtracting the argument from 1
«|»@_        pointwise considering both that and the original array

नक्शा anyनिर्माण से भरा एक सरणी बनाता है , जो बड़े पैमाने पर गुणा करता हैany निर्माणों , लूप की आवश्यकता के बिना समस्या को बड़े करीने से हल करता है।

कार्यक्रम के लिए सबसे छोटी भाषा नहीं है, लेकिन यह समस्या का बहुत सीधा अनुवाद है।

0

Dyalog एपीएल , 10 बाइट्स

नया समाधान

इंडेक्स मूल स्वतंत्र। अनाम फ़ंक्शन। संभाव्यता सूची को तर्क के रूप में लेता है।

∘.×/⊢,¨1-⊢

∘.×/ कार्टेशियन उत्पाद में कमी

⊢ तर्क मान

,¨ प्रत्येक के साथ जोड़ा गया

1-⊢ पूरक तर्क मान (लिट एक तर्क मान)

TryAPL ऑनलाइन!

पुराना हल

⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है। संभावनाओं की सूची के लिए संकेत।

|⎕∘.×.-⊂⍳2

व्याख्या

| का पूर्ण मूल्य

⎕इनपुट, ɑ = [ ɑ ₁ ɑ ₂ ɑ ₃]

∘.×.-संशोधित आंतरिक टेंसर गुणा, ( ɑ b - b ipl) ɑ (or ₂ - b ⊗) ɑ (⊗ ₃ - b ,), के साथ

⊂⍳2संलग्न सूची b = [[० १]]

गणितीय परिभाषा

के रूप में ख संलग्न है, यह अदिश, और इसलिए की लंबाई के लिए बढ़ा दिया है ɑ , अर्थात् 3 इसलिए पूरी अभिव्यक्ति है

एक = │ ( ɑ ₁ - ख ) ⊗ ( ɑ ₂ - ख ) ⊗ ( ɑ ₃ - ख ) │ =

│ ( ɑ ₁ - [0,1]) ⊗ ( ɑ ₂ - [0,1]) ⊗ ( ɑ ₃ - [0,1]) │ =

│ [ ɑ ₁, ɑ ₁ - 1] ⊗ [ ɑ ₂ , ɑ ₂ - 1] ⊗ [ ɑ ₃, ɑ ₃ - 1] │ =

⎢ ⎡ ⎡ ɑ ₁ ɑ ₂ ɑ₃ ⎤ ⎡ ɑ ₁ ɑ ₂ ( ɑ ₃ -1) ⎤ ⎤ ⎥
⎢ ⎢ ⎣ ɑ ₁ ( ɑ ₂ -1) ɑ ₃ ⎦ ⎣ ɑ ₁ ( ɑ ₂-1) ( ɑ ₃ -1) ⎦ ⎥ ⎥
⎢ ⎢ ⎡ ( ɑ ⎢ ⎣ ⎣ ( ɑ ₁-1) ( ɑ ₂ -1) ɑ ₃⎦ ⎣ ( ɑ ₁- 1) ( ɑ ₂-1) (₃ 1-1) ɑ ɑ ɑ₁ -1) ɑ ₂ ɑ ₃ ⎤ ⎡ ( ɑ ₁ -1) ɑ ₂ ( ɑ ₃ -1) ⎤ ⎥ ⎥

TryAPL ऑनलाइन!

नोट्स (पुराने और नए समाधान दोनों पर लागू होते हैं)

प्रोग्राम और सूत्र चर के किसी भी संख्या ( n ) के लिए काम करता है , और हर आयाम में लंबाई 2 की n -dimensional सरणी देता है । तीन चर के साथ, एक विशिष्ट परिणाम
P ( p , q , r ) = A _p_,_q की संभावना_{, r}
जिसे आसानी से सरणी से चुना जा सकता है(⊃A)[p;q;r] निकालेp q r⌷⊃A

जैसे P1 1 0⌷⊃|0.55 0.67 0.13∘.×.-⊂⍳2 देता है (55%, 67%, ¬13%) = 1.9305%

— एडम
स्रोत

0

PHP, 105 97 94 93 87 बाइट्स

for(;$i<2**$c=count($a=$argv)-$p=1;$i+=print-abs($p))for(;$c;)$p*=$a[$c--]-!($i>>$c&1);

इस तरह से चलाएं:

php -r 'for(;$i<2**$c=count($a=$argv)-$p=1;$i+=print-abs($p))for(;$c;)$p*=$a[$c--]-!($i>>$c&1);' -- .55 .67 .13 2>/dev/null;echo
> -0.129195-0.157905-0.262305-0.320595-0.019305-0.023595-0.039195-0.047905

ध्यान दें कि आउटपुट थोड़ा एंडियन है:

[0,0,0]
[1,0,0]
[0,1,0]
[1,1,0]
[0,0,1]
[1,0,1]
[0,1,1]
[1,1,1]

व्याख्या

for(
  ;
  $i<2**$c=                 # Iterate over possible combinations: 2^c,
    count($a=$argv)-$p=1;   #   where c is input length -p (set p to 1)
  $i+=print-abs($p)         # Increment i and print product after each
)                           #   iteration, dash separated
  for(
     ;
     $c;                    # Iterate over input ($c..0)
  )
    $p*=                    # Multiply the product by difference between:
      $a[$c--]-             # - The $c-th item of the input.
      !($i>>$c&1);          # - The $c-th bit of `$i`, negated (1 or 0)

बदलाव

बाइनरी लॉजिक का उपयोग करके 8 बाइट्स को स्ट्रिंग में परिवर्तित करने के बजाय बिट प्राप्त करने के लिए
की $pगणना के साथ 1 के रीसेटिंग के संयोजन से एक बाइट को बचाया$c
प्रिंट (1) के परिणाम को जोड़कर एक बाइट को बचाया $iवृद्धि के बजाय
उत्पादन परिसीमन के रूप में अंडरस्कोर का उपयोग करके एक बाइट को बचाया
माइनस साइन को सीमांकक के रूप में उपयोग करके एक बाइट को बचाया (कोई नकारात्मक संभावना नहीं है)।
के $cबजाय का उपयोग करके 6 बाइट्स बचाता है$$i

— aross
स्रोत

0

सी ++ 17, 137 131 129 बाइट्स

घोषित करके 6 बाइट्स बचा रहा है #define A auto , पहली बार इतना कम मैक्रो कुछ भी बचाता है। #importपहले अंतरिक्ष का उपयोग और हटाने के लिए -2 बाइट्स<

#import<iostream>
#define A auto
A g(A r){std::cout<<r<<",";}A g(A r,A x,A...p){g(x*r,p...);g(r-x*r,p...);}A f(A...p){g(1,p...);}

सभी संभव संयोजनों को जन्म देता है।

Ungolfed:

//base case to print the result
int g(auto r){std::cout << r << ",";}

//extract item from parameter pack
int g(auto r, auto x, auto... p) {
 g(x*r,p...);    //multiply with temp result and call with tail
 g(r-x*r,p...);  //same as above for (1-x)
}

//start of recursion, setting temp result to 1
int f(auto...p){g(1,p...);}

उपयोग:

f(0.55, 0.67, 0.13);

— कार्ल नेफ
स्रोत

दिए गए घटनाओं के सभी संयोजनों की संभावना

हास्केल, 86 बाइट्स

गणितज्ञ, ४६ 45 बाइट्स

परीक्षण का मामला:

व्याख्या

पर्ल, 42 40 बाइट्स

MATL , 12 11 बाइट्स

पर्ल, 116 बाइट्स

आर, 72 69 बाइट्स

जेली , 9 बाइट्स

जे, 14 बाइट्स

प्रयोग

व्याख्या

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

स्पष्टीकरण:

सी, 110 बाइट्स

05AB1E , 8 बाइट्स

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 57 बाइट्स

पर्ल 6, 24 1 लैटिन -1 के बाइट्स

Dyalog एपीएल , 10 बाइट्स

नया समाधान

पुराना हल

व्याख्या

गणितीय परिभाषा

नोट्स (पुराने और नए समाधान दोनों पर लागू होते हैं)

PHP, 105 97 94 93 87 बाइट्स

व्याख्या

बदलाव

सी ++ 17, 137 131 129 बाइट्स