Desafio

Dada uma lista arbitrária de duas tuplas e um único elemento em uma dessas tuplas, produza seu "parceiro", isto é, dado ae [(i,j),...,(a,b),...,(l,m)], saída b. Você pode assumir que todas as tuplas são únicas e que todos os elementos nas tuplas são cadeias. Além disso, assuma que você não possui os dois (x,y)e (y,x).

Casos de teste

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"

Menos bytes ganha!

Japonês, 6 bytes

Funciona com cadeias ou números inteiros.

æøV kV

Teste-o

Explicação

Entrada implícita de matriz Ue sequência / número inteiro V.

æ

Obtenha o primeiro elemento (subarray) Unesse ...

øV

Contém V.

kV

Remova Ve retorne implicitamente a matriz de elemento único resultante.

Haskell , 33 bytes

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

Experimente online!

Define um operador binário !, que assume como argumento à esquerda um valor xdo tipo τ e como argumento à direita uma lista de tuplas (τ, τ). O padrão de definição corresponde à cabeça (a,b)e à cauda cda lista fornecida; se x==aentão bé retornado; se x==bthen afor retornado; caso contrário, continuaremos procurando no restante da lista recorrendo.

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

(Se não houver um "parceiro" na lista, isso falhará, porque não definimos o que x![]deveria ser.)

JavaScript (ES6), 39 bytes

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

Toma a entrada e a matriz de matrizes como argumentos ao curry. A melhor versão não recursiva que eu pude fazer foi 44 bytes:

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

MATL , 4 14 5 6 bytes

yY=P)u

Experimente online!

Entrada é uma matriz como [{a;b},{c;d}]. O Bytecount flutua fortemente enquanto o OP descobre o que é realmente permitido.

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.

Comecei com uma versão de 4 bytes que só podia lidar com cadeias de caracteres únicos, que era o único caso de teste no desafio original. Quando isso se mostrou inválido, criei uma versão muito longa de 14 bytes, que era agradável e hacky (verifique o histórico de revisões!), Me fez descobrir um bug e depois me tornei completamente desnecessário Y=, com entrada adequada , funcionou tão bem quanto meu original de 4 bytes y=P).

Python 2 , 37 bytes

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

Experimente online!

Próton , 31 bytes

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

Experimente online!

(Essas duas respostas são tão parecidas que as estou postando juntas para evitar repfarming)

Perl 5 , 30 + 1 (-p) = 31 bytes

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

Experimente online!

Python 2 , 59 45 42 bytes

-14 bytes graças a Emigna. -3 bytes graças a Maltysen.

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

Experimente online!

^{Ainda quero usar curry embora. ; -;}

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 ++ com tipo de dados mapa, 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"";}

Com o MSVC, o código compila mesmo que a última returninstrução ( return"";) seja omitida. Torna o código 9 bytes mais leve, mas sair pelo final da função (ou seja, não sair por uma returninstrução no loop) sem instruções de retorno causará um comportamento indefinido e não funcionará se a matriz tupla não contiver o elemento "key"

PowerShell, 36 bytes

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

encontra o elemento que contém a intput e, em seguida, obtém o elemento 'other' excluindo a entrada, o PowerShell não possui o gerenciamento de matriz mais incrível, mas pode haver um recurso interno para isso de que não conheço.

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

Röda , 30 bytes

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

Experimente online!

Explicação:

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

Casesseleciona elementos de uma lista que correspondem a um padrão. Quando usado com uma seta, os elementos correspondentes aos padrões podem ser transformados.

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

Uso:

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

Explicação: Neste exemplo, depois de encontrar o primeiro argumento, 3, a função passa a Cases[{3,x_}|{x_,3}:>x]ser uma forma de operador Casesque é aplicada ao segundo argumento, {{1, 2}, {3, 4}}selecionando assim o companheiro de 3, seja na posição de abcissa ou ordenada. Notavelmente, essa função listará todos os companheiros se, de fato, o 1º argumento aparecer mais de uma vez no segundo argumento, ou seja, isso vai um pouco além das suposições da pergunta declarada.

Os glifos envolventes devem ser chaveados. 3 bytes salvos com a sugestão "Currying" de @Notatree

R , 47 42 bytes

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

Experimente online!

Funciona em uma matriz ou em um vetor reto. v = o valor da pesquisa, a = matriz de tupla.

Gelatina , 6 bytes

ċÞṪ⁻ÞṪ

Um link diádico que pega a lista de parceiros à esquerda e o parceiro perdido à direita e retorna o parceiro.

Experimente online!

Quão?

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

Pitão - 11 9 8 bytes

h-hf}QTE

Experimente online aqui .

Haskell , 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)

Experimente online!

Explicação

Isso usa span para encontrar a primeira instância em que xestá contida na tupla. Ele pega o primeiro elemento da tupla, se não for igual, e o segundo, caso contrário.

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

Experimente online!

Explicação

Isso usa Data.Lista firstfunção s para reduzir os bytes usados ​​por (!!0).snd.span, no entanto, porque firstretorna a Maybe, precisamos adicionar Justà nossa correspondência de padrões em #.

05AB1E , 7 bytes

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

Experimente online!

Solução alternativa de 7 bytes

˜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

Experimente online!

Lisp comum, 74 bytes

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

Experimente online!

Java 8, 78 bytes

Um lambda (com curry) de Stream<List<String>>para um lambda de Stringpara String(embora a digitação implícita ocorra para permitir que isso funcione para listas arbitrárias). O idioma não possui classes de tupla dedicadas e eu não conheço nenhuma na biblioteca padrão; portanto, os pares de entrada são representados como listas. Pode ser atribuído a 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()

Experimente Online

Vou creditar o salvamento dos últimos 6 bytes a qualquer pessoa que possa me convencer de que retornar um Optionalé válido. Não consegui me convencer.

Uma das partes interessantes desta solução para mim foi determinar a maneira mais barata de obter a saída do fluxo. Eu considerei reduce, findFirste min/ max, mas nenhum foi menor que o intuitivo findAny.

Ruby, 31 bytes

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

Retorna uma matriz singleton.

JavaScript (ES6), 45 bytes

Cheguei com isso ontem à noite e notei que Neil havia me derrotado para uma solução JS melhor; achei que eu poderia postá-lo de qualquer maneira.

Funciona com cadeias e números inteiros.

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

Prolog (SWI) , 43 bytes

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

Experimente online!

C# (.NET Core), 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!

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!

Husk, 10 bytes

→ḟo=⁰←S+m↔

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

Swift 4, 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:

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

Mathematica, 50 bytes

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

Try it online!

Stacked, 21 bytes

[:$revmap,KeyArray\#]

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

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