Prawo Kirchhoffa mówi, że jeśli zsumujesz wszystkie prądy (dodatnie dla prądów zmierzających do skrzyżowania i ujemne dla prądu opuszczającego skrzyżowanie), zawsze otrzymasz wynik 0.

Spójrz na następujący schemat:

Korzystając z prawa Kirchhoffa, możesz zobaczyć, że i1 + i4 - i2 - i3 = 0, więc i1 + i4 = i2 + i3.

Biorąc pod uwagę dwie listy, jedną ze wszystkimi prądami wchodzącymi do skrzyżowania i jedną ze wszystkimi prądami opuszczającymi węzeł oprócz jednej, wysyłamy ostatnią.

Przypadki testowe:

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

Druga lista zawsze zawiera jeden element mniej niż pierwsza lista. Wynik nie może być ujemny. Najmniejszy program wygrywa.

Galaretka, 2 bajty

_S

Wypróbuj tutaj!

Bierze prądy wejściowe w pierwszym argumencie, a prądy wyjściowe w drugim argumencie. _odejmuje je parami, pozostawiając pojedynczy element z dłuższej listy w niezmienionej postaci i Ssumuje wynik.

Haskell, 14 bajtów

(.sum).(-).sum

Przykład użycia: ( (.sum).(-).sum ) [5,7,3,4,5,2] [8,4,5,2,1]-> 6.

Zsumuj każdą listę i weź różnicę.

CJam, 8 6 bajtów

q~.-:+

Wejście wykorzystuje dwie tablice w stylu CJam.

Uruchom wszystkie przypadki testowe. (Odczytuje to jednocześnie wiele przypadków testowych i zawiera strukturę do przetwarzania każdej linii osobno, odrzucając oczekiwany wynik z danych wejściowych.)

Wyjaśnienie

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

.-działa niezawodnie, ponieważ mamy gwarancję, że pierwsza lista jest zawsze dłuższa niż druga. (W przeciwnym razie obce elementy drugiej listy zostałyby dołączone do wyniku, który dodałby je do sumy zamiast odejmować.)

MATL , 3 4,0 bajty

_hs

Wejścia to: najpierw pozostawienie prądów, a następnie wprowadzenie prądów.

Wypróbuj 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 bajtów

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

Kod:

OEO-

Wyjaśnienie:

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

Podziękowania dla Luisa Mendo za przypomnienie, że muszę zaimplementować funkcję konkatenacji. Gdybym go wcześniej wdrożył, byłyby to 3 bajty:

Wersja niekonkurencyjna (3 bajty):

Pierwsza lista to pozostawiając bieżącą listę, druga to wejście do bieżącej listy. Kod:

(«O

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252.

Mathematica, 17 11 bajtów

Tr@#-Tr@#2&

Całkiem proste.

Common Lisp, 40

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

Perl 6 , 11 bajtów

*.sum-*.sum

Stosowanie:

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

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

lub

Python 2, 19 bajtów

print sum(a)-sum(b)

w zależności od tego, czy mam wydrukować wynik, czy po prostu utworzyć funkcję, która go zwraca.

ES6, 39 bajtów

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

Ponieważ chciałem użyć reduceRight.

Python 2, 30 bajtów

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

Pyth, 6 bajtów

-.*sRQ

Wyjaśnienie

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

Wypróbuj tutaj

K5, 5 bajtów

-/+/'

Różnica w stosunku do ( -/) sumy w stosunku do ( +/) każdego (' ).

W akcji:

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

-FsMQ

Wypróbuj online. Zestaw testowy.

Map sna obu listach wejściowych, a następnie Fstare odejmowanie ( -).

Można to również napisać jako -sQsE, który prowadzi listy w dwóch wierszach.

𝔼𝕊𝕄𝕚𝕟, 5 znaków / 7 bajtów

⨭î-⨭í

Try it here (Firefox only).

Wut

Wyjaśnienie

sum(input1) - sum(input2)

Common Lisp REPL, SBCL 28 24 bajty

napisz to do REPL:

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

następnie napisz takie listy wejściowe:

(2 3 4)
(2 3)

Mam nadzieję, że można użyć takiego formatu listy (zamiast np. '(2 3 4)) Użyłem odpowiedzi Coredumpa jako wzoru dla mojego rozwiązania, a następnie uzyskałem efekt obliczeniowy w inny sposób.

Wyjaśnienie

Niech e_1,...,e_nbędą elementami pierwszej listy i f_1,...,f_{n-1}będą elementami drugiej listy. Chcemy ocenić wyrażenie (-(+ e_1 e_2 ... e_n)f_1 f_2 ...f_{n-1}) Oznaczałoby to odjęcie elementów drugiej listy od sumy elementów pierwszej listy. Potrzebne wyrażenie jest zbudowane w następujący sposób:

backqoute zatrzymuje ocenę

#1= oszczędza trochę pisania, zapamiętywania ,@(read)

,@ zatrzymuje efekty cudzysłowu (tak, że (odczyt) zostanie oceniony) i usuwa elementy z listy.

(read) prosi o dane wejściowe

#1# „ładuje” obiekt Lisp zapisany przez #1=

#. dokonuje oceny wydrukowanej reprezentacji obiektu Lisp