इनपुट करने के लिए एक अव्यवस्थित सूची से दो पूर्णांक खोजें

Question

यह एक Google साक्षात्कार प्रश्न है, यहां एक यूट्यूब लिंक के लिए देखें।

काम:

किसी अनियंत्रित सूची से 2 पूर्णांक प्राप्त करें जो किसी पूर्णांक को योग करता है।

1. पूर्णांकों की एक अव्यवस्थित सूची को देखते हुए, 2 पूर्णांकों को खोजें, जो किसी दिए गए मान को जोड़ते हैं, इन 2 पूर्णांकों को प्रिंट करें, और सफलता का संकेत दें (बाहर निकलें 0)। उन्हें किसी विशेष संख्या (यानी पहले 2 पूर्णांक सही संख्या में सम्‍मिलित होने की जरूरत नहीं है), कोई भी जोड़ी जो मान के लिए काम करती है।
2. पूर्णांक धनात्मक है और शून्य से अधिक है।
3. पूर्णांक की एक सूची किसी भी डेटा संरचना में हो सकती है जिसमें पूर्णांक की एक फ़ाइल शामिल है - प्रति पंक्ति एक पूर्णांक।
4. यदि कोई पूर्णांक नहीं मिल सकता है, तो विफलता का संकेत दें (निकास 1)।
5. सूची में विभिन्न पदों पर दो पूर्णांकों को लौटाया जाना चाहिए। (यानी आप एक ही स्थिति से एक ही नंबर को दो बार नहीं लौटा सकते)

(नोट: वीडियो में, ये वास्तव में आवश्यकताएं नहीं हैं। 'साक्षात्कारकर्ता' ने अपने कई बार बदल दिए।)

जैसे।

sum2 8 <<EOF
1
7
4
6
5
3
8
2
EOF

प्रिंट 3और 5निकास स्थिति 0. नोट है कि इसमें भी 1,7और 2,6परिणाम की अनुमति दी जाएगी।

sum2 8 <<EOF
1
2
3
4

कोई संभावित कॉम्बो के बाद से स्थिति से बाहर निकलें 1। 4,4नियम 5 के अनुसार अनुमति नहीं है।

Comments

यह एक बड़ा सवाल हो सकता है अगर पहले सैंडबॉक्स में कुछ ढीले सिरों को हिलाने का मौका होता । उदाहरण के लिए, इस तरह के कुछ के लिए मैं एक फ़ंक्शन लिखने की उम्मीद करूंगा जो या तो गलत मूल्य या संख्याओं की एक जोड़ी लौटाए।

— नील

उदाहरण में, लौटी हुई जोड़ी क्यों है (3,5) और नहीं (1,7)?

— रॉड

एक अनियंत्रित सूची में "पहली" जोड़ी कैसे हो सकती है? यह स्वाभाविक रूप से आत्म-विरोधाभासी है।

— पीटर टेलर

मुझे नहीं लगता कि बाहर निकलना 0 / बाहर निकलें 1 बात एक अच्छा विचार है। कई भाषाएं इस तरह आसानी से मौजूद नहीं हो सकती हैं, और यह आम तौर पर एक त्रुटि के साथ बाहर निकलने की अनुमति है (यानी STDERR को नजरअंदाज करें) कई गोल्फिंग भाषाओं को बाहर निकलने का एक आसान तरीका भी नहीं है जो मुझे लगता है

— R like

दूसरे विचार पर, कुछ उत्तर एक्ज़िट कोड 1 का निर्माण करने के कुछ प्रयासों से गुजरे हैं, इसलिए बेहतर हो सकता है कि अब आवश्यकताओं को न बदला जाए

— लुइस मेंडो

Answer 1

बैश, 84 बाइट्स

मेरा (लगभग) Google के इंजीनियर के समाधान का कार्यान्वयन लेकिन बैश और एक इनपुट स्ट्रीम का उपयोग करना - मेरा समाधान नहीं है, इसलिए यह गणना नहीं करता है।

while read V;do((V<$1))&&{ ((T=R[V]))&&echo $T $V&&exit;((R[$1-V]=V));};done;exit 1

तरीका

जबकि हम पूर्णांक V को इनपुट स्ट्रीम से पढ़ सकते हैं यदि लक्ष्य $ 1 से कम है तो यदि पहले से ही $ 1-V दिखाई देता है तो $ 1-V और V प्रिंट करें और 0 (और) इनपुट $ 1-V से बाहर निकलने के लिए उम्मीदवार को सहेजें 1

Answer 2

ब्रेकीलॉग , 9 बाइट्स

h⊇Ċ.+~t?∧

इसे ऑनलाइन आज़माएं!

यह मानते हुए कि मैंने चुनौती को सही ढंग से समझा है ...

व्याख्या

h⊇Ċ          Ċ ('couple') has two elements, and is a subset of the head of the input
  Ċ.         Output = Ċ
   .+~t?     The sum of the elements of the Output is the tail of the Input
        ∧    (disable implicit unification)

Answer 3

पर्ल 6 , 59 बाइट्स

$_=get;put lines().combinations(2).first(*.sum==$_)//exit 1

इसे आज़माएं बिना संभव परिणाम के साथ इसे
आज़माएं

विस्तारित:

$_ = get;            # get one line (the value to sum to)

put                  # print with trailing newline
    lines()          # get the rest of the lines of input
    .combinations(2) # get the possible combinations
    .first(          # find the first one
      *.sum == $_    # that sums to the input
    )
  //                 # if there is no value (｢Nil｣)
    exit 1           # exit with a non-zero value (｢put｣ is not executed)

Answer 4

जावास्क्रिप्ट ईएस 6, 58 70 68 64 बाइट्स

a=>b=>{for(i in a)if(a.includes(b-a[i],i+1))return[a[i],b-a[i]]}

एक सरणी के रूप में संख्याओं की एक जोड़ी लौटाता है यदि मिला, अन्यथा वापस आता है undefined, एक मिथ्या मूल्य।

f=a=>b=>{for(i in a)if(a.includes(b-a[i],i+1))return[a[i],b-a[i]]}

console.log(f([1,7,4,6,5,3,8,2])(8));
console.log(f([1,2,3,4,5,6,7,8])(8));
console.log(f([1,2,3,4])(8));
console.log(f([2,2])(4));

Comments

उदाहरण था 3, 5लेकिन यह आउटपुट 1, 7...

— नील

@ नील, क्षमा करें, मैंने नियमों में संशोधन किया है क्योंकि मैंने गड़बड़ की है। 1,7 ठीक है।

— दार्शनिकोर्न

यह काम नहीं करेगा f([2,2] 4)?

— क्लिफरॉट

@ क्लिफट्रॉट को उस मामले के लिए अब काम करना चाहिए

— टॉम

अच्छी includesचाल है।

— नील

Answer 5

जावास्क्रिप्ट (ईएस 6), 61 57 56 बाइट्स

पूर्णांक के सरणी aऔर sकरी सिंटैक्स में अपेक्षित योग लेता है (a)(s)। एक सरणी के रूप में पूर्णांक की एक जोड़ी लौटाता है, या undefinedयदि कोई ऐसी जोड़ी मौजूद नहीं है।

a=>s=>(r=a.find((b,i)=>a.some(c=>i--&&b+c==s)))&&[r,s-r]

प्रारूपित और टिप्पणी की गई

a =>                      // given an array of integers (a)
  s => (                  // and an expected sum (s)
    r = a.find((b, i) =>  // look for b at position i in a such that:
      a.some(c =>         //   there exists another c in a:
        i-- &&            //     - at a different position
        b + c == s        //     - satisfying b + c == s
      )                   //   end of some()
    )                     // end of find(): assign the result to r
  ) &&                    // if it's not falsy:
  [r, s - r]              // return the pair of integers

परीक्षा

let f =

a=>s=>(r=a.find((b,i)=>a.some(c=>i--&&b+c==s)))&&[r,s-r]

console.log(f([1,7,4,6,5,3,8,2])(8))
console.log(f([1,2,3,4])(8))

Answer 6

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

ŒcS=⁹$$ÐfḢṄo⁶H

इसे ऑनलाइन आज़माएं!

यह एक फ़ंक्शन है (एक पूर्ण कार्यक्रम नहीं) जो मानक आउटपुट को आउटपुट करता है। (TIO लिंक में एक आवरण होता है जो एक फ़ंक्शन चलाता है और इसके रिटर्न मान की अवहेलना करता है।)

यदि बाहर निकलने की कोड की आवश्यकता नहीं है, तो यह कार्यक्रम 4 बाइट्स छोटा हो सकता है; जेली में 1 का एग्जिट कोड लौटना काफी कठिन है। (यह संभव है कि ऐसा करने के लिए एक कठिन तरीका हो जो मैंने याद किया हो।)

व्याख्या

ŒcS=⁹$$ÐfḢṄo⁶H
Œc                All pairs of values from {the first argument}
       Ðf         Take only those which
  S=⁹               sum to {the second argument}
     $$           Parse the preceding three builtins as a group
         Ḣ        Take the first result (0 if there are no results)

          Ṅ       Output this result (plus a newline) on standard output
           o⁶     If this value is falsey, replace it with a space character
             H    Halve every element of the value

हम हर पूर्णांक को एक जोड़ी में ही ठीक कर सकते हैं, इसलिए o⁶Hयदि हम कोई परिणाम नहीं पाते हैं, तो बेकार रिटर्न रिटर्न मान के अलावा कुछ भी नहीं करेंगे, जो वैसे भी प्रासंगिक नहीं है ( Ṅफ़ंक्शन के रिटर्न का निर्धारण करने के लिए सुविधाजनक सिंगल-बाइट विधि के रूप में कार्य करता है) पीपीसीजी नियमों के तहत मूल्य जल्दी)। हालांकि, अगर हमें कोई परिणाम नहीं मिला, तो हम अंत में एक अंतरिक्ष चरित्र को समाप्त करने की कोशिश कर रहे हैं, एक ऑपरेशन इतना अर्थहीन है कि इससे जेली दुभाषिया दुर्घटना का कारण बनता है। सौभाग्य से, यह दुर्घटना 1 का निकास कोड उत्पन्न करती है।

Answer 7

पर्ल 5 , 51 बाइट्स

-pliझंडे के लिए 5 बाइट्स के लिए कोड + के 46 बाइट्स ।

$\="$_ $v"if$h{$v=$^I-$_};$h{$_}=1}{$\||exit 1

इसे ऑनलाइन आज़माएं!

विचार इनपुट सूची पर पुनरावृत्त करना है: एक नंबर पर x( $_), अगर हमने पहले देखा n-x( $^I-$_) तो हमने पाया कि हम क्या देख रहे थे और $\इन दो मूल्यों ( "$_ $v") पर सेट करें । अंत में, अगर $\सेट नहीं किया गया है, तो हम exit 1, अन्यथा इसे स्पष्ट रूप से मुद्रित किया जाएगा।

Comments

क्या दो अक्षरों के स्थान पर एक शाब्दिक टैब काम करता है ^I?

@ ais523 ऐसा लगता है कि मैं नहीं कर सकता। शायद यह पर्ल के पुराने संस्करणों पर संभव था।

— दादा

Answer 8

रोड़ा , 60 56 बाइट्स

f s,a{seq 1,s|{|x|[[x,s-x]]if[x in a,s-x in a-x]}_|pull}

इसे ऑनलाइन आज़माएं!

यदि कोई उत्तर नहीं है, तो यह कोड एक त्रुटि फेंकता है। यह सभी संभावित जोड़े उत्पन्न करता है जो योग का निर्माण कर सकते हैं s, अर्थात। 1, s-1, 2, s-2, 3, s-3, ... तो यह जाँच करता है अगर दोनों संख्या सरणी में हैं aऔर अगर ऐसा है, उन्हें धारा के लिए धक्का। pullस्ट्रीम से एक मान पढ़ता है और उसे वापस करता है। यदि स्ट्रीम में कोई मान नहीं हैं, तो यह एक त्रुटि फेंकता है। हटाए a-xगए सरणी के aसाथ देता xहै।

Answer 9

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

यह छोटा है, जब तक कि कोड 1 के साथ बाहर निकलने के नियमों को स्पष्ट नहीं किया जाता है। अब कुछ नहीं मिला तो त्रुटि के साथ बाहर निकलता है।

-5 बाइट्स @Peilonrayz को धन्यवाद

-4 बाइट्स @Rod का धन्यवाद

इसे ऑनलाइन आज़माएं

a,s=input()
while a:
 x=a.pop()
 if s-x in a:r=s-x,x
print r

Comments

@Peilonrayz ने महसूस नहीं किया कि, धन्यवाद!

— मृत पोसम

@Peilonrayz यह नियम का उल्लंघन करेगा: सूची में विभिन्न पदों पर दो पूर्णांकों को लौटाया जाना चाहिए। (यानी आप एक ही स्थिति से दो बार एक ही नंबर नहीं लौटा सकते हैं)

— मृत पोसुम

आप मिश्रित बाइट के लिए रिक्त स्थान + टैब का उपयोग कर सकते हैं 2 बाइट्स को कम करने केinput() लिए या 4 बाइट्स को कम करने के लिए स्विच करें

— रॉड

@Rod धन्यवाद! इनपुट अच्छा लगता है

— मृत पोसम

@ एरिक डुमिनील हाँ। यह eval(raw_input())(मुझे लगता है) के बराबर है ।

— यति

Answer 10

C ++ 133 बाइट्स (क्लैंग 4 और gcc 5.3 -std = c ++ 14 के साथ संकलित)

#include <set>
auto f=[](auto s,int v,int&a,int&b){std::set<int>p;for(auto i:s)if(p.find(i)==end(p))p.insert(v-i);else{a=v-i;b=i;}};

C 108 बाइट्स

void f(int*s,int*e,int v,int*a,int*b){do{int*n=s+1;do if(v-*s==*n){*a=*s;*b=*n;}while(++n<e);}while(++s<e);}

Comments

साइट पर आपका स्वागत है! दुर्भाग्य से, मुझे लगता है कि आपको इसके लिए 15 बाइट #include <set>और कुछ और जोड़ने की आवश्यकता है std::set। यद्यपि आप कुछ बाइट्स को बचा भी सकते हैं यदि आप ब्रेसिज़ को निकालते हैंp.insert(v-i);

— जेम्स

@DJMcMayhem ओह, धन्यवाद। तो क्या मुझे मुख्य () शामिल करना चाहिए?

— एमर

@ em2er नहीं, आपको शामिल करने की आवश्यकता नहीं है main। हम मानते हैं (जब तक कि अन्यथा चुनौती में न कहा गया हो) कि एक फ़ंक्शन एक मान्य सबमिशन है। (साइट पर आपका स्वागत है btw!)

— दादा

नहीं, एक फ़ंक्शन सबमिशन ठीक है। (और बहुत कम क्योंकि आप इनपुट को तर्कों के रूप में ले सकते हैं) आपको बस किसी भी गणना की आवश्यकता है जिसमें आपके जमा की आवश्यकता है।

— जेम्स

@DJMcMayhem @Dada बहुत बहुत धन्यवाद! मैं endभी यकीन नहीं कर रहा हूँ , लेकिन यह बिना gcc पर संकलित std::(और सेट अगर नहीं)

— em2er

Answer 11

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

(n:v)#s|elem(s-n)v=(n,s-n)|1<2=v#s

इसे ऑनलाइन आज़माएं!

सूची के प्रत्येक तत्व के लिए, यह फ़ंक्शन जाँचता है कि क्या (योग-तत्व) सूची के निम्नलिखित भाग में है। वह पहले जोड़े को पाता है। यदि फ़ंक्शन सूची के अंत तक पहुंचता है, तो यह "गैर-बेअसर पैटर्न" त्रुटि फेंकता है और कोड 1 से बाहर निकलता है।

Comments

मुझे डर है कि यह दृष्टिकोण इनपुट की तरह काम नहीं करता है [2,2]#4।

— लकोनी

@ लिकोनी धन्यवाद, मैंने चुनौती को अच्छी तरह से नहीं पढ़ा था। यह नया संस्करण सही होना चाहिए (और छोटा ^ ^)

— सिंह

Answer 12

पॉवरशेल, 109 97 बाइट्स

param($i,$a)($c=0..($a.count-1))|%{$c-ne($f=$_)|%{if($a[$f]+$a[$_]-eq$i){$a[$f,$_];exit}}};exit 1

AdmBorkBork ने एक 12 बाइट का सौदा किया

व्याख्या

# Get the parameter passed where $i is the addition target from the array of numbers in $a
param($i,$a)

($c=0..($a.count-1))|%{
    # We are going to have two loops to process the array elements.
    # The first loop element will be held by $f
    $f=$_
    # Create a second loop that will be the same as the first except for the position of $f to
    # prevent counting the same number twice. 
    $c|?{$_-ne$f}|%{
        # Check if the number at the current array indexes add to the target value. If so print and exit.
        if($a[$f]+$a[$_]-eq$i){$a[$f],$a[$_];exit}        
    }

}
# If nothing was found in the loop then we just exit with error.
exit 1

मौजूदा नियम एग्जिट कोड की तलाश करते हैं जो यह करता है। जिन्हें हटाया जा सकता है और बस वापस किए जा रहे नंबरों और झूठे के लिए जांच की जा सकती है।

नमूना उपयोग

यदि उपरोक्त कोड फ़ंक्शन के रूप में सहेजा गया था s

s 8 @(1,2,3,4)
s 8 @(1,7,4,6,5,3,8,2) 

Comments

आप कुछ और बाइट्स को खत्म करके $cनीचे की ओर लूप करके बचा सकते हैं -($a.count-1)..1|%{$f=$_;--$_..0|%{if...

— AdmBorkBork

Answer 13

आर, 49 बाइट्स

function(x,y){r=combn(x,2);r[,colSums(r)==y][,1]}

यह xमैट्रिक्स के सभी 2-संयोजनों को ढूंढता है और वापस लौटाता है। फिर, कॉलम द्वारा sums और सभी योगों को खोजता है जो बराबर हैं y(इसलिए [,1]अंत में भाग के बिना यह उन सभी संयोजनों को प्रिंट करेगा जो उनके योगों के बराबर हैं y)

Answer 14

जाप , 9 बाइट्स

कई बाइट्स @ETHproductions की बदौलत सहेजे गए

à2 æ_x ¥V

इसे ऑनलाइन आज़माएं!

व्याख्या

à2 æ_x ¥V
à2         // Creates all combinations of the input, length 2
   æ       // Returns the first item where:
    _x     //     The sum of the two items in each set
       ¥V  //     == Second input   

उदाहरण

Input:        [1,2,3], 4
à2         // [[1,2],[1,3],[2,3]]
   æ_x     // [3,    4,    5    ]
       ¥V  //  3!=4, 4==4 ✓
Output:    //  1,3

Answer 15

जावास्क्रिप्ट, 114 96 86 84 बाइट्स

a=>b=>{c=b.length;for(x=0;x<c;x++)for( y=x;++y<c;)if(b[x]+b[y]==a)return[b[x],b[y]]}

@ बाइट के लिए 1 बाइट का धन्यवाद और @ETHProductions के साथ एक और 8 बाइट्स के लिए धन्यवाद

यह सूची-तत्वों के पहले संयोजन के साथ एक ट्यूपल लौटाता है जो दिए गए इनपुट तक योग करता है, या बिना मैच के कुछ भी नहीं। मैंने varफ़ंक्शन में एस हटा दिया है ; REPL.it उनके बिना क्रैश हो जाता है, लेकिन क्रोम देव कंसोल इसे ठीक करता है ...

इसे ऑनलाइन आज़माएं!

Comments

कोड 1 से बाहर नहीं निकलता, क्योंकि चुनौती विशेष रूप से अमान्य इनपुट के लिए अनुरोध करती है। यह अब के लिए एक अमान्य उत्तर है, लेकिन मैंने ओपी से इस आवश्यकता के बारे में उन भाषाओं के लिए कहा है जो आसानी से नहीं कर सकते।

— R

@ मैट हां, यह नियम देखा जाता है: इसका y=x+1ध्यान रखता है।

— steenbergh

आप a=>b=>...बाइट बचाने के लिए उपयोग कर सकते हैं

— Cyoce

आप के साथ एक और तीन बाइट्स बचा सकते हैं for(y=x;++y<b.length;){। इसके अलावा, आप सबसे बाहरी को छोड़कर ब्रेसिज़ के सभी सेटों को हटा सकते हैं, और इसके बाद के स्पेस को हटा सकते हैंreturn

— ETHproductions

Answer 16

क्लोजर, 77 बाइट्स

#(first(mapcat(fn[i a](for[b(drop(inc i)%):when(=(+ a b)%2)][a b]))(range)%))

पहली ऐसी जोड़ी लौटाता है या nil।

Answer 17

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

r=return;s#[]=r 1;s#(a:b)|elem(s-a)b=print(a,s-a)>>r 0|1<2=s#b

मैं अभी भी नहीं जानता कि चुनौती से क्या अनुमति है और क्या नहीं। मैं एक ऐसे फंक्शन के लिए जा रहा हूँ जो संख्याओं की एक जोड़ी को प्रिंट करता है और 0 देता है अगर कोई समाधान है और कुछ भी नहीं प्रिंट करता है और यदि कोई समाधान नहीं है तो 1 रिटर्न देता है। जैसा कि मुद्रण I / O है, मुझे IO-Monad (के माध्यम से return) में रिटर्न मान को उठाना है और वास्तविक प्रकार का फ़ंक्शन है Num a => IO a।

उपयोग उदाहरण (उत्तर द्वारा मुद्रित मूल्य के साथ):

*Main> 4 # [2,2]
(2,2)
0

इसे ऑनलाइन आज़माएं! ।

यदि अपवादों को बढ़ाने की अनुमति दी जाती है, failतो कुछ बाइट्स (कुल 51) बचेंगे:

s#[]=fail"";s#(a:b)|elem(s-a)b=print(a,s-a)|1<2=s#b

Answer 18

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

ŒcS=¥ÐfḢZ

जेली के पास बाहर निकलने के कोड को मनमाने मूल्यों पर सेट करने का कोई तरीका नहीं है, इसलिए यह एक वैध समाधान के बिना इनपुट के लिए एक टाइपएयर का उत्पादन करता है जिससे अभिभावक दुभाषिया से बाहर निकलें कोड 1 के साथ बाहर निकल जाएगा ।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

ŒcS=¥ÐfḢZ  Main link. Argument: A (array of integers), n (integer)

Œc         Yield all 2-combinations of different elements of A.
     Ðf    Filter by the link to the left.
    ¥        Combine the two links to the left into a dyadic chain.
  S            Take the sum of the pair.
   =           Compare the result with n.
       Ḣ   Head; extract the first pair of the resulting array.
           This yields 0 if the array is empty.
        Z  Zip/transpose the result.
           This doesn't (visibly) alter pairs, but it raise a TypeError for 0.

Answer 19

नोवा , 101 बाइट्स

q(Int[] a,Int x)=>a{if(Int y=a.firstWhere({a.contains(x-a.remove(0))}))return [y,x-y];System.exit(1)}

कोड गोल्फ के बारे में एक अच्छी बात यह है कि यह मेरी भाषा में कीड़े खोजने में मदद करता है। उदाहरण के लिए returnऔर के बीच आवश्यक स्थान [y,x-y]।

एक बार जब मैं Array.nova पर पुश / पॉप फ़ंक्शंस जोड़ता हूं और रिटर्न को ठीक करता हूं, तो 96 बाइट्स होंगे:

q(Int[] a,Int x)=>a{if(Int y=a.firstWhere({a.contains(x-a.pop())}))return[y,x-y];System.exit(1)}

उपयोग:

class Test {
    static q(Int[] a,Int x)=>a{if(Int y=a.firstWhere({a.contains(x-a.remove(0))}))return [y,x-y];System.exit(1)}

    public static main(String[] args) {
        Console.log(q([1, 2, 3, 4, 5], 8)) // [5, 3]
        Console.log(q([1, 2, 3, 4, 5], 5)) // [1, 4]
        Console.log(q([1, 2, 3, 4], 8)) // exit code 1
    }
}

संपादित करें: इसके अलावा, 73 बाइट्स (69 पॉप का उपयोग करके) पर भी इस तरह है:

q(Int[] a,Int x)=>[Int y=a.firstOrThrow({a.contains(x-a.remove(0))}),x-y]

firstOrThrow एक अपवाद को फेंक देगा, जो बिना पढ़ाया जाएगा और इसलिए अंततः प्रोग्राम को एक्जिट कोड 1 से बाहर कर देगा;)

यह तरीका और भी पठनीय लगता है।

Answer 20

पायथ, 12 बाइट्स

hfqsThQ.ceQ2

व्याख्या

       .ceQ2   Get all pairs from the second input
 fqsThQ        Find the ones whose sum is the first input
h              Take the first (exits with error code 1 if there aren't any)

Answer 21

PHP, 88 बाइट्स

for($i=1;$a=$argv[$k=++$i];)for(;$b=$argv[++$k];)if($a+$b==$argv[1])die("$a $b");die(1);

कमांड लाइन तर्कों से इनपुट लेता है, पहले योग। के साथ चला -nr।

सौभाग्य से, die/ जब आप इसे एक स्ट्रिंग पैरामीटर के रूप में देते हैं, तब exitबाहर निकलता है 0।

_{मैंने छोरों को एक में मिलाने की कोशिश की; लेकिन इसके लिए इस समय एक लंबी शुरुआत और परीक्षण की आवश्यकता है।}

Comments

बुरा दिन? for($i=1;$a=$argv[$k=++$i];)for(;$b=$argv[++$k];)$a+$b!=$argv[1]?:die(!0);और आपको इस कोडगुल्फ.स्टैकएक्सचेंज.com

— Jörg Hülsermann

Answer 22

मैथेमेटिका, 76 बाइट्स

f::e="1";If[(l=Cases[#~Subsets~{2},x_/;Tr@x==#2])=={},Message@f::e,First@l]&

बहुत सीधा: #~Subsets~{2}सूची के सभी 2-तत्व सबसेट प्राप्त करता है, फिर Cases[...,x_/;Tr@x==#2]केवल उन लोगों को चुनता है जिनकी राशि वह संख्या है जो हम चाहते हैं। अगर इनमें से कोई भी नहीं है, If[l=={}, Message@f::e,First@l]तो त्रुटि संदेश प्रिंट करता है f::e : 1जिसे हमने पहले परिभाषित किया था (क्योंकि मुझे नहीं पता है कि "एक्ज़िट स्टेटस 1" का क्या मतलब है, जो मैथमेटिका के लिए हो सकता है); अन्यथा, यह उन जोड़ों की सूची में पहली प्रविष्टि देता है जो सही चीज़ के लिए योग करते हैं।

यदि हमें उस अजीब निकास स्थिति चीज़ को करने के बजाय एक गलत मूल्य वापस करने की अनुमति है, तो निम्न कोड में 58 बाइट्स हैं:

If[(l=Cases[#~Subsets~{2},x_/;Tr@x==#2])=={},1<0,First@l]&

Answer 23

स्काला, 55 41 बाइट्स

(l,n)=>l combinations 2 find(_.sum==n)get

यदि वे मौजूद हैं तो दो नंबरों की एक सूची लौटाता है और अन्यथा एक त्रुटि फेंकता है। अनकैप्ड, यह त्रुटि 1 के बाहर निकलने की स्थिति में परिणाम देगी।

Answer 24

रूबी, 53 48 बाइट्स

->a,s{p(a.combination(2).find{|x,y|x+y==s})?0:1}

इनपुट: एक सूची है, एस अपेक्षित राशि है।

यदि 2 नंबर मिलते हैं, तो उन्हें प्रिंट करें और 0 वापस करें, अन्यथा विनिर्देश में 1 वापस करें।

Answer 25

टीआई-बेसिक, 59 बाइट्स

Prompt L1
Prompt X
While 1
L1(1→B
seq(L1(C),C,2,dim(L1→L1
If sum(not(X-L1-B
Then
Disp B,X-B
Return
End
End

स्पष्टीकरण:

Prompt L1               # 4 bytes, input array like "{1, 2, 3}"
Prompt X                # 3 bytes, Input target sum
While 1                 # 3 bytes, until the list is empty
L1(1→B                  # 7 bytes, try the first element (now B)
seq(L1(C),C,2,dim(L1→L1  # 18 bytes, remove first element from list
If sum(not(X-L1-B       # 10 bytes, if any element in the list plus B is the target
Then                    # 2 bytes, then...
Disp B,X-B              # 7 bytes, print it and it's "complement"
Return                  # 2 bytes, and exit gracefully
End                     # 2 bytes
End                     # 1 byte

यदि प्रोग्राम इनायत से बाहर नहीं निकला, तो इसे जारी रखने के लिए सूची में पर्याप्त तत्व नहीं होने पर यह एक त्रुटि का कारण होगा।

Answer 26

सीजेएम, 23 बाइट्स

l~_,1>{e!2f<::+#)}{;;}?

इनपुट है sum numbers। उदाहरण के लिए 6 [3 2 3]:। सत्य के लिए एक सकारात्मक संख्या छोड़ देता है और एक खाली स्ट्रिंग या झूठी के लिए 0।

स्पष्टीकरण:

l~    e# Read input and evaluate:  | 7 [3 2 3]
_     e# Duplicate:                | 7 [3 2 3] [3 2 3]
,     e# Take the length:          | 7 [3 2 3] 3
1>{   e# If more than 1:           | 7 [3 2 3]
  e!  e#   Unique permutations:    | 7 [[2 3 3] [3 2 3] [3 3 2]]
  2f< e#   Slice each to length 2: | 7 [[2 3] [3 2] [3 3]]
  ::+ e#   Some each:              | 7 [5 5 6]
  #   e#   Index:                  | -1
  )   e#   Increment:              | 0
}{    e# Else:                     | 7 [3 2 3]
  ;   e#   Pop                     | 7
  ;   e#   pop                     |
}?    e# Endif
e# Implicit output: 0