Appliquer la loi de Kirchhoff


15

La loi de Kirchhoff dit que lorsque vous additionnez tous les courants (positifs pour les courants allant à une jonction et négatifs pour le courant sortant d'une jonction), vous obtiendrez toujours le résultat 0.

Regardez le schéma suivant:

entrez la description de l'image ici

En utilisant la loi de Kirchhoff, vous pouvez voir que i1 + i4 - i2 - i3 = 0, donc i1 + i4 = i2 + i3.

Étant donné deux listes, une avec tous les courants entrant dans la jonction et une avec tous les courants sortant de la jonction sauf une, sort la dernière.

Testcases:

[1, 2, 3], [1, 2] = 3
[4, 5, 6], [7, 8] = 0
[5, 7, 3, 4, 5, 2], [8, 4, 5, 2, 1] = 6

La deuxième liste contient toujours un élément de moins que la première liste. La sortie ne peut pas être négative. Le plus petit programme gagne.


1
Le casse-tête aurait été meilleur si vous aviez donné des valeurs de résistance et de courant. Ce Q semble que vous ayez introduit la loi comme un homonyme. (Le Q aurait pu être facilement énoncé sans la loi)
ghosts_in_the_code

5
Loi actuelle de Kirchoff
Luis Mendo


Pouvez-vous spécifier si nous pouvons simplement créer une fonction qui renvoie le résultat ou réellement imprimer / retourner le résultat.
tpvasconcelos

Réponses:


14

Gelée, 2 octets

_S

Essayez-le ici!

Prend les courants entrants dans le premier argument et les courants sortants dans le second argument. _les soustrait par paire, en laissant l'élément unique de la liste plus longue tel Squel et résume le résultat.


9

Haskell, 14 octets

(.sum).(-).sum

Exemple d'utilisation: ( (.sum).(-).sum ) [5,7,3,4,5,2] [8,4,5,2,1]-> 6.

Additionnez chaque liste et faites la différence.


5

CJam, 8 6 octets

q~.-:+

L'entrée utilise deux tableaux de style CJam.

Exécutez tous les cas de test. (Cela lit plusieurs cas de test à la fois et inclut un cadre pour traiter chaque ligne individuellement, en rejetant le résultat attendu de l'entrée.)

Explication

q~  e# Read and evaluate input.
.-  e# Elementwise difference.
:+  e# Get sum.

.-fonctionne de manière fiable car nous sommes garantis que la première liste est toujours plus longue que la seconde. (Sinon, les éléments étrangers de la deuxième liste seraient ajoutés au résultat, ce qui les ajouterait à la somme au lieu de les soustraire.)


1
Félicitations pour exactement 80k!
ETHproductions

4

MATL , 3 4,0 octets

_hs

Les entrées sont: laisser les courants en premier, puis entrer les courants.

Essayez-le en ligne!

_     % implicitly input array with leaving currents (except one). Negate
h     % implicitly input array with entering currents. Concatenate  
s     % sum of all elements in concatenated array

La même solution exacte que la mienne, mais avec des lettres différentes haha, +1
Adnan

@Adnan j'ai vu! (+1 déjà)
Luis Mendo

@Adnan J'ai réduit à 3 octets la modification de l'ordre d'entrée et la concaténation des deux tableaux. Peut-être que cela peut également s'appliquer à votre réponse?
Luis Mendo

Ahhh, je devrais vraiment implémenter une fonction de concaténation: p. Très belle réponse! :)
Adnan

3

Javascript, 36 octets

(a,b)=>eval(a.join`+`+'-'+b.join`-`)


3

05AB1E , 4 octets

Code:

OEO-

Explication:

O     # Take the sum of the input list
 E    # Evaluate input
  O   # Take the sum of the input list
   -  # Substract from each other

Merci à Luis Mendo de m'avoir rappelé que je dois implémenter une fonction de concaténation. Si je l'avais implémenté plus tôt, cela aurait été de 3 octets:

Version non concurrente (3 octets):

La première liste est la liste actuelle sortante, la seconde est la liste actuelle entrante. Code:

(«O

Explication:

(    # Negate the list, e.g. [3, 4, 5] would become [-3, -4, -5]
 «   # Concatenate the second list to the first
  O  # Take the sum and implicitly output it

Utilise l'encodage CP-1252.



2

Lisp commun, 40

(lambda(x y)(-(reduce'+ x)(reduce'+ y)))

2

Perl 6 , 11 octets

*.sum-*.sum

Usage:

# give it a lexical name
my &code = *.sum-*.sum;

say code [1, 2, 3], [1, 2]; # 3
say code [4, 5, 6], [7, 8]; # 0
say code [5, 7, 3, 4, 5, 2], [8, 4, 5, 2, 1]; # 6

2

Python 3, 24 octets

lambda a,b:sum(a)-sum(b)

ou

Python 2, 19 octets

print sum(a)-sum(b)

selon que je dois imprimer le résultat ou simplement créer une fonction qui le renvoie.


1

ES6, 39 octets

(i,o)=>i.reduceRight((r,a,j)=>r+a-o[j])

Parce que je voulais utiliser reduceRight.


1

Python 2, 30 octets

a,b=map(sum,input());print a-b

1

Pyth, 6 octets

-.*sRQ

Explication

       - autoassign Q = eval(input())
   sRQ - map(sum, Q)
-.*    - imp_print(minus(*^))

Essayez-le ici


1

K5, 5 octets

-/+/'

Différence sur ( -/) somme sur ( +/) chacun ( ').

En action:

  (-/+/')'((1 2 3;1 2);(4 5 6;7 8);(5 7 3 4 5 2;8 4 5 2 1))
3 0 6



0

Common Lisp REPL, SBCL 28 24 octets

écrivez ceci dans REPL:

#.`(-(+ #1=,@(read))#1#)

puis écrivez des listes d'entrée comme ceci:

(2 3 4)
(2 3)

J'espère que c'est correct d'utiliser un tel format de liste (au lieu de par exemple '(2 3 4)) J'ai utilisé la réponse de coredump comme formule pour ma solution, puis j'ai obtenu son effet de calcul d'une manière différente.

Explication

Soit des e_1,...,e_néléments de la première liste et des f_1,...,f_{n-1}éléments de la deuxième liste. Nous voulons évaluer l'expression (-(+ e_1 e_2 ... e_n)f_1 f_2 ...f_{n-1}) Cela signifierait soustraire les éléments de la deuxième liste de la somme des éléments de la première liste. L'expression nécessaire est construite comme suit:

backqoute arrête l'évaluation

#1= économise un peu d'écriture, de mémoire ,@(read)

,@ arrête les effets de backquote (pour que (lecture) soit évalué) et retire les éléments d'une liste.

(read) demande des commentaires

#1# "charge" l'objet Lisp enregistré par #1=

#. fait l'évaluation de la représentation imprimée d'un objet Lisp

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.