Résistance parallèle dans les circuits électriques

20

Introduction:

Deux résistances R1et R2, en parallèle (notées R1 || R2) ont une résistance combinée Rpdonnée par:

RP2=R1⋅R2R1+R2
ou comme suggéré dans les commentaires:

RP2=11R1+1R2

Trois résistances R1, R2et R3en parallèle ( R1 || R2 || R3) ont une résistance combinée (R1 || R2) || R3 = Rp || R3:

RP3=R1⋅R2R1+R2⋅R3R1⋅R2R1+R2+R3

ou encore, comme suggéré dans les commentaires:

RP3=11R1+1R2+1R3

Ces formules peuvent bien entendu être étendues à un nombre indéfini de résistances.

Défi:

Prenez une liste de valeurs de résistance positives en entrée et sortez la résistance combinée si elles ont été placées en parallèle dans un circuit électrique. Vous ne pouvez pas supposer un nombre maximum de résistances (sauf que votre ordinateur peut bien sûr le gérer).

Cas de 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

Le code le plus court dans chaque langue gagne. Les explications sont fortement encouragées.

code-golf  math  physics  electrical-engineering 
— Stewie Griffin
source
6
Il y a quelques autres défis qui se réfèrent à la moyenne harmonique ( 1 2 3 ) mais je ne pense pas qu'il y ait de doublon. En accord avec ce que Flawr a suggéré, je pense que cet organisme de défi devrait avoir cette phrase quelque part afin que nous puissions clôturer plus facilement une future dupe.
— FryAmTheEggman

Réponses:

9

MATLAB , 14 octets

Dans MATLAB norm(...,p)calcule la p-norm d'un vecteur. Ceci est généralement défini pour p⩾1 comme

‖v‖p=(∑i|vi|p)1p.

Mais heureusement pour nous, cela fonctionne aussi pour p=−1 . (Notez que cela ne fonctionne pas dans Octave.)

@(x)norm(x,-1)

Ne l'essayez pas en ligne!

— flawr
source
4
C'est horrible et beau à la fois!
— cessé de tourner dans le sens inverse des aiguilles d'une montre le
1
Merci, ce sont les meilleurs compliments :)
— flawr
7

Gelée ,  5  3 octets

İSİ

Essayez-le en ligne!

Comment?

Au début, j'ai oublié ce formulaire de mes jours d'ingénierie électronique ... avec quelle facilité nous oublions.

İ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
source
4
Je suppose İest prononcé de la même façon iest prononcée list. Est-ce une façon de dire que le défi a été facile?
— Stewie Griffin
3

Perl 6 , 14 octets

1/*.sum o 1/**

Essayez-le en ligne!

1 / **est une fonction anonyme qui renvoie une liste des inverses de ses arguments. 1 / *.sumest une autre fonction anonyme qui retourne l'inverse de la somme des éléments de son argument list. L' oopérateur compose ces deux fonctions.

— Sean
source
Très agréable. Je ne vois pas HyperWhatevers utilisé assez souvent dans le golf car ils ne peuvent pas être utilisés dans des expressions plus complexes. S'ils étaient plus proches des Whatevers normaux, je m'attendrais à ce que cela fonctionne, mais hélas ...
— Jo King
Ouais, c'est probablement la première fois que je pense à en utiliser un pour le golf, et j'ai été déçu de découvrir ses limites.
— Sean
2

PHP , 51 octets

Réciproque de la somme des réciproques. L'entrée est $a.

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

Essayez-le en ligne!

Avec PHP7.4, je pense que vous pouvez le faire: 1/array_reduce($a,fn($c,$i)=>$c+1/$i);(38 octets). En savoir plus sur wiki.php.net/rfc/arrow_functions
— Ismael Miguel
Je pense que tu as raison! Mais nulle part où faire une démonstration?
Vous devez le télécharger vous-même. Cependant, depuis que PHP 7.4.0RC1 a été publié le 5 de ce mois ( php.net/archive/2019.php#2019-09-05-1 ), vous pouvez probablement l'utiliser en toute sécurité. Si vous avez des doutes, vous pouvez demander dans la méta.
— Ismael Miguel
2

x86-64 Code machine - 20 18 octets

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

Entrée - Convention d'appel Windows. Le premier paramètre est le nombre de résistances RCX. Un pointeur vers les résistances se trouve RDX. *psles instructions sont utilisées car elles sont plus petites d'un octet. Techniquement, vous ne pouvez avoir qu'environ 2 ^ 61 résistances mais vous serez à court de RAM bien avant. La précision n'est pas grande non plus, puisque nous utilisons rcpps.

— moi'
source
"Seulement 2⁶¹ résistances" rempliraient probablement l'univers observable (plusieurs fois)!
En fait, 2 ^ 61 ne fait que 2,305843e + 18 et l'univers observable mesure 8,8 × 10 ^ 26 m de diamètre.
— moi le
Ouais, surestimation sérieuse! La magnitude réelle serait de la taille et de la masse de Deimos, la plus petite lune de Mars.
2

Java 8, 24 octets

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

J'ai remarqué qu'il n'y avait pas encore de réponse Java, alors j'ai pensé en ajouter une.

Essayez-le en ligne.

Explication:

Utilise la même approche de la moyenne harmonique que les autres réponses:

M(X1,...,Xn)=11X1+1X2+...+1Xn

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
source
2

MATL , 5 octets

,1w/s

Essayez-le en ligne!

I'm not sure if "do twice" (,) counts as a loop, but this is just the harmonic mean, divided by n.

Alternately, ,-1^s is five bytes as well.

— Giuseppe
source
2

Intel 8087 FPU machine code, 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]

This uses the stack-based floating point instructions in the original IBM PC's 8087 FPU.

L'entrée est un pointeur sur les valeurs des résistances en [SI], nombre de résistances enCX. Output is to a single precision (DD) value at [DI].

— 640KB
source
1

Dard , 42 octets

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

Essayez-le en ligne!

numDevoir spécifier explicitement le type est un peu nul, empêche l'inférence de type, car il en déduirait que ne (dynamic, dynamic) => dynamicpeut pas donner de double pour une raison quelconque

— Elcan
source
1

Python 3, 58 44 octets

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

Une fonction récursive. Nécessite que les arguments soient passés décompressés, comme ceci:

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

ou

f(10, 10, 20)

Explication:

# 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
— Triggernométrie
source
1

Fusain , 7 octets

Ｉ∕¹Σ∕¹Ａ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Fonctionne en calculant le courant consommé par chaque résistance lorsque 1 V est appliqué, en prenant le total et en calculant la résistance qui tirerait ce courant lorsque 1 V est appliqué. Explication:

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

[MATLAB], 15 octets

Un octet de plus que flawr excellente réponse, mais j'ai dû utiliser d'autres fonctions alors voici:

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

C'est plutôt explicite, il additionne l'inverse des résistances, puis inverse la somme pour sortir la résistance parallèle équivalente.

— Hoki
source
1

Forth (gforth) , 49 octets

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

Essayez-le en ligne!

L'entrée est une adresse mémoire et une longueur de tableau (utilisée comme tableau impromptu, car Forth n'a pas de construction de tableau intégrée)

Utilise la méthode de la somme des inverses car la plupart des autres réponses sont

Explication du code

: 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
source
1

expl3 (couche de programmation LaTeX3), 65 octets

Ce qui suit définit une fonction qui imprime le résultat sur le terminal (a malheureusement expl3des noms de fonction très verbeux):

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

Un script complet qui peut être exécuté depuis le terminal comprenant tous les cas de test ainsi que la configuration pour entrer 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 exécuté avec pdflatex <filename>ce qui suit est la sortie de la 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.

Explication

\fp_show:n : évalue son argument comme une expression à virgule flottante et imprime le résultat sur le terminal, chaque macro extensible est développée pendant ce processus.

\clist_map_function:nN : prend deux arguments, une liste séparée par des virgules et une fonction / macro, si elle est appelée comme \clist_map_function:nN { l1, l2, l3 } \fooelle se développe en quelque chose comme \foo{l1}\foo{l2}\foo{l3}. Dans notre cas, au lieu de \foola macro \2est utilisée, qui se développe pour +1/que l'expression se développe pour+1/{l1}+1/{l2}+1/{l3}

— Skillmon
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.