Ihren Partner finden

20

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!

Nate Stemen
quelle
Außerdem, was zu tun ist, wenn die Eingabe mehrmals erscheint oder nicht erscheint
Luis Mendo
Ich nehme nicht an, dass wir Eingaben als flache Liste akzeptieren können, oder? Zum Beispiel [a, b, c, d]anstelle von [(a, b), (c, d)]. Es würde eine Menge Bytes von meiner Antwort abschneiden. : P
totalhuman
Ich habe bearbeitet, um hoffentlich einiges aufzuklären und um Testfälle hinzuzufügen. Fühlen Sie sich frei, einen Rollback durchzuführen, wenn etwas nicht stimmt.
Totalhuman
@totallyhuman Ich fragte(a,a) speziell nach und mir wurde gesagt, dass es nicht passieren würde . Nate bearbeitete dann sogar die Frage, um diese Tatsache zu spezifizieren. Sie haben jedoch einen Testfall mit einem solchen Eintrag hinzugefügt und auch die Spezifikation bearbeitet, um diese Entscheidung umzukehren - warum? Es ist eine Reihe von Antworten gebrochen.
Jonathan Allan
1
@totallyhuman Ich habe es als "irgendetwas zurückgeben, abstürzen, was auch immer" verstanden, zumal der Beitrag dann dahingehend überarbeitet wurde, dass alles einzigartig sein würde.
Jonathan Allan

Antworten:

8

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.

Zottelig
quelle
Das ist ... Ich habe buchstäblich genau dieses Szenario ausprobiert, denselben Input und alles. Ich muss etwas verpasst haben ... EDIT: Ach, ich war mit fstatt æan der Zeit. Duh: P
ETHproductions
@ETHproductions: Nimmt eine nette Abwechslung vor - normalerweise bin ich derjenige, der es vergisst æund versucht, durchzudrehen f! : D
Shaggy
8

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

Lynn
quelle
5

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)
Neil
quelle
Hier ist eine nicht-rekursive 41-Byte-Lösung:a=>b=>a.map(e=>b=e[1-e.indexOf(b)]||b)&&b
Rick Hitchcock
Sie ... Sie haben sich endlich dem Curry hingegeben ?! : o
Shaggy
@Shaggy Normalerweise kümmere ich mich nicht um die (a,b)=>=> a=>b=>Art des Currying, aber die nicht-rekursive Version ging von der rekursiven Version aus, die Currying war, weil ich beim rekursiven Aufruf 2 Bytes einsparen konnte (das Currying selbst kostet tatsächlich ein Byte).
Neil
5

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

Sanchises
quelle
4

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

HyperNeutrino
quelle
Benennen Sie, reversedum reversefür -1 Byte in Proton. \ s: P Im Ernst, reverseist ein viel besserer Name, nein? : P
totalhuman
@totallyafloppydisk vielleicht / Achselzucken, aber ich habe die meisten Python-Buildins, die auf Proton
HyperNeutrino
@Sanchises Ich sehe nicht, was los ist?
HyperNeutrino
Entschuldigen Sie meine schlechte, ignorieren Sie diesen Kommentar.
Sanchises
2

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

total menschlich
quelle
1
45 Bytes
Emigna
Aha, wusste, dass es einen kürzeren Weg gibt y+[1,-1][y%2]. Dachte nur nicht, dass es bitweise war ... Danke!
Totalhuman
2

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

HatsuPointerKun
quelle
2

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
colsw
quelle
Dieser Ansatz funktioniert nicht für den ("boop", "boop")Testfall.
AdmBorkBork
2

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  */
fergusq
quelle
2

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

Kelly Lowder
quelle
1
Wenn Sie Version 10 haben und Eingaben durch Currying vornehmen , können Sie 3 Bytes sparen:, Cases[{#,x_}|{x_,#}:>x]&verwendet wie%[3][{{1,2},{3,4}}]
Not a tree
Kannst du das ein bisschen erklären?
Nate Stemen
2

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.

MickyT
quelle
@Sanchises Danke, alles in Ordnung.
MickyT
2

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)
Jonathan Allan
quelle
Dies ist ungültig, da die neuen Testfälle hinzugefügt wurden.
Sanchises
1
Vielen Dank für den Hinweis - ich habe unter der Frage an den Herausgeber (ich hatte speziell das OP gefragt (a,a)und wurde gesagt, wir brauchen nicht damit umzugehen) kommentiert . Ich bin mir sicher, dass ich das Problem beheben konnte, bin mir aber nicht sicher, ob die Spezifikation jetzt so ist, wie sie beabsichtigt war.
Jonathan Allan
Hmm, obwohl wir uns die Revisionshistorie ansehen, scheint es, als müssten wir Strings unterstützen, nicht nur Zeichen, damit dies sowieso nicht funktioniert ...
Jonathan Allan
Funktioniert jetzt mit der neuen Spezifikation.
Jonathan Allan
Das war auch meine Interpretation des "na ja" -Kommentars, aber offensichtlich war dies nicht der Fall.
Sanchises
1

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

Weizen-Assistent
quelle
2
Denken Sie nicht darüber nach ... x!((a,b):c)|x==a=b|x==b=a|1<2=x!ces sind 33 Bytes.
Lynn
1
@Lynn Mach weiter und poste es. Ich fühle mich ein bisschen dumm, wenn ich nicht daran denke, aber es ist wirklich deine Antwort.
Weizen-Zauberer
Fair, posted ^^
Lynn
1

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!

Emigna
quelle
˜D²k>èfür 6, es sei denn, es gibt einen bestimmten Grund für die XOR-Verknüpfung mit 1?
Magic Octopus Urn
@MagicOctopusUrn: Der Grund ist, dass gerade Indizes dekrementieren und ungerade Indizes inkrementieren sollten.
Emigna
Außer der Umkehrung dessen, was ich dort geschrieben habe ...
Emigna
1

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.

Jakob
quelle
1

Ruby, 31 Bytes

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

Gibt ein Singleton-Array zurück.

m-chrzan
quelle
1

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)
Zottelig
quelle
1

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!

Dennis.Verweij
quelle
x=>y=>ist kürzer als (x,y)=>( Func<a, b, c>wird Func<a, Func<b, c>>und Funktionsaufruf f(a, b)wird f(a)(b)) - Tolle Antwort übrigens!
Grzegorz Puławski
Auch für die erste Antwort verwendet die Funktion selbst nichts anderes als System.Linq, so dass Sie nur 18 Bytes hinzufügen können, um zu antworten ( using System.Linq;versus namespace System.Linq{})
Grzegorz Puławski
@ GrzegorzPuławski Danke für die Hilfe und das Kompliment, hoffentlich habe ich die Antworten auf Schnupftabak
korrigiert
1

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

ბიმო
quelle
1

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!")
}
Alexander - Setzen Sie Monica wieder ein
quelle
1

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.

steenbergh
quelle
0

Mathematica, 50 Bytes

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

Probieren Sie es online!

J42161217
quelle
Dies funktioniert nicht für den {'boop','boop'}Testfall.
Sanchises
@Sanchises "boop" war nicht da, als ich geantwortet habe und die Frage ging nicht um [a, a] Tupel. Ich glaube, Antworten vor dem Boop-Edit sind gültig
J42161217
Ich kenne die Richtlinie zur Klärung des OP nicht, die bestehende Antworten ungültig macht. Es war nur ein Heads-up über die Bearbeitung.
Sanchises
0

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

Conor O'Brien
quelle
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

Taylor Scott
quelle