前書き：

2つの抵抗、R1およびR2、並列（で示されるR1 || R2）は、次のように結合された抵抗を持ちますRp。

3個の抵抗器はR1、R2とR3平行に（R1 || R2 || R3）合成抵抗を有しています(R1 || R2) || R3 = Rp || R3。

または、再びコメントで提案されたとおり：

もちろん、これらの式は無制限の抵抗に拡張できます。

チャレンジ：

入力として正の抵抗値のリストを取得し、電気回路に並列に配置されている場合は合成抵抗を出力します。抵抗器の最大数を想定することはできません（もちろん、コンピュータがそれを処理できることを除いて）。

テストケース：

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  

各言語の最短コードが優先されます。説明を強くお勧めします。

05AB1E、5 3バイト

zOz

オンラインでお試しください！

説明

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

ハスケル、18 16バイト

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

オンラインでお試しください！

MATLAB、14バイト

MATLAB norm(...,p)では、pベクトルの- ノルムを計算します。これは通常のために定義され$p \geqslant 1$として

しかし、幸運なことに、$p=-1$ます。（Octaveでは機能しないことに注意してください。）

@(x)norm(x,-1)

オンラインで試さないでください！

ゼリー、 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)

PowerShell、22バイト

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

オンラインでお試しください！

スプラッティングを介して入力を受け取り、他の多くが行っているのと同じ1 / sumの逆トリックを使用します

オクターブ、15バイト

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

オンラインでお試しください！

調和平均をで割った値n。簡単です。

APL（Dyalog Unicode）、4 バイト

÷1⊥÷

オンラインでお試しください！

-1Adámに感謝します。

R、15バイト

1/sum(1/scan())

オンラインでお試しください！

他の回答で見られるのと同じ調和平均の原則に従います。

JavaScript、28バイト

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

オンラインでお試しください！

Perl 5、26 -pa -MList::Util=reduceバイト

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

オンラインでお試しください！

Perl 6、14バイト

1/*.sum o 1/**

オンラインでお試しください！

1 / **引数の逆数のリストを返す匿名関数です。 1 / *.sumリスト引数の要素の合計の逆数を返す別の匿名関数です。oオペレータは、これらの二つの機能を構成します。

bash + coreutils、25バイト

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

TIO

Wolfram言語（Mathematica）、10バイト

1/Tr[1/#]&

オンラインでお試しください！

MathGolf、3 バイト

∩Σ∩

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

オンラインでお試しください。

PHP、51バイト

逆数の合計の逆数。入力は$aです。

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

オンラインでお試しください！

JavaScript（ES6）、29バイト

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

オンラインでお試しください！

または：

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

オンラインでお試しください！

しかし、このアプローチでは、map()（asシャギーがしたように）使用することは1バイト短くなります。

Python 3、30バイト

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

オンラインでお試しください！

Perl 5（-p）、17バイト

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

オンラインでお試しください！

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  

入力-Windows呼び出し規約。最初のパラメーターは、の抵抗器の数ですRCX。抵抗へのポインタはにありRDXます。*ps命令は1バイト小さいため使用されます。技術的には、約2 ^ 61の抵抗しか使用できませんが、それよりずっと前にRAMが不足します。を使用しているため、精度も優れていませんrcpps。

Java 8、24バイト

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

Javaの回答がまだないことに気付いたので、追加することを考えました。

オンラインでお試しください。

説明：

他の回答と同じ調和平均アプローチを使用します。

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

MATL、5バイト

,1w/s

オンラインでお試しください！

「2回行う」（,）がループとしてカウントされるかどうかはわかりませんが、これは単にで割った調和平均nです。

または、,-1^s5バイトも同様です。

Intel 8087 FPUマシンコード、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]

これは、元のIBM PCの8087 FPUのスタックベースの浮動小数点命令を使用します。

入力は、の抵抗値へのポインタ、の抵抗の[SI]数ですCX。出力は、の単精度（DD）値[DI]です。

Dart、42バイト

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

オンラインでお試しください！

num型を明示的に指定する必要があるのは、ややこしい(dynamic, dynamic) => dynamicです。何らかの理由で倍精度が得られない型を推論するため、型の推論を防ぎます。

PHP、40バイト

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

オンラインでお試しください！

テスト：オンラインで試してみてください！

Yimin Rongのソリューションに似ていますが、組み込みおよびすべてのプログラムバイトはバイトカウントに含まれません。

Pythonの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

炭、7バイト

Ｉ∕¹Σ∕¹Ａ

オンラインでお試しください！リンクは、コードの詳細バージョンです。1Vが印加されたときに各抵抗器に流れる電流を計算し、合計を取得して、1Vが印加されたときにその電流を流す抵抗を計算することにより機能します。説明：

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

J、6バイト

1%1#.%

オンラインでお試しください！

[MATLAB]、15バイト

flawrの優れた答えよりも1バイト多くなりましたが、他の関数を使用する必要があったため、ここに進みます。

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

かなり明示的で、抵抗の逆数を合計し、合計を反転して等価の並列抵抗を出力します。

Forth（gforth）、49バイト

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

オンラインでお試しください！

入力はメモリアドレスと配列の長さです（Forthには組み込みの配列構造がないため、即席配列として使用されます）

他のほとんどの答えがそうであるように、逆算法を使用します

コードの説明

: 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

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}