Вызов

Если дан произвольный список из двух кортежей и одного элемента в одном из этих кортежей, выведите его «партнера», то есть, заданный 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}]. Bytecount сильно колеблется, в то время как OP выясняет, что на самом деле разрешено.

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 байтов благодаря Emigna. -3 байта благодаря Maltysen.

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 ++ с типом данных карты, 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}

находит элемент, содержащий intput, затем получает элемент 'other', исключая входные данные из него, 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 байта с предложением "Curry" от @Notatree

R , 47 42 байта

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

Попробуйте онлайн!

Работает на матрице или прямом векторе. v = значение поиска, а = массив кортежей.

Желе , 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)

Попробуйте онлайн!

объяснение

Это использует span, чтобы найти первый экземпляр, где 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возвращает a, который 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

Попробуйте онлайн!

Common Lisp, 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↔

Попробуйте онлайн!

Ungolfed / Пояснение

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

Примечание : приведенный выше пример работает с целыми числами только для удобства чтения, сам тип не имеет значения (если вы можете сравнить его).

Swift 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

Это в основном делает то же самое, что и более длинная версия, но немедленно завершает работу, когда находит совпадение. Я перечислил это как альтернативу, потому что вы не можете ввести все кортежи в эту программу, учитывая, что она закрывается рано.

Mathematica, 50 байтов

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

Попробуйте онлайн!

Stacked , 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)

Образец ввода / вывода должен быть включен, когда это возможно