Défi

Étant donné une liste arbitraire de 2-tuples, et un seul élément dans l'un de ces tuples, sortez son "partenaire", c'est-à-dire given aet [(i,j),...,(a,b),...,(l,m)], output b. Vous pouvez supposer que tous les tuples sont uniques et que tous les éléments des tuples sont des chaînes. Supposons en outre que vous n'avez pas les deux (x,y)et (y,x).

Cas de 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"

Le moins d'octets gagne!

Japt, 6 octets

Fonctionne avec des chaînes ou des entiers.

æøV kV

Essaye-le

Explication

Entrée implicite de tableau Uet chaîne / entier V.

æ

Obtenez le premier élément (sous-tableau) dans Uce ...

øV

Contient V.

kV

Supprimez Vet renvoyez implicitement le tableau à un élément résultant.

Haskell , 33 octets

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

Essayez-le en ligne!

Définit un opérateur binaire !, qui prend comme argument de gauche une valeur xde type τ et comme argument de droite une liste de tuples (τ, τ). Le modèle de définition correspond à la tête (a,b)et à la queue cde la liste donnée; si x==aalors best retourné; si x==balors aest retourné, et sinon on continue à chercher dans le reste de la liste en récursif.

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

(S'il n'y a pas de «partenaire» dans la liste, cela plantera, car nous n'avons pas défini ce qui x![]devrait être.)

JavaScript (ES6), 39 octets

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

Prend l'entrée et le tableau de tableaux comme arguments au curry. La meilleure version non récursive que je pouvais faire était de 44 octets:

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

MATL , 4 14 5 6 octets

yY=P)u

Essayez-le en ligne!

L'entrée est un tableau en tant que [{a;b},{c;d}]. Bytecount fluctue fortement pendant que le PO détermine ce qui est réellement autorisé.

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.

J'ai commencé avec une version à 4 octets qui ne pouvait gérer que des chaînes de caractères uniques, ce qui était le seul cas test du défi d'origine. Lorsque cela s'est avéré invalide, j'ai fait une très longue version de 14 octets, qui était agréable et hacky (vérifiez l'historique des révisions!), M'a fait découvrir un bug, puis s'est avéré complètement inutile car Y=, avec une entrée appropriée , fonctionnait aussi bien que mon 4 octets d'origine y=P).

Python 2 , 37 octets

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

Essayez-le en ligne!

Proton , 31 octets

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

Essayez-le en ligne!

(Ces deux réponses sont si similaires que je les poste ensemble pour éviter de repfarming)

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

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

Essayez-le en ligne!

Python 2 , 59 45 42 octets

-14 octets grâce à Emigna. -3 octets grâce à Maltysen.

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

Essayez-le en ligne!

^{Je veux toujours utiliser le curry. ; -;}

C ++, 179 octets

#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 ++ avec type de données de carte, 162 octets

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

Avec MSVC, le code se compile même si la dernière returninstruction ( return"";) est omise. Cela rend le code 9 octets plus léger, MAIS la sortie par la fin de la fonction (c'est-à-dire la non-sortie par une returninstruction dans la boucle) sans instruction de retour entraînera un comportement indéfini et ne fonctionnera pas si le tableau de tuple ne contient pas l'élément "key"

PowerShell, 36 octets

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

trouve l'élément contenant l'entrée, puis obtient l'élément `` autre '' en excluant l'entrée de celui-ci, PowerShell n'a pas la gestion de tableau la plus étonnante mais il pourrait y avoir une fonction intégrée pour cela dont je ne suis pas au courant.

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

Röda , 30 octets

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

Essayez-le en ligne!

Explication:

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 octets

Casessélectionne les éléments d'une liste qui correspondent à un modèle. Lorsqu'il est utilisé avec une flèche, les éléments correspondant aux motifs peuvent être transformés.

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

Usage:

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

Explication: Dans cet exemple, après avoir rencontré le premier argument, 3, la fonction devient Cases[{3,x_}|{x_,3}:>x]qui est une forme opérateur Casesqui est ensuite appliquée au 2ème argument, {{1, 2}, {3, 4}}sélectionnant ainsi le compagnon de 3, que ce soit en abscisse ou en position ordonnée. Notamment, cette fonction listera tous les compagnons si en fait le 1er argument apparaît plus d'une fois dans le 2ème argument, en d'autres termes, cela va un peu au-delà des hypothèses de la question posée.

Les glyphes fermants doivent être des accolades ondulées. 3 octets enregistrés avec la suggestion "Currying" de @Notatree

R , 47 42 octets

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

Essayez-le en ligne!

Fonctionne sur une matrice ou un vecteur droit. v = la valeur de recherche, a = tableau de tuple.

Gelée , 6 octets

ċÞṪ⁻ÞṪ

Un lien dyadique prenant la liste des partenaires à gauche et le partenaire perdu à droite et renvoyant le partenaire.

Essayez-le en ligne!

Comment?

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

h-hf}QTE

Essayez-le en ligne ici .

Haskell , 65 62 octets

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

Essayez-le en ligne!

Explication

Cela utilise span pour trouver la première instance où xest contenu par le tuple. Il saisit ensuite le premier élément du tuple s'il n'est pas égal et le second sinon.

Haskell Lambdabot, 59 56 octets

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

Essayez-le en ligne!

Explication

Cela utilise la fonction Data.Lists firstpour réduire les octets utilisés par (!!0).snd.span, cependant, car firstrenvoie un que Maybenous devons ajouter Justà notre correspondance de modèle dans #.

05AB1E , 7 octets

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

Essayez-le en ligne!

Solution alternative à 7 octets

˜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

Essayez-le en ligne!

Lisp commun, 74 octets

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

Essayez-le en ligne!

Java 8, 78 octets

Un lambda (au curry) de Stream<List<String>>à un lambda de Stringà String(bien qu'un typage implicite arrive pour permettre à cela de fonctionner pour des listes arbitraires). Le langage n'a pas de classes de tuple dédiées, et je n'en connais pas dans la bibliothèque standard, donc les paires d'entrée sont représentées sous forme de listes. Peut être affecté à 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()

Essayez-le en ligne

Je créditerai la sauvegarde des 6 derniers octets à toute personne pouvant me convaincre que le retour d'un Optionalest valide. Je n'ai pas réussi à me convaincre.

Pour moi, l'une des parties intéressantes de cette solution consistait à déterminer le moyen le moins cher d'obtenir la sortie du flux. J'ai considéré reduce,, findFirstet min/ max, mais aucun n'était plus court que l'intuitif findAny.

Rubis, 31 octets

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

Renvoie un tableau singleton.

JavaScript (ES6), 45 octets

Je suis venu avec cette dernière nuit, puis j'ai remarqué que Neil m'avait battu pour une meilleure solution JS; pensé que je pourrais aussi bien le poster de toute façon.

Fonctionne avec des chaînes et des entiers.

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

Prolog (SWI) , 43 octets

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

Essayez-le en ligne!

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

merci à Grzegorz Puławski d'avoir aidé à réduire quelques octets.

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Husk , 10 octets

→ḟo=⁰←S+m↔

Essayez-le en ligne!

Non golfé / Explication

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

Remarque : l'exemple ci-dessus fonctionne sur des entiers juste pour des raisons de lisibilité, le type lui-même n'a pas d'importance (tant que vous pouvez le comparer).

Swift 4 , 43 octets

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

La sortie est un tableau, qui est soit vide (aucun partenaire trouvé), soit a un seul élément (le partenaire).

Cas de 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 octets

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

QBIC n'est pas fort sur les listes et les tuples. Le code ci-dessus prenda comme paramètre de ligne de commande, puis demande l'entrée utilisateur par paires pour les tuples. Lorsqu'un élément vide est donné, il sort b.

Exemple d'exécution

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

Meta

Explication

{           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

Version alternative, 22 octets

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

Cela fait essentiellement la même chose que la version plus longue, mais se ferme immédiatement lorsqu'il trouve une correspondance. Je l'ai répertorié comme alternative, car vous ne pouvez pas saisir tous les tuples dans ce programme étant donné qu'il se ferme tôt.

Mathematica, 50 octets

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

Essayez-le en ligne!

Empilé , 21 octets

[:$revmap,KeyArray\#]

Essayez-le en ligne! Cela prend l'entrée de la pile et laisse la sortie sur la pile. Développé, cela ressemble à:

[ : $rev map , KeyArray \ # ]

Explication

Prenons (('sad' 'beep') ('boop' 'boop'))et 'boop'comme entrée. Ensuite, un tableau comme celui-ci est construit par :$revmap,:

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

C'est-à-dire qu'une copie du tableau est mappée, chaque membre est inversé et les deux sont concaténés ensemble. KeyArrayà son tour crée un hachage des valeurs données, comme ceci:

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

Ensuite, place \la chaîne de recherche en haut de la pile et obtient la clé du KeyArray qui correspond à #. Cela ne renvoie qu'une seule valeur, il n'est donc pas nécessaire de s'inquiéter de la clé en double dans le KeyArray.

D'autres approches

32 octets: (entrée de la pile, sortie vers STDOUT) [@x:$revmap,uniq[...x=$out*]map]

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

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

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

Excel, 18 octets

Formule de classeur Excel anonyme qui prend les entrées <Lookup Value>de la plage A1, <Key Array>de la plage B:Bet <Def Array>de la plage C:Cet renvoie la valeur de la définition associée à la valeur de recherche à la cellule appelante

=VLOOKUP(A1,B:C,2)

Des échantillons d'E / S doivent être inclus lorsque cela est possible