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:

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.

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.

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.

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

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

Javascript, 36 octets

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

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

document.body.innerHTML = '<pre>' +
  'f([1,2,3],[1,2]) = ' + f([1,2,3],[1,2]) + '\n' +
  'f([4,5,6],[7,8]) = ' + f([4,5,6],[7,8]) + '\n' +
  'f([5,7,3,4,5,2],[8,4,5,2,1]) = ' + f([5,7,3,4,5,2],[8,4,5,2,1]) + '\n' +
'</pre>'

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.

Mathematica, 17 11 octets

Tr@#-Tr@#2&

Assez facile.

Lisp commun, 40

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

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

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.

ES6, 39 octets

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

Parce que je voulais utiliser reduceRight.

Python 2, 30 octets

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

Pyth, 6 octets

-.*sRQ

Explication

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

Essayez-le ici

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

Pyth, 5 octets

-FsMQ

Essayez-le en ligne. Suite de tests.

Map sum sur les deux listes d'entrée, puis Fancienne soustraction ( -).

Cela pourrait également s'écrire -sQsE, ce qui prend les listes sur deux lignes.

𝔼𝕊𝕄𝕚𝕟, 5 caractères / 7 octets

⨭î-⨭í

Try it here (Firefox only).

Wut.

Explication

sum(input1) - sum(input2)

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