A lei de Kirchhoff diz que, quando você soma todas as correntes (positivas para as correntes que vão para uma junção e negativas para as correntes que saem de uma junção), você sempre obtém o resultado 0.

Veja o seguinte diagrama:

Usando a lei de Kirchhoff, você pode ver que i1 + i4 - i2 - i3 = 0, então i1 + i4 = i2 + i3.

Dadas duas listas, uma com todas as correntes entrando na junção e outra com todas as correntes saindo da junção, exceto uma, produz a última.

Casos de teste:

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

A segunda lista sempre tem um item a menos que a primeira lista. A saída não pode ser negativa. O menor programa vence.

Gelatina, 2 bytes

_S

Experimente aqui!

Leva as correntes de entrada no primeiro argumento e as correntes de saída no segundo argumento. _subtrai-os aos pares, deixando o elemento único da lista maior como está e Ssoma o resultado.

Haskell, 14 bytes

(.sum).(-).sum

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

Resuma cada lista e faça a diferença.

CJam, 8 6 bytes

q~.-:+

A entrada usa duas matrizes no estilo CJam.

Execute todos os casos de teste. (Ele lê vários casos de teste de uma só vez e inclui uma estrutura para processar cada linha individualmente, descartando o resultado esperado da entrada.)

Explicação

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

.-funciona de maneira confiável, porque garantimos que a primeira lista é sempre maior que a segunda. (Caso contrário, os elementos estranhos da segunda lista seriam anexados ao resultado que os adicionaria à soma em vez de subtraí-los.)

MATL , 3 4,0 bytes

_hs

As entradas são: deixando as correntes primeiro e depois inserindo as correntes.

Experimente 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

Código:

OEO-

Explicação:

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

Agradecimentos a Luis Mendo por me lembrar que eu preciso implementar uma função concatenada. Se eu o tivesse implementado mais cedo, seriam 3 bytes:

Versão não concorrente (3 bytes):

A primeira lista é a lista atual que sai, a segunda é a lista atual que entra. Código:

(«O

Explicação:

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

Usa a codificação CP-1252.

Mathematica, 17 11 bytes

Tr@#-Tr@#2&

Bem simples.

Lisp comum, 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)

ou

Python 2, 19 bytes

print sum(a)-sum(b)

dependendo se for necessário imprimir o resultado ou apenas criar uma função que o retorne.

ES6, 39 bytes

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

Porque eu queria usar reduceRight.

Python 2, 30 bytes

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

Pitão, 6 bytes

-.*sRQ

Explicação

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

Experimente aqui

K5, 5 bytes

-/+/'

Diferença sobre ( -/) soma sobre ( +/) cada ( ').

Em ação:

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

Pitão, 5 bytes

-FsMQ

Experimente online. Suíte de teste.

Map shum em ambas as listas de entrada, em seguida, Fa subtração de idade ( -).

Isso também pode ser escrito como -sQsE, que leva as listas em duas linhas.

, 5 caracteres / 7 bytes

⨭î-⨭í

Try it here (Firefox only).

Que.

Explicação

sum(input1) - sum(input2)

Lisp REPL comum, SBCL 28 24 bytes

escreva isso no REPL:

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

escreva listas de entrada como estas:

(2 3 4)
(2 3)

Espero que esteja tudo bem em usar esse formato de lista (em vez de, por exemplo '(2 3 4)). Usei a resposta de coredump como fórmula para minha solução e, em seguida, alcancei seu efeito de cálculo de uma maneira diferente.

Explicação

Let e_1,...,e_nSer elementos da primeira lista e f_1,...,f_{n-1}ser elementos da segunda lista. Queremos avaliar a expressão(-(+ e_1 e_2 ... e_n)f_1 f_2 ...f_{n-1}) Significaria subtrair elementos da segunda lista da soma dos elementos da primeira lista. A expressão necessária é construída da seguinte maneira:

backqoute interrompe a avaliação

#1= economiza um pouco de escrita, lembrando ,@(read)

,@ interrompe os efeitos da cotação posterior (para que (leitura) seja avaliada) e retira elementos de uma lista.

(read) pede entrada

#1# "carrega" o objeto Lisp salvo por #1=

#. faz avaliação da representação impressa de um objeto Lisp