Применить закон Кирхгофа

15

Закон Кирхгофа гласит, что когда вы суммируете все токи (положительные для токов, идущих на соединение, и отрицательные для тока, выходящего из соединения), вы всегда получите 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

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

Шестьдесят шесть
источник
1
Головоломка была бы лучше, если бы вы указали значения резистора и тока. Этот вопрос кажется, что вы ввели закон так же, как тезка. (Вопрос легко можно было сформулировать без закона)
ghosts_in_the_code
5
Кирхгофа ток закон
Луис Mendo
Относящиеся .
Стьюи Гриффин
Можете ли вы указать, что мы можем просто создать функцию, которая возвращает результат, или фактически напечатать / вернуть результат.
tpvasconcelos

Ответы:

14

Желе, 2 байта

_S

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

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

Линн
источник
9

Haskell, 14 байтов

(.sum).(-).sum

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

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

Ними
источник
5

CJam, 8 6 байтов

q~.-:+

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

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

объяснение

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

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

Мартин Эндер
источник
1
Поздравляю ровно на 80к!
ETHproductions
4

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
Луис Мендо
источник
Точно такое же решение, как и у меня, но с разными буквами, ха-ха, +1
Аднан,
@ Аднан, я видел! (+1 уже)
Луис Мендо
@Adnan Я уменьшил до 3 байтов, изменив порядок ввода и объединив оба массива. Может быть, это применимо и к вашему ответу?
Луис Мендо
Аааа, я действительно должен реализовать объединенную функцию: с. Очень хороший ответ! :)
Аднан
3

Javascript, 36 байт

(a,b)=>eval(a.join`+`+'-'+b.join`-`)

удален
источник
3

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.

Аднан
источник
2

Mathematica, 17 11 байтов

Tr@#-Tr@#2&

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

LegionMammal978
источник
2

Common Lisp, 40

(lambda(x y)(-(reduce'+ x)(reduce'+ y)))
CoreDump
источник
2

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
Брэд Гилберт b2gills
источник
2

Python 3, 24 байта

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

или

Python 2, 19 байт

print sum(a)-sum(b)

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

tpvasconcelos
источник
1

ES6, 39 байт

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

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

Нил
источник
1

К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
Johne
источник
0

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


источник