Trouver votre partenaire


20

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!


Aussi, que faire si l'entrée apparaît plusieurs fois ou n'apparaît pas
Luis Mendo

Je ne suppose pas que nous pouvons prendre l'entrée comme une liste plate, non? Par exemple, [a, b, c, d]au lieu de [(a, b), (c, d)]. Cela réduirait une tonne d'octets de ma réponse. : P
totalement humain

J'ai édité pour, espérons-le, clarifier certaines choses et j'ai ajouté des cas de test. N'hésitez pas à revenir en arrière si quelque chose ne va pas.
totalement humain

@totallyhuman J'ai posé une question(a,a) spécifique et on m'a dit que cela n'arriverait pas . Nate a même édité la question pour préciser ce fait. Cependant, vous avez ajouté un cas de test avec une telle entrée et également modifié la spécification en inversant cette décision - pourquoi? C'est cassé un tas de réponses.
Jonathan Allan

1
@totallyhuman Je l'ai pris pour signifier "retourner n'importe quoi, planter, quoi que ce soit", d'autant plus que le message a ensuite été révisé pour dire que tout serait unique.
Jonathan Allan

Réponses:


8

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.


C'est ... J'ai littéralement essayé ce scénario exact, la même entrée et tout. J'ai dû manquer quelque chose ... EDIT: Ah oui, j'utilisais fplutôt æqu'à l'époque. Duh: P
ETHproductions

@ETHproductions: fait un bon changement - généralement je suis celui qui oublie æet essaie de se débrouiller avec f! : D
Shaggy

8

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


5

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)

Voici une solution non récursive de 41 octets:a=>b=>a.map(e=>b=e[1-e.indexOf(b)]||b)&&b
Rick Hitchcock

Vous ... Vous avez finalement cédé au curry?! : o
Shaggy

@Shaggy Normalement, je ne me soucie pas du type de curry (a,b)=>=> a=>b=>, mais la version non récursive a commencé à partir de la version récursive, qui a été curry parce que j'ai pu économiser 2 octets sur l'appel récursif (le curry lui-même coûte réellement un octet).
Neil

5

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


4

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)


Renommez- reversedle reverseen Proton pour -1 octet. \ s: P Plus sérieusement, reverseest-ce un bien meilleur nom, non? : P
totalement humain

@totallyafloppydisk peut-être / hausser les épaules mais je n'ai pas renommé la plupart des modules internes Python qui sont transférés vers Proton
HyperNeutrino


Désolé mon mauvais, ne tenez pas compte de ce commentaire.
Sanchises



2

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"


2

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

Cette approche ne fonctionne pas pour le ("boop", "boop")cas de test.
AdmBorkBork

2

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

2

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


1
Si vous avez la version 10 et que vous prenez des entrées par curry , vous pouvez économiser 3 octets:, Cases[{#,x_}|{x_,#}:>x]&utilisé comme%[3][{{1,2},{3,4}}]
Pas un arbre

Pouvez-vous expliquer un peu celui-ci?
Nate Stemen

2

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.


@Sanchises Merci, tout est réglé maintenant.
MickyT

2

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)

Ceci n'est pas valide car les nouveaux testcases ont été ajoutés.
Sanchises

1
Merci de l'avoir signalé - j'ai commenté la question à l'éditeur (j'avais spécifiquement demandé à l'OP à propos (a,a)et on m'a dit que nous n'avions pas besoin de le gérer). Je suis sûr que je pourrais le réparer, mais je ne sais pas si la spécification est telle qu'elle était prévue maintenant.
Jonathan Allan

Hmm, bien qu'en regardant l'historique des révisions, il semble que nous devons prendre en charge les chaînes et pas seulement les caractères, donc cela ne fonctionnera pas de toute façon ...
Jonathan Allan

Fonctionne avec la nouvelle spécification maintenant.
Jonathan Allan

C'était aussi mon interprétation du commentaire "eh bien", mais ce n'était évidemment pas le cas.
Sanchises


1

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


2
N'y pensez pas trop ... x!((a,b):c)|x==a=b|x==b=a|1<2=x!cc'est 33 octets.
Lynn

1
@Lynn Allez-y et postez-le. Je me sens un peu idiot de ne pas y penser, mais c'est vraiment votre réponse.
Wheat Wizard

Fair, publié ^^
Lynn

1

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!


˜D²k>èpour 6, à moins qu'il n'y ait une raison spécifique pour XOR'ing avec 1?
Magic Octopus Urn

@MagicOctopusUrn: La raison en est que même les indices devraient décrémenter et les indices impairs augmenter.
Emigna

Sauf l'inverse de ce que j'y ai écrit ...
Emigna


1

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.


1

Rubis, 31 octets

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

Renvoie un tableau singleton.


1

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)


1

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!


x=>y=>est plus court que (x,y)=>( Func<a, b, c>devient Func<a, Func<b, c>>et l'appel de fonction f(a, b)devient f(a)(b)) - Excellente réponse btw!
Grzegorz Puławski

Aussi pour la première réponse, la fonction elle-même n'utilise rien d'autre que System.Linq, donc vous ne pouvez ajouter que 18 octets pour répondre ( using System.Linq;contre namespace System.Linq{})
Grzegorz Puławski

@ GrzegorzPuławski merci pour l'aide et le compliment, j'espère avoir corrigé les réponses au tabac
Dennis.Verweij

1

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


1

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!")
}

1

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.


0

Mathematica, 50 octets

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

Essayez-le en ligne!


Cela ne fonctionne pas pour le {'boop','boop'}testcase.
Sanchises

@Sanchises "boop" n'était pas là quand j'ai répondu et la question ne portait pas sur [a, a] tuples.Je crois que les réponses avant boop-edit sont valides
J42161217

Je ne connais pas la politique de clarification du PO qui invalide les réponses existantes; c'était juste un avertissement sur le montage.
Sanchises

0

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


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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.