Kirchhoff yasası , tüm akımları (bir kavşağa giden akımlar için pozitif ve bir kavşaktan ayrılan akım için negatif) topladığınızda her zaman sonuç olarak 0 alacağınızı söylüyor.

Aşağıdaki şemaya bakın:

Kirchhoff yasasını kullanarak, i1 + i4 - i2 - i3 = 0, yani i1 + i4 = i2 + i3 olduğunu görebilirsiniz.

Biri hariç tüm akımların kavşağa girdiği iki liste ve biri hariç tüm akımların kavşaktan çıktığı iki liste verilir.

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

İkinci listede her zaman ilk listeden bir öğe daha az bulunur. Çıktı negatif olamaz. En küçük program kazanır.

Jöle, 2 bayt

_S

Burada deneyin!

Birinci argümandaki giriş akımlarını ve ikinci argümandaki çıkış akımlarını alır. _tek bir öğeyi daha uzun listeden olduğu gibi bırakarak çift olarak çıkarır Sve sonucu toplar.

Haskell, 14 bayt

(.sum).(-).sum

Kullanım örneği: ( (.sum).(-).sum ) [5,7,3,4,5,2] [8,4,5,2,1]-> 6.

Her listeyi toplayın ve farkı alın.

CJam, 8 6 bayt

q~.-:+

Giriş, iki CJam tarzı dizi kullanır.

Tüm test senaryolarını çalıştırın. (Bu aynı anda birden fazla test durumunu okur ve girişten beklenen sonucu atarak her satırı ayrı ayrı işlemek için bir çerçeve içerir.)

açıklama

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

.-İlk listenin her zaman ikinciden daha uzun olduğu garanti edildiğinden güvenilir şekilde çalışır. (Aksi takdirde, ikinci listenin yabancı unsurları, sonuca çıkarılmak yerine toplamaya eklenecek sonuca eklenir.)

MATL , 3 4,0 bayt

_hs

Girişler şunlardır: önce akımları bırakmak, sonra akımları girmek.

Çevrimiçi deneyin!

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

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

Kod:

OEO-

Açıklama:

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

Luis Mendo'ya birleştirilmiş bir işlev uygulamam gerektiğini hatırlattığı için teşekkürler . Daha erken uygulasaydım, 3 bayt olurdu:

Rakip olmayan sürüm (3 bayt):

İlk liste geçerli listeden ayrılırken, ikinci liste geçerli listeden girilir. Kod:

(«O

Açıklama:

(    # 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 kodlamasını kullanır.

Mathematica, 17 11 bayt

Tr@#-Tr@#2&

Oldukça basit.

Ortak Lisp, 40

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

Perl 6 , 11 bayt

*.sum-*.sum

Kullanımı:

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

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

veya

Python 2, 19 bayt

print sum(a)-sum(b)

Sonucu yazdırmam veya yalnızca döndüren bir işlev oluşturmam gerekip gerekmediğine bağlı olarak.

ES6, 39 bayt

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

Çünkü kullanmak istedim reduceRight.

Python 2, 30 bayt

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

Pyth, 6 bayt

-.*sRQ

açıklama

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

Burada deneyin

K5, 5 bayt

-/+/'

( -/) Üzerindeki fark ( ) toplamı ( +/)' ) .

Eylemde:

  (-/+/')'((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 bayt

-FsMQ

Çevrimiçi deneyin. Test odası.

MsHer iki giriş listesindeki ap um, ardından Feski çıkarma (- ).

Bu -sQsE, listeleri iki satırdan alan şu şekilde de yazılabilir .

𝔼𝕊𝕄𝕚𝕟, 5 karakter / 7 bayt

⨭î-⨭í

Try it here (Firefox only).

Wut.

açıklama

sum(input1) - sum(input2)

Ortak Lisp REPL, SBCL 28 24 bayt

bunu REPL'e yaz:

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

daha sonra şöyle bir girdi listesi yazın:

(2 3 4)
(2 3)

Umarım böyle bir liste formatını kullanmanın bir sakıncası yoktur (örneğin '(2 3 4)) coredump'ın cevabını kullandım formül olarak ve daha sonra hesaplama etkisini farklı bir şekilde elde ettim.

açıklama

Izin vermek e_1,...,e_nilk listenin f_1,...,f_{n-1}elemanları ve ikinci listenin elemanları olsun. İfadeyi değerlendirmek istiyoruz(-(+ e_1 e_2 ... e_n)f_1 f_2 ...f_{n-1}) Bu, ikinci listenin öğelerini ilk listenin öğelerinin toplamından çıkarmak anlamına gelir. Gerekli ifade şöyle yapılandırılmıştır:

backqoute değerlendirmeyi durdurur

#1= hatırlamak, biraz yazı yazmak ,@(read)

,@ backquote'un etkilerini durdurur (böylece (okuma) değerlendirilir) ve öğeleri listeden çıkarır.

(read) giriş ister

#1# tarafından kaydedilen Lisp nesnesini "yükler" #1=

#. Lisp nesnesinin basılı temsilini değerlendirir