किरचॉफ का नियम लागू करें

Question

किरचॉफ का नियम कहता है कि जब आप सभी धाराओं (एक जंक्शन पर जाने वाली धाराओं के लिए सकारात्मक, और वर्तमान में जंक्शन छोड़ने के लिए नकारात्मक) को जोड़ते हैं, तो आपको हमेशा परिणाम 0 मिलेगा।

निम्नलिखित चित्र देखें:

किरचॉफ के नियम का उपयोग करते हुए, आप देख सकते हैं कि i1 + i4 - i2 - i3 = 0, इसलिए i1 + i4 = i2 + i3।

दो सूचियों को देखते हुए, जंक्शन में प्रवेश करने वाली सभी धाराओं के साथ एक और जंक्शन को छोड़कर सभी धाराओं के साथ एक, पिछले एक को आउटपुट करता है।

परीक्षण के मामलों:

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

दूसरी सूची में हमेशा पहली सूची से एक आइटम कम होता है। आउटपुट नकारात्मक नहीं हो सकता। सबसे छोटा कार्यक्रम जीत जाता है।

Comments

यदि आप वास्तविक रूप से अवरोधक और वर्तमान मान देते हैं तो पहेली बेहतर होती। ऐसा क्यू लगता है जैसे आपने कानून को केवल एक नाम के रूप में पेश किया है। (Q को कानून के बिना आसानी से कहा जा सकता था)

— भूत_____कोड

किरचॉफ का वर्तमान कानून

— लुइस मेंडो

संबंधित ।

— स्टिव ग्रिफ़िन

क्या आप निर्दिष्ट कर सकते हैं कि हम केवल एक फ़ंक्शन बना सकते हैं जो परिणाम देता है या वास्तव में परिणाम प्रिंट / वापस करता है।

— tpvasconcelos

Answer 1

जेली, 2 बाइट्स

_S

यहाँ यह कोशिश करो!

पहले तर्क में प्रवेश करने वाली धाराएँ लेता है, और दूसरे तर्क में धाराएँ छोड़ता है। _लम्बी सूची से एकल तत्व को छोड़ते हुए, उन्हें जोड़ीदार रूप में घटाता है और Sपरिणाम को बताता है।

Answer 2

हास्केल, 14 बाइट्स

(.sum).(-).sum

प्रयोग उदाहरण: ( (.sum).(-).sum ) [5,7,3,4,5,2] [8,4,5,2,1]-> 6।

प्रत्येक सूची में योग करें और अंतर लें।

Answer 3

सीजाम, 8 6 बाइट्स

q~.-:+

इनपुट दो CJam शैली सरणियों का उपयोग करता है।

सभी परीक्षण मामलों को चलाएं। (यह एक ही बार में कई परीक्षण मामलों को पढ़ता है और व्यक्तिगत रूप से इनपुट से अपेक्षित परिणाम को त्यागते हुए प्रत्येक पंक्ति को व्यक्तिगत रूप से संसाधित करने के लिए एक रूपरेखा शामिल करता है।)

व्याख्या

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

.-मज़बूती से काम करता है क्योंकि हम गारंटी देते हैं कि पहली सूची हमेशा दूसरे से अधिक लंबी होती है। (अन्यथा, दूसरी सूची के बाहरी तत्वों को परिणाम में जोड़ दिया जाएगा जो उन्हें घटाना करने के बजाय योग में जोड़ देगा।)

Comments

बिल्कुल 80k पर बधाई!

— ETHproductions

Answer 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

Comments

मेरा एक ही समाधान, लेकिन विभिन्न अक्षरों के साथ haha, +1

— अदनान

@ अदनान मैंने देखा! (पहले से ही)

— लुइस मेंडो

@ अदनान मैं 3 बाइट्स घटाकर इनपुट ऑर्डर बदल रहा हूं और दोनों सरणियों को मिला रहा हूं। हो सकता है कि आपके उत्तर पर भी लागू किया जा सकता है?

— लुइस मेन्डो

आह, मुझे वास्तव में एक संक्षिप्त समारोह लागू करना चाहिए: पी। बहुत अच्छा जवाब! :)

— अदनान

Answer 5

जावास्क्रिप्ट, 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>'

Answer 6

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 एन्कोडिंग का उपयोग करता है।

Answer 7

मेथेमेटिका, 17 11 बाइट्स

Tr@#-Tr@#2&

काफी सरल।

Answer 8

आम लिस्प, 40

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

Answer 9

पर्ल 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

Answer 10

पायथन 3, 24 बाइट्स

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

या

पायथन 2, 19 बाइट्स

print sum(a)-sum(b)

निर्भर करता है कि क्या मुझे परिणाम प्रिंट करना है या केवल एक फ़ंक्शन बनाना है जो इसे लौटाता है।

Answer 11

ईएस 6, 39 बाइट्स

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

क्योंकि मैं उपयोग करना चाहता था reduceRight।

Answer 12

पायथन 2, 30 बाइट्स

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

Answer 13

अजगर, 6 बाइट्स

-.*sRQ

व्याख्या

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

इसे यहाँ आज़माएँ

Answer 14

K5, 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

Answer 15

अजगर, 5 बाइट्स

-FsMQ

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

Mएपी sum दोनों इनपुट सूचियों पर, फिर Fपुराना घटाव ( -)।

यह भी लिखा जा सकता है -sQsE, जो दो लाइनों पर सूचियों को लेता है।

Answer 16

S, 5 चार्ट / 7 बाइट्स

⨭î-⨭í

Try it here (Firefox only).

Wut।

व्याख्या

sum(input1) - sum(input2)

Answer 17

आम लिस्प 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}) इसका मतलब पहली सूची के तत्वों के योग से दूसरी सूची के तत्वों को घटाना होगा। आवश्यक अभिव्यक्ति का निर्माण इस तरह किया गया है:

backqoute मूल्यांकन बंद कर देता है

#1= याद रखने से थोड़ा सा बच जाता है ,@(read)

,@ बैककौट के प्रभावों को रोकता है (ताकि (पढ़ें) का मूल्यांकन किया जाएगा) और तत्वों को एक सूची से बाहर ले जाता है।

(read) इनपुट के लिए पूछता है

#1# "लोड" लिस्प ऑब्जेक्ट द्वारा सहेजा गया #1=

#. एक लिस्प वस्तु के मुद्रित प्रतिनिधित्व का मूल्यांकन करता है