La ley de Kirchhoff dice que cuando sumas todas las corrientes (positivas para las corrientes que van a un cruce, y negativas para la corriente que sale de un cruce), siempre obtendrás como resultado 0.

Mira el siguiente diagrama:

Usando la ley de Kirchhoff, puede ver que i1 + i4 - i2 - i3 = 0, entonces i1 + i4 = i2 + i3.

Dadas dos listas, una con todas las corrientes que entran en la unión y otra con todas las corrientes que salen de la unión, excepto una, emite la última.

Casos de prueba:

[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 segunda lista siempre tiene un elemento menos que la primera lista. La salida no puede ser negativa. El programa más pequeño gana.

Jalea, 2 bytes

_S

Pruébalo aquí!

Toma las corrientes entrantes en el primer argumento y las corrientes salientes en el segundo argumento. _los resta por pares, dejando el elemento individual de la lista más larga tal cual, y Ssuma el resultado.

Haskell, 14 bytes

(.sum).(-).sum

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

Suma cada lista y toma la diferencia.

CJam, 8 6 bytes

q~.-:+

La entrada usa dos matrices de estilo CJam.

Ejecute todos los casos de prueba. (Esto lee múltiples casos de prueba a la vez e incluye un marco para procesar cada línea individualmente, descartando el resultado esperado de la entrada).

Explicación

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

.-funciona de manera confiable porque estamos garantizados de que la primera lista siempre es más larga que la segunda. (De lo contrario, los elementos extraños de la segunda lista se agregarían al resultado que los agregaría a la suma en lugar de restarlos).

MATL , 3 4.0 bytes

_hs

Las entradas son: dejar las corrientes primero, luego ingresar las corrientes.

Pruébalo en línea!

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

Código:

OEO-

Explicación:

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

Gracias a Luis Mendo por recordarme que necesito implementar una función concatenada. Si lo hubiera implementado antes, habría sido de 3 bytes:

Versión no competitiva (3 bytes):

La primera lista es la lista actual que sale, la segunda es la lista actual entrante. Código:

(«O

Explicación:

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

Utiliza la codificación CP-1252.

Mathematica, 17 11 bytes

Tr@#-Tr@#2&

Bastante sencillo.

Lisp común, 40

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

Perl 6 , 11 bytes

*.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 bytes

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

o

Python 2, 19 bytes

print sum(a)-sum(b)

dependiendo de si debo imprimir el resultado o simplemente crear una función que lo devuelva.

ES6, 39 bytes

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

Debido a que quería utilizar reduceRight.

Python 2, 30 bytes

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

Pyth, 6 bytes

-.*sRQ

Explicación

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

Pruébalo aquí

K5, 5 bytes

-/+/'

Diferencia sobre ( -/) suma sobre ( +/) cada ( ').

En acción:

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

Pruébalo en línea. Banco de pruebas.

Map sum en ambas listas de entrada, luego Fresta antigua ( -).

Esto también podría escribirse como -sQsE, que toma las listas en dos líneas.

𝔼𝕊𝕄𝕚𝕟, 5 caracteres / 7 bytes

⨭î-⨭í

Try it here (Firefox only).

Wut

Explicación

sum(input1) - sum(input2)

Common Lisp REPL, SBCL 28 24 bytes

escribe esto en REPL:

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

luego escriba listas de entrada como esta:

(2 3 4)
(2 3)

Espero que esté bien usar ese formato de lista (en lugar de, por ejemplo '(2 3 4)). Utilicé la respuesta de coredump como fórmula para mi solución y luego logré su efecto de cálculo de una manera diferente.

Explicación

Dejar e_1,...,e_nser elementos de la primera lista y f_1,...,f_{n-1}ser elementos de la segunda lista. Queremos evaluar la expresión (-(+ e_1 e_2 ... e_n)f_1 f_2 ...f_{n-1}) Significaría restar elementos de la segunda lista de la suma de elementos de la primera lista. La expresión necesaria se construye así:

backqoute detiene la evaluación

#1= ahorra un poco de escritura, recordando ,@(read)

,@ detiene los efectos de la cita inversa (para que se evalúe (leer)) y elimina elementos de una lista.

(read) pide entrada

#1# "carga" el objeto Lisp guardado por #1=

#. evalúa la representación impresa de un objeto Lisp