ท้าทาย

รับรายการโดยพลการของ 2 tuples และองค์ประกอบหนึ่งในหนึ่งในสิ่งอันดับผู้ส่งออก "พันธมิตร" ของมันคือให้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"

ไบต์ที่น้อยที่สุดจะชนะ!

Japtap, 6 ไบต์

ทำงานร่วมกับสตริงหรือจำนวนเต็ม

æøV kV

ทดสอบมัน

คำอธิบาย

การป้อนข้อมูลโดยปริยายของอาร์เรย์และสตริงU / จำนวนเต็มV

æ

รับองค์ประกอบแรก (subarray) ในUที่ ...

øV

Vมี

kV

ลบVและส่งคืนอาเรย์องค์ประกอบเดี่ยวที่ได้ผลลัพธ์โดยปริยาย

Haskell , 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![]ควรจะเป็น)

JavaScript (ES6), 39 ไบต์

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

รับรายการและอาร์เรย์ของอาร์เรย์เป็นอาร์กิวเมนต์ที่ curried รุ่นที่ไม่ใช่แบบเรียกซ้ำที่ดีที่สุดที่ฉันทำได้คือ 44 ไบต์:

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

MATL , 4 14 5 6 ไบต์

yY=P)u

ลองออนไลน์!

อินพุตเป็นอาร์เรย์[{a;b},{c;d}]ดังนี้ Bytecount ผันผวนอย่างมากในขณะที่ OP พิจารณาว่าอะไรได้รับอนุญาตจริง

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 ไบต์ที่สามารถจัดการกับสตริงอักขระเดี่ยวซึ่งเป็น testcase เดียวในความท้าทายดั้งเดิม เมื่อเปิดออกมาจะไม่ถูกต้องผมทำรุ่นที่ยาวมาก 14 ไบต์ซึ่งเป็นสิ่งที่ดีและ hacky (ตรวจสอบประวัติการแก้ไข!) ทำให้ผมค้นพบข้อผิดพลาดและหันแล้วออกจะสมบูรณ์ไม่จำเป็นY=กับข้อมูลที่เหมาะสม ทำงานเช่นเดียวกับต้นฉบับ 4 ไบต์ของy=P)ฉัน

Python 2 , 37 ไบต์

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

ลองออนไลน์!

โปรตอน , 31 ไบต์

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

ลองออนไลน์!

(คำตอบทั้งสองนี้คล้ายกันมากกับที่ฉันโพสต์ไว้ด้วยกันเพื่อหลีกเลี่ยงการติดอาวุธใหม่)

Perl 5 , 30 + 1 (-p) = 31 ไบต์

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

ลองออนไลน์!

Python 2 , 59 45 42 ไบต์

-14 ไบต์ขอบคุณ Emigna -3 ไบต์ขอบคุณ Maltysen

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

ลองออนไลน์!

^{ยังคงต้องการใช้การแกงแม้ว่า ; -;}

C ++, 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คำสั่งในลูป) โดยไม่มีคำสั่งส่งคืนจะทำให้เกิดพฤติกรรมที่ไม่ได้กำหนดและไม่ทำงานหากอาร์เรย์ tuple ไม่มีองค์ประกอบ "คีย์"

PowerShell ขนาด 36 ไบต์

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

ค้นหาองค์ประกอบที่มีการป้อนข้อมูลจากนั้นรับองค์ประกอบ 'อื่น ๆ ' โดยไม่รวมอินพุตจากนั้น PowerShell ไม่มีการจัดการอาเรย์ที่น่าทึ่งที่สุด แต่อาจมีการติดตั้งในตัวสำหรับฉันไม่ทราบ

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

Röda 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  */

Mathematica 27 24 Bytes

Casesเลือกองค์ประกอบของรายการที่ตรงกับรูปแบบ เมื่อใช้กับลูกศรคุณสามารถเปลี่ยนรูปแบบการจับคู่องค์ประกอบ

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

การใช้งาน:

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

คำอธิบาย: ในตัวอย่างนี้หลังจากพบอาร์กิวเมนต์แรก 3 ฟังก์ชันจะกลายCases[{3,x_}|{x_,3}:>x]เป็นรูปแบบโอเปอเรเตอร์ของCasesนั้นจะถูกนำไปใช้กับอาร์กิวเมนต์ที่ 2 {{1, 2}, {3, 4}}ดังนั้นจึงเลือกคู่หูของ 3 ไม่ว่าจะอยู่ในตำแหน่ง abscissa หรือกำหนดตำแหน่ง โดยเฉพาะอย่างยิ่งฟังก์ชั่นนี้จะแสดงรายการสหายทั้งหมดหากในความเป็นจริงอาร์กิวเมนต์ที่ 1 ปรากฏมากกว่าหนึ่งครั้งภายในอาร์กิวเมนต์ที่ 2 กล่าวอีกนัยหนึ่งนี่จะเกินขอบเขตของคำถามที่กล่าวมาเพียงเล็กน้อย

ร่ายมนตร์ที่ปิดล้อมจะต้องอยู่ในวงเล็บปีกกา บันทึก 3 ไบต์พร้อมคำแนะนำ "Currying" จาก @Notatree

R , 47 42ไบต์

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

ลองออนไลน์!

ใช้งานได้ทั้งเมทริกซ์หรือเวกเตอร์แบบตรง v = ค่าการค้นหา, a = tuple array

เยลลี่ 6 ไบต์

ċÞṪ⁻ÞṪ

ลิงค์ dyadic นำรายชื่อพันธมิตรไปทางซ้ายและหุ้นส่วนที่สูญหายทางด้านขวาและส่งคืนพาร์ทเนอร์

ลองออนไลน์!

อย่างไร?

ċÞṪ⁻ÞṪ - 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)

Pyth - 11 9 8 ไบต์

h-hf}QTE

ลองมันออนไลน์ได้ที่นี่

Haskell , 65 62 ไบต์

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

ลองออนไลน์!

คำอธิบาย

สิ่งนี้ใช้ span เพื่อค้นหาอินสแตนซ์แรกที่ xมีอยู่ใน tuple จากนั้นจะคว้าองค์ประกอบแรกของ tuple หากไม่เท่ากันและที่สองเป็นอย่างอื่น

Haskell Lambdabot, 59 56 bytes

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#

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

ลองออนไลน์!

Lisp ทั่วไป, 74 ไบต์

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

ลองออนไลน์!

Java 8, 78 ไบต์

แลมบ์ดา (curried) จากStream<List<String>>ไปยังแลมบ์ดาจากStringถึงString(แม้ว่าการพิมพ์โดยนัยเกิดขึ้นเพื่อให้สิ่งนี้สามารถทำงานกับรายการที่ต้องการได้) ภาษาไม่มีคลาส tuple โดยเฉพาะและฉันไม่ทราบเลยในไลบรารีมาตรฐานดังนั้นคู่อินพุตจะแสดงเป็นรายการ 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/ แต่ไม่มีผู้ใดก็สั้นกว่าที่ใช้งานง่ายmaxfindAny

Ruby, 31 ไบต์

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

ส่งคืนอาร์เรย์แบบซิงเกิล

JavaScript (ES6), 45 ไบต์

เมื่อคืนนี้มาแล้วสังเกตเห็นว่านีลได้เอาชนะฉันในการแก้ปัญหา JS ที่ดีกว่า คิดว่าฉันอาจโพสต์ได้เช่นกัน

ทำงานร่วมกับสตริงและจำนวนเต็ม

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

Prolog (SWI) 43 ไบต์

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

ลองออนไลน์!

C # (.NET แกน) , 101 100 + 18 ไบต์

ขอบคุณ Grzegorz Puławskiที่ช่วยลดจำนวนไบต์สักสองสาม

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"";}

ลองออนไลน์!

Huskขนาด 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

หมายเหตุ : ตัวอย่างข้างต้นใช้งานได้กับจำนวนเต็มเพื่อประโยชน์ในการอ่านเท่านั้นตัวพิมพ์เองไม่สำคัญ (ตราบใดที่คุณสามารถเปรียบเทียบได้)

Swift 4 , 43 bytes

{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!")
}

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

โดยทั่วไปแล้วจะเหมือนกับเวอร์ชั่นที่ยาวกว่า แต่จะออกทันทีเมื่อพบการแข่งขัน ฉันได้แสดงรายการนี้เป็นทางเลือกเนื่องจากคุณไม่สามารถป้อนสิ่งอันดับทั้งหมดลงในโปรแกรมนี้ได้เนื่องจากโปรแกรมหยุดทำงานก่อนกำหนด

Mathematica, 50 ไบต์

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

ลองออนไลน์!

ซ้อนกัน 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 ไบต์: (อินพุตจากสแต็กเอาต์พุตไปยัง STDOUT) [@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#]

Excel, 18 ไบต์

ไม่ประสงค์ออกนามสมุดงาน Excel สูตรที่จะเข้าเป็น<Lookup Value>ระยะA1, <Key Array>ระยะB:Bและ<Def Array>จากช่วงC:Cและผลลัพธ์ค่าความหมายที่เกี่ยวข้องกับการค้นหาค่าไปยังมือถือโทร

=VLOOKUP(A1,B:C,2)

ตัวอย่าง I / O จะถูกรวมเมื่อเป็นไปได้