Introducción:

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

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}$ o como se sugiere en los comentarios:

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}}$

Tres resistencias, R1, R2y R3en paralelo ( R1 || R2 || R3) tienen una resistencia combinada (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}$

o, nuevamente como se sugiere en los comentarios:

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}}$

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.

— Stewie Griffin
fuente

66

Hay algunos otros desafíos que se refieren a la media armónica ( 1 2 3 ) pero no creo que haya un duplicado. En línea con lo que sugirió la falla, creo que este organismo de desafío debería tener esa frase en alguna parte para que podamos cerrar un futuro engaño más fácilmente.

— FryAmTheEggman

13

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

— Datos caducados
fuente

44

Con excepción de las funciones integradas, ¡esto es probablemente lo más bajo posible!

9

Haskell , 18 16 bytes

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

Pruébalo en línea!

— falla
fuente

3

Se ve hermoso.

— Eric Duminil

Solución a lo largo de las líneas recursivas de la OP sería 22 caracteres: foldr1(\r s->r*s/(r+s)).

— dejó de girar en sentido antihorario el

9

MATLAB , 14 bytes

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

‖ v ‖_{p} = {(\sum_{i} | v_{i} |^{p})}^{\frac{1}{p}} .

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

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!

— falla
fuente

44

¡Esto es horrible y hermoso al mismo tiempo!

— dejó de girar en sentido antihorario el

1

Gracias, estos son los mejores cumplidos :)

— flawr

7

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)

— Jonathan Allan
fuente

44

Estoy asumiendo que İse pronuncia de la misma manera ique se pronuncia en list. ¿Es esta una forma de decir que el desafío fue fácil?

— Stewie Griffin

4

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

— Veskah
fuente

4

Octava , 15 bytes

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

Pruébalo en línea!

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

— Giuseppe
fuente

@tsh sabes, creo que nunca me di cuenta de eso. Supongo que es casi el significado armónico ...

— Giuseppe

4

APL (Dyalog Unicode) , 4 bytes

÷1⊥÷

Pruébalo en línea!

-1 gracias a Adám .

— Erik el Outgolfer
fuente

1

¡APL es el lenguaje original de golf!

@YiminRong No es un lenguaje de golf ...: P

— Erik the Outgolfer

Lo sé, ¡pero su número de bytes está a la par con los idiomas modernos de golf!

-1 byte: ¡ ÷1⊥÷ Pruébelo en línea!

— Adám

@ Adám Oh, por supuesto, 1∘⊥es lo mismo que +/para los vectores ...

— Erik the Outgolfer

3

R , 15 bytes

1/sum(1/scan())

Pruébalo en línea!

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

— Sumner18
fuente

3

JavaScript, 28 bytes

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

Pruébalo en línea!

— Lanudo
fuente

3

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

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

Pruébalo en línea!

— Xcali
fuente

20 bytes

— Nahuel Fouilleul

@NahuelFouilleul 17 bytes, no -M

— Grimmy

3

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.

— Sean
fuente

Muy agradable. No veo que HyperWhatevers se use con suficiente frecuencia en el golf, ya que no se pueden usar en expresiones más complejas. Si estaban más cerca de Whatevers normales, esperaría sumething como este para trabajar, pero por desgracia ...

— Jo Rey

Sí, esta es probablemente la primera vez que pienso en usar uno para jugar al golf, y me decepcionó descubrir sus limitaciones.

— Sean

3

bash + coreutils, 25 bytes

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

TIO

— Nahuel Fouilleul
fuente

3

Wolfram Language (Mathematica) , 10 bytes

1/Tr[1/#]&

Pruébalo en línea!

— attinat
fuente

¿No hay armónico medio incorporado, o es más largo para escribir?

— Eric Duminil

@Eric AFAIK tiene un nombre intuitivo HarmonicMeany es más largo.

— mi pronombre es monicareinstate el

3

MathGolf , 3 bytes

∩Σ∩

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

METRO (X_{1}, . . ., X_{norte}) = \frac{1}{\frac{1}{X_{1}} + \frac{1}{X_{2}} + . . . + \frac{1}{X_{norte}}}

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

Pruébalo en línea.

— Kevin Cruijssen
fuente

2

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!

Con PHP7.4, creo que puedes hacer esto: 1/array_reduce($a,fn($c,$i)=>$c+1/$i);(38 bytes). Lea más en wiki.php.net/rfc/arrow_functions

— Ismael Miguel

¡Creo que tienes razón! Pero no hay lugar para demo?

Tienes que descargarlo tú mismo. Sin embargo, dado que PHP 7.4.0RC1 se lanzó el 5 de este mes ( php.net/archive/2019.php#2019-09-05-1 ), probablemente esté seguro de usarlo. Si tienes dudas, puedes preguntar en el meta.

— Ismael Miguel

2

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.

— Arnauld
fuente

2

Python 3 , 30 bytes

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

Pruébalo en línea!

— Jonathan Allan
fuente

2

Perl 5 (-p), 17 bytes

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

Pruébalo en línea!

— Mugriento
fuente

2

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.

— yo'
fuente

¡"Solo 2⁶¹ resistencias" probablemente llenarían el universo observable (muchas veces)!

En realidad, 2 ^ 61 es solo 2.305843e + 18 y el universo observable tiene 8.8 × 10 ^ 26 m de diámetro.

— yo

Sí, sobreestimación seria! La magnitud real sería del tamaño y la masa de Deimos, la luna más pequeña de Marte.

2

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:

METRO (X_{1}, . . ., X_{norte}) = \frac{1}{\frac{1}{X_{1}} + \frac{1}{X_{2}} + . . . + \frac{1}{X_{norte}}}

$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

— Kevin Cruijssen
fuente

2

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.

— Giuseppe
fuente

2

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].

— 640 KB
fuente

1

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

— Elcan
fuente

1

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.

— Noche2
fuente

1

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

— Triggernometry
fuente

1

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

— Neil
fuente

1

J , 6 bytes

1%1#.%

Pruébalo en línea!

— Galen Ivanov
fuente

2

que es una "suma bajo recíproco" lástima es el mismo número de bytes:+/&.:%

— NGN

@ngn Sí, pero su solución parece más idiomática para J.

— Galen Ivanov

1

[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.

— Hoki
fuente

1

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

— reffu
fuente

1

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}

— Skillmon
fuente

Resistencia paralela en circuitos eléctricos.

Introducción:

Desafío:

Casos de prueba:

05AB1E , 5 3 bytes

Explicación

Haskell , 18 16 bytes

MATLAB , 14 bytes

Jalea , 5 3 bytes

¿Cómo?

PowerShell , 22 bytes

Octava , 15 bytes

APL (Dyalog Unicode) , 4 bytes

R , 15 bytes

JavaScript, 28 bytes

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

Perl 6 , 14 bytes

bash + coreutils, 25 bytes

Wolfram Language (Mathematica) , 10 bytes

MathGolf , 3 bytes

PHP , 51 bytes

JavaScript (ES6), 29 bytes

Python 3 , 30 bytes

Perl 5 (-p), 17 bytes

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

Java 8, 24 bytes

MATL , 5 bytes

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

Dart , 42 bytes

PHP , 40 bytes

Python 3, 58 44 bytes

Carbón de leña , 7 bytes

J , 6 bytes

[MATLAB], 15 bytes

Adelante (gforth) , 49 bytes

Explicación del código

expl3 (capa de programación LaTeX3), 65 bytes

Explicación

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