Kirchhoffs Gesetz besagt, dass Sie immer als Ergebnis 0 erhalten, wenn Sie alle Ströme (positiv für die Ströme, die zu einer Kreuzung gehen, und negativ für den Strom, der eine Kreuzung verlässt) summieren.

Schauen Sie sich das folgende Diagramm an:

Mit dem Kirchhoffschen Gesetz können Sie sehen, dass i1 + i4 - i2 - i3 = 0, also i1 + i4 = i2 + i3.

Wenn zwei Listen gegeben sind, eine mit allen Strömen, die in die Verbindungsstelle eintreten, und eine mit allen Strömen, die die Verbindungsstelle mit Ausnahme einer verlassen, wird die letzte ausgegeben.

Testfälle:

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

Die zweite Liste enthält immer ein Element weniger als die erste Liste. Der Ausgang kann nicht negativ sein. Das kleinste Programm gewinnt.

Gelee, 2 Bytes

_S

Probieren Sie es hier aus!

Nimmt die Eingangsströme im ersten Argument und die Ausgangsströme im zweiten Argument. _Subtrahiert sie paarweise, lässt das einzelne Element unverändert von der längeren Liste und Ssummiert das Ergebnis.

Haskell, 14 Bytes

(.sum).(-).sum

Anwendungsbeispiel: ( (.sum).(-).sum ) [5,7,3,4,5,2] [8,4,5,2,1]-> 6.

Summiere jede Liste und nimm die Differenz.

CJam, 8 6 Bytes

q~.-:+

Die Eingabe verwendet zwei Arrays im CJam-Stil.

Führen Sie alle Testfälle aus. (Dies liest mehrere Testfälle gleichzeitig und beinhaltet ein Framework, um jede Zeile einzeln zu verarbeiten und das erwartete Ergebnis aus der Eingabe zu verwerfen.)

Erläuterung

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

.-funktioniert zuverlässig, weil wir garantiert sind, dass die erste Liste immer länger als die zweite ist. (Andernfalls werden die überflüssigen Elemente der zweiten Liste an das Ergebnis angehängt, wodurch sie zur Summe addiert werden, anstatt sie zu subtrahieren.)

MATL , 3 4,0 Bytes

_hs

Eingaben sind: zuerst Ströme verlassen, dann Ströme eingeben.

Probieren Sie es online!

_     % 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 Bytes

(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 Bytes

Code:

OEO-

Erläuterung:

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

Vielen Dank an Luis Mendo , der mich daran erinnert hat, dass ich eine Verkettungsfunktion implementieren muss. Wenn ich es früher implementiert hätte, wären es 3 Bytes gewesen:

Nicht konkurrierende Version (3 Bytes):

Die erste Liste ist die abgehende aktuelle Liste, die zweite die eintretende aktuelle Liste. Code:

(«O

Erläuterung:

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

Verwendet die CP-1252-Codierung.

Mathematica, 17 11 Bytes

Tr@#-Tr@#2&

Ziemlich einfach.

Gemeiner Lisp, 40

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

Perl 6 , 11 Bytes

*.sum-*.sum

Verwendung:

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

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

oder

Python 2, 19 Bytes

print sum(a)-sum(b)

je nachdem, ob ich das Ergebnis ausdrucken oder nur eine Funktion erstellen muss, die es zurückgibt.

ES6, 39 Bytes

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

Weil ich nutzen wollte reduceRight.

Python 2, 30 Bytes

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

Pyth, 6 Bytes

-.*sRQ

Erläuterung

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

Probieren Sie es hier aus

K5, 5 Bytes

-/+/'

Differenz über ( -/) Summe über ( +/) je ( ').

In Aktion:

  (-/+/')'((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 Bytes

-FsMQ

Probieren Sie es online aus. Testsuite.

Map sum auf beiden Eingangslisten, dann Falte Subtraktion ( -).

Dies könnte auch so geschrieben werden -sQsE, dass die Listen in zwei Zeilen erscheinen.

𝔼𝕊𝕄𝕚𝕟, 5 Zeichen / 7 Bytes

⨭î-⨭í

Try it here (Firefox only).

Wut.

Erläuterung

sum(input1) - sum(input2)

Common Lisp REPL, SBCL 28 24 Bytes

schreibe dies in REPL:

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

dann schreibe Eingabelisten wie diese:

(2 3 4)
(2 3)

Ich hoffe, es ist in Ordnung, ein solches Listenformat zu verwenden (anstelle von z. B. '(2 3 4)). Ich habe die Antwort von coredump als Formel für meine Lösung verwendet und dann seinen Berechnungseffekt auf eine andere Weise erzielt.

Erläuterung

Sei e_1,...,e_nElemente der ersten Liste und f_1,...,f_{n-1}seien Elemente der zweiten Liste. Wir wollen den Ausdruck auswerten. (-(+ e_1 e_2 ... e_n)f_1 f_2 ...f_{n-1}) Es würde bedeuten, Elemente der zweiten Liste von der Summe der Elemente der ersten Liste zu subtrahieren. Der benötigte Ausdruck ist folgendermaßen aufgebaut:

backqoute stoppt die Auswertung

#1= Spart ein bisschen Schreiben, Erinnern ,@(read)

,@ Stoppt die Effekte von backquote (damit (read) ausgewertet wird) und entfernt Elemente aus einer Liste.

(read) fragt nach Eingabe

#1# "lädt" Lisp-Objekt, das von gespeichert wurde #1=

#. Bewertung der gedruckten Darstellung eines Lisp-Objekts