Định luật Kirchhoff nói rằng khi bạn tổng hợp tất cả các dòng điện (dương cho dòng điện đi đến một ngã ba và âm cho dòng điện rời khỏi một ngã ba), bạn sẽ luôn nhận được kết quả là 0.

Nhìn vào sơ đồ sau:

Sử dụng định luật Kirchhoff, bạn có thể thấy rằng i1 + i4 - i2 - i3 = 0, vì vậy i1 + i4 = i2 + i3.

Đưa ra hai danh sách, một danh sách có tất cả các dòng điện đi vào đường giao nhau và một danh sách có tất cả các dòng điện rời khỏi điểm nối ngoại trừ một danh sách, xuất ra dòng cuối cùng.

Testcase:

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

Danh sách thứ hai luôn có một mục ít hơn danh sách đầu tiên. Đầu ra không thể âm. Chương trình nhỏ nhất chiến thắng.

Thạch, 2 byte

_S

Hãy thử nó ở đây!

Đưa các dòng vào trong đối số thứ nhất và các dòng còn lại trong đối số thứ hai. _trừ chúng theo cặp, để lại phần tử duy nhất từ ​​danh sách dài hơn và tính Stổng kết quả.

Haskell, 14 byte

(.sum).(-).sum

Ví dụ sử dụng: ( (.sum).(-).sum ) [5,7,3,4,5,2] [8,4,5,2,1]-> 6.

Tính tổng mỗi danh sách và lấy sự khác biệt.

CJam, 8 6 byte

q~.-:+

Đầu vào sử dụng hai mảng kiểu CJam.

Chạy tất cả các trường hợp thử nghiệm. (Điều này đọc nhiều trường hợp thử nghiệm cùng một lúc và bao gồm một khung để xử lý từng dòng riêng lẻ, loại bỏ kết quả mong đợi từ đầu vào.)

Giải trình

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

.-hoạt động đáng tin cậy bởi vì chúng tôi đảm bảo rằng danh sách đầu tiên luôn dài hơn danh sách thứ hai. (Mặt khác, các phần tử không liên quan của danh sách thứ hai sẽ được thêm vào kết quả sẽ thêm chúng vào tổng thay vì trừ chúng.)

MATL , 3 byte 4.0

_hs

Đầu vào là: để lại dòng điện trước, sau đó nhập dòng điện.

Hãy thử trực tuyến!

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

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

Mã số:

OEO-

Giải trình:

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

Cảm ơn Luis Mendo nhắc nhở tôi rằng tôi cần thực hiện chức năng nối. Nếu tôi đã thực hiện nó sớm hơn, nó sẽ có 3 byte:

Phiên bản không cạnh tranh (3 byte):

Danh sách đầu tiên là danh sách hiện tại rời khỏi, danh sách thứ hai là danh sách hiện tại. Mã số:

(«O

Giải trình:

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

Sử dụng mã hóa CP-1252.

Toán học, 17 11 byte

Tr@#-Tr@#2&

Khá đơn giản.

Lisp thường gặp, 40

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

Perl 6 , 11 byte

*.sum-*.sum

Sử dụng:

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

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

hoặc là

Python 2, 19 byte

print sum(a)-sum(b)

tùy thuộc vào việc tôi bắt buộc phải in kết quả hay chỉ cần tạo một hàm trả về nó.

ES6, 39 byte

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

Bởi vì tôi muốn sử dụng reduceRight.

Python 2, 30 byte

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

Bình thường, 6 byte

-.*sRQ

Giải trình

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

Hãy thử nó ở đây

K5, 5 byte

-/+/'

Sự khác biệt so với ( -/) tổng trên ( +/) mỗi ( ').

Trong hành động:

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

Bình thường, 5 byte

-FsMQ

Hãy thử trực tuyến. Bộ thử nghiệm.

Map sum trên cả hai danh sách đầu vào, sau đó Ftrừ- ).

Điều này cũng có thể được viết là -sQsE, trong đó có danh sách trên hai dòng.

, 5 ký tự / 7 byte

⨭î-⨭í

Try it here (Firefox only).

Wut.

Giải trình

sum(input1) - sum(input2)

REPL thường gặp, SBCL 28 24 byte

viết cái này vào REPL:

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

sau đó viết danh sách đầu vào như thế này:

(2 3 4)
(2 3)

Tôi hy vọng sẽ ổn khi sử dụng định dạng danh sách như vậy (thay vì ví dụ '(2 3 4)) Tôi đã sử dụng câu trả lời của coredump làm công thức cho giải pháp của mình và sau đó đạt được hiệu quả tính toán của anh ấy theo một cách khác.

Giải trình

Hãy e_1,...,e_nlà các yếu tố của danh sách đầu tiên và f_1,...,f_{n-1}là các yếu tố của danh sách thứ hai. Chúng tôi muốn đánh giá biểu thức (-(+ e_1 e_2 ... e_n)f_1 f_2 ...f_{n-1}) Nó có nghĩa là trừ các phần tử của danh sách thứ hai khỏi tổng các phần tử của danh sách đầu tiên. Biểu thức cần thiết được xây dựng như vậy:

backqoute dừng đánh giá

#1= tiết kiệm một chút của việc viết, ghi nhớ ,@(read)

,@ dừng các hiệu ứng của backquote (để (đánh giá) sẽ được đánh giá) và đưa các yếu tố ra khỏi danh sách.

(read) yêu cầu đầu vào

#1# "tải" đối tượng Lisp được lưu bởi #1=

#. không đánh giá đại diện in của một đối tượng Lisp