Thử thách

Đưa ra một danh sách tùy ý gồm 2 bộ dữ liệu và một phần tử trong một trong các bộ dữ liệu đó, xuất ra "đối tác" của nó, tức là đã cho avà [(i,j),...,(a,b),...,(l,m)], đầu ra b. Bạn có thể giả sử tất cả các bộ dữ liệu là duy nhất và tất cả các thành phần trong bộ dữ liệu là các chuỗi. Hơn nữa giả sử bạn không có cả hai (x,y)và (y,x).

Các trường hợp thử nghiệm

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"

Ít byte nhất sẽ thắng!

Japt, 6 byte

Hoạt động với chuỗi hoặc số nguyên.

æøV kV

Kiểm tra nó

Giải trình

Nhập ngầm định của mảng Uvà chuỗi / số nguyên V.

æ

Lấy phần tử đầu tiên (subarray) trong Uđó ...

øV

Chứa V.

kV

Loại bỏ Vvà hoàn toàn trả về mảng phần tử đơn kết quả.

Haskell , 33 byte

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

Hãy thử trực tuyến!

Xác định một toán tử nhị phân !, lấy tham số bên trái của nó một giá trị xkiểu τ và làm đối số bên phải của nó một danh sách các bộ dữ liệu (τ,). Mẫu định nghĩa khớp với đầu (a,b)và đuôi ccủa danh sách đã cho; nếu x==asau đó bđược trả lại; nếu x==bsau đó ađược trả về, và nếu không chúng ta tiếp tục tìm kiếm trong phần còn lại của danh sách bằng cách đệ quy.

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

(Nếu không có đối tác của người Viking trong danh sách, điều này sẽ sụp đổ, vì chúng tôi đã không xác định điều gì x![]sẽ xảy ra.)

JavaScript (ES6), 39 byte

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

Lấy mục và mảng của mảng làm đối số bị quấy rối. Phiên bản không đệ quy tốt nhất tôi có thể làm là 44 byte:

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

MATL , 4 14 5 6 byte

yY=P)u

Hãy thử trực tuyến!

Đầu vào là một mảng như [{a;b},{c;d}]. Bytecount biến động mạnh trong khi OP chỉ ra những gì thực sự được phép.

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.

Tôi đã bắt đầu với một phiên bản 4 byte chỉ có thể xử lý các chuỗi ký tự đơn, đây là thử nghiệm duy nhất trong thử thách ban đầu. Khi điều này trở nên không hợp lệ, tôi đã tạo một phiên bản 14 byte rất dài, rất hay và hack (kiểm tra lịch sử sửa đổi!), Khiến tôi phát hiện ra một lỗi, và sau đó hóa ra là hoàn toàn không cần thiết vì Y=, với đầu vào phù hợp , hoạt động tốt như 4 byte ban đầu của tôi y=P).

Python 2 , 37 byte

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

Hãy thử trực tuyến!

Proton , 31 byte

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

Hãy thử trực tuyến!

(Hai câu trả lời này giống nhau đến mức tôi đăng chúng cùng nhau để tránh phản hồi)

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

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

Hãy thử trực tuyến!

Python 2 , 59 45 42 byte

-14 byte nhờ Emigna. -3 byte nhờ Maltysen.

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

Hãy thử trực tuyến!

^{Vẫn muốn sử dụng cà ri mặc dù. ; -;}

C ++, 179 byte

#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 / kiểu dữ liệu bản đồ, 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"";}

Với MSVC, mã sẽ biên dịch ngay cả khi returncâu lệnh cuối cùng ( return"";) bị bỏ qua. Nó làm cho mã 9 byte nhẹ hơn, NHƯNG thoát khỏi cuối hàm (nghĩa là không thoát bởi một returncâu lệnh trong vòng lặp) mà không có câu lệnh trả về sẽ gây ra hành vi không xác định và không hoạt động nếu mảng tuple không chứa phần tử "key"

PowerShell, 36 byte

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

tìm thấy phần tử có chứa thông số, sau đó lấy phần tử 'khác' bằng cách loại trừ đầu vào từ nó, PowerShell không có quản lý mảng tuyệt vời nhất nhưng có thể có một phần tử tích hợp cho điều này mà tôi không biết.

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

Röda , 30 byte

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

Hãy thử trực tuyến!

Giải trình:

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

Toán học 27 24 byte

Caseschọn ra các yếu tố của một danh sách phù hợp với một mô hình. Khi được sử dụng với một mũi tên, các yếu tố phù hợp với các mẫu có thể được chuyển đổi.

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

Sử dụng:

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

Giải thích: Trong ví dụ này, sau khi gặp đối số thứ nhất, 3, hàm trở thành Cases[{3,x_}|{x_,3}:>x]dạng toán tử của Casesnó sau đó được áp dụng cho đối số thứ 2 {{1, 2}, {3, 4}}, do đó chọn đồng hành của 3, cho dù nó ở vị trí abscissa hay tọa độ. Đáng chú ý, hàm này sẽ liệt kê tất cả các bạn đồng hành nếu trên thực tế, đối số thứ nhất xuất hiện nhiều hơn một lần trong đối số thứ 2, nói cách khác, điều này vượt xa các giả định của câu hỏi đã nêu.

Gõ glyphs phải là niềng răng nguệch ngoạc. Đã lưu 3 byte với đề xuất "Currying" từ @Notatree

R , 47 42 byte

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

Hãy thử trực tuyến!

Hoạt động trên ma trận hoặc vectơ thẳng. v = giá trị tìm kiếm, a = tuple mảng.

Thạch , 6 byte

ċÞṪ⁻ÞṪ

Một liên kết dyadic lấy các đối tác danh sách ở bên trái và đối tác bị mất ở bên phải và trả lại đối tác.

Hãy thử trực tuyến!

Làm sao?

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

h-hf}QTE

Hãy thử trực tuyến tại đây .

Haskell , 65 62 byte

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

Hãy thử trực tuyến!

Giải trình

Điều này sử dụng span để tìm phiên bản đầu tiên xđược chứa bởi bộ dữ liệu. Sau đó, nó lấy phần tử đầu tiên của bộ dữ liệu nếu nó không bằng và phần thứ hai nếu không.

Haskell Lambdabot, 59 56 byte

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

Hãy thử trực tuyến!

Giải trình

Điều này sử dụng hàm Data.Lists firstđể cắt giảm các byte được sử dụng (!!0).snd.span, tuy nhiên vì firsttrả về một giá trị Maybemà chúng ta cần thêm Justvào khớp mẫu của chúng ta #.

05AB1E , 7 byte

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

Hãy thử trực tuyến!

Giải pháp thay thế 7 byte

˜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

Hãy thử trực tuyến!

Lisp thông thường, 74 byte

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

Hãy thử trực tuyến!

Java 8, 78 byte

Một lambda (cà ri) từ Stream<List<String>>một lambda từ Stringđến String(mặc dù gõ tiềm ẩn xảy ra để cho phép này để làm việc cho các danh sách tùy ý). Ngôn ngữ không có các lớp tuple chuyên dụng và tôi không biết bất kỳ lớp nào trong thư viện chuẩn, vì vậy các cặp đầu vào được biểu diễn dưới dạng danh sách. Có thể được chỉ định để 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()

Dùng thử trực tuyến

Tôi sẽ ghi nhận việc tiết kiệm 6 byte cuối cùng cho bất kỳ ai có thể thuyết phục tôi rằng việc trả lại Optionallà hợp lệ. Tôi đã không thể thuyết phục bản thân mình.

Một trong những phần thú vị của giải pháp này đối với tôi là xác định cách rẻ nhất để có được đầu ra từ luồng. Tôi đã xem xét reduce, findFirstvà min/ max, nhưng không cái nào ngắn hơn trực quan findAny.

Ruby, 31 byte

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

Trả về một mảng đơn.

JavaScript (ES6), 45 byte

Đến với tối hôm qua, sau đó nhận thấy Neil đã đánh bại tôi với một giải pháp JS tốt hơn; hình như tôi cũng có thể gửi nó

Hoạt động với chuỗi và số nguyên.

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

Prolog (SWI) , 43 byte

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

Hãy thử trực tuyến!

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

cảm ơn Grzegorz Puławski đã giúp giảm một vài byte.

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

Hãy thử trực tuyến!

C # (.NET Core), 122 121 120 byte

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

Hãy thử trực tuyến!

Husk , 10 byte

→ḟo=⁰←S+m↔

Hãy thử trực tuyến!

Ungolfed / Giải thích

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

Lưu ý : Ví dụ trên hoạt động trên các số nguyên chỉ vì mục đích dễ đọc, bản thân loại không quan trọng (miễn là bạn có thể so sánh nó).

Swift 4 , 43 byte

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

Đầu ra là một mảng, là trống (không tìm thấy đối tác) hoặc có một phần tử duy nhất (đối tác).

Các trường hợp thử nghiệm:

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 byte

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

QBIC không mạnh về danh sách và bộ dữ liệu. Đoạn mã trên lấy alàm tham số dòng lệnh, sau đó yêu cầu người dùng nhập theo cặp cho các bộ dữ liệu. Khi một yếu tố trống được đưa ra, nó xuất ra b.

Chạy mẫu

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

Meta

Giải trình

{           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

Phiên bản thay thế, 22 byte

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

Điều này về cơ bản giống như phiên bản dài hơn, nhưng ngay lập tức thoát ra khi tìm thấy kết quả khớp. Tôi đã liệt kê đây là phương án thay thế, vì bạn không thể nhập tất cả các bộ dữ liệu vào chương trình này nếu nó thoát sớm.

Toán học, 50 byte

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

Hãy thử trực tuyến!

Xếp chồng lên nhau , 21 byte

[:$revmap,KeyArray\#]

Hãy thử trực tuyến! Điều này lấy đầu vào từ ngăn xếp và để lại đầu ra trên ngăn xếp. Mở rộng, nó trông giống như:

[ : $rev map , KeyArray \ # ]

Giải trình

Hãy lấy (('sad' 'beep') ('boop' 'boop'))và 'boop'làm đầu vào. Sau đó, một mảng như vậy được xây dựng bởi :$revmap,:

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

Đó là, một bản sao của mảng là bản đồ, mỗi thành viên được đảo ngược và hai bản được nối với nhau. KeyArraylần lượt tạo ra một hàm băm trong số các giá trị đã cho, như vậy:

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

Sau đó, \đưa chuỗi tìm kiếm lên đầu ngăn xếp và lấy khóa từ KeyArray phù hợp với #. Điều này chỉ trả về một giá trị, vì vậy khóa trùng lặp trong KeyArray không cần phải lo lắng.

Các cách tiếp cận khác

32 byte: (đầu vào từ ngăn xếp, đầu ra đến STDOUT) [@x:$revmap,uniq[...x=$out*]map]

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

38 byte: [@x:$revmap#,[KeyArray x#]map:keep 0#]

46 byte: [@x:KeyArray\$revmap KeyArray,[x#]map:keep 0#]

Excel, 18 byte

Công thức sổ làm việc Excel ẩn danh nhận đầu vào là <Lookup Value>từ phạm vi A1, <Key Array>từ phạm vi B:Bvà <Def Array>từ phạm vi C:Cvà xuất giá trị của định nghĩa được liên kết với giá trị tra cứu đến ô gọi

=VLOOKUP(A1,B:C,2)

I / O mẫu sẽ được đưa vào khi có thể