La legge di Kirchhoff dice che quando sommi tutte le correnti (positive per le correnti che vanno a una giunzione e negative per la corrente che lascia una giunzione), otterrai sempre come risultato 0.

Guarda il diagramma seguente:

Usando la legge di Kirchhoff, puoi vedere che i1 + i4 - i2 - i3 = 0, quindi i1 + i4 = i2 + i3.

Dati due elenchi, uno con tutte le correnti che entrano nella giunzione e uno con tutte le correnti che lasciano la giunzione tranne una, producono l'ultima.

Casi test:

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

Il secondo elenco ha sempre un elemento in meno rispetto al primo elenco. L'output non può essere negativo. Vince il programma più piccolo.

Gelatina, 2 byte

_S

Provalo qui!

Prende le correnti di entrata nel primo argomento e le correnti di uscita nel secondo argomento. _li sottrae in modo accoppiato, lasciando il singolo elemento dall'elenco più lungo così com'è e Ssomma il risultato.

Haskell, 14 byte

(.sum).(-).sum

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

Somma ogni elenco e prendi la differenza.

CJam, 8 6 byte

q~.-:+

L'input utilizza due array in stile CJam.

Esegui tutti i casi di test. (Questo legge più casi di test contemporaneamente e include un framework per elaborare ciascuna riga singolarmente, scartando il risultato atteso dall'input.)

Spiegazione

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

.-funziona in modo affidabile perché siamo certi che il primo elenco è sempre più lungo del secondo. (Altrimenti, gli elementi estranei del secondo elenco verrebbero aggiunti al risultato che li aggiungerebbe alla somma invece di sottrarli.)

MATL , 3 4.0 byte

_hs

Gli input sono: lasciare prima le correnti, quindi inserire le correnti.

Provalo 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 byte

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

Codice:

OEO-

Spiegazione:

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

Grazie a Luis Mendo per avermi ricordato che ho bisogno di implementare una funzione concatenata. Se l'avessi implementato prima, sarebbe stato di 3 byte:

Versione non competitiva (3 byte):

Il primo elenco è l'elenco corrente in uscita, il secondo è l'elenco corrente in entrata. Codice:

(«O

Spiegazione:

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

Utilizza la codifica CP-1252.

Mathematica, 17 11 byte

Tr@#-Tr@#2&

Abbastanza semplice.

Lisp comune, 40

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

Perl 6 , 11 byte

*.sum-*.sum

Uso:

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

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

o

Python 2, 19 byte

print sum(a)-sum(b)

a seconda che mi venga richiesto di stampare il risultato o semplicemente creare una funzione che lo restituisca.

ES6, 39 byte

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

Perché volevo usare reduceRight.

Python 2, 30 byte

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

Pyth, 6 byte

-.*sRQ

Spiegazione

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

Provalo qui

K5, 5 byte

-/+/'

Differenza su ( -/) somma su (+/ ) ciascuno ( ').

In azione:

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

-FsMQ

Provalo online. Suite di test.

Map sum su entrambi gli elenchi di input, quindi Fvecchia sottrazione (- ).

Questo potrebbe anche essere scritto come -sQsE, che prende gli elenchi su due righe.

𝔼𝕊𝕄𝕚𝕟, 5 caratteri / 7 byte

⨭î-⨭í

Try it here (Firefox only).

Wut.

Spiegazione

sum(input1) - sum(input2)

Common Lisp REPL, SBCL 28 24 byte

scrivere questo in REPL:

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

quindi scrivere elenchi di input in questo modo:

(2 3 4)
(2 3)

Spero che vada bene usare questo formato di elenco (anziché ad esempio '(2 3 4)) che ho usato vada la risposta di coredump come formula per la mia soluzione e poi ho ottenuto il suo effetto di calcolo in modo diverso.

Spiegazione

Sia e_1,...,e_nelementi del primo elenco e f_1,...,f_{n-1}sia elementi del secondo elenco. Vogliamo valutare l'espressione(-(+ e_1 e_2 ... e_n)f_1 f_2 ...f_{n-1}) Significherebbe sottrarre elementi della seconda lista dalla somma degli elementi della prima lista. L'espressione necessaria è costruita in questo modo:

backqoute interrompe la valutazione

#1= salva un po 'di scrittura, ricordando ,@(read)

,@ interrompe gli effetti del backquote (in modo che (leggi) vengano valutati) e estrae gli elementi da un elenco.

(read) chiede input

#1# "carica" ​​l'oggetto Lisp salvato da #1=

#. fa la valutazione della rappresentazione stampata di un oggetto Lisp