Introdução:

Dois resistores R1e R2, em paralelo (denotados R1 || R2), têm uma resistência combinada Rpdada como:

Três resistências, R1, R2e R3em paralelo ( R1 || R2 || R3) tem uma resistência combinada (R1 || R2) || R3 = Rp || R3:

ou, novamente, como sugerido nos comentários:

Naturalmente, essas fórmulas podem ser estendidas a um número indefinido de resistores.

Desafio:

Pegue uma lista de valores positivos do resistor como entrada e produza a resistência combinada se eles foram colocados em paralelo em um circuito elétrico. Você não pode assumir um número máximo de resistores (exceto que o seu computador pode lidar com isso, é claro).

Casos de teste:

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  

O código mais curto em cada idioma vence. As explicações são altamente encorajadas.

05AB1E , 5 3 bytes

zOz

Experimente online!

Explicação

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

Haskell , 18 16 bytes

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

Experimente online!

MATLAB , 14 bytes

No MATLAB norm(...,p)calcula a p-norm de um vetor. Isso geralmente é definido para $p \geqslant 1$ como

Mas, felizmente para nós, isso também funciona para . (Observe que ele não funciona no Octave.)$p=-1$

@(x)norm(x,-1)

Não tente online!

Geléia ,  5  3 bytes

İSİ

Experimente online!

Quão?

Inicialmente esqueci este formulário dos meus dias de engenharia eletrônica ... com que facilidade esquecemos.

İ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 bytes

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

Experimente online!

Recebe informações por meio de splatting e usa a mesma soma de truque inverso que muitos outros estão fazendo

Oitava , 15 bytes

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

Experimente online!

Média harmônica, dividida por n. Mole-mole.

APL (Dyalog Unicode) , 4 bytes

÷1⊥÷

Experimente online!

-1 graças a Adám .

R , 15 bytes

1/sum(1/scan())

Experimente online!

Segue o mesmo princípio da Média Harmônica visto em outras respostas.

JavaScript, 28 bytes

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

Experimente Online!

Perl 5 -pa -MList::Util=reduce , 26 bytes

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

Experimente online!

Perl 6 , 14 bytes

1/*.sum o 1/**

Experimente online!

1 / **é uma função anônima que retorna uma lista dos recíprocos de seus argumentos. 1 / *.sumé outra função anônima que retorna o inverso da soma dos elementos de seu argumento de lista. O ooperador compõe essas duas funções.

bash + coreutils, 25 bytes

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

TIO

Wolfram Language (Mathematica) , 10 bytes

1/Tr[1/#]&

Experimente online!

MathGolf , 3 bytes

∩Σ∩

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

Experimente online.

PHP , 51 bytes

Recíproco da soma dos recíprocos. Entrada é $a.

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

Experimente online!

JavaScript (ES6), 29 bytes

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

Experimente online!

ou:

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

Experimente online!

Mas com essa abordagem, usar map()(como Shaggy fez ) é 1 byte mais curto.

Python 3 , 30 bytes

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

Experimente online!

Perl 5 (-p), 17 bytes

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

Experimente online!

x86-64 Código da máquina - 20 18 bytes

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  

Entrada - convenção de chamada do Windows. O primeiro parâmetro é o número de resistores em RCX. Um apontador para as resistências está em RDX. *psAs instruções são usadas, pois são um byte menor. Tecnicamente, você pode ter apenas 2 ^ 61 resistores, mas estará sem memória RAM muito antes disso. A precisão também não é ótima, pois estamos usando rcpps.

Java 8, 24 bytes

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

Notei que ainda não havia uma resposta em Java, então achei que adicionaria uma.

Experimente online.

Explicação:

Usa a mesma abordagem de Média Harmônica de outras respostas:

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 bytes

,1w/s

Experimente online!

Não tenho certeza se "fazer duas vezes" ( ,) conta como um loop, mas essa é apenas a média harmônica, dividida por n.

Como alternativa, ,-1^ssão cinco bytes também.

Código da máquina FPU Intel 8087, 19 bytes

 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]

Isso usa as instruções de ponto flutuante baseadas em pilha na FPU 8087 original do IBM PC.

A entrada é um ponteiro para os valores do resistor em [SI], número de resistores em CX. A saída é para um único valor de precisão (DD) em [DI].

Dardo , 42 bytes

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

Experimente online!

Ter que especificar explicitamente o numtipo é meio chato, evita a dedução de tipos, porque inferiria o (dynamic, dynamic) => dynamicque não pode resultar em duplicado por algum motivo

PHP , 40 bytes

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

Experimente online!

Testes: Experimente online!

Semelhante à solução de Yimin Rong, mas sem built-ins e todos os bytes de programa estão incluídos na contagem de bytes.

Python 3, 58 44 bytes

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

Uma função recursiva. Requer que os argumentos sejam passados ​​descompactados, da seguinte maneira:

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

ou

f(10, 10, 20)

Explicação:

# 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

Carvão , 7 bytes

Ｉ∕¹Σ∕¹Ａ

Experimente online! Link é a versão detalhada do código. Funciona calculando a corrente consumida por cada resistor quando 1V é aplicado, obtendo o total e calculando a resistência que consumiria essa corrente quando 1V for aplicado. Explicação:

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

J , 6 bytes

1%1#.%

Experimente online!

[MATLAB], 15 bytes

Mais um byte de flawr resposta excelente, mas eu tive que usar outras funções então aqui vai:

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

É bastante explícito, soma o inverso das resistências e inverte a soma para produzir a resistência paralela equivalente.

Quarto (gforth) , 49 bytes

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

Experimente online!

Entrada é um endereço de memória e comprimento da matriz (usado como uma matriz improvisada, pois Forth não possui uma construção de matriz incorporada)

Usa o método da soma inversa, pois a maioria das outras respostas é

Código Explicação

: 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 (camada de programação LaTeX3), 65 bytes

A seguir, define uma função que imprime o resultado no terminal (infelizmente, expl3possui nomes de funções muito detalhados):

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

Um script completo que pode ser executado no terminal, incluindo todos os casos de teste, bem como a configuração para inserir 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

Se executar com pdflatex <filename>o seguinte é a saída do console:

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.

Explicação

\fp_show:n : avalia seu argumento como uma expressão de ponto flutuante e imprime o resultado no terminal, toda macro expansível é expandida durante esse processo.

\clist_map_function:nN : recebe dois argumentos, uma lista separada por vírgula e uma função / macro, se chamada como \clist_map_function:nN { l1, l2, l3 } \foose expande para algo como \foo{l1}\foo{l2}\foo{l3}. No nosso caso, em vez da \foomacro \2é usada, a qual se expande para +1/que a expressão se expanda para+1/{l1}+1/{l2}+1/{l3}