Виклик

Враховуючи довільний перелік 2-кортежів і єдиний елемент в одному з цих кортежів, виведіть свого "партнера", тобто дайте aта [(i,j),...,(a,b),...,(l,m)], виведіть b. Ви можете припустити, що всі кортежі унікальні, і що всі елементи в кортежах - це рядки. Далі припустимо, що у вас немає обох (x,y)і (y,x).

Тестові кейси

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"

Виграє найменше байтів!

Japt, 6 байт

Працює з рядками або цілими числами.

æøV kV

Перевірте це

Пояснення

Неявне введення масиву Uта рядка / цілого числа V.

æ

Отримайте перший елемент (subarray) у Uцьому ...

øV

Містить V.

kV

Видаліть Vта неявно поверніть отриманий одноелементний масив.

Haskell , 33 байти

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

Спробуйте в Інтернеті!

Визначає двійковий оператор !, який приймає за лівий аргумент значення xтипу τ, а його правою аргументом - список кортежів (τ, τ). Шаблон визначення відповідає голові (a,b)та хвосту cданого списку; якщо x==aтодіb повертається; якщо x==bпотім aповертається, і в іншому випадку ми продовжуємо шукати решту списку повторно.

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

(Якщо в списку немає «партнера», це вийде з ладу, оскільки ми не визначилися, що x![]має бути.)

JavaScript (ES6), 39 байт

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

Вважає запис та масив масивів як виправлені аргументи. Найкраща нерекурсивна версія, яку я міг зробити, - це 44 байти:

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

MATL , 4 14 5 6 байт

yY=P)u

Спробуйте в Інтернеті!

Вхід - це масив як [{a;b},{c;d}]. Рахунок сильно коливається, в той час як ОР визначає, що насправді дозволено.

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.

Я почав з 4-байтової версії, яка могла обробляти лише односимвольні рядки, що було єдиним тестовим контрольним рядком в оригінальному виклику. Коли це виявилося недійсним, я зробив дуже довгу 14-байтову версію, яка була приємною і хитрою (перевірте історію редагування!), Змусила мене виявити помилку, а потім виявилася абсолютно непотрібною, як Y=з відповідним входом , працював так само добре, як і мій оригінальний 4-байт y=P).

Python 2 , 37 байт

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

Спробуйте в Інтернеті!

Протон , 31 байт

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

Спробуйте в Інтернеті!

(Ці дві відповіді настільки схожі, що я публікую їх разом, щоб уникнути повторного фармування)

Perl 5 , 30 + 1 (-p) = 31 байт

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

Спробуйте в Інтернеті!

Python 2 , 59 45 42 байт

-14 байт завдяки Еміньї. -3 байти завдяки Мальтісену.

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

Спробуйте в Інтернеті!

^{Ще хочу використовувати каррі. ; -;}

C ++, 179 байт

#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 ++ w / карта, 162 байти

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

З MSVC код компілюється, навіть якщо останнє returnтвердження ( return"";) пропущено. Це робить код 9 байтів легшим, АЛЕ вихід з кінця функції (тобто не вихід з returnоператором у циклі) без операторів повернення не спричинить невизначене поведінку , і не працюватиме, якщо масив кортежу не містить елемента "ключ"

PowerShell, 36 байт

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

знаходить елемент, що містить вхід, а потім отримує "інший" елемент, виключаючи вхід з нього, PowerShell не має найдивовижнішого управління масивом, але може бути вбудований для цього я не знаю.

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

Рода , 30 байт

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

Спробуйте в Інтернеті!

Пояснення:

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 байт

Casesвибирає елементи списку, які відповідають шаблону. При використанні зі стрілкою елементи, що відповідають шаблонам, можуть бути перетворені.

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

Використання:

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

Пояснення: У цьому прикладі, після зустрічі з першим аргументом, 3 стає функцією, Cases[{3,x_}|{x_,3}:>x]яка є операторною формою, Casesяка потім застосовується до 2-го аргументу,{{1, 2}, {3, 4}} вибираючи таким чином супутник 3, чи він знаходиться в абсцисі чи ординатній позиції. Зокрема, ця функція перелічить усіх супутників, якщо насправді 1-й аргумент з’являється не раз у межах 2-го аргументу, іншими словами, це трохи перевищує припущення заявленого питання.

Огортаючі гліфи повинні бути чітко підтягнуті. Збережено 3 байти з пропозицією "Currying" від @Notatree

R , 47 42 байти

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

Спробуйте в Інтернеті!

Працює або на матриці, або на прямий вектор. v = значення пошуку, a = масив кортежу.

Желе , 6 байт

ċÞṪ⁻ÞṪ

Діадичне посилання, що приймає списку партнерів зліва та програв-партнер праворуч та повертає партнера.

Спробуйте в Інтернеті!

Як?

ċÞṪ⁻ÞṪ - 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 байт

h-hf}QTE

Спробуйте його онлайн тут .

Haskell , 65 62 байт

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

Спробуйте в Інтернеті!

Пояснення

Для цього використовується проміжок, щоб знайти перший екземпляр, де xміститься кортеж. Потім він захоплює перший елемент кортежу, якщо його немає, а другий інакше.

Haskell Lambdabot, 59 56 байт

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

Спробуйте в Інтернеті!

Пояснення

Ця функція використовує Data.Lists firstдля скорочення байтів, якими користується (!!0).snd.span, однак тому, що firstповертає Maybeнам потрібно додати Justдо нашого збігу шаблонів у #.

05AB1E , 7 байт

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

Спробуйте в Інтернеті!

Альтернативно 7-байтний розчин

˜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

Спробуйте в Інтернеті!

Лист звичайний, 74 байти

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

Спробуйте в Інтернеті!

Java 8, 78 байт

Лямбда (з викривленням) від Stream<List<String>>лямбда від Stringдо String(хоча трапляється неявна введення, яка дозволяє це працювати для довільних списків). У мові немає виділених кортежних класів, і я не знаю жодного в стандартній бібліотеці, тому пари введення представлені у вигляді списків. Можна призначити 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()

Спробуйте в Інтернеті

Я зарахую заощадження останніх 6 байт тому, хто може переконати мене в тому, що повертається Optional є дійсним. Я не зміг переконати себе.

Однією з цікавих частин цього рішення для мене було визначення найдешевшого способу отримання виходу з потоку. Я вважав reduce, findFirstта min/ max, але жоден не був коротшим, ніж інтуїтивний findAny.

Рубін, 31 байт

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

Повертає однотонний масив.

JavaScript (ES6), 45 байт

Придумав цю минулу ніч, тоді помітив, що Ніл побив мене до кращого рішення JS; подумав, що я можу також розмістити це все одно.

Працює з рядками та цілими числами.

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

Пролог (SWI) , 43 байти

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

Спробуйте в Інтернеті!

C # (.NET Core) , 101 100 + 18 байт

дякую Гжегожу Пулавському, який допомагає скоротити пару байтів.

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

Спробуйте в Інтернеті!

C # (.NET Core), 122 121 120 байт

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

Спробуйте в Інтернеті!

Лушпиння , 10 байт

→ḟo=⁰←S+m↔

Спробуйте в Інтернеті!

Безголів / пояснення

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

Примітка . Наведений вище приклад працює на цілі числа лише для читабельності, сам тип не має значення (доки ви можете порівнювати його).

Швидкий 4 , 43 байти

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

Вихід - це масив, який або порожній (партнера не знайдено), або має один елемент (партнер).

Тестові приклади:

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 байт

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

QBIC не сильний у списках та кортежах. Вищевказаний код приймає aяк параметр командного рядка, після чого запитує користувацьке введення парами для кортежів. Коли дається порожній елемент, він виводить b.

Вибірка зразка

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

Meta

Пояснення

{           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

Альтернативна версія, 22 байти

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

Це в основному робить те саме, що і довша версія, але одразу ж закривається, коли знаходить відповідність. Я перерахував це як альтернативу, тому що ви не можете вводити всі кортежі в цю програму, враховуючи, що вона закривається рано.

Математика, 50 байт

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

Спробуйте в Інтернеті!

Складено , 21 байт

[:$revmap,KeyArray\#]

Спробуйте в Інтернеті! Це бере вхід зі стека і залишає вихід на стеку. Розширено, це виглядає так:

[ : $rev map , KeyArray \ # ]

Пояснення

Візьмемо (('sad' 'beep') ('boop' 'boop'))і 'boop'як вхід. Тоді такий масив будується за допомогою :$revmap,:

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

Тобто копія масиву є картою, кожен член реверсується, а два об'єднуються разом. KeyArrayу свою чергу робить хеш із заданих значень, як-от так:

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

Потім \виводить рядок пошуку у верхню частину стека та отримує ключ із KeyArray, який відповідає #. Це повертає лише одне значення, тому дублюючий ключ у KeyArray не потрібно турбуватися.

Інші підходи

32 байти: (вхід із стека, вихід у STDOUT) [@x:$revmap,uniq[...x=$out*]map]

36 байт: {%x[y index#+]YES 0# :y neq keep 0#}

38 байт: [@x:$revmap#,[KeyArray x#]map:keep 0#]

46 байт: [@x:KeyArray\$revmap KeyArray,[x#]map:keep 0#]

Excel, 18 байт

Формула анонімної робочої книги Excel, яка приймає введення як <Lookup Value>з діапазону A1, <Key Array>діапазону, так B:Bі <Def Array>з діапазону C:C, а також виводить значення визначення, пов'язане зі значенням пошуку, у викликову клітинку

=VLOOKUP(A1,B:C,2)

Зразок вводу / виводу включається, коли це можливо