Wyzwanie

Biorąc pod uwagę dowolną listę 2-krotek i jednego elementu w jednym z tych krotek, wypisz „partnera”, tzn. Dane ai [(i,j),...,(a,b),...,(l,m)], wyjście b. Możesz założyć, że wszystkie krotki są unikalne i że wszystkie elementy w krotkach są łańcuchami. Dalej zakładamy, że nie masz obu (x,y)i (y,x).

Przypadki testowe

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"

Wygrywa najmniej bajtów!

Japt, 6 bajtów

Działa z ciągami lub liczbami całkowitymi.

æøV kV

Sprawdź to

Wyjaśnienie

Domniemane wprowadzanie tablicy Ui łańcucha / liczby całkowitej V.

æ

Pobierz pierwszy element (podtablicę) z Utego ...

øV

Zawiera V.

kV

Usuń Vi niejawnie zwróć wynikową tablicę jednoelementową.

Haskell , 33 bajty

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

Wypróbuj online!

Definiuje operator binarny !, który jako lewy argument przyjmuje wartość xtypu τ, a jako prawy argument listę krotek (τ, τ). Wzór definicji pasuje do nagłówka (a,b)i ogona cpodanej listy; jeśli x==ato bzostanie zwrócone; jeśli x==bnastępnie azostanie zwrócone, a w przeciwnym razie będziemy przeglądać resztę listy przez rekurencję.

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

(Jeśli na liście nie ma „partnera”, nastąpi awaria, ponieważ nie zdefiniowaliśmy, co x![]powinno być.)

JavaScript (ES6), 39 bajtów

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

Traktuje wpis i tablicę tablic jako argumenty curry. Najlepsza nierekurencyjna wersja, jaką mogłem zrobić, to 44 bajty:

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

MATL , 4 14 5 6 bajtów

yY=P)u

Wypróbuj online!

Dane wejściowe to tablica jak [{a;b},{c;d}]. Liczba bajtów zmienia się silnie, podczas gdy OP zastanawia się, co jest faktycznie dozwolone.

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.

Zacząłem od 4-bajtowej wersji, która mogła obsługiwać tylko ciągi jednoznakowe, co było jedynym testem w oryginalnym wyzwaniu. Kiedy okazało się to nieważne, stworzyłem bardzo długą 14-bajtową wersję, która była ładna i zhackowana (sprawdź historię wersji!), Kazała mi odkryć błąd, a następnie okazała się całkowicie niepotrzebna, ponieważ Y=z odpowiednim wejściem , działał tak samo dobrze, jak mój oryginalny 4-bajtowy y=P).

Python 2 , 37 bajtów

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

Wypróbuj online!

Proton , 31 bajtów

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

Wypróbuj online!

(Te dwie odpowiedzi są tak podobne, że zamieszczam je razem, aby uniknąć ponownej instalacji)

Perl 5 , 30 + 1 (-p) = 31 bajtów

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

Wypróbuj online!

Python 2 , 59 45 42 bajtów

-14 bajtów dzięki Emignie. -3 bajty dzięki Maltysen.

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

Wypróbuj online!

^{Nadal chcę jednak używać curry. ; -;}

C ++, 179 bajtów

#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 ++ z typem mapy, 162 bajty

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

W MSVC kod kompiluje się, nawet jeśli ostatnia returninstrukcja ( return"";) zostanie pominięta. Sprawia, że ​​kod 9 bajtów jest lżejszy, ALE wychodzenie z końca funkcji (tj. Nie wychodzenie przez returninstrukcję w pętli) bez instrukcji return spowoduje niezdefiniowane zachowanie i nie będzie działać, jeśli tablica krotek nie zawiera elementu „klucz”

PowerShell, 36 bajtów

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

znajduje element zawierający intput, a następnie pobiera element „inny”, wykluczając z niego dane wejściowe, PowerShell nie ma najbardziej niesamowitego zarządzania tablicą, ale może istnieć wbudowana funkcja, której nie jestem świadomy.

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

Röda , 30 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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 bajtów

Caseswybiera elementy listy pasujące do wzorca. W połączeniu ze strzałką elementy pasujące do wzorów można przekształcić.

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

Stosowanie:

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

Objaśnienie: W tym przykładzie po napotkaniu pierwszego argumentu 3, funkcja, Cases[{3,x_}|{x_,3}:>x]która jest formą operatora Cases, jest następnie stosowana do drugiego argumentu, {{1, 2}, {3, 4}}wybierając w ten sposób towarzysza 3, niezależnie od tego, czy znajduje się on w pozycji odciętej, czy rzędnej. W szczególności funkcja ta wyświetli listę wszystkich towarzyszy, jeśli w rzeczywistości pierwszy argument pojawia się więcej niż raz w drugim argumencie, innymi słowy, wykracza to nieco poza założenia zadanego pytania.

Glify otaczające muszą być nawiasami klamrowymi. Zapisano 3 bajty z sugestią „Currying” z @Notatree

R , 47 42 bajtów

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

Wypróbuj online!

Działa na macierzy lub na prostym wektorze. v = wartość wyszukiwania, a = tablica krotek.

Galaretka , 6 bajtów

ċÞṪ⁻ÞṪ

Dyadyczny link prowadzący do listy partnerów po lewej i utraconego partnera po prawej i zwracający partnera.

Wypróbuj online!

W jaki sposób?

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

h-hf}QTE

Wypróbuj online tutaj .

Haskell , 65 62 bajtów

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

Wypróbuj online!

Wyjaśnienie

Używa span, aby znaleźć pierwszą instancję, w której xznajduje się krotka. Następnie chwyta pierwszy element krotki, jeśli nie jest równy, a drugi w przeciwnym razie.

Haskell Lambdabot, 59 56 bajtów

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

Wypróbuj online!

Wyjaśnienie

Korzysta z funkcji Data.Lists, firstaby zmniejszyć liczbę używanych bajtów (!!0).snd.span, ponieważ firstzwraca wartość, Maybektórą musimy dodać Justdo dopasowania wzorca w #.

05AB1E , 7 bajtów

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

Wypróbuj online!

Alternatywne rozwiązanie 7-bajtowe

˜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

Wypróbuj online!

Common Lisp, 74 bajty

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

Wypróbuj online!

Java 8, 78 bajtów

Lambda (curry) od Stream<List<String>>do lambda od Stringdo String(chociaż zdarza się, że niejawne pisanie pozwala na to, aby działało to na dowolnych listach). W języku nie ma dedykowanych klas krotek i nie znam ich w standardowej bibliotece, więc pary wejściowe są reprezentowane jako listy. Można przypisać do 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()

Wypróbuj online

Poświęcę oszczędność ostatnich 6 bajtów każdemu, kto może mnie przekonać, że zwrócenie an Optionaljest ważne. Nie byłem w stanie się przekonać.

Jedną z interesujących części tego rozwiązania było dla mnie określenie najtańszego sposobu uzyskania wyjścia ze strumienia. Rozważyłem reduce, findFirsti min/ max, ale żaden nie był krótszy niż intuicyjny findAny.

Ruby, 31 bajtów

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

Zwraca tablicę singletonów.

JavaScript (ES6), 45 bajtów

Przyszedł do mnie wczoraj, a potem zauważył, że Neil pobił mnie do lepszego rozwiązania JS; pomyślałem, że i tak mogę to opublikować.

Działa z ciągami i liczbami całkowitymi.

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

Prolog (SWI) , 43 bajty

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

Wypróbuj online!

C # (.NET Core) , 101 100 + 18 bajtów

dziękuję Grzegorzowi Puławskiemu za zmniejszenie kilku bajtów.

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

Wypróbuj online!

C # (.NET Core), 122 121 120 bajtów

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

Wypróbuj online!

Łuska , 10 bajtów

→ḟo=⁰←S+m↔

Wypróbuj online!

Niegolfowane / Wyjaśnienie

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

Uwaga : powyższy przykład działa na liczbach całkowitych tylko ze względu na czytelność, sam typ nie ma znaczenia (o ile można go porównać).

Swift 4 , 43 bajty

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

Dane wyjściowe to tablica, która jest albo pusta (nie znaleziono partnera), albo ma pojedynczy element (partner).

Przypadki testowe:

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 bajtów

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

QBIC nie jest silny na listach i krotkach. Powyższy kod przyjmuje ajako parametr wiersza poleceń, a następnie pyta o dane wejściowe użytkownika parami dla krotek. Gdy podany jest pusty element, jest on generowany b.

Przykładowy przebieg

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

Meta

Wyjaśnienie

{           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

Alternatywna wersja, 22 bajty

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

Zasadniczo działa to tak samo jak dłuższa wersja, ale natychmiast kończy pracę, gdy znajdzie dopasowanie. Wymieniłem to jako alternatywę, ponieważ nie możesz wprowadzić wszystkich krotek do tego programu, biorąc pod uwagę, że kończy się wcześnie.

Mathematica, 50 bajtów

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

Wypróbuj online!

Skumulowane , 21 bajtów

[:$revmap,KeyArray\#]

Wypróbuj online! To pobiera dane wejściowe ze stosu i pozostawia dane wyjściowe na stosie. Po rozwinięciu wygląda to następująco:

[ : $rev map , KeyArray \ # ]

Wyjaśnienie

Weźmy (('sad' 'beep') ('boop' 'boop'))i 'boop'jako dane wejściowe. Następnie taka tablica jest konstruowana przez :$revmap,:

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

Oznacza to, że kopia tablicy jest odwzorowana, każdy element jest odwrócony, a oba są łączone razem. KeyArrayz kolei tworzy hasz z podanych wartości, takich jak:

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

Następnie \umieszcza szukany ciąg na górze stosu i uzyskuje klucz z tablicy KeyArray, która pasuje do #. Zwraca tylko jedną wartość, więc nie trzeba się martwić o zduplikowany klucz w tablicy kluczy.

Inne podejścia

32 bajty: (wejście ze stosu, wyjście do STDOUT) [@x:$revmap,uniq[...x=$out*]map]

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

38 bajtów: [@x:$revmap#,[KeyArray x#]map:keep 0#]

46 bajtów: [@x:KeyArray\$revmap KeyArray,[x#]map:keep 0#]

Excel, 18 bajtów

Anonimowa formuła skoroszytu programu Excel, która przyjmuje dane wejściowe jako <Lookup Value> z zakresu A1, <Key Array>z zakresu B:Bi <Def Array>z zakresu C:Ci przekazuje wartość definicji powiązanej z wartością wyszukiwania do komórki wywołującej

=VLOOKUP(A1,B:C,2)

Próbki we / wy powinny być uwzględnione, jeśli to możliwe