परिचय:

दो प्रतिरोधों, R1और R2, समानांतर (निरूपित R1 || R2) में एक संयुक्त प्रतिरोध Rpदिया गया है:

R_{P_{2}} = \frac{R_{1} \cdot R_{2}}{R_{1} + R_{2}}

$R_{P_2} = \frac{R_1\cdot R_2}{R_1+R_2}$ या जैसा कि टिप्पणियों में सुझाया गया है:

R_{P_{2}} = \frac{1}{\frac{1}{R_{1}} + \frac{1}{R_{2}}}

$R_{P_2} = \frac{1}{\frac{1}{R_1} + \frac{1}{R_2}}$

तीन प्रतिरोधों, R1, R2और R3समानांतर में ( R1 || R2 || R3) एक संयुक्त प्रतिरोध (R1 || R2) || R3 = Rp || R3:

R_{P_{3}} = \frac{\frac{R_{1} \cdot R_{2}}{R_{1} + R_{2}} \cdot R_{3}}{\frac{R_{1} \cdot R_{2}}{R_{1} + R_{2}} + R_{3}}

$R_{P_3} = \frac{\frac{R_1\cdot R_2}{R_1+R_2}\cdot R_3}{\frac{R_1\cdot R_2}{R_1+R_2}+R_3}$

या फिर, जैसा कि टिप्पणियों में सुझाया गया है:

R_{P_{3}} = \frac{1}{\frac{1}{R_{1}} + \frac{1}{R_{2}} + \frac{1}{R_{3}}}

$R_{P_3} = \frac{1}{\frac{1}{R_1} + \frac{1}{R_2}+ \frac{1}{R_3}}$

इन सूत्रों को निश्चित रूप से प्रतिरोधों की अनिश्चित संख्या तक बढ़ाया जा सकता है।

चुनौती:

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

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

1, 1
0.5

1, 1, 1
0.3333333

4, 6, 3
1.3333333

20, 14, 18, 8, 2, 12
1.1295

10, 10, 20, 30, 40, 50, 60, 70, 80, 90
2.6117

प्रत्येक भाषा में सबसे छोटा कोड जीतता है। स्पष्टीकरण को अत्यधिक प्रोत्साहित किया जाता है।

— स्टीवी ग्रिफिन
स्रोत

6

कुछ अन्य चुनौतियां हैं जो हार्मोनिक माध्य ( 1 2 3 ) को संदर्भित करती हैं, लेकिन मुझे नहीं लगता कि कोई डुप्लिकेट है। जो भी दोष सुझाया गया है, उसके अनुसार, मुझे लगता है कि इस चुनौती शरीर में वह वाक्यांश कहीं न कहीं सूचीबद्ध होना चाहिए ताकि हम भविष्य के डूप को अधिक आसानी से बंद कर सकें।

— FryAmTheEggman

13

05AB1E , 5 3 बाइट्स

zOz

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

व्याख्या

z                     # compute 1/x for each x in input 
 O                    # sum input 
  z                   # compute 1/sum

— समय सीमा समाप्त डेटा
स्रोत

4

बिल्ट-इन को छोड़कर, यह शायद उतना ही कम है जितना कि हम जा सकते हैं!

9

हास्केल , 18 16 बाइट्स

(1/).sum.map(1/)

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

— flawr
स्रोत

3

ये बहुत सुन्दर है।

— एरिक डुमिनील

ओपी की पुनरावर्ती लाइनों के साथ समाधान 22 वर्ण होंगे foldr1(\r s->r*s/(r+s)):।

— को चालू करना बंद कर दिया

9

MATLAB , 14 बाइट्स

MATLAB में एक वेक्टर norm(...,p)का p-norm गणना करता है । यह आमतौर पर $p \geqslant 1$ रूप में परिभाषित किया गया है

‖ v ‖_{पी} = {(\underset{मैं}{Σ} | v_{मैं} |^{पी})}^{\frac{1}{पी}} ।

$\Vert v \Vert_p = \left( \sum_i \vert v_i \vert^p \right)^{\frac{1}{p}}.$

लेकिन सौभाग्य से हमारे लिए, यह $p=-1$ लिए भी काम करता है । (ध्यान दें कि यह ऑक्टेव में काम नहीं करता है।)

@(x)norm(x,-1)

यह ऑनलाइन कोशिश मत करो!

— flawr
स्रोत

4

यह एक साथ भयानक और सुंदर है!

— काउंटरक्लॉकवाइज

1

धन्यवाद, ये सबसे अच्छी तारीफ हैं :)

— त्रुटी

7

जेली , 5 3 बाइट्स

İSİ

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

कैसे?

शुरू में मैं अपने इलेक्ट्रॉनिक इंजीनियरिंग के दिनों से इस फॉर्म को भूल गया ... हम कितनी आसानी से भूल जाते हैं।

İSİ - Link: list of numbers, R   e.g. [r1, r2, ..., rn]
İ   - inverse (vectorises)            [1/r1, 1/r2, ..., 1/rn]
 S  - sum                             1/r1 + 1/r2 + ... + 1/rn
  İ - inverse                         1/(1/r1 + 1/r2 + ... + 1/rn)

— जोनाथन एलन
स्रोत

4

मैं मान रहा हूँ İ जिस तरह iसे उच्चारित किया जाता है उसी तरह से उच्चारण किया जाता है list। क्या यह चुनौती को आसान कहने का एक तरीका है?

— स्टीवी ग्रिफिन

4

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

$args|%{$y+=1/$_};1/$y

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

छींटे के माध्यम से इनपुट लेता है और कई अन्य कर रहे हैं के रूप में उलटा चाल की एक ही 1 / राशि का उपयोग करता है

— Veskah
स्रोत

4

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

@(x)1/sum(1./x)

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

हार्मोनिक मतलब, द्वारा विभाजित n। बहुत आसान।

— ग्यूसेप
स्रोत

@ आप जानते हैं, मुझे नहीं लगता कि मैंने कभी इस पर ध्यान दिया है। मुझे लगता है कि यह लगभग हार्मोनिक मतलब है ...

— Giuseppe

4

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

÷1⊥÷

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

-1 Adám को धन्यवाद ।

— आउटग्रॉफर को एरिक करें
स्रोत

1

एपीएल मूल गोल्फिंग भाषा है!

@ यमीनरॉन्ग यह एक गोल्फ की भाषा नहीं है ...: पी

— एरिक आउटगोल्फर

मुझे पता है, लेकिन इसकी बाइट गिनती आधुनिक गोल्फ भाषाओं के बराबर है!

-1 बाइट: ÷1⊥÷ इसे ऑनलाइन आज़माएं!

— आदम

@ एडम ओह की जोड़ी वैक्टर के लिए 1∘⊥एक ही है +/...

— एरिक आउट द गोल्फर

3

आर , 15 बाइट्स

1/sum(1/scan())

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

अन्य उत्तरों में देखे गए समान हार्मोनिक माध्य सिद्धांत का अनुसरण करता है।

— Sumner18
स्रोत

3

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

a=>a.map(y=>x+=1/y,x=0)&&1/x

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

— झबरा
स्रोत

3

पर्ल 5 `-pa -MList::Util=reduce` , 26 बाइट्स

$_=reduce{$a*$b/($a+$b)}@F

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

— Xcali
स्रोत

20 बाइट्स

— नाहुएल फौइलुल

@NahuelFouilleul 17 बाइट्स, कोई -M

— ग्रिमी

3

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

1/*.sum o 1/**

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

1 / **एक अनाम फ़ंक्शन है जो अपने तर्कों के पारस्परिक की सूची देता है। 1 / *.sumएक अन्य अनाम फ़ंक्शन है जो अपने सूची तर्क के तत्वों के योग का प्रतिफल देता है। oऑपरेटर उन दो कार्यों तैयार करता।

— शॉन
स्रोत

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

— जो राजा

हाँ, यह संभवत: पहली बार है जब मैंने गोल्फ के लिए एक का उपयोग करने के बारे में सोचा है, और मुझे इसकी सीमाओं की खोज करने में निराशा हुई।

— सीन

3

बैश + कोरुटिल्स, 25 बाइट्स

bc -l<<<"1/(0${@/#/+1/})"

TIO

— नहुएल फौलीउल
स्रोत

3

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

1/Tr[1/#]&

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

— attinat
स्रोत

क्या कोई हार्मोनिक मीन बिलियन नहीं है, या यह टाइप करने के लिए लंबा है?

— एरिक डुमिनील

@Eric AFAIK इसे सहज रूप से नाम दिया गया है HarmonicMeanऔर लंबा है।

— मेरा सर्वनाम

3

मठगोल्फ , 3 बाइट्स

∩Σ∩

∩ $\frac{1}{n}$ Σ

म ({एक्स}_{1}, । । ।, {एक्स}_{n}) = \frac{1}{\frac{1}{{एक्स}_{1}} + \frac{1}{{एक्स}_{2}} + । । । + \frac{1}{{एक्स}_{n}}}

$M(x_1,...,x_n)=\frac{1}{\frac{1}{x_1} + \frac{1}{x_2} + ... + \frac{1}{x_n}}$

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

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

2

PHP , 51 बाइट्स

पारस्परिक के योग का पारस्परिक। इनपुट है $a।

1/array_reduce($a,function($c,$i){return$c+1/$i;});

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

PHP7.4 के साथ, मुझे लगता है कि आप ऐसा कर सकते हैं: 1/array_reduce($a,fn($c,$i)=>$c+1/$i);(38 बाइट्स)। और अधिक पढ़ें wiki.php.net/rfc/arrow_functions

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

मुझे लगता है कि आप सही हैं! लेकिन कहीं भी डेमो करने के लिए?

आपको इसे स्वयं डाउनलोड करना होगा। हालाँकि, चूंकि PHP 7.4.0RC1 इस महीने की 5 तारीख को जारी किया गया था ( php.net/archive/2019.php#2019-09-05-1 ), आप शायद इसका उपयोग कर सुरक्षित हैं। यदि आपको संदेह है, तो आप मेटा में पूछ सकते हैं।

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

2

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

a=>a.reduce((p,c)=>p*c/(p+c))

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

या:

a=>1/a.reduce((p,c)=>p+1/c,0)

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

लेकिन इस दृष्टिकोण के साथ, map()(जैसा कि शैगी ने किया था ) 1 बाइट छोटा है।

— Arnauld
स्रोत

2

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

lambda r:1/sum(1/v for v in r)

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

— जोनाथन एलन
स्रोत

2

पर्ल 5 (-पी), 17 बाइट्स

$a+=1/$_}{$_=1/$a

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

— ग्रिमी
स्रोत

2

x86-64 मशीन कोड - 20 18 बाइट्स

0F 57 C0             xorps       xmm0,xmm0  
loopHead
F3 0F 53 4C 8A FC    rcpss       xmm1,dword ptr [rdx+rcx*4-4]
0F 58 C1             addps       xmm0,xmm1  
E2 F6                loop        loopHead
0F 53 C0             rcpps       xmm0,xmm0  
C3                   ret

इनपुट - विंडोज कॉलिंग कन्वेंशन। पहला पैरामीटर प्रतिरोधों की संख्या है RCX। प्रतिरोधों के लिए एक सूचक अंदर है RDX। *psनिर्देश का उपयोग तब किया जाता है जब वे एक बाइट से छोटे होते हैं। तकनीकी रूप से, आपके पास लगभग 2 ^ 61 प्रतिरोधक हो सकते हैं, लेकिन आप तब से बहुत पहले रैम से बाहर होंगे। जब से हम उपयोग कर रहे हैं, तब तक परिशुद्धता बहुत अच्छी नहीं है rcpps।

— मुझे '
स्रोत

"केवल 2erv प्रतिरोधक" संभवतया अवलोकनीय ब्रह्मांड (कई बार खत्म) भर देंगे!

दरअसल, 2 ^ 61 केवल 2.305843e + 18 है और अवलोकन योग्य ब्रह्मांड 8.8 × 10 ^ 26 मीटर व्यास का है।

— मुझे

हाँ, गंभीर overestimation! वास्तविक परिमाण मंगल के छोटे चंद्रमा, डिमोस के आकार और द्रव्यमान के आसपास होगा।

2

जावा 8, 24 बाइट्स

a->1/a.map(d->1/d).sum()

मैंने देखा कि अभी तक जावा जवाब नहीं था, इसलिए मुझे लगा कि मैं एक जोड़ दूंगा।

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

स्पष्टीकरण:

अन्य उत्तरों के समान हार्मोनिक मीन दृष्टिकोण का उपयोग करता है:

म ({एक्स}_{1}, । । ।, {एक्स}_{n}) = \frac{1}{\frac{1}{{एक्स}_{1}} + \frac{1}{{एक्स}_{2}} + । । । + \frac{1}{{एक्स}_{n}}}

$M(x_1,...,x_n)=\frac{1}{\frac{1}{x_1} + \frac{1}{x_2} + ... + \frac{1}{x_n}}$

a->                       // Method with DoubleStream parameter and double return-type
     a.map(d->1/d)        //  Calculate 1/d for each value `d` in the input-stream
                  .sum()  //  Then take the sum of the mapped list
   1/                     //  And return 1/sum as result

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

2

MATL , 5 बाइट्स

,1w/s

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

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

वैकल्पिक रूप से, ,-1^sपांच बाइट्स भी है।

— ग्यूसेप
स्रोत

2

इंटेल 8087 एफपीयू मशीन कोड, 19 बाइट्स

 D9 E8      FLD1                    ; push 1 for top numerator on stack
 D9 EE      FLDZ                    ; push 0 for running sum 
        R_LOOP: 
 D9 E8      FLD1                    ; push 1 numerator for resistor
 DF 04      FILD WORD PTR[SI]       ; push resistor value onto stack 
 DE F9      FDIV                    ; divide 1 / value 
 DE C1      FADD                    ; add to running sum 
 AD         LODSW                   ; increment SI by 2 bytes 
 E2 F4      LOOP R_LOOP             ; keep looping 
 DE F9      FDIV                    ; divide 1 / result                  
 D9 1D      FSTP WORD PTR[DI]       ; store result as float in [DI]

यह मूल आईबीएम पीसी के 8087 एफपीयू में स्टैक-आधारित फ्लोटिंग पॉइंट निर्देशों का उपयोग करता है।

इनपुट प्रतिरोधक मानों के लिए सूचक है, प्रतिरोधों की [SI]संख्या अंदर CX। आउटपुट एकल परिशुद्धता (DD) मान पर है [DI]।

— 640KB
स्रोत

1

डार्ट , 42 बाइट्स

f(List<num>a)=>a.reduce((p,e)=>p*e/(p+e));

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

स्पष्ट रूप से निर्दिष्ट करने के लिए numटाइप थोथा चूसना है, प्रकार को रोकने से रोकता है, क्योंकि यह ऐसा होगा (dynamic, dynamic) => dynamicजो किसी कारण से दोगुना नहीं कर सकता है

— Elcan
स्रोत

1

PHP , 40 बाइट्स

for(;$n=$argv[++$i];$r+=1/$n);echo 1/$r;

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

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

करने के लिए इसी तरह के Yimin रोंग के समाधान बाइट्स गिनती में लेकिन बनाया इन और सभी कार्यक्रम बाइट्स के बिना शामिल किए गए हैं।

— Night2
स्रोत

1

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

f=lambda x,y=0,*i:f(x*y/(x+y),*i)if y else x

एक पुनरावर्ती कार्य। इस तरह से पास होने के लिए तर्क की आवश्यकता होती है:

i=[10, 10, 20]
f(*i)

या

f(10, 10, 20)

स्पष्टीकरण:

# lambda function with three arguments. *i will take any unpacked arguments past x and y,
# so a call like f(10, 20) is also valid and i will be an empty tuple
# since y has a default value, f(10) is also valid
f=lambda x,y=0,*i: \

# a if case else b
# determine parallel resistance of x and y and use it as variable x
# since i is passed unpacked, the first item in the remaining list will be y and
# the rest of the items will be stored in i
# in the case where there were no items in the list, y will have the default value of 0
f(x*y/(x+y),*i) \

# if y does not exist or is zero, return x
if y else x

— Triggernometry
स्रोत

1

चारकोल , 7 बाइट्स

Ｉ∕¹Σ∕¹Ａ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। 1V लागू होने पर प्रत्येक रोकनेवाला द्वारा खींची गई वर्तमान की गणना करके काम करता है, कुल ले रहा है, और 1V लागू होने पर उस वर्तमान को आकर्षित करने वाले प्रतिरोध की गणना करेगा। स्पष्टीकरण:

      Ａ Input array
    ∕¹  Reciprocal (vectorised)
   Σ    Sum
 ∕¹     Reciprocal
Ｉ       Cast to string for implicit print

— नील
स्रोत

1

जे , 6 बाइट्स

1%1#.%

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

— गैलेन इवानोव
स्रोत

2

यह एक दया है "पारस्परिक के तहत राशि" बाइट्स की एक ही संख्या है:+/&.:%

— ngn

@ हाँ, लेकिन आपका समाधान जे को अधिक मुहावरेदार लगता है

— गैलेन इवानोव

1

[MATLAB], 15 बाइट्स

त्रुटिपूर्ण उत्कृष्ट उत्तर की तुलना में एक और बाइट , लेकिन मुझे अन्य कार्यों का उपयोग करना पड़ा, इसलिए यहाँ जाता है:

@(x)1/sum(1./x)

यह स्पष्ट रूप से स्पष्ट है, यह प्रतिरोधों के व्युत्क्रम को बताता है, फिर समतुल्य समानांतर प्रतिरोध का उत्पादन करने के लिए योग को उल्टा करता है।

— Hoki
स्रोत

1

फोर्थ (gforth) , 49 बाइट्स

: f 0e 0 do dup i cells + @ s>f 1/f f+ loop 1/f ;

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

इनपुट एक मेमोरी एड्रेस और एरे की लंबाई है (जिसका उपयोग इम्प्रोमापु एरे के रूप में किया जाता है, क्योंकि फोर्थ में बिल्ट-इन एरे कंस्ट्रक्शन नहीं है)

अधिकांश अन्य उत्तर के रूप में सम-व्युत्क्रम विधि का उपयोग करता है

कोड स्पष्टीकरण

: f           \ start a new word definition
  0e          \ stick an accumulator on the floating point stack
  0 do        \ start a loop from 0 to array-length -1
    dup       \ copy the array address
    i cells + \ get the address of the current array value
    @ s>f     \ get the value and convert it to a float
    1/f f+    \ invert and add to accumulator
  loop        \ end the loop definition
  1/f         \ invert the resulting sum
;             \ end the word definition

— reffu
स्रोत

1

expl3 (LaTeX3 प्रोग्रामिंग लेयर), 65 बाइट्स

निम्नलिखित एक फ़ंक्शन को परिभाषित करता है जो टर्मिनल के परिणाम को प्रिंट करता है (दुर्भाग्य expl3से बहुत वर्बोज़ फ़ंक्शन नाम हैं):

\def\1#1{\fp_show:n{1/(\clist_map_function:nN{#1}\2)}}\def\2{+1/}

एक संपूर्ण स्क्रिप्ट जो टर्मिनल से सभी परीक्षण मामलों के साथ-साथ प्रवेश करने के लिए सेटअप सहित चलाया जा सकता है expl3:

\RequirePackage{expl3}\ExplSyntaxOn
\def\1#1{\fp_show:n{1/(\clist_map_function:nN{#1}\2)}}\def\2{+1/}
\1{1, 1}
\1{1, 1, 1}
\1{4, 6, 3}
\1{20, 14, 18, 8, 2, 12}
\1{10, 10, 20, 30, 40, 50, 60, 70, 80, 90}
\stop

यदि pdflatex <filename>निम्न के साथ चलाया जाता है तो कंसोल आउटपुट है:

This is pdfTeX, Version 3.14159265-2.6-1.40.20 (TeX Live 2019) (preloaded format=pdflatex)
 restricted \write18 enabled.
entering extended mode
(./cg_resistance.tex
LaTeX2e <2018-12-01>
(/usr/local/texlive/2019/texmf-dist/tex/latex/unravel/unravel.sty
(/usr/local/texlive/2019/texmf-dist/tex/latex/l3kernel/expl3.sty
(/usr/local/texlive/2019/texmf-dist/tex/latex/l3kernel/expl3-code.tex)
(/usr/local/texlive/2019/texmf-dist/tex/latex/l3backend/l3backend-pdfmode.def))
 (/usr/local/texlive/2019/texmf-dist/tex/latex/l3packages/xparse/xparse.sty)
(/usr/local/texlive/2019/texmf-dist/tex/generic/gtl/gtl.sty))
> 1/(\clist_map_function:nN {1,1}\2)=0.5.
<recently read> }

l.3 \1{1, 1}

?
> 1/(\clist_map_function:nN {1,1,1}\2)=0.3333333333333333.
<recently read> }

l.4 \1{1, 1, 1}

?
> 1/(\clist_map_function:nN {4,6,3}\2)=1.333333333333333.
<recently read> }

l.5 \1{4, 6, 3}

?
> 1/(\clist_map_function:nN {20,14,18,8,2,12}\2)=1.129538323621694.
<recently read> }

l.6 \1{20, 14, 18, 8, 2, 12}

?
> 1/(\clist_map_function:nN
{10,10,20,30,40,50,60,70,80,90}\2)=2.611669603067675.
<recently read> }

l.7 \1{10, 10, 20, 30, 40, 50, 60, 70, 80, 90}

?
 )
No pages of output.
Transcript written on cg_resistance.log.

व्याख्या

\fp_show:n : एक अस्थायी बिंदु अभिव्यक्ति के रूप में इसके तर्क का मूल्यांकन करता है और टर्मिनल पर परिणाम को प्रिंट करता है, उस प्रक्रिया के दौरान हर विस्तार योग्य मैक्रो का विस्तार होता है।

\clist_map_function:nN : दो तर्क लेता है, एक अल्पविराम से अलग की गई सूची और एक फ़ंक्शन / मैक्रो, अगर \clist_map_function:nN { l1, l2, l3 } \fooइसे बुलाया जाता है जैसे यह कुछ इस तरह फैलता है \foo{l1}\foo{l2}\foo{l3}। हमारे मामले \fooमें मैक्रो के बजाय का \2उपयोग किया जाता है, जो +1/कि विस्तार करता है ताकि अभिव्यक्ति का विस्तार हो+1/{l1}+1/{l2}+1/{l3}

— Skillmon
स्रोत

इलेक्ट्रिक सर्किट में समानांतर प्रतिरोध

परिचय:

चुनौती:

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

05AB1E , 5 3 बाइट्स

व्याख्या

हास्केल , 18 16 बाइट्स

MATLAB , 14 बाइट्स

जेली , 5 3 बाइट्स

कैसे?

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

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

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

आर , 15 बाइट्स

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

पर्ल 5 -pa -MList::Util=reduce , 26 बाइट्स

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

बैश + कोरुटिल्स, 25 बाइट्स

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

मठगोल्फ , 3 बाइट्स

PHP , 51 बाइट्स

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

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

पर्ल 5 (-पी), 17 बाइट्स

x86-64 मशीन कोड - 20 18 बाइट्स

जावा 8, 24 बाइट्स

MATL , 5 बाइट्स

इंटेल 8087 एफपीयू मशीन कोड, 19 बाइट्स

डार्ट , 42 बाइट्स

PHP , 40 बाइट्स

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

चारकोल , 7 बाइट्स

जे , 6 बाइट्स

[MATLAB], 15 बाइट्स

फोर्थ (gforth) , 49 बाइट्स

कोड स्पष्टीकरण

expl3 (LaTeX3 प्रोग्रामिंग लेयर), 65 बाइट्स

व्याख्या

पर्ल 5 `-pa -MList::Util=reduce` , 26 बाइट्स