Desafío

Dada una lista arbitraria de 2 tuplas, y un solo elemento en una de esas tuplas, genera su "compañero", es decir, dado ay [(i,j),...,(a,b),...,(l,m)], salida b. Puede suponer que todas las tuplas son únicas y que todos los elementos de las tuplas son cadenas. Además, suponga que no tiene ambos (x,y)y (y,x).

Casos de prueba

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"

¡Pocos bytes ganan!

Japt, 6 bytes

Funciona con cadenas o enteros.

æøV kV

Pruébalo

Explicación

Entrada implícita de matriz Uy cadena / entero V.

æ

Obtenga el primer elemento (subarreglo) en Ueso ...

øV

Contiene V.

kV

Elimine Vy devuelva implícitamente la matriz resultante de un solo elemento.

Haskell , 33 bytes

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

Pruébalo en línea!

Define un operador binario !, que toma como argumento izquierdo un valor xde tipo τ y como argumento derecho una lista de tuplas (τ, τ). El patrón de definición coincide en la cabeza (a,b)y la cola cde la lista dada; si x==aluego bse devuelve; si x==bluego ase devuelve, y de lo contrario seguimos buscando en el resto de la lista recurriendo.

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

(Si no hay un "socio" en la lista, se bloqueará porque no definimos lo que x![]debería ser).

JavaScript (ES6), 39 bytes

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

Toma la entrada y la matriz de matrices como argumentos curriculares. La mejor versión no recursiva que pude hacer fue de 44 bytes:

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

MATL , 4 14 5 6 bytes

yY=P)u

Pruébalo en línea!

La entrada es una matriz como [{a;b},{c;d}]. El recuento de bytes fluctúa fuertemente mientras el OP descubre lo que realmente está 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.

Comencé con una versión de 4 bytes que solo podía manejar cadenas de un solo carácter, que era el único caso de prueba en el desafío original. Cuando esto resultó no ser válido, hice una versión muy larga de 14 bytes, que era agradable y hacky (¡revise el historial de revisiones!), Me hizo descubrir un error y luego resultó ser completamente innecesario Y=, ya que con la entrada adecuada , funcionó tan bien como mi original de 4 bytes y=P).

Python 2 , 37 bytes

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

Pruébalo en línea!

Protón , 31 bytes

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

Pruébalo en línea!

(Estas dos respuestas son tan similares que las publico juntas para evitar repfarming)

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

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

Pruébalo en línea!

Python 2 , 59 45 42 bytes

-14 bytes gracias a Emigna. -3 bytes gracias a Maltysen.

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

Pruébalo en línea!

^{Sin embargo, todavía quiero usar curry. ; -;}

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 ++ con tipo de datos de 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"";}

Con MSVC, el código se compila incluso si se omite la última returninstrucción ( return"";). Hace que el código sea 9 bytes más liviano, PERO salir por el final de la función (es decir, no salir por una returndeclaración en el bucle) sin declaraciones de retorno causará un comportamiento indefinido y no funcionará si la matriz de tuplas no contiene el elemento "clave"

PowerShell, 36 bytes

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

encuentra el elemento que contiene el intput, luego obtiene el 'otro' elemento al excluir la entrada de él, PowerShell no tiene la administración de matriz más sorprendente, pero puede haber una función incorporada para esto que no conozco.

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

Röda , 30 bytes

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

Pruébalo en línea!

Explicación:

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

Casesselecciona elementos de una lista que coinciden con un patrón. Cuando se usa con una flecha, los elementos que coinciden con los patrones se pueden transformar.

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

Uso:

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

Explicación: en este ejemplo, después de encontrar el primer argumento, 3, la función se convierte en Cases[{3,x_}|{x_,3}:>x]una forma de operador Casesque luego se aplica al segundo argumento, {{1, 2}, {3, 4}}seleccionando así el compañero de 3, ya sea en la posición de abscisa u ordenada. Notablemente, esta función enumerará a todos los compañeros si de hecho el primer argumento aparece más de una vez dentro del segundo argumento, en otras palabras, esto va un poco más allá de los supuestos de la pregunta planteada.

Los glifos que encierran deben ser llaves onduladas. Guardado 3 bytes con la sugerencia "Curry" de @Notatree

R , 47 42 bytes

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

Pruébalo en línea!

Funciona en una matriz o en un vector lineal. v = el valor de búsqueda, a = matriz de tuplas.

Jalea , 6 bytes

ċÞṪ⁻ÞṪ

Un enlace diádico que toma la lista de socios a la izquierda y el compañero perdido a la derecha y devuelve al compañero.

Pruébalo en línea!

¿Cómo?

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

h-hf}QTE

Pruébelo en línea aquí .

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)

Pruébalo en línea!

Explicación

Esto utiliza span para encontrar la primera instancia donde xestá contenida la tupla. Luego toma el primer elemento de la tupla si no es igual y el segundo de lo contrario.

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

Pruébalo en línea!

Explicación

Esto utiliza Data.Listla firstfunción s para reducir los bytes utilizados por (!!0).snd.span, sin embargo, porque firstdevuelve un Maybenecesitamos agregar Justa nuestra coincidencia de patrón #.

05AB1E , 7 bytes

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

Pruébalo en línea!

Solución 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

Pruébalo en línea!

Lisp común, 74 bytes

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

Pruébalo en línea!

Java 8, 78 bytes

Una lambda (al curry) de Stream<List<String>>a una lambda de Stringa String(aunque la escritura implícita permite que esto funcione para listas arbitrarias). El lenguaje no tiene clases de tupla dedicadas, y no conozco ninguna en la biblioteca estándar, por lo que los pares de entrada se representan como listas. Se puede asignar 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()

Pruébalo en línea

Acreditaré el ahorro de los últimos 6 bytes a cualquiera que pueda convencerme de que devolver un Optionales válido. No he podido convencerme a mí mismo.

Una de las partes interesantes de esta solución para mí fue determinar la forma más barata de obtener la salida de la transmisión. Lo consideré reduce, findFirsty min/ max, pero ninguno fue más corto que el intuitivo findAny.

Ruby, 31 bytes

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

Devuelve una matriz singleton.

JavaScript (ES6), 45 bytes

Se me ocurrió esto anoche y luego noté que Neil me había golpeado para una mejor solución JS; Supuse que también podría publicarlo de todos modos.

Funciona con cuerdas y enteros.

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

Prólogo (SWI) , 43 bytes

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

Pruébalo en línea!

C # (.NET Core) , 101 + 18 bytes

Gracias a Grzegorz Puławski por ayudarnos a reducir un par de bytes.

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

Pruébalo en línea!

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

Pruébalo en línea!

Casco , 10 bytes

→ḟo=⁰←S+m↔

Pruébalo en línea!

Ungolfed / Explicación

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

Nota : El ejemplo anterior funciona en enteros solo por razones de legibilidad, el tipo en sí mismo no importa (siempre y cuando pueda compararlo).

Swift 4 , 43 bytes

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

La salida es una matriz, que está vacía (no se encontró ningún socio) o tiene un solo elemento (el socio).

Casos de prueba:

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 no es fuerte en listas y tuplas. El código anterior toma acomo parámetro de línea de comando, luego solicita la entrada del usuario en pares para las tuplas. Cuando se da un elemento vacío, generab .

Ejecución de la muestra

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

Meta

Explicación

{           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

Versión alternativa, 22 bytes.

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

Básicamente, hace lo mismo que la versión más larga, pero se cierra inmediatamente cuando encuentra una coincidencia. He enumerado esto como la alternativa, porque no puede ingresar todas las tuplas en este programa dado que se cierra antes.

Mathematica, 50 bytes

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

Pruébalo en línea!

Apilado , 21 bytes

[:$revmap,KeyArray\#]

Pruébalo en línea! Esto toma la entrada de la pila y deja la salida en la pila. Ampliado, esto se ve así:

[ : $rev map , KeyArray \ # ]

Explicación

Tomemos (('sad' 'beep') ('boop' 'boop'))y 'boop'como entrada. Entonces, una matriz como esta es construida por :$revmap,:

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

Es decir, una copia de la matriz es map, cada miembro se invierte y los dos se concatenan juntos. KeyArraya su vez hace un hash de los valores dados, así:

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

Luego, \lleva la cadena de búsqueda a la parte superior de la pila y obtiene la clave de KeyArray que coincide con# . Esto devuelve solo un valor, por lo que no es necesario preocuparse por la clave duplicada en KeyArray.

Otros enfoques

32 bytes: (entrada de la pila, salida a 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

Fórmula anónima del libro de Excel que toma la entrada como <Lookup Value>desde el rango A1, <Key Array>desde el rango B:By <Def Array>desde el rango C:C, y genera el valor de la definición asociada con el valor de búsqueda en la celda de llamada

=VLOOKUP(A1,B:C,2)

Se incluirán muestras de E / S cuando sea posible