Закон Кирхгофа гласит, что когда вы суммируете все токи (положительные для токов, идущих на соединение, и отрицательные для тока, выходящего из соединения), вы всегда получите 0.

Посмотрите на следующую диаграмму:

Используя закон Кирхгофа, вы можете видеть, что i1 + i4 - i2 - i3 = 0, поэтому i1 + i4 = i2 + i3.

Учитывая два списка, один со всеми токами, входящими в соединение, и один со всеми токами, выходящими из соединения, кроме одного, выведите последний.

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

Во втором списке всегда есть элемент меньше первого списка. Выход не может быть отрицательным. Самая маленькая программа выигрывает.

Желе, 2 байта

_S

Попробуй это здесь!

Принимает входящие токи в первом аргументе и уходящие токи во втором аргументе. _вычитает их попарно, оставляя один элемент из более длинного списка как есть, и Sсуммирует результат.

Haskell, 14 байтов

(.sum).(-).sum

Пример использования: ( (.sum).(-).sum ) [5,7,3,4,5,2] [8,4,5,2,1]-> 6.

Суммируйте каждый список и возьмите разницу.

CJam, 8 6 байтов

q~.-:+

Для ввода используются два массива в стиле CJam.

Запустите все тестовые случаи.(Это считывает несколько тестовых случаев одновременно и включает структуру для обработки каждой строки отдельно, отбрасывая ожидаемый результат от ввода.)

объяснение

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

.-работает надежно, потому что мы гарантируем, что первый список всегда длиннее второго. (В противном случае посторонние элементы второго списка будут добавлены к результату, который будет добавлять их к сумме, а не вычитать их.)

MATL , 3 4,0 байта

_hs

Входы: сначала выходя из токов, затем вводя токи.

Попробуйте онлайн!

_     % 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 байт

(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 байта

Код:

OEO-

Объяснение:

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

Благодаря Луису Мендо за напоминание, что мне нужно реализовать функцию сцепления. Если бы я реализовал это раньше, это было бы 3 байта:

Неконкурентная версия (3 байта):

Первый список - выходящий текущий список, второй - входящий текущий список. Код:

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

Использует кодировку CP-1252.

Mathematica, 17 11 байтов

Tr@#-Tr@#2&

Довольно просто.

Common Lisp, 40

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

Perl 6 , 11 байт

*.sum-*.sum

Использование:

# 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 байта

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

или

Python 2, 19 байт

print sum(a)-sum(b)

в зависимости от того, требуется ли мне напечатать результат или просто создать функцию, которая его возвращает.

ES6, 39 байт

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

Потому что я хотел использовать reduceRight.

Python 2, 30 байт

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

Pyth, 6 байт

-.*sRQ

объяснение

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

Попробуй здесь

К5, 5 байт

-/+/'

Разница по ( -/) сумме по ( +/) каждому ( ').

В бою:

  (-/+/')'((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 байт

-FsMQ

Попробуйте онлайн. Тестирование.

Mар sит на обоих входных списков, тоF старое вычитание (- ).

Это также можно записать как -sQsE, что занимает списки в две строки.

𝔼𝕊𝕄𝕚𝕟, 5 символов / 7 байтов

⨭î-⨭í

Try it here (Firefox only).

Wut.

объяснение

sum(input1) - sum(input2)

Common Lisp REPL, SBCL 28 24 байта

запишите это в REPL:

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

затем напишите списки ввода, как это:

(2 3 4)
(2 3)

Я надеюсь, что можно использовать такой формат списка (вместо, например '(2 3 4)), который я использовал ответ coredump качестве формулы для своего решения, а затем достиг его эффекта вычисления другим способом.

объяснение

Позвольте e_1,...,e_nбыть элементами первого списка и f_1,...,f_{n-1}быть элементами второго списка. Мы хотим оценить выражение(-(+ e_1 e_2 ... e_n)f_1 f_2 ...f_{n-1}) Это означало бы вычитание элементов второго списка из суммы элементов первого списка. Нужное выражение строится так:

обратная связь останавливает оценку

#1= экономит немного письма, помня ,@(read)

,@ останавливает эффекты обратной кавычки (так что (чтение) будет оцениваться) и удаляет элементы из списка.

(read) просит ввода

#1# "загружает" объект Lisp, сохраненный #1=

#. выполняет оценку печатного представления объекта Lisp