[Question]
  [
## Challenge
Given an arbitrary list of 2-tuples, and a single element in one of those tuples, output its "partner", i.e. given `a` and `[(i,j),...,(a,b),...,(l,m)]`, output `b`. You can assume all tuples are unique, and that all elements in tuples are strings. Further assume you do not have both `(x,y)` and `(y,x)`.
### Test cases
```
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"
```
Fewest bytes wins!
  
[Answer]
# Japt, 6 bytes
Works with strings or integers.
```
æøV kV
```
[Test it](http://ethproductions.github.io/japt/?v=2.0a0&code=5vhWIGtW&input=W1sxLDJdLFszLDRdLFs1LDZdXQo0)
---
## Explanation
Implicit input of array `U` and string/integer `V`.
```
æ
```
Get the first element (subarray) in `U` that ...
```
øV
```
Contains `V`.
```
kV
```
Remove `V` and implicitly return the resulting single-element array.
[Answer]
# [Haskell](https://www.haskell.org/), 33 bytes
```
x!((a,b):c)|x==a=b|x==b=a|1<2=x!c
```
[Try it online!](https://tio.run/##lcuxCsIwFEbh3af4A8JNIIuO0vsk4nBvkmJpraIdMvTd00gXRzOds3x3@YxpmkrJxlrx6i7BrZlZWL9RlvXUnTmbUB4yzGDE5wF4vYd5wREkBIOrrfWk5Dwshbpx31S3J3f7FdosQrOIzSI1i/4/UTY "Haskell – Try It Online")
Defines a binary operator `!`, which takes as its left argument a value `x` of type τ and as its right argument a list of tuples (τ, τ). The definition pattern matches on the head `(a,b)` and tail `c` of the given list; if `x==a` then `b` is returned; if `x==b` then `a` is returned, and otherwise we go on looking in the rest of the list by recursing.
```
  'f' ! [('a', 'b'), ('c', 'd'), ('e', 'f'), ('g', 'h')]
≡ 'f' ! [('c', 'd'), ('e', 'f'), ('g', 'h')]
≡ 'f' ! [('e', 'f'), ('g', 'h')]
≡ 'e'
```
(If there’s no “partner” in the list, this will crash, because we didn’t define what `x![]` should be.)
[Answer]
## JavaScript (ES6), 39 bytes
```
e=>g=([[b,c],...a])=>e==b?c:e==c?b:g(a)
```
Takes the entry and array of arrays as curried arguments. Best non-recursive version I could do was 44 bytes:
```
e=>a=>a.find(a=>a.includes(e)).find(b=>b!=e)
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~4~~ ~~14~~ ~~5~~ 6 bytes
```
yY=P)u
```
[Try it online!](https://tio.run/##y00syfn/vzLSNkCz9P//6Gr1RHVr9aQk9VqdavWUzAIgJyW/AMxzK0rNS84AySaml6aWlKSCRQvySxJL8oGixfmlQHWxXDB1AA "MATL – Try It Online")
Input is an array as `[{a;b},{c;d}]`. Bytecount fluctuates heavily while the OP figures out what's actually allowed.
```
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.
```
I started off with a 4-byte version that could only handle single-character strings, which was the only testcase in the original challenge. When this turned out to be invalid, I made a very long 14-byte version, which was nice and hacky (check the revision history!), made me discover a bug, and then turned out to be completely unnecessary as `Y=`, with suitable input, worked just as well as my original 4-byte `y=P)`.
[Answer]
# [Python 2](https://docs.python.org/2/), 37 bytes
```
lambda x,y:dict(x+map(reversed,x))[y]
```
[Try it online!](https://tio.run/##JchBCoAgEADAr3jbXdpTx6CXmAdLIyFLTEKJ3m5Ft2FCScu@tXXuh7pqPxotMpfOuClhbrwOGO1p42ENZyJZVA3RbQlnlAgIDATEAuF6ef@ULxWQYvEN1Qc "Python 2 – Try It Online")
# [Proton](https://github.com/alexander-liao/proton), 31 bytes
```
a,b=>dict(a+map(reversed,a))[b]
```
[Try it online!](https://tio.run/##JcgxDoAgDADAr7C1jf0CfoQwFIGEQSBIXIxvrxq3y/XRZquarQoHu8ayTZRll44jnWkcKbIQueC1j1InZnQICAwExAbhenn/dC89kGfzDekD "Proton – Try It Online")
(These two answers are so similar that I'm posting them together to avoid repfarming)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ċÞṪ⁻ÞṪ
```
A dyadic link taking the list partners on the left and the lost-partner on the right and returning the partner.
**[Try it online!](https://tio.run/##y0rNyan8//9I9@F5D3euetS4G0z///8/WkPJUz1XSUdBKThfSVNHQUPJN7UkEcR3LUvNg4iEZGQWg0Qck4vy8ypzlTRj/0NkAQ "Jelly – Try It Online")**
### How?
```
ċÞṪ⁻ÞṪ - 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)
```
[Answer]
# [Perl 5](https://www.perl.org/), 30 + 1 (-p) = 31 bytes
```
$_={@f=eval$_,reverse@f}->{<>}
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3rbaIc02tSwxRyVepyi1LLWoONUhrVbXrtrGrvb/fw11DXUddU11TR0FDfVqILMWwowGMmPVNbli/@UXlGTm5xX/1/U11TMwNPivWwAA "Perl 5 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~59~~ ~~45~~ 42 bytes
*-14 bytes thanks to Emigna. -3 bytes thanks to Maltysen.*
```
lambda l,v:sum(l,())[sum(l,()).index(v)^1]
```
[Try it online!](https://tio.run/##TZAxC8IwEIX3/orDJYkUQUfBwcGhg1PdaoW0TTHQJiFJi0X87dVLqpglj3fvexdiJn/Xaje3h@vc8b5qOHTpuHdDT7uUMlb81EaqRjzoyG7bcvbCeQcHKBL4HFpQQkkKhBGWAiVP1K@oC9QlYeVifYFVRvrVx8t1zJ2F5xg9jUJF53KXDp1jbbWa@lixjH9rM0zkS0XgFziQkTn@A/hynNXcCRez3Ap02kHFfIj8IY43OK@EMBGotDbBwTsgQQFLyiRptQUJUkH4o31oMVYqDy1dSza/AQ "Python 2 – Try It Online")
Still wanna use currying though. ;-;
[Answer]
## C++, 179 bytes
```
#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/ map data type, 162 bytes
```
#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"";}
```
With MSVC, the code compiles even if the last `return` statement ( `return"";` ) is omitted. It makes the code 9 bytes lighter, **BUT** exiting by the function end ( i.e. not exiting by a `return` statement in the loop ) with no return statements will cause **undefined behavior**, and not work if the tuple array does not contains the "key" element
[Answer]
# PowerShell, 36 Bytes
```
param($a,$c)$a|?{$c-in$_}|%{$_-ne$c}
```
finds the element containing the intput, then gets the 'other' element by excluding the input from it, PowerShell doesn't have the most amazing array management but there might be a built-in for this i'm not aware of.
```
.\Partner.ps1 (("I'm","So"),("Meta","Even"),("This","Acronym")) "Even"
Meta
```
[Answer]
# [Röda](https://github.com/fergusq/roda), 30 bytes
```
f a{[(_+"")[1-indexOf(a,_1)]]}
```
[Try it online!](https://tio.run/##fcyxDoIwFAXQWb@i6WIbceATHBwcjINuTUMeUCIDLaHVaJBvr7wW2GTq7c19pzMleF8R6AXL9pRykR5qXar3tWKQZCmXcvAN1Jr0240QVNCEUEllQgTtMQ8xz70kX1KxseVjKIwuwDGMbVdrxzIekPOuwfnNxNuLcoD/00vp2NwftcXmWHRGf5qFDYtVObgTG8wJDNriHFcRp6zDfQFW2XgPncKmeurFCKs1xkKJN7lSbURyY9rQ4Dsz4fOPGfwP "Röda – Try It Online")
Explanation:
```
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]
## Mathematica ~~27~~ 24 Bytes
`Cases` picks out elements of a list that match a pattern. When used with an arrow, elements matching patterns can be transformed.
```
Cases[{#,x_}|{x_,#}:>x]&
```
Usage:
```
%[3][{{1, 2}, {3, 4}}]
```
Explanation: In this example, after encountering the first argument, 3, the function becomes `Cases[{3,x_}|{x_,3}:>x]` which is an operator form of `Cases` that is then applied to the 2nd argument, `{{1, 2}, {3, 4}}`, thus selecting the companion of 3, whether it be in the abscissa or ordinate position. Notably, this function will list out all of the companions if in fact the 1st argument appears more than once within the 2nd argument, in other words, this goes a little beyond the assumptions of the stated question.
Enclosing glyphs must be squiggly braces. Saved 3 bytes with "Currying" suggestion from @Notatree
[Answer]
# [R](https://www.r-project.org/), 47 ~~42~~ bytes
```
function(v,a)a[(i=min(which(v==a)))+(i%%2*2-1)]
```
[Try it online!](https://tio.run/##fYsxDsIwDEX3nqKKVNkGM5A9J6k6pKFRPTSpSilIiLMHw1AxMb0vvf@WEl2JtxRWyQk39uRbFDdJwvsoYcTNOU9ER5SmsQd7OlNXIkKf8ww8@XWRBwY0V38xXJt@GOYvVe8ktkSVRu1PAQgMBFzDU8frM1RDB/tb5b8bVeUN "R – Try It Online")
Works on either a matrix or a straight vector. v = the search value, a = tuple array.
[Answer]
# Pyth - ~~11~~ ~~9~~ 8 bytes
```
h-hf}QTE
```
[Try it online here](http://pyth.herokuapp.com/?code=h-hf%7DQTE&input=%27%5D%27%0A%5B%28%27%28%27%2C%27%29%27%29%2C+%28%27%7B%27%2C%27%7D%27%29%2C+%28%27%5B%27%2C%27%5D%27%29%5D&debug=0).
[Answer]
# [Haskell](https://www.haskell.org/), ~~65~~ 62 bytes
```
c#(a,b)|a==c=b|1>0=a
x%l=x#(snd(span(\(a,b)->a/=x&&b/=x)l)!!0)
```
[Try it online!](https://tio.run/##JYpBDoIwEADvvgKCsLtJVXjAcvLoD5DDFk1sLLWhPZCIb6@NXiaTyTwkPO/WJjP71xKLs0Q5XkyIaapQlKZNmCfWW9e3LLu1trxWGNwNgxeH199z6OXEa9PoTLJUli2lWYxjvxgX9/CGekBAUEBAqsAcFHz@OmQdgcb0BQ "Haskell – Try It Online")
## Explanation
This uses span to find the first instance where `x` is contained by the tuple. It then grabs the first element of the tuple if its not equal and the second otherwise.
# 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
```
[Try it online!](https://tio.run/##JYlBCsIwEADvvqLQlt1AFH3A9uRJ/EHtYVMVF9NYmhQCxrfHoJdhmHmwf96szTLNryVURw68O4sPeaxPqw/I2qjERCOZdOj2xJvYWor1XdwVL7@97cqPKZlCZfPE4mhexIUG3tD2CAgaFChdYQkaPn/tiw6ghvwF "Haskell – Try It Online")
## Explanation
This uses `Data.List`s `first` function to cut down on the bytes used by `(!!0).snd.span`, however because `first` returns a `Maybe` we need to add `Just` to our pattern match in `#`.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
```
.åÏ`¹K`
  Ï      # keep only pairs that contain the first input
   `     # flatten
    ¹K   # remove the first input
      `  # flatten
```
[Try it online!](https://tio.run/##MzBNTDJM/f9f7/DSw/0Jh3Z6J/z/r8EVHa2uoa6jrqkeqxOtXg1k1YJZ0UBWrHpsLAA "05AB1E – Try It Online")
**Alternative 7 byte solution**
```
˜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
```
[Try it online!](https://tio.run/##MzBNTDJM/f//9BwXz@yIuMMr/v@PjlbXUNdR11SP1YlWrwayasGsaCArVj02lksDAA "05AB1E – Try It Online")
[Answer]
# Common Lisp, 74 bytes
```
(lambda(a x)(or(cdr(assoc x a :test'equal))(car(rassoc x a :test'equal))))
```
[Try it online!](https://tio.run/##dck7CoAwEEXRrQzT@F7jAtyKWIzRQoi/SQRBXHtEe7vDvSFOaSvYfFqyoCDa3A8Gk5NYHWFwWEprkFNMmjymXI37YZFEMIf/TLJUgEJrUSoFer28P7YvOyW/wPIA)
[Answer]
# Java 8, 78 bytes
A lambda (curried) from `Stream<List<String>>` to a lambda from `String` to `String` (although implicit typing happens to allow this to work for arbitrary lists). The language has no dedicated tuple classes, and I'm not aware of any in the standard library, so input pairs are represented as lists. Can be assigned to `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()
```
[Try It Online](https://tio.run/##fVDLasMwEDwnXyF8qQS2oNc8DDm0UGhoIb2VHlRbSZXKayGt3Rrjb3fXUUpCDz1JmtkZ7cxRtSqrnYZj@Tm65t2aghVWhcC2ygDr5zPnTatQs4AKiTySQDZorNw3UKCpQd6fL6sLF9BrVcnd6bjCH03AFaEGDnme/msWp1L2O80OGp@VR9CerUeb5SHLSWcsas9dljtZ1IC0dOBBCFkpF1GS8dvMSQOl/n7aT6QgGZQb6Lg40WKcLeeUNMY/B21rU7KK/Hjc4PWNKX8IYupk9gsRSC2tGegvdoX1ffJwUyUpS3Z1MqSsT7Ya1fS@azVE5OXDhAnZFL6GrkqGYTkZdwF1JesGJRUPaIFfckvlnO34pbWN96oL57a5gRj7L79YqDAVT7mjQdxGCPpwmA/jDw)
I'll credit the saving of the last 6 bytes to anyone who can convince me that returning an `Optional` is valid. I haven't been able to convince myself.
One of the interesting parts of this solution for me was determining the cheapest way to get the output from the stream. I considered `reduce`, `findFirst`, and `min`/`max`, but none was shorter than the intuitive `findAny`.
[Answer]
# JavaScript (ES6), 45 bytes
Came up with this last night then noticed Neil had beaten me to a better JS solution; figured I may as well post it anyway.
Works with strings and integers.
```
a=>n=>a.reduce((x,y)=>y[1-y.indexOf(n)]||x,0)
```
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org), 43 bytes
```
f([[A,B]|T],X,R):-A=X,R=B;B=X,R=A;f(T,X,R).
```
[Try it online!](https://tio.run/##KyjKz8lP1y0uz/z/P00jOtpRxym2JiRWJ0InSNNK19EWSNs6WTuBaUfrNI0QsIweRLGShpKOgpKmUqxOtFI1iFkLZCpEK0WD2LFKsbE6IOEITT0A "Prolog (SWI) – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), ~~101~~ 100 + 18 bytes
thank you to Grzegorz Puławski helping reducing a couple of bytes.
```
x=>y=>x.Where(z=>z.Item1==y).FirstOrDefault()?.Item2??x.Where(z=>z.Item2==y).FirstOrDefault()?.Item1
```
[Try it online!](https://tio.run/##fY9Pa8MwDMXP86cQPtmQGdpraufQUShs7LBBDyEHkymdIXU629mahnz2LH/GWFuYdBD6vQfSy/19Xjnsa2/sHl4aH/AQk7@beDT2IyZ5qb2HY0vABx1MDpva5qvX@ljiygc3@COYp0qzaBLhiqtC9iepGqlOYveODtlZqrPYDkcWUjZcbIzz4dk9YKHrMjCeTNoySW78y3/8iz4mPz9@VuYNnrSxbH4hzUC7veekJXfryvqqRLFzJuCQEVnBLH7BRaTfRO2ExdqhDsgooxFQTnl0idsRdzc4HXFGecfZqPKYdEPDXIT03w "C# (.NET Core) – Try It Online")
# C# (.NET Core), ~~122~~ ~~121~~ 120 bytes
```
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"";}
```
[Try it online!](https://tio.run/##bY9Ba4QwEIXPza8YckpYK929ZuNloVDYnlroQTwEO9qAGyWJrRLy262uIN22c5nhe2/gvdLdl63FqXfa1PAyOo8XQYy6oOtUieACKRvlHHSBgPPK6xIee1MeX/uuwaPzdv5LYN1ZXiRXEX7xrJLTILNRZqFqLdPGg5YPQh@H9Iym9h9C73Y86IoNuS7SpznEXsqRB4u@twY2ehDxp@nwr2kvYlwZpSJOYgv@2ep3eFbasDVXXoCyteMkkLtTa1zbYPpmtcezNsgqZvALbnpuNcMVpyeLyiOjjCZAOeXJLQ4Ljn9wvuCC8sjZonJBIoF15itO3w "C# (.NET Core) – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 10 bytes
```
→ḟo=⁰←S+m↔
```
[Try it online!](https://tio.run/##yygtzv7//1HbpIc75ufbPmrc8KhtQrB27qO2Kf///1dKys8vUPofraFUnJiipKOUlJpaoKSpowER14FQmrEA "Husk – Try It Online")
### Ungolfed/Explanation
```
            -- 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
```
**Note**: The above example works on integers just for the sake of readability, the type itself doesn't matter (as long as you can compare it).
[Answer]
# [Swift 4](http://swift.sandbox.bluemix.net/#/repl/59c7ce136032437898077606), 43 bytes
```
{a,m in a.flatMap{$0==m ?$1:$1==m ?$0:nil}}
```
The output is an array, which is either empty (no partner found), or has a single element (the partner).
[Test cases:](http://swift.sandbox.bluemix.net/#/repl/59c7ce136032437898077606)
```
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]
# [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), 30 bytes
```
{_?~A=G|_X]_?~A=;|Z=B]~B=C|Z=A
```
QBIC isn't strong on lists and tuples. The above code takes `a` as a command line parameter, then asks for user input in pairs for the tuples. When an empty element is given, it outputs `b`. 
# Sample run
```
Command line: Even
I'm
So
Meta
Even
This
Acronym
Meta
```
# Explanation
```
{           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
```
## Alternative version, 22 bytes
```
{_?_?~A=;|_XB]~B=C|_XA
```
This basically does the same as the longer version, but immediately quits when it finds a match. I've listed this as the alternative, because you can't input all tuples into this program given that it quits early.
[Answer]
# [Arturo](https://arturo-lang.io), 32 bytes
```
$[a,s][--select.n:1a=>[in? s&]s]
```
[Try it](http://arturo-lang.io/playground?Lq5Mzm)
[Answer]
# Mathematica, 50 bytes
```
(t={#2};Select[Complement[#,t]&/@#,Length@#==1&])&
```
[Try it online!](https://tio.run/##y00sychMLv6fZvtfo8S2Wtmo1jo4NSc1uSTaOT@3ICc1NzWvJFpZpyRWTd9BWccnNS@9JMNB2dbWUC1WU@1/QFFmXomCQ1p0dbVSopKOglKSUq2OQrVSMoidAmGngthpSrW1YCr2PwA "Mathics – Try It Online")
[Answer]
# Ruby, 31 bytes
```
->a,e{e=*e;a.find{|p|p!=p-e}-e}
```
Returns a singleton array.
[Answer]
# [Stacked](https://github.com/ConorOBrien-Foxx/stacked), 21 bytes
```
[:$revmap,KeyArray\#]
```
[Try it online!](https://tio.run/##TZAxa8MwEIV3/YoHKZwUQoaOTluSoUMondrN8aA4Z5y2toykBEzpb3dPtlMqENLdfe@ddCHa8pNPw5Bnd56vje1WL9zvvLf9YVEM26xSSi/ReY6xR@QQUV3aMp5di6VR@WKFDOv1GhUOEIfOQzxA2Mj@cOdW0mN2JfHj0y3pLrHANkt@amwwOpc2cNjAVYg1o3K@AQW2vqwJOl66LzapqdIKoB/CvLQmTSBDBpq@KZXSLZdbQcYk@PnKLd3gPVEjtTc3Yq8cLc1Eit/rc5B4V3rX9s2s3/1vtk/iSZuEkypJZnj8Bs1w@hjdcom0niWWIc700bnu72nBnqR4ZO5GdqpNh9DK4H7xgDzNO/kWaGXYwy8 "Stacked – Try It Online") This takes input from the the stack and leaves output on the stack. Expanded, this looks like:
```
[ : $rev map , KeyArray \ # ]
```
## Explanation
Let's take `(('sad' 'beep') ('boop' 'boop'))` and `'boop'` as the input. Then, an array like so is constructed by `:$revmap,`:
```
(( 'sad' 'beep')
 ('boop' 'boop')
 ('beep'  'sad')
 ('boop' 'boop'))
```
That is, a copy of the array is map, each member is reversed, and the two are concatenated together. `KeyArray` in turn makes a hash out of the values given, like so:
```
KeyArray [ sad => beep, boop => boop, beep => sad, boop => boop ]
```
Then, `\` brings the search string to the top of the stack, and obtains the key from the KeyArray that matches with `#`. This returns only one value, so the duplicate key in the KeyArray does not need to be worried about.
## Other approaches
32 bytes: (input from stack, output to STDOUT) `[@x:$revmap,uniq[...x=$out*]map]`
36 bytes: `{%x[y index#+]YES 0# :y neq keep 0#}`
38 bytes: `[@x:$revmap#,[KeyArray x#]map:keep 0#]`
46 bytes: `[@x:KeyArray\$revmap KeyArray,[x#]map:keep 0#]`
[Answer]
# Excel, 18 Bytes
Anonymous Excel Workbook Formula that takes input as `<Lookup Value>` from range `A1`, `<Key Array>` from range `B:B` and `<Def Array>` from range `C:C`, and outputs the value of the definition associated with the lookup value to the calling cell
```
=VLOOKUP(A1,B:C,2)
```
Sample I/O shall be included when possible
]