挑战

给定一个任意的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"

最小字节获胜！

Japt，6个字节

适用于字符串或整数。

æøV kV

测试一下

说明

数组U和字符串/整数的隐式输入V。

æ

获取那个中的第一个元素（子数组）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==bthen 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)

将数组的条目和数组作为咖喱参数。我能做的最好的非递归版本是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}]。字节数波动很大，而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字节版本开始，这是原始挑战中唯一的测试用例。当发现这是无效的时，我制作了一个非常长的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]

在线尝试！

^{仍然想使用currying。;-;}

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 ++，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没有返回语句的函数结尾退出（即未由循环中的语句退出）将导致未定义的行为，并且如果元组数组不包含“ key”元素，则该行不起作用

PowerShell，36字节

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

找到包含intput的元素，然后通过从中排除输入来获取'other'元素，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字节

Cases从列表中挑选出与模式匹配的元素。与箭头一起使用时，可以转换与模式匹配的元素。

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

用法：

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

说明：在此示例中，遇到第一个参数3后，该函数成为Cases[{3,x_}|{x_,3}:>x]操作符形式的函数Cases，然后将其应用于第二个参数{{1, 2}, {3, 4}}，从而选择3的同伴，无论其在横坐标还是纵坐标位置。值得注意的是，如果实际上第一个参数在第二个参数中多次出现，则此函数将列出所有伴随对象，换句话说，这超出了所陈述问题的假设。

封闭的字形必须是弯曲的花括号。使用@Notatree的“ Currying”建议保存了3个字节

R，47 42字节

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

在线尝试！

适用于矩阵或直线向量。v =搜索值，a =元组数组。

果冻，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)

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元组所包含的第一个实例。然后，如果元组的第一个元素不相等，则将其获取，否则将获取第二个元素。

Haskell Lambdabot，59个 56字节

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

在线尝试！

说明

这使用Data.Lists first函数减少了所使用的字节(!!0).snd.span，但是由于first返回a，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

在线尝试！

Common Lisp，74个字节

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

在线尝试！

Java 8，78字节

Lambda（咖喱）从Stream<List<String>>到Lambda from 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。

Ruby，31个字节

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

返回单例数组。

JavaScript（ES6），45个字节

昨晚出现了这个问题，然后发现Neil在更好的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 Core），101 + 18字节

感谢GrzegorzPuławski帮助减少了几个字节。

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

在线尝试！

C＃（.NET核心），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"";}

在线尝试！

外壳，10个字节

→ḟo=⁰←S+m↔

在线尝试！

取消高尔夫/解释

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

注意：上面的示例仅出于可读性的目的而对整数起作用，类型本身并不重要（只要您可以比较它即可）。

斯威夫特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!")
}

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'))

也就是说，该数组的副本是map，每个成员都被反向，并且两者串联在一起。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>range A1，<Key Array>range B:B和<Def Array>range的输入C:C，并将与查找值关联的定义的值输出到调用单元格

=VLOOKUP(A1,B:C,2)

如果可能，应包括样本I / O