Herausforderung

Bei einer beliebigen Liste von 2 Tupeln und einem einzelnen Element in einem dieser Tupel wird dessen "Partner" ausgegeben, dh gegeben aund [(i,j),...,(a,b),...,(l,m)]ausgegeben b. Sie können davon ausgehen, dass alle Tupel eindeutig sind und dass alle Elemente in Tupeln Zeichenfolgen sind. Weiter nimm an du hast nicht beides (x,y)und (y,x).

Testfälle

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"

Wenigste Bytes gewinnt!

Japt, 6 Bytes

Funktioniert mit Zeichenfolgen oder ganzen Zahlen.

æøV kV

Probier es aus

Erläuterung

Implizite Eingabe von Array Uund String / Integer V.

æ

Holen Sie sich das erste Element (Subarray) in Udiesem ...

øV

Enthält V.

kV

Entfernen Sie Vdas resultierende Einzelelement-Array und geben Sie es implizit zurück.

Haskell , 33 Bytes

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

Probieren Sie es online!

Definiert einen binären Operator !, der als linkes Argument einen Wert xvom Typ τ und als rechtes Argument eine Liste von Tupeln (τ, τ) verwendet. Das Definitionsmuster stimmt mit dem Anfang (a,b)und dem Ende cder angegebenen Liste überein . wenn x==adann bwird zurückgegeben; wenn x==bdann awird zurückgegeben, und ansonsten fahren wir mit der Suche im Rest der Liste fort, indem wir rekursiv vorgehen.

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

(Wenn die Liste keinen „Partner“ enthält, stürzt dies ab, da wir nicht definiert haben, was x![]sein soll.)

JavaScript (ES6), 39 Byte

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

Nimmt den Eintrag und das Array von Arrays als gewöhnliche Argumente. Die beste nicht-rekursive Version, die ich machen konnte, war 44 Bytes:

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

MATL , 4 14 5 6 Bytes

yY=P)u

Probieren Sie es online!

Eingabe ist ein Array als [{a;b},{c;d}]. Die Anzahl der Bytes schwankt stark, während das OP herausfindet, was tatsächlich zulässig ist.

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.

Ich begann mit einer 4-Byte-Version, die nur einzelne Zeichenfolgen verarbeiten konnte, was der einzige Testfall in der ursprünglichen Herausforderung war. Als sich herausstellte, dass dies ungültig war, erstellte ich eine sehr lange 14-Byte-Version, die nett und abgehackt war (siehe Versionsgeschichte!), Die mich einen Fehler entdecken ließ und sich dann als völlig unnötig herausstellte, da sie Y=mit geeigneten Eingaben versehen war , funktionierte genauso gut wie mein ursprüngliches 4-Byte y=P).

Python 2 , 37 Bytes

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

Probieren Sie es online!

Proton , 31 Bytes

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

Probieren Sie es online!

(Diese beiden Antworten sind sich so ähnlich, dass ich sie zusammen veröffentliche, um ein erneutes Aufwärmen zu vermeiden.)

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

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

Probieren Sie es online!

Python 2 , 59 45 42 Bytes

-14 Bytes dank Emigna. -3 Bytes dank Maltysen.

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

Probieren Sie es online!

^{Ich möchte immer noch Curry verwenden. ; -;}

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 ++ mit Map-Datentyp, 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"";}

Mit MSVC wird der Code kompiliert, auch wenn die letzte returnAnweisung ( return"";) weggelassen wird. Es macht den Code 9 Bytes leichter, ABER das Verlassen durch das Funktionsende (dh das Nicht-Verlassen durch eine returnAnweisung in der Schleife) ohne Rückgabeanweisungen führt zu undefiniertem Verhalten und funktioniert nicht, wenn das Tupel-Array das "key" -Element nicht enthält

PowerShell, 36 Bytes

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

Findet das Element, das den Intput enthält, und erhält dann das 'andere' Element, indem die Eingabe von ihm ausgeschlossen wird. PowerShell verfügt nicht über die erstaunlichste Array-Verwaltung, aber möglicherweise ist eine integrierte Funktion dafür vorhanden, die mir nicht bekannt ist.

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

Röda , 30 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Caseswählt Elemente einer Liste aus, die einem Muster entsprechen. Bei Verwendung mit einem Pfeil können Elemente, die mit Mustern übereinstimmen, transformiert werden.

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

Verwendung:

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

Erläuterung: In diesem Beispiel wird die Funktion nach dem Auftreten des ersten Arguments 3 zu Cases[{3,x_}|{x_,3}:>x]einer Operatorform Cases, die dann auf das zweite Argument angewendet {{1, 2}, {3, 4}}wird. Auf diese Weise wird der Begleiter von 3 ausgewählt, unabhängig davon, ob er sich auf der Abszisse oder auf der Ordinate befindet. Bemerkenswerterweise listet diese Funktion alle Gefährten auf, wenn das erste Argument tatsächlich mehr als einmal im zweiten Argument vorkommt, mit anderen Worten, dies geht ein wenig über die Annahmen der angegebenen Frage hinaus.

Umschließende Glyphen müssen geschweifte Klammern sein. 3 Bytes mit dem Vorschlag "Currying" von @Notatree gespeichert

R , 47 42 Bytes

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

Probieren Sie es online!

Funktioniert entweder mit einer Matrix oder einem geraden Vektor. v = der Suchwert, a = Tupelarray.

Gelee , 6 Bytes

ċÞṪ⁻ÞṪ

Ein dyadischer Link, der die Listenpartner links und den verlorenen Partner rechts aufnimmt und den Partner zurückgibt.

Probieren Sie es online!

Wie?

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

Probieren Sie es hier online aus .

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)

Probieren Sie es online!

Erläuterung

Dies verwendet span, um die erste Instanz zu finden, in der xdas Tupel enthalten ist. Es erfasst dann das erste Element des Tupels, wenn es nicht gleich ist, und das zweite, wenn es nicht gleich ist.

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

Probieren Sie es online!

Erläuterung

Dies verwendet die Data.Lists- firstFunktion, um die von verwendeten Bytes zu reduzieren (!!0).snd.span, da jedoch firsta zurückgegeben wird, das Maybewir Justzu unserer Musterübereinstimmung in hinzufügen müssen #.

05AB1E , 7 Bytes

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

Probieren Sie es online!

Alternative 7-Byte-Lösung

˜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

Probieren Sie es online!

Common Lisp, 74 Bytes

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

Probieren Sie es online!

Java 8, 78 Bytes

Ein Lambda (Curry) von Stream<List<String>>bis zu einem Lambda von Stringbis String(obwohl implizite Typisierung dazu führt, dass dies für beliebige Listen funktioniert). Die Sprache hat keine dedizierten Tupelklassen, und mir ist keine in der Standardbibliothek bekannt, sodass Eingabepaare als Listen dargestellt werden. Kann zugewiesen werdenFunction<Stream<List<String>>, Function<String, String>> .

l->s->l.filter(p->p.contains(s)).map(p->p.get(1-p.indexOf(s))).findAny().get()

Probieren Sie es online

Ich werde die Ersparnis der letzten 6 Bytes jedem gutschreiben, der mich davon überzeugen kann Optional gültig ist. Ich konnte mich nicht überzeugen.

Einer der interessanten Teile dieser Lösung war für mich, den günstigsten Weg zu finden, um die Ausgabe aus dem Stream zu erhalten. Ich überlegte reduce, findFirstund min/ max, aber keiner war kürzer als das Intuitive findAny.

Ruby, 31 Bytes

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

Gibt ein Singleton-Array zurück.

JavaScript (ES6), 45 Byte

Kam mit dieser letzten Nacht auf, bemerkte dann, dass Neil mich zu einer besseren JS-Lösung geschlagen hatte; dachte, ich könnte es trotzdem posten.

Arbeitet mit Zeichenketten und ganzen Zahlen.

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

Probieren Sie es online!

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

Vielen Dank an Grzegorz Puławski, der dabei geholfen hat, ein paar Bytes zu reduzieren.

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

Probieren Sie es 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"";}

Probieren Sie es online!

Schale , 10 Bytes

→ḟo=⁰←S+m↔

Probieren Sie es online!

Ungolfed / Erklärung

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

Hinweis : Das obige Beispiel funktioniert nur aus Gründen der Lesbarkeit mit ganzen Zahlen. Der Typ selbst spielt keine Rolle (solange Sie ihn vergleichen können).

Schnelle 4 , 43 Bytes

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

Die Ausgabe ist ein Array, das entweder leer ist (kein Partner gefunden) oder ein einzelnes Element (der Partner) enthält.

Testfälle:

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 ist nicht stark in Listen und Tupeln. Der obige Code verwendet aeinen Befehlszeilenparameter und fordert dann paarweise zur Eingabe der Tupel durch den Benutzer auf. Wenn ein leeres Element angegeben wird, wird es ausgegeben b.

Probelauf

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

Meta

Erläuterung

{           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

Dies entspricht im Wesentlichen der längeren Version, wird jedoch sofort beendet, wenn eine Übereinstimmung gefunden wird. Ich habe dies als Alternative aufgeführt, da Sie nicht alle Tupel in dieses Programm eingeben können, da es vorzeitig beendet wird.

Mathematica, 50 Bytes

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

Probieren Sie es online!

Gestapelt , 21 Bytes

[:$revmap,KeyArray\#]

Probieren Sie es online! Dies nimmt Eingaben vom Stapel entgegen und belässt Ausgaben auf dem Stapel. Erweitert sieht das so aus:

[ : $rev map , KeyArray \ # ]

Erläuterung

Nehmen wir (('sad' 'beep') ('boop' 'boop'))und 'boop'als Eingabe. Dann wird ein Array wie das folgende erstellt :$revmap,:

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

Das heißt, eine Kopie des Arrays wird zugeordnet, jedes Mitglied wird umgekehrt, und die beiden werden miteinander verkettet. KeyArrayIm Gegenzug wird aus den angegebenen Werten ein Hash erstellt, wie folgt:

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

Dann \bringt die Suchzeichenfolge an die Spitze des Stapels, und erhält den Schlüssel aus dem KeyArray dass Begegnungen mit #. Dies gibt nur einen Wert zurück, sodass der doppelte Schlüssel im KeyArray nicht besorgt sein muss.

Andere Ansätze

32 Bytes: (Eingabe vom Stack, Ausgabe nach 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

Anonyme Excel-Arbeitsmappenformel, die Eingaben <Lookup Value>aus dem Bereich A1, <Key Array>aus dem Bereich B:Bund <Def Array>aus dem Bereich entgegennimmt C:Cund den Wert der Definition, die dem Suchwert zugeordnet ist, an die aufrufende Zelle ausgibt

=VLOOKUP(A1,B:C,2)

Wenn möglich, sind Muster-E / A einzubeziehen