अपने साथी को ढूंढना

Question

चुनौती

2-ट्यूपल्स की एक मनमानी सूची को देखते हुए, और उन ट्यूपल्स में से एक में एक तत्व, अपने "पार्टनर" को आउटपुट देता है, अर्थात aऔर [(i,j),...,(a,b),...,(l,m)]आउटपुट b। आप मान सकते हैं कि सभी ट्यूपल्स अद्वितीय हैं, और यह कि ट्यूपल्स के सभी तत्व तार हैं। इसके अलावा मान लें कि आपके पास दोनों नहीं हैं (x,y)और (y,x)।

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

Input                                                           Output

[("(", ")"), ("{", "}"), ("[", "]")], "}"                       "{"
[("I'm", "So"), ("Meta", "Even"), ("This", "Acronym")], "Even"  "Meta"
[("I", "S"), ("M", "E"), ("T", "A")], "A"                       "T"
[("test", "cases"), ("are", "fun")], "test"                     "cases"
[("sad", "beep"), ("boop", "boop")], "boop"                     "boop"

सबसे शानदार बाइट्स जीतता है!

Comments

इसके अलावा, यदि इनपुट कई बार दिखाई देता है या क्या नहीं है, तो क्या करें

— लुइस मेंडो

मुझे नहीं लगता कि हम एक फ्लैट सूची के रूप में इनपुट ले सकते हैं, है ना? उदाहरण के लिए, के [a, b, c, d]बजाय [(a, b), (c, d)]। यह मेरे जवाब से एक टन बाइट्स दाढ़ी करेगा। : पी

— बिलकुल अमानवीय

मैंने कुछ सामान को उम्मीद से साफ़ करने के लिए संपादित किया है और परीक्षण मामलों को जोड़ा है। अगर कुछ भी गलत हो तो बेझिझक रोल बैक करें।

— पूरी तरह से

@totallyhuman मैंने विशेष रूप से पूछा(a,a) और कहा गया कि ऐसा नहीं होगा । नैट ने इस तथ्य को निर्दिष्ट करने के लिए प्रश्न को संपादित भी किया। हालाँकि आपने इस तरह के प्रवेश के साथ एक परीक्षण मामला जोड़ा है और इस निर्णय को उलटते हुए विनिर्देश भी संपादित किया है - क्यों? यह जवाब का एक गुच्छा टूट गया है।

— जोनाथन एलन

@totallyhuman मैंने इसे "कुछ भी लौटाने, दुर्घटनाग्रस्त, जो भी हो" का अर्थ लिया, खासकर जब से पोस्ट को संशोधित किया गया था, यह कहने के लिए कि सब कुछ अद्वितीय होगा।

— जोनाथन एलन

Answer 1

जाप, 6 बाइट्स

तार या पूर्णांक के साथ काम करता है।

æøV kV

झसे आज़माओ

---

व्याख्या

सरणी Uऔर स्ट्रिंग / पूर्णांक का निहित इनपुट V।

æ

Uउसमें पहला तत्व (सबर्रे) प्राप्त करें ...

øV

समाहित है V।

kV

निकालें Vऔर संक्षेप में परिणामी एकल तत्व सरणी लौटें।

Comments

यह ... मैंने सचमुच उस सटीक परिदृश्य, एक ही इनपुट और सभी की कोशिश की। मुझे कुछ याद आया होगा ... संपादित करें: ठीक है, मैं समय के fबजाय उपयोग कर रहा था æ। Duh: P

— ETHproductions

@ETHproductions: एक अच्छा बदलाव बनाता है - आमतौर पर मैं वह होता हूं जो भूल जाता है æऔर साथ में घुलने -मिलने की कोशिश करता है f! : डी

— झबरा

Answer 2

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

x!((a,b):c)|x==a=b|x==b=a|1<2=x!c

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

एक द्विआधारी ऑपरेटर को परिभाषित करता है !, जो अपने बाएं तर्क xको प्रकार, के मान के रूप में लेता है और इसके सही तर्क के रूप में ट्यूपल्स की सूची (τ,,)। दी गई सूची के सिर (a,b)और पूंछ पर परिभाषा पैटर्न मेल खाता है c; अगर x==aफिर bलौटा है; यदि x==bफिर aलौटा दिया जाता है, और अन्यथा हम शेष सूची को हटाकर देखते हैं।

  'f' ! [('a', 'b'), ('c', 'd'), ('e', 'f'), ('g', 'h')]
≡ 'f' ! [('c', 'd'), ('e', 'f'), ('g', 'h')]
≡ 'f' ! [('e', 'f'), ('g', 'h')]
≡ 'e'

(यदि सूची में कोई "भागीदार" नहीं है, तो यह दुर्घटनाग्रस्त हो जाएगा, क्योंकि हमने परिभाषित नहीं किया कि क्या x![]होना चाहिए।)

Answer 3

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

e=>g=([[b,c],...a])=>e==b?c:e==c?b:g(a)

करीबी तर्कों के रूप में सरणियों के प्रवेश और सरणी लेता है। सर्वश्रेष्ठ गैर-पुनरावर्ती संस्करण मैं कर सकता था 44 बाइट्स:

e=>a=>a.find(a=>a.includes(e)).find(b=>b!=e)

Comments

यहाँ एक 41-बाइट गैर-पुनरावर्ती समाधान है:a=>b=>a.map(e=>b=e[1-e.indexOf(b)]||b)&&b

— रिक हिचकॉक

तुम ... तुम अंत में करी करने के लिए दिया ?! : ओ

— झबरा

@ शागि आम तौर पर मैं (a,b)=>=> a=>b=>प्रकार के करी के लिए परेशान नहीं करता हूं, लेकिन गैर-पुनरावर्ती संस्करण को पुनरावर्ती संस्करण से शुरू किया गया था, जिसे करी गई थी क्योंकि मैं पुनरावर्ती कॉल पर 2 बाइट्स को बचाने में सक्षम था (करी खुद को वास्तव में खर्च करता है एक बाइट)।

— नील

Answer 4

MATL , 4 14 5 6 बाइट्स

yY=P)u

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

इनपुट के रूप में एक सरणी है [{a;b},{c;d}]। ओपेकाउंट भारी रूप से उतार-चढ़ाव करता है जबकि ओपी यह बताता है कि वास्तव में क्या अनुमति है।

y     % Implicitly input tuples T and 'lonely element' E, duplicate from below to get [T E T] on the stack
 Y=   % String comparison, element wise, between T and E. Yields a boolean array with a 1 at the correct location.
   P  % Flip this array vertically, to put the 1 at the 'partner' of E.
    ) % Select this partner from the bottom T.

मैंने 4-बाइट संस्करण के साथ शुरुआत की, जो केवल एकल-वर्ण स्ट्रिंग्स को संभाल सकता था, जो मूल चुनौती में एकमात्र टेस्टकेस था। जब यह अमान्य हो गया, तो मैंने एक बहुत लंबा 14-बाइट संस्करण बनाया, जो अच्छा था और हैकी (पुनरीक्षण इतिहास की जाँच करें!), ने मुझे एक बग की खोज की, और फिर Y=उपयुक्त इनपुट के साथ पूरी तरह से अनावश्यक हो गया । , मेरे मूल 4-बाइट के साथ ही काम किया y=P)।

Answer 5

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

lambda x,y:dict(x+map(reversed,x))[y]

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

प्रोटॉन , 31 बाइट्स

a,b=>dict(a+map(reversed,a))[b]

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

(ये दोनों जवाब इतने ही समान हैं कि मैं इन्हें हटाने के लिए एक साथ पोस्ट कर रहा हूं)

Comments

नाम बदलें reversedकरने के लिए reverse-1 बाइट के लिए प्रोटॉन में। \ s: पी अधिक गंभीरता से, reverseएक बेहतर नाम है, नहीं? : पी

— बिलकुल अमानवीय

@totallyafloppydisk शायद / कंधे उचकाने की क्रिया लेकिन मैं अजगर builtins कि प्रोटॉन को खत्म किया पाने के सबसे का नाम नहीं था

— HyperNeutrino

@ सेंचुरीज़ मुझे नहीं दिखता कि क्या गलत है?

— हाइपरएन्यूट्रीनो

क्षमा करें मेरे बुरे, उस टिप्पणी की अवहेलना।

— सांचेस

Answer 6

पर्ल 5 , 30 + 1 (-पी) = 31 बाइट्स

$_={@f=eval$_,reverse@f}->{<>}

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

Answer 7

पायथन 2 , 59 45 42 बाइट्स

-14 बाइट्स एमिग्ना के लिए धन्यवाद। -3 बाइट्स माल्टीसेन को धन्यवाद।

lambda l,v:sum(l,())[sum(l,()).index(v)^1]

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

^{हालांकि अभी भी करी का उपयोग करना चाहते हैं। ; -;}

Comments

45 बाइट्स

— एमिग्ना

अहा, पता था कि करने का एक छोटा तरीका था y+[1,-1][y%2]। बस यह समझ में नहीं आया कि यह ठीक है ... धन्यवाद!

— 21 अक्टूबर को पूरी तरह से अमानवीय

Answer 8

सी ++, 179 बाइट्स

#include<vector>
#include<string>
#define S std::string
S f(std::vector<std::pair<S,S>>s,S t){for(auto&a:s){if(a.first==t)return a.second;if(a.second==t)return a.first;}return"";}

C ++ w / मैप डेटा प्रकार, 162 बाइट्स

#include<map>
#include<string>
#define S std::string
S f(std::map<S,S>s,S t){for(auto&a:s){if(a.first==t)return a.second;if(a.second==t)return a.first;}return"";}

MSVC के साथ, कोड संकलित करता है भले ही अंतिम returnविवरण ( return"";) छोड़ा गया हो। यह कोड 9 बाइट्स को हल्का बनाता है, लेकिन फ़ंक्शन के अंत से बाहर निकलने ( लेकिनreturn लूप में एक बयान से बाहर नहीं निकलता ) के साथ कोई रिटर्न स्टेटमेंट अपरिभाषित व्यवहार का कारण नहीं होगा , और काम नहीं करेगा यदि टपल सरणी में "कुंजी" तत्व नहीं है।

Answer 9

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

param($a,$c)$a|?{$c-in$_}|%{$_-ne$c}

इंट्रप्यूट वाले तत्व को खोजता है, फिर इनपुट से बाहर निकालकर 'अन्य' तत्व प्राप्त करता है, PowerShell में सबसे आश्चर्यजनक सरणी प्रबंधन नहीं है, लेकिन इसके लिए अंतर्निहित कोई जानकारी नहीं हो सकती है।

.\Partner.ps1 (("I'm","So"),("Meta","Even"),("This","Acronym")) "Even"
Meta

Comments

यह दृष्टिकोण ("boop", "boop")परीक्षण मामले के लिए काम नहीं करता है ।

— AdmBorkBork

Answer 10

रोदा , 30 बाइट्स

f a{[(_+"")[1-indexOf(a,_1)]]}

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

स्पष्टीकरण:

f a{[(_+"")[1-indexOf(a,_1)]]}
f a{                         } /* Function f(a)                         */
                               /* For each pair _1 in the stream:       */
              indexOf(a,_1)    /*   Index of a in _1 or -1 if not found */
            1-                 /*   Subtract from 1 to get the index of
                                     the other value in the pair or 2 if
                                     a is not in the pair               */
     (_+"")                    /*   Append "" to _1                     */
           [               ]   /*   Get element the other element or "" */
    [                       ]  /*   Push it to the straem               */
                               /* All values in the stream are printed  */

Answer 11

गणितज्ञ 27 24 बाइट्स

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

Cases[{#,x_}|{x_,#}:>x]&

उपयोग:

%[3][{{1, 2}, {3, 4}}]

स्पष्टीकरण: इस उदाहरण में, पहले तर्क, 3 का सामना करने के बाद, फ़ंक्शन बन जाता है Cases[{3,x_}|{x_,3}:>x]जो उस का एक ऑपरेटर रूप Casesहै, फिर इसे 2 तर्क पर लागू किया जाता है {{1, 2}, {3, 4}}, इस प्रकार 3 के साथी का चयन किया जाता है, चाहे वह अनुपस्थिति या समन्वयित स्थिति में हो। विशेष रूप से, यह फ़ंक्शन उन सभी साथियों को सूचीबद्ध करेगा यदि वास्तव में 1 तर्क 2 तर्क के भीतर एक से अधिक बार प्रकट होता है, दूसरे शब्दों में, यह कहा गया प्रश्न की धारणाओं से थोड़ा परे है।

ग्लिफ़ संलग्न करना स्क्वीगली ब्रेसिज़ होना चाहिए। @Notatree से "करी" सुझाव के साथ 3 बाइट्स सहेजे गए

Comments

यदि आपके पास संस्करण 10 है और आप करीने से इनपुट लेते हैं , तो आप 3 बाइट्स बचा सकते हैं: Cases[{#,x_}|{x_,#}:>x]&जैसे इस्तेमाल किया जाता है%[3][{{1,2},{3,4}}]

— न कि पेड़

क्या आप इसे थोड़ा समझा सकते हैं?

— नैट स्टमेन

Answer 12

आर , 47 42 बाइट्स

function(v,a)a[(i=min(which(v==a)))+(i%%2*2-1)]

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

मैट्रिक्स या स्ट्रेट वेक्टर पर काम करता है। v = खोज मान, = a tuple array।

Comments

@ धन्यवाद धन्यवाद, अब सब ठीक हो गया।

— मिकट

Answer 13

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

ċÞṪ⁻ÞṪ

दाईं ओर सूची भागीदारों और दाईं ओर खो-साथी ले रहा है और भागीदार वापस लौट रहा है।

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

कैसे?

ċÞṪ⁻ÞṪ - Link: list, partners; item, lost-partner
 Þ     - sort (the tuples) by:
ċ      -   count occurrence of lost-partner
  Ṫ    - tail (gets the tuple containing the lost-partner)
    Þ  - sort (that tuple's items) by:
   ⁻   -   not equals (non-vectorising version)
     Ṫ - tail (get the other one, or the rightmost one if they were equla)

Comments

यह तब से अमान्य है जब नए टेस्टकेस जोड़े गए हैं।

— Sanchises

यह इंगित करने के लिए धन्यवाद - मैंने संपादक से प्रश्न के तहत टिप्पणी की है (मैंने विशेष रूप से ओपी के बारे में पूछा (a,a)था और कहा गया था कि हमें इसे संभालने की आवश्यकता नहीं है)। मुझे यकीन है कि मैं इसे ठीक कर सकता हूं, लेकिन यह सुनिश्चित करने के लिए अनिश्चित हूं कि विनिर्देश जैसा कि अभी था।

— जोनाथन एलन

हम्म, हालांकि संशोधन इतिहास को देखते हुए ऐसा लगता है कि हमें न केवल पात्रों का समर्थन करने की आवश्यकता है, बल्कि इस तरह से काम भी नहीं किया जाएगा ...

— जोनाथन एलन

अब नए चश्मे के साथ काम करता है।

— जोनाथन एलन

"मेरी अच्छी तरह से" टिप्पणी की भी मेरी व्याख्या थी, लेकिन जाहिर है कि यह मामला नहीं था।

— सांचेस

Answer 14

पायथ - 11 9 8 बाइट्स

h-hf}QTE

इसे यहाँ ऑनलाइन आज़माएँ ।

Answer 15

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

c#(a,b)|a==c=b|1>0=a
x%l=x#(snd(span(\(a,b)->a/=x&&b/=x)l)!!0)

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

व्याख्या

यह पहला उदाहरण खोजने के लिए स्पैन का उपयोग करता है जहां xटुपल द्वारा निहित है। यह तब टपल के पहले तत्व को पकड़ लेता है यदि इसके बराबर और दूसरा नहीं तो।

हास्केल लैंबडॉट, 59 56 बाइट्स

c#Just(a,b)|a==c=b|1>0=a
x%l=x#find(\(a,b)->a==x||b==x)l

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

व्याख्या

इस का उपयोग करता है Data.Listरों firstसमारोह द्वारा प्रयोग किया जाता बाइट्स में कटौती करने के लिए (!!0).snd.span, तथापि, क्योंकि firstरिटर्न एक Maybeहम जोड़ने की जरूरत Justमें हमारे पैटर्न मैच के लिए #।

Comments

इसे उखाड़ फेंकना मत ... x!((a,b):c)|x==a=b|x==b=a|1<2=x!c33 बाइट्स है।

— लिन

@ लियन आगे बढ़ो और इसे पोस्ट करें। मैं उस के बारे में नहीं सोच के लिए थोड़ा मूर्खतापूर्ण महसूस करता हूं, लेकिन यह वास्तव में आपका जवाब है।

— गेहूं जादूगर

मेला, पोस्ट ^ ^

— लिन

Answer 16

05AB1E , 7 बाइट्स

.åÏ`¹K`
  Ï      # keep only pairs that contain the first input
   `     # flatten
    ¹K   # remove the first input
      `  # flatten

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

वैकल्पिक 7 बाइट समाधान

˜DIkX~è
˜        # deep flatten
 D       # duplicate
  Ik     # get the index of the second input in this list
    X^   # XOR with 1
      è  # get the element at this index

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

Comments

˜D²k>è6 के लिए, जब तक कि 1 के साथ XOR'ing का कोई विशेष कारण न हो?

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: इसका कारण यह है कि सूचकांकों को भी घटाना चाहिए और विषम सूचकांकों को बढ़ाना चाहिए।

— एमिगा

वहाँ जो मैंने लिखा था, उसके

— उलट

Answer 17

आम लिस्प, 74 बाइट्स

(lambda(a x)(or(cdr(assoc x a :test'equal))(car(rassoc x a :test'equal))))

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

Answer 18

जावा 8, 78 बाइट्स

एक लैम्ब्डा (curried) से Stream<List<String>>से एक लैम्ब्डा करने Stringके लिए String(हालांकि अंतर्निहित टाइपिंग मनमाने ढंग से सूचियों के लिए काम करने के लिए इस अनुमति देने के लिए होता है)। भाषा में कोई समर्पित टुपल कक्षाएं नहीं हैं, और मुझे मानक पुस्तकालय में किसी के बारे में पता नहीं है, इसलिए इनपुट जोड़े को सूचियों के रूप में दर्शाया गया है। को सौंपा जा सकता है Function<Stream<List<String>>, Function<String, String>>।

l->s->l.filter(p->p.contains(s)).map(p->p.get(1-p.indexOf(s))).findAny().get()

यह ऑनलाइन की कोशिश करो

मैं अंतिम 6 बाइट्स की बचत का श्रेय किसी को भी दूंगा जो मुझे आश्वस्त कर सकता है कि लौटना Optionalवैध है। मैं खुद को समझाने में सक्षम नहीं हूं।

मेरे लिए इस समाधान के दिलचस्प हिस्सों में से एक धारा से आउटपुट प्राप्त करने का सबसे सस्ता तरीका निर्धारित कर रहा था। मैंने माना reduce, findFirstऔर min/ max, लेकिन कोई भी सहज से कम नहीं था findAny।

Answer 19

रूबी, 31 बाइट्स

->a,e{e=*e;a.find{|p|p!=p-e}-e}

एक एकल सरणी देता है।

Answer 20

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

कल रात के साथ आया तो देखा कि नील ने मुझे बेहतर जेएस समाधान के लिए पीटा था; मुझे लगा कि मैं इसे वैसे भी पोस्ट कर सकता हूं।

तार और पूर्णांक के साथ काम करता है।

a=>n=>a.reduce((x,y)=>y[1-y.indexOf(n)]||x,0)

Answer 21

प्रोलॉग (एसडब्ल्यूआई) , 43 बाइट्स

f([[A,B]|T],X,R):-A=X,R=B;B=X,R=A;f(T,X,R).

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

Answer 22

सी # (.NET कोर) , 101 100 + 18 बाइट्स

बाइट्स के एक जोड़े को कम करने में मदद करने के लिए ग्रेज़गोरज़ पुलावस्की का धन्यवाद।

x=>y=>x.Where(z=>z.Item1==y).FirstOrDefault()?.Item2??x.Where(z=>z.Item2==y).FirstOrDefault()?.Item1

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

C # (.NET Core), 122 121 120 बाइट्स

x=>y=>{for(int i=0;i<x.Length;i++){if(x[i].Item1==y){return x[i].Item2;}if(x[i].Item2==y){return x[i].Item1;}}return"";}

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

Comments

x=>y=>से छोटा है (x,y)=>( Func<a, b, c>बन जाता है Func<a, Func<b, c>>और फंक्शन कॉल f(a, b)बन जाता है f(a)(b)) - शानदार जवाब!

— ग्रेज़गोरज़ पुलावस्की

इसके अलावा पहले जवाब के लिए, फ़ंक्शन स्वयं सिस्टम के अलावा कुछ भी उपयोग नहीं करता है। लिन्क, इसलिए आप उत्तर के लिए केवल 18 बाइट्स जोड़ सकते हैं ( using System.Linq;बनाम namespace System.Linq{})

— ग्रेज़गोरज़ पुलावस्की

@ GrzegorzPuławski मदद और बधाई के लिए धन्यवाद, उम्मीद है कि मैं सूंघने के लिए जवाब तय

— डेनिस.वीरवीज

Answer 23

भूसी , 10 बाइट्स

→ḟo=⁰←S+m↔

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

Ungolfed / स्पष्टीकरण

            -- example input:                         4 [(1,2),(3,4)]
      S+    -- concatenate list with                -
        m↔  --   itself but all pairs flipped       -   [(1,2),(3,4),(2,1),(4,3)]
 ḟo         -- find first occurence where           -
   =⁰←      --   the left element is equal to input -   (4,3)
→           -- get the right element                -   3

नोट : उपरोक्त उदाहरण केवल पठनीयता के लिए पूर्णांकों पर काम करता है, प्रकार ही मायने नहीं रखता (जब तक आप इसकी तुलना कर सकते हैं)।

Answer 24

स्विफ्ट 4 , 43 बाइट्स

{a,m in a.flatMap{$0==m ?$1:$1==m ?$0:nil}}

आउटपुट एक सरणी है, जो या तो खाली है (कोई साथी नहीं मिला), या इसमें एक ही तत्व (पार्टनर) है।

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

let testcases: [(pairs: [(String, String)], match: String, expected: String)] = [
    (
        pairs: [("(", ")"), ("{", "}"), ("[", "]")],
        match: "}", expected: "{"
    ),
    (
        pairs: [("I'm", "So"), ("Meta", "Even"), ("This", "Acronym")],
        match: "Even", expected: "Meta"
    ),
    (
        pairs: [("I", "S"), ("M", "E"), ("T", "A")],
        match: "A", expected: "T"
    ),
    (
        pairs: [("test", "cases"), ("are", "fun")],
        match: "test", expected: "cases"
    ),
    (
        pairs: [("sad", "beep"), ("boop", "boop")],
        match: "boop", expected: "boop"
    ),
]

for (caseNumber, testcase) in testcases.enumerated() {
    let actual = f(testcase.pairs, testcase.match).first

    assert(actual == testcase.expected,
        "Testcase #\(caseNumber) \((testcase.pairs, testcase.match)) failed. Got \(String(reflecting: actual)), but expected \(testcase.expected)!")
    print("Testcase #\(caseNumber) passed!")
}

Answer 25

QBIC , 30 बाइट्स

{_?~A=G|_X]_?~A=;|Z=B]~B=C|Z=A

QBIC सूचियों और टुपल्स पर मजबूत नहीं है। उपरोक्त कोड aकमांड लाइन पैरामीटर के रूप में लेता है , फिर ट्यूपल्स के लिए जोड़े में उपयोगकर्ता इनपुट के लिए पूछता है। जब एक खाली तत्व दिया जाता है, तो यह आउटपुट करता है b।

नमूना चला

Command line: Even
I'm
So
Meta
Even
This
Acronym

Meta

व्याख्या

{           DO infinitely
_?          Ask for part 1 of tuple, A$
~A=G|  ]    IF A$ is empty (equal to G$, which is undefined and therefore "") THEN
     _X         Quit
_?          Ask for part 2 of tuple, B$
~A=;|       IF part 1 of the tuple equals teh cmd line param (loaded in as C$) THEN
    Z=B]        set Z$ to part 2 of the tuple (Z$ gets printed when QBIC quits)
~B=C|Z=A    IF part 2 of the tuple matches input, set Z$ to part 1
            The final IF and the DO loop are closed implicitly

वैकल्पिक संस्करण, 22 बाइट्स

{_?_?~A=;|_XB]~B=C|_XA

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

Answer 26

गणितज्ञ, 50 बाइट्स

(t={#2};Select[Complement[#,t]&/@#,Length@#==1&])&

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

Comments

यह {'boop','boop'}टेस्टकेस के लिए काम नहीं करता है ।

— Sanchises

@Sanchises "boop" तब नहीं था जब मैंने उत्तर दिया था और सवाल [a, a] tuples के बारे में नहीं था। मेरा मानना ​​है कि boop-edit से पहले उत्तर मान्य हैं

— J42161217

मुझे पता नहीं है कि मौजूदा जवाबों को अमान्य करने वाले ओपी के स्पष्टीकरण पर नीति क्या है; यह संपादन के बारे में सिर्फ एक हेड-अप था।

— Sanchises

Answer 27

ढेर , 21 बाइट्स

[:$revmap,KeyArray\#]

इसे ऑनलाइन आज़माएं! यह स्टैक से इनपुट लेता है और स्टैक पर आउटपुट छोड़ देता है। विस्तारित, ऐसा दिखता है:

[ : $rev map , KeyArray \ # ]

व्याख्या

आइए लेते हैं (('sad' 'beep') ('boop' 'boop'))और 'boop'इनपुट के रूप में। फिर, इस तरह एक सरणी का निर्माण किया जाता है :$revmap,:

(( 'sad' 'beep')
 ('boop' 'boop')
 ('beep'  'sad')
 ('boop' 'boop'))

अर्थात्, सरणी की एक प्रति नक्शा है, प्रत्येक सदस्य उलटा है, और दोनों को एक साथ समेटा गया है। KeyArrayबदले में, दिए गए मूल्यों से एक हैश बनाता है, जैसे:

KeyArray [ sad => beep, boop => boop, beep => sad, boop => boop ]

फिर, \स्टैक के शीर्ष पर खोज स्ट्रिंग लाता है, और KeyArray से कुंजी को प्राप्त करता है जो के साथ मेल खाता है #। यह केवल एक मूल्य देता है, इसलिए KeyArray में डुप्लिकेट कुंजी के बारे में चिंतित होने की आवश्यकता नहीं है।

अन्य दृष्टिकोण

32 बाइट्स: (स्टैक से इनपुट, आउटपुट के बारे में) [@x:$revmap,uniq[...x=$out*]map]

36 बाइट्स: {%x[y index#+]YES 0# :y neq keep 0#}

38 बाइट्स: [@x:$revmap#,[KeyArray x#]map:keep 0#]

46 बाइट्स: [@x:KeyArray\$revmap KeyArray,[x#]map:keep 0#]

Answer 28

एक्सेल, 18 बाइट्स

बेनामी Excel वर्कबुक फॉर्मूला कि के रूप में इनपुट लेता <Lookup Value>श्रृंखला से A1, <Key Array>सीमा से B:Bऔर <Def Array>सीमा से C:C, और आउटपुट बुला सेल करने के लिए देखने मूल्य के साथ जुड़े परिभाषा का मूल्य

=VLOOKUP(A1,B:C,2)

संभव होने पर नमूना I / O शामिल किया जाएगा