Sfida

Dato un elenco arbitrario di 2 tuple e un singolo elemento in una di quelle tuple, produce il suo "partner", ovvero dato ae [(i,j),...,(a,b),...,(l,m)], prodotto b. Puoi presumere che tutte le tuple siano uniche e che tutti gli elementi nelle tuple siano stringhe. Supponi inoltre che non hai entrambi (x,y)e (y,x).

Casi test

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"

Vince il minor numero di byte!

Japt, 6 byte

Funziona con stringhe o numeri interi.

æøV kV

Provalo

Spiegazione

Input implicito di array Ue stringa / intero V.

æ

Ottieni il primo elemento (subarray) in Uquel ...

øV

Contiene V.

kV

Rimuovi Ve restituisce implicitamente l'array a singolo elemento risultante.

Haskell , 33 byte

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

Provalo online!

Definisce un operatore binario !, che assume come argomento sinistro un valore xdi tipo τ e come argomento destro un elenco di tuple (τ, τ). Il modello di definizione corrisponde sulla testa (a,b)e sulla coda cdell'elenco dato; se x==apoi bviene restituito; se x==bpoi aviene restituito, e altrimenti continuiamo a cercare nel resto dell'elenco ricorrendo.

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

(Se non c'è un "partner" nell'elenco, questo si bloccherà, perché non abbiamo definito ciò che x![]dovrebbe essere.)

JavaScript (ES6), 39 byte

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

Prende la voce e la matrice di array come argomenti al curry. La migliore versione non ricorsiva che ho potuto fare è stata di 44 byte:

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

MATL , 4 14 5 6 byte

yY=P)u

Provalo online!

L'input è un array come [{a;b},{c;d}]. Bytecount fluttua pesantemente mentre l'OP capisce cosa è effettivamente consentito.

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.

Ho iniziato con una versione a 4 byte in grado di gestire solo stringhe a carattere singolo, che era l'unica testcase nella sfida originale. Quando questo si è rivelato non valido, ho realizzato una versione a 14 byte molto lunga, che era carina e caotica (controlla la cronologia delle revisioni!), Mi ha fatto scoprire un bug e poi si è rivelato completamente superfluo come Y=, con input adatto , ha funzionato bene come il mio originale a 4 byte y=P).

Python 2 , 37 byte

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

Provalo online!

Proton , 31 byte

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

Provalo online!

(Queste due risposte sono così simili che le sto postando insieme per evitare il repfarming)

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

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

Provalo online!

Python 2 , 59 45 42 byte

-14 byte grazie a Emigna. -3 byte grazie a Maltysen.

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

Provalo online!

^{Voglio comunque usare il curry. ; -;}

C ++, 179 byte

#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 di dati cartografici, 162 byte

#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, il codice viene compilato anche se l'ultima returnistruzione ( return"";) viene omessa. Rende il codice di 9 byte più leggero, MA uscendo dall'estremità della funzione (cioè non uscendo da returnun'istruzione nel ciclo) senza istruzioni di ritorno causerà un comportamento indefinito e non funzionerà se l'array tuple non contiene l'elemento "chiave"

PowerShell, 36 byte

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

trova l'elemento contenente l'intput, quindi ottiene l'elemento "altro" escludendo l'input da esso, PowerShell non ha la gestione dell'array più sorprendente ma potrebbe esserci un built-in per questo di cui non sono a conoscenza.

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

Röda , 30 byte

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

Provalo online!

Spiegazione:

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 byte

Casesseleziona gli elementi di un elenco che corrispondono a un modello. Se utilizzato con una freccia, gli elementi che corrispondono ai motivi possono essere trasformati.

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

Uso:

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

Spiegazione: In questo esempio, dopo aver incontrato il primo argomento, 3, la funzione diventa Cases[{3,x_}|{x_,3}:>x]quale forma di operatore Casesviene quindi applicata al 2 ° argomento, {{1, 2}, {3, 4}}selezionando quindi il compagno di 3, sia che si trovi in ​​ascissa o in posizione ordinata. In particolare, questa funzione elencherà tutti i compagni se in effetti il ​​1 ° argomento appare più di una volta nel 2 ° argomento, in altre parole, questo va un po 'oltre le ipotesi della domanda dichiarata.

I glifi inclusi devono essere parentesi graffe. Salvato 3 byte con il suggerimento "Currying" da @Notatree

R , 47 42 byte

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

Provalo online!

Funziona su una matrice o un vettore dritto. v = il valore di ricerca, a = matrice tupla.

Gelatina , 6 byte

ċÞṪ⁻ÞṪ

Un collegamento diadico che prende i partner della lista a sinistra e il partner perduto a destra e restituisce il partner.

Provalo online!

Come?

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

h-hf}QTE

Provalo online qui .

Haskell , 65 62 byte

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

Provalo online!

Spiegazione

Questo utilizza span per trovare la prima istanza in cui xè contenuta la tupla. Quindi prende il primo elemento della tupla se non è uguale e il secondo altrimenti.

Haskell Lambdabot, 59 56 byte

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

Provalo online!

Spiegazione

Questa utilizza Data.Listla firstfunzione s per ridurre i byte utilizzati da (!!0).snd.span, tuttavia poiché firstrestituisce un valore Maybeche è necessario aggiungere Justalla corrispondenza del modello in #.

05AB1E , 7 byte

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

Provalo online!

Soluzione alternativa a 7 byte

˜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

Provalo online!

Lisp comune, 74 byte

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

Provalo online!

Java 8, 78 byte

Un lambda (curry) da Stream<List<String>>a un lambda da Stringa String(anche se la tipizzazione implicita accade per consentire a questo di funzionare per elenchi arbitrari). Il linguaggio non ha classi di tuple dedicate e non ne sono a conoscenza nella libreria standard, quindi le coppie di input sono rappresentate come liste. Può essere assegnato 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()

Provalo online

Accrediterò il salvataggio degli ultimi 6 byte a chiunque possa convincermi che la restituzione di un valore Optionalè valida. Non sono stato in grado di convincermi.

Una delle parti interessanti di questa soluzione per me è stata determinare il modo più economico per ottenere l'output dal flusso. Ho considerato reduce, findFirste min/ max, ma nessuno era più breve dell'intuitivo findAny.

Rubino, 31 byte

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

Restituisce un array singleton.

JavaScript (ES6), 45 byte

Arrivò con quest'ultima notte, poi notò che Neil mi aveva battuto per una soluzione JS migliore; ho pensato di poterlo pubblicare comunque.

Funziona con stringhe e numeri interi.

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

Prolog (SWI) , 43 byte

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

Provalo online!

C # (.NET Core) , 101 100 + 18 byte

grazie a Grzegorz Puławski che aiuta a ridurre un paio di byte.

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

Provalo online!

C # (.NET Core), 122 121 120 byte

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

Provalo online!

Buccia , 10 byte

→ḟo=⁰←S+m↔

Provalo online!

Ungolfed / Spiegazione

            -- 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 : l'esempio sopra funziona su numeri interi solo per motivi di leggibilità, il tipo stesso non ha importanza (purché sia ​​possibile confrontarlo).

Swift 4 , 43 byte

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

L'output è un array, che è vuoto (nessun partner trovato) o ha un singolo elemento (il partner).

Casi test:

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 byte

{_?~A=G|_X]_?~A=;|Z=B]~B=C|Z=A

QBIC non è forte su elenchi e tuple. Il codice sopra riportato assume acome parametro la riga di comando, quindi richiede l'input dell'utente in coppia per le tuple. Quando viene dato un elemento vuoto, viene emesso b.

Esecuzione del campione

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

Meta

Spiegazione

{           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

Versione alternativa, 22 byte

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

Questo sostanzialmente fa lo stesso della versione più lunga, ma si chiude immediatamente quando trova una corrispondenza. L'ho elencato come alternativa, perché non puoi inserire tutte le tuple in questo programma dato che si chiude presto.

Mathematica, 50 byte

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

Provalo online!

Impilato , 21 byte

[:$revmap,KeyArray\#]

Provalo online! Questo prende input dallo stack e lascia l'output nello stack. Espanso, questo assomiglia a:

[ : $rev map , KeyArray \ # ]

Spiegazione

Prendiamo (('sad' 'beep') ('boop' 'boop'))e 'boop'come input. Quindi, un array come questo è costruito da :$revmap,:

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

Cioè, una copia dell'array è map, ogni membro viene invertito e i due vengono concatenati insieme. KeyArraya sua volta crea un hash dai valori indicati, in questo modo:

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

Quindi, \porta la stringa di ricerca in cima allo stack e ottiene la chiave dall'Array Key corrispondente# . Ciò restituisce un solo valore, quindi non è necessario preoccuparsi della chiave duplicata in KeyArray.

Altri approcci

32 byte: (input dallo stack, output a STDOUT) [@x:$revmap,uniq[...x=$out*]map]

36 byte: {%x[y index#+]YES 0# :y neq keep 0#}

38 byte: [@x:$revmap#,[KeyArray x#]map:keep 0#]

46 byte: [@x:KeyArray\$revmap KeyArray,[x#]map:keep 0#]

Excel, 18 byte

Formula anonima della cartella di lavoro di Excel che accetta input <Lookup Value>dall'intervallo A1, <Key Array>dall'intervallo B:Be <Def Array>dall'intervallo C:Ce genera il valore della definizione associato al valore di ricerca nella cella chiamante

=VLOOKUP(A1,B:C,2)

Gli I / O del campione devono essere inclusi quando possibile