Resistenza parallela nei circuiti elettrici

20

Introduzione:

Due resistori R1e R2, in parallelo (indicato R1 || R2) hanno una resistenza combinata Rpdata come:

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 come suggerito nei commenti:

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

Tre resistori R1, R2e R3in parallelo ( R1 || R2 || R3) hanno una resistenza combinata (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, ancora come suggerito nei commenti:

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

Queste formule possono ovviamente essere estese a un numero indefinito di resistori.

Sfida:

Prendi un elenco di valori di resistori positivi come input e genera la resistenza combinata se fossero posizionati in parallelo in un circuito elettrico. Non puoi assumere un numero massimo di resistori (tranne che il tuo computer può gestirlo ovviamente).

Casi test:

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

Vince il codice più corto in ogni lingua. Le spiegazioni sono fortemente incoraggiate.

code-golf math physics electrical-engineering

— Stewie Griffin
fonte

6

Ci sono alcune altre sfide che si riferiscono alla media armonica ( 1 2 3 ) ma non credo che ci sia un duplicato. In linea con quanto suggerito da Flawr, penso che questo corpo di sfida dovrebbe avere quella frase elencata da qualche parte in modo da poter chiudere un futuro imbroglio più facilmente.

— FryAmTheEggman,

Risposte:

13

05AB1E , 5 3 byte

zOz

Provalo online!

Spiegazione

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

— Dati scaduti
fonte

4

Tranne i built-in, questo è probabilmente il più basso possibile!

9

Haskell , 18 16 byte

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

Provalo online!

— flawr
fonte

3

Sembra bellissimo.

— Eric Duminil,

Soluzione lungo linee ricorsive del PO sarebbe 22 caratteri: foldr1(\r s->r*s/(r+s)).

— cessò di girare in senso antiorario il

9

MATLAB , 14 byte

In MATLAB norm(...,p)calcola il pnormale di un vettore. Questo è generalmente definito per $p \geqslant 1$ come

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

Ma fortunatamente per noi, funziona anche per $p=-1$ . (Nota che non funziona in Octave.)

@(x)norm(x,-1)

Non provarlo online!

— flawr
fonte

4

Questo è orribile e bello contemporaneamente!

— cessò di girare in senso antiorario il

1

Grazie, questi sono i migliori complimenti :)

— flawr

7

Gelatina , 5 3 byte

İSİ

Provalo online!

Come?

Inizialmente ho dimenticato questo modulo dai miei giorni di ingegneria elettronica ... quanto facilmente dimentichiamo.

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

4

Suppongo che İsia pronunciato allo stesso modo in cui iè pronunciato list. È un modo per dire che la sfida è stata facile?

— Stewie Griffin,

4

PowerShell , 22 byte

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

Provalo online!

Riceve input tramite splatting e usa la stessa 1 / somma di trucco inverso di molti altri

— Veskah
fonte

4

Ottava , 15 byte

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

Provalo online!

Media armonica, divisa per n. Vai tranquillo.

— Giuseppe
fonte

@tsh sai, non credo di averlo mai notato. Immagino sia quasi il significato armonico ...

— Giuseppe,

4

APL (Dyalog Unicode) , 4 byte

÷1⊥÷

Provalo online!

-1 grazie ad Adám .

— Erik the Outgolfer
fonte

1

APL è il linguaggio golfistico originale!

@YiminRong Non è un linguaggio da golf ...: P

— Erik the Outgolfer,

Lo so, ma il suo conteggio dei byte è alla pari con le moderne lingue del golf!

-1 byte: ÷1⊥÷ provalo online!

— Adám,

@ Adám Oh duh ovviamente 1∘⊥è lo stesso +/dei vettori ...

— Erik the Outgolfer

3

R , 15 byte

1/sum(1/scan())

Provalo online!

Segue lo stesso principio della media armonica visto in altre risposte.

— Sumner18
fonte

3

JavaScript, 28 byte

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

Provalo online!

— ispido
fonte

3

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

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

Provalo online!

— Xcali
fonte

20 byte

— Nahuel Fouilleul,

@NahuelFouilleul 17 byte, no -M

— Grimmy,

3

Perl 6 , 14 byte

1/*.sum o 1/**

Provalo online!

1 / **è una funzione anonima che restituisce un elenco dei reciproci dei suoi argomenti. 1 / *.sumè un'altra funzione anonima che restituisce il reciproco della somma degli elementi del suo argomento list. L' ooperatore compone queste due funzioni.

— Sean
fonte

Molto bella. Non vedo HyperWhatevers usato abbastanza spesso nel golf poiché non possono essere utilizzati in espressioni più complesse. Se fossero più vicini ai normali Whatevers, mi aspetterei che un consumo di questo tipo funzioni, ma ahimè ...

— Jo King,

Sì, questa è probabilmente la prima volta che ho persino pensato di usarne uno per giocare a golf e sono rimasto deluso nello scoprire i suoi limiti.

— Sean,

3

bash + coreutils, 25 byte

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

— Nahuel Fouilleul
fonte

3

Wolfram Language (Mathematica) , 10 byte

1/Tr[1/#]&

Provalo online!

— attinat
fonte

Non esiste una media armonica incorporata o è più lungo da digitare?

— Eric Duminil,

@Eric AFAIK ha un nome intuitivo HarmonicMeaned è più lungo.

— mio pronome è monicareinstate il

3

MathGolf , 3 byte

∩Σ∩

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

M (X_{1}, . . ., X_{n}) = \frac{1}{\frac{1}{X_{1}} + \frac{1}{X_{2}} + . . . + \frac{1}{X_{n}}}

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

Provalo online.

— Kevin Cruijssen
fonte

2

PHP , 51 byte

Alternativo della somma dei reciproci. L'input è $a.

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

Provalo online!

Con PHP7.4, penso che tu possa fare questo: 1/array_reduce($a,fn($c,$i)=>$c+1/$i);(38 byte). Maggiori informazioni su wiki.php.net/rfc/arrow_functions

— Ismael Miguel,

Penso tu abbia ragione! Ma da nessuna parte la demo?

Devi scaricarlo da solo. Tuttavia, poiché PHP 7.4.0RC1 è stato rilasciato il 5 di questo mese ( php.net/archive/2019.php#2019-09-05-1 ), probabilmente sei sicuro di usarlo. Se hai dubbi, puoi chiedere nel meta.

— Ismael Miguel,

2

JavaScript (ES6), 29 byte

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

Provalo online!

o:

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

Provalo online!

Ma con questo approccio, l'utilizzo map()(come ha fatto Shaggy ) è più breve di 1 byte.

— Arnauld
fonte

2

Python 3 , 30 byte

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

Provalo online!

— Jonathan Allan
fonte

2

Perl 5 (-p), 17 byte

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

Provalo online!

— Grimmy
fonte

2

x86-64 Codice macchina - 20 18 byte

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

Input: convenzione di chiamata di Windows. Il primo parametro è il numero di resistori in RCX. È presente un puntatore ai resistori RDX. *psle istruzioni vengono utilizzate poiché hanno un byte più piccolo. Tecnicamente, puoi avere solo circa 2 ^ 61 resistenze ma sarai fuori dalla RAM molto prima di allora. Anche la precisione non è eccezionale, dal momento che stiamo usando rcpps.

— me'
fonte

"Solo 2⁶¹ resistori" riempirebbero probabilmente l'universo osservabile (molte volte)!

In realtà, 2 ^ 61 ha solo 2.305843e + 18 e l'universo osservabile ha un diametro di 8,8 × 10 ^ 26 m.

— io

Sì, grave sopravvalutazione! La grandezza reale sarebbe intorno alle dimensioni e alla massa di Deimos, la più piccola luna di Marte.

2

Java 8, 24 byte

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

Ho notato che non c'era ancora una risposta Java, quindi ho pensato di aggiungerne una.

Provalo online.

Spiegazione:

Utilizza lo stesso approccio Media armonica delle altre risposte:

M (X_{1}, . . ., X_{n}) = \frac{1}{\frac{1}{X_{1}} + \frac{1}{X_{2}} + . . . + \frac{1}{X_{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

— Kevin Cruijssen
fonte

2

MATL , 5 byte

,1w/s

Provalo online!

Non sono sicuro che "do due volte" ( ,) conti come un ciclo, ma questa è solo la media armonica, divisa per n.

In alternativa, anche ,-1^scinque byte.

— Giuseppe
fonte

2

Codice macchina Intel 8087 FPU, 19 byte

 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]

Questo utilizza le istruzioni in virgola mobile basate su stack nella FPU 8087 del PC IBM originale.

L'ingresso è puntatore a valori di resistenza in [SI], numero di resistori in CX. L'output è a un singolo valore di precisione (DD) a [DI].

— 640KB
fonte

1

Dardo , 42 byte

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

Provalo online!

Dover specificare esplicitamente il numtipo è un po 'sucky, impedisce di inferire il tipo, perché dedurrebbe a (dynamic, dynamic) => dynamicchi non può produrre doppi per qualche motivo

— Elcan
fonte

1

PHP , 40 byte

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

Provalo online!

Test: provalo online!

Simile alla soluzione di Yimin Rong ma senza built-in e tutti i byte del programma sono inclusi nel conteggio dei byte.

— night2
fonte

1

Python 3, 58 44 byte

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

Una funzione ricorsiva. Richiede che gli argomenti vengano passati spacchettati, in questo modo:

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

o

f(10, 10, 20)

Spiegazione:

# 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
fonte

1

Carbone , 7 byte

Ｉ∕¹Σ∕¹Ａ

Provalo online! Il collegamento è alla versione dettagliata del codice. Funziona calcolando la corrente assorbita da ciascun resistore quando viene applicato 1V, prendendo il totale e calcolando la resistenza che assorbirebbe quella corrente quando viene applicato 1V. Spiegazione:

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

— Neil
fonte

1

J , 6 byte

1%1#.%

Provalo online!

— Galen Ivanov
fonte

2

è un peccato "somma sotto reciproco" è lo stesso numero di byte:+/&.:%

— ngn

@ngn Sì, ma la tua soluzione sembra più idiomatica per J.

— Galen Ivanov il

1

[MATLAB], 15 byte

Un byte in più rispetto alla risposta eccellente flawr , ma ho dovuto usare altre funzioni, quindi ecco qui:

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

È piuttosto esplicito, somma l'inverso delle resistenze, quindi inverte la somma per produrre la resistenza parallela equivalente.

— hoki
fonte

1

Forth (gforth) , 49 byte

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

Provalo online!

L'input è un indirizzo di memoria e una lunghezza dell'array (usato come array improvvisato, poiché Forth non ha un costrutto array incorporato)

Utilizza il metodo della somma inversa come la maggior parte delle altre risposte

Spiegazione del codice

: 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
fonte

1

expl3 (livello di programmazione LaTeX3), 65 byte

Quanto segue definisce una funzione che stampa il risultato sul terminale (purtroppo expl3ha nomi di funzione molto dettagliati):

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

Uno script completo che può essere eseguito dal terminale, inclusi tutti i casi di test e l'installazione per inserire 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 eseguito con pdflatex <filename>il seguente è l'output della 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.

Spiegazione

\fp_show:n : valuta il suo argomento come espressione in virgola mobile e stampa il risultato sul terminale, ogni macro espandibile viene espansa durante quel processo.

\clist_map_function:nN : accetta due argomenti, un elenco separato da virgole e una funzione / macro, se chiamato come \clist_map_function:nN { l1, l2, l3 } \foosi espande in qualcosa di simile \foo{l1}\foo{l2}\foo{l3}. Nel nostro caso invece viene utilizzata \foola macro \2, che si espande in +1/modo che l'espressione si espanda+1/{l1}+1/{l2}+1/{l3}

— Skillmon
fonte

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.

Licensed under cc by-sa 3.0 with attribution required.