Introducción:

Dos resistencias R1y R2, en paralelo (denotado R1 || R2) tienen una resistencia combinada Rpdada como:

Tres resistencias, R1, R2y R3en paralelo ( R1 || R2 || R3) tienen una resistencia combinada (R1 || R2) || R3 = Rp || R3:

o, nuevamente como se sugiere en los comentarios:

Estas fórmulas, por supuesto, pueden extenderse a un número indefinido de resistencias.

Desafío:

Tome una lista de valores de resistencia positiva como entrada y envíe la resistencia combinada si se colocan en paralelo en un circuito eléctrico. No puede asumir un número máximo de resistencias (excepto que su computadora puede manejarlo, por supuesto).

Casos de prueba:

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  

El código más corto en cada idioma gana. Las explicaciones son altamente alentadas.

05AB1E , 5 3 bytes

zOz

Pruébalo en línea!

Explicación

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

Haskell , 18 16 bytes

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

Pruébalo en línea!

MATLAB , 14 bytes

En MATLAB norm(...,p)calcula la pforma de un vector. Esto generalmente se define para $p \geqslant 1$ como

Pero afortunadamente para nosotros, también funciona para $p=-1$ . (Tenga en cuenta que no funciona en Octave).

@(x)norm(x,-1)

¡No lo intentes en línea!

Jalea ,  5  3 bytes

İSİ

Pruébalo en línea!

¿Cómo?

Inicialmente olvidé este formulario de mis días de ingeniería electrónica ... con qué facilidad lo olvidamos.

İ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

Pruébalo en línea!

Toma información a través de salpicaduras y usa el mismo 1 / suma de truco inverso que muchos de los otros están haciendo

Octava , 15 bytes

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

Pruébalo en línea!

Media armónica, dividida por n. Pan comido.

APL (Dyalog Unicode) , 4 bytes

÷1⊥÷

Pruébalo en línea!

-1 gracias a Adám .

R , 15 bytes

1/sum(1/scan())

Pruébalo en línea!

Sigue el mismo principio de media armónica visto en otras respuestas.

JavaScript, 28 bytes

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

Pruébalo en línea!

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

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

Pruébalo en línea!

Perl 6 , 14 bytes

1/*.sum o 1/**

Pruébalo en línea!

1 / **es una función anónima que devuelve una lista de los recíprocos de sus argumentos. 1 / *.sumes otra función anónima que devuelve el recíproco de la suma de los elementos de su argumento de lista. El ooperador compone esas dos funciones.

bash + coreutils, 25 bytes

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

TIO

Wolfram Language (Mathematica) , 10 bytes

1/Tr[1/#]&

Pruébalo en línea!

MathGolf , 3 bytes

∩Σ∩

Lo mismo que otras respuestas, usando los builtins ∩($\frac{1}{n}$) y Σ(suma):

Pruébalo en línea.

PHP , 51 bytes

Recíproco de suma de recíprocos. Entrada es $a.

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

Pruébalo en línea!

JavaScript (ES6), 29 bytes

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

Pruébalo en línea!

o:

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

Pruébalo en línea!

Pero con este enfoque, usar map()(como lo hizo Shaggy ) es 1 byte más corto.

Python 3 , 30 bytes

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

Pruébalo en línea!

Perl 5 (-p), 17 bytes

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

Pruébalo en línea!

x86-64 Código de 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: convención de llamadas de Windows. El primer parámetro es el número de resistencias en RCX. Un puntero a las resistencias está adentro RDX. *psLas instrucciones se utilizan ya que son un byte más pequeño. Técnicamente, solo puede tener alrededor de 2 ^ 61 resistencias, pero se quedará sin RAM mucho antes. La precisión tampoco es excelente, ya que la estamos usando rcpps.

Java 8, 24 bytes

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

Noté que aún no había una respuesta de Java, así que pensé en agregar una.

Pruébalo en línea.

Explicación:

Utiliza el mismo enfoque de media armónica que otras respuestas:

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

Pruébalo en línea!

No estoy seguro de si "do two" ( ,) cuenta como un bucle, pero esta es solo la media armónica, dividida por n.

Alternativamente, ,-1^ses de cinco bytes también.

Código de máquina Intel 8087 FPU, 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]

Utiliza las instrucciones de coma flotante basadas en pila en la FPU 8087 de la PC IBM original.

La entrada es puntero a los valores de resistencia en [SI], número de resistencias en CX. La salida tiene un solo valor de precisión (DD) en [DI].

Dart , 42 bytes

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

Pruébalo en línea!

Tener que especificar explícitamente que el numtipo es un poco sucio, evita la inferencia de tipos, porque inferiría a los (dynamic, dynamic) => dynamiccuales no se pueden obtener dobles por alguna razón

PHP , 40 bytes

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

Pruébalo en línea!

Pruebas: ¡ Pruébelo en línea!

Similar a la solución de Yimin Rong pero sin elementos integrados y todos los bytes del programa están incluidos en el recuento de bytes.

Python 3, 58 44 bytes

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

Una función recursiva. Requiere que los argumentos se pasen sin empaquetar, así:

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

o

f(10, 10, 20)

Explicación:

# 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

Carbón de leña , 7 bytes

Ｉ∕¹Σ∕¹Ａ

Pruébalo en línea! El enlace es a la versión detallada del código. Funciona calculando la corriente dibujada por cada resistencia cuando se aplica 1V, tomando el total y calculando la resistencia que dibujaría esa corriente cuando se aplica 1V. Explicación:

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

J , 6 bytes

1%1#.%

Pruébalo en línea!

[MATLAB], 15 bytes

Un byte más que una excelente respuesta, pero tuve que usar otras funciones, así que aquí va:

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

Es bastante explícito, suma el inverso de las resistencias, luego invierte la suma para generar la resistencia paralela equivalente.

Adelante (gforth) , 49 bytes

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

Pruébalo en línea!

La entrada es una dirección de memoria y una longitud de matriz (utilizada como una matriz improvisada, ya que Forth no tiene una construcción de matriz incorporada)

Utiliza el método de suma de inversa, ya que la mayoría de las otras respuestas son

Explicación del código

: 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 (capa de programación LaTeX3), 65 bytes

Lo siguiente define una función que imprime el resultado en el terminal (desafortunadamente expl3tiene nombres de funciones muy detallados):

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

Un script completo que se puede ejecutar desde la terminal, incluidos todos los casos de prueba, así como la configuración para ingresar 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

Si se ejecuta con pdflatex <filename>lo siguiente es la salida de la consola:

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.

Explicación

\fp_show:n : evalúa su argumento como una expresión de coma flotante e imprime el resultado en el terminal, cada macro expandible se expande durante ese proceso.

\clist_map_function:nN : toma dos argumentos, una lista separada por comas y una función / macro, si se llama como \clist_map_function:nN { l1, l2, l3 } \foose expande a algo así \foo{l1}\foo{l2}\foo{l3}. En nuestro caso se usa en lugar de \foola macro \2, que se expande a +1/para que la expresión se expanda a+1/{l1}+1/{l2}+1/{l3}