Meydan okuma

Rasgele 2-tuples listesi ve bu tuples birinde tek bir eleman, verilen "ortak", yani verilen ave [(i,j),...,(a,b),...,(l,m)]çıktı b. Tüm grupların benzersiz olduğunu ve gruplardaki tüm öğelerin dize olduğunu varsayabilirsiniz. Ayrıca her ikisine de sahip olmadığını (x,y)ve (y,x).

Test senaryoları

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"

Birkaç bayt kazanır!

Japt, 6 bayt

Dize veya tamsayılarla çalışır.

æøV kV

Dene

açıklama

Örtülü dizi Uve dize / tamsayı girişi V.

æ

İçindeki ilk elemanı (altdizini) al U...

øV

İçerir V.

kV

VOrtaya çıkan tek öğeli diziyi kaldırın ve dolaylı olarak döndürün.

Haskell , 33 bayt

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

Çevrimiçi deneyin!

!Sol argüman xolarak τ türünde bir değer ve sağ argüman olarak da tuples (τ, τ) listesi alan bir ikili işleç tanımlar . Tanım paterni , verilen listenin baş (a,b)ve kuyruğuyla eşleşir c; eğer x==ao bzaman iade edilir; eğer x==bo zaman adöndürülür ve aksi takdirde biz recursing listenin geri kalanında bakarak gidin.

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

(Listede “ortak” yoksa, bu kilitlenecektir, çünkü ne x![]olması gerektiğini tanımlayamadık .)

JavaScript (ES6), 39 bayt

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

Dizilerin girişini ve dizisini eğri argümanlar olarak alır. Yapabileceğim en iyi özyinelemesiz sürüm 44 bayt oldu:

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

MATL , 4 14 5 6 bayt

yY=P)u

Çevrimiçi deneyin!

Girdi, bir dizidir [{a;b},{c;d}]. OP gerçekten neye izin verildiğini anlarken, bytecount çok dalgalanıyor.

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.

Orijinal meydan okumadaki tek testcase olan tek karakterli dizeleri işleyebilen 4 baytlık bir sürümle başladım. Bu geçersiz olduğu ortaya çıktı, ben, güzel ve hacky oldu çok uzun 14 bayt sürümü (düzeltme geçmişi kontrol edin!) Bana da hata keşfetmek ve sonra olarak tamamen gereksiz olduğu ortaya çıktı yapılan Y=uygun girişli, , orijinal 4 baytlık gibi çalıştı y=P).

Python 2 , 37 bayt

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

Çevrimiçi deneyin!

Proton , 31 bayt

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

Çevrimiçi deneyin!

(Bu iki cevap o kadar benzer ki, yeniden yetiştirmekten kaçınmak için bunları birlikte gönderiyorum)

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

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

Çevrimiçi deneyin!

Python 2 , 59 45 42 bayt

Emigna sayesinde -14 bayt. Maltysen sayesinde -3 bayt.

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

Çevrimiçi deneyin!

^{Yine de körili kullanmak istiyorum. , -;}

C ++, 179 bayt

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

Harita veri türüyle C ++, 162 bayt

#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 ile, kod son returnifade ( return"";) atlansa bile derlenir . 9 bayt kodunu daha açık hale getirir, ancak işlev sonu tarafından çıkan (yani returndöngüdeki bir deyimden çıkmayan) herhangi bir döndürme ifadesi olmadan tanımlanmamış davranışa neden olur ve tuple dizisi "anahtar" öğesi içermiyorsa çalışmaz

PowerShell, 36 Bayt

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

intput içeren öğeyi bulur, ardından girdiyi dışarıda bırakarak 'diğer' öğeyi alır, PowerShell en şaşırtıcı dizi yönetimine sahip değildir, ancak bunun için farkında olmadığım bir yerleşik olabilir.

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

Röda , 30 bayt

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

Çevrimiçi deneyin!

Açıklama:

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 Bayt

Caseslistenin desenle eşleşen öğelerini seçer. Bir okla birlikte kullanıldığında, desenlerle eşleşen öğeler dönüştürülebilir.

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

Kullanımı:

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

Açıklama: Bu örnekte, birinci argüman olan 3 ile karşılaştıktan sonra işlev , daha sonra 2. argümana uygulanan Cases[{3,x_}|{x_,3}:>x]bir operatör formu olan fonksiyon haline gelir , böylece apsis veya sıradan konumda olsun, 3'ün tamamlayıcısını seçer. Özellikle, bu işlev, 1'inci argüman 2'inci argüman içinde birden fazla görünüyorsa, başka bir deyişle, söz konusu sorunun varsayımlarının biraz ötesine geçerse, tüm arkadaşları listeleyecektir.Cases{{1, 2}, {3, 4}}

Çevreleyen glifler dalgalı diş telleri olmalıdır. @Notatree tarafından "Currying" önerisiyle 3 bayt kaydedildi

R , 47 42 bayt

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

Çevrimiçi deneyin!

Bir matris veya düz vektör üzerinde çalışır. v = arama değeri, a = grup dizisi.

Jöle , 6 bayt

ċÞṪ⁻ÞṪ

Soldaki liste ortaklarını ve sağdaki kayıp ortağı alıp ortağı geri döndüren ikili bir bağlantı.

Çevrimiçi deneyin!

Nasıl?

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

h-hf}QTE

Burada çevrimiçi deneyin .

Haskell , 65 62 bayt

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

Çevrimiçi deneyin!

açıklama

Bu x, demet tarafından içerilen ilk örneği bulmak için span kullanır . Daha sonra, eğer eşit değilse tupleın ilk elemanını ve aksi takdirde ikincisini yakalar.

Haskell Lambdabot, 59 56 bayt

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

Çevrimiçi deneyin!

açıklama

Bu, tarafından kullanılan baytları azaltmak için Data.Lists firstişlevini kullanır (!!0).snd.span, ancak firstdöndürdüğü için kalıp eşlememize Maybeeklememiz gerekir .Just#

05AB1E , 7 bayt

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

Çevrimiçi deneyin!

Alternatif 7 bayt çözümü

˜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

Çevrimiçi deneyin!

Ortak Lisp, 74 bayt

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

Çevrimiçi deneyin!

Java 8, 78 bayt

Bir lambda (curried) ' Stream<List<String>>den lambda' Stringdan String(her ne kadar bunun rasgele listelerde çalışmasına izin vermek için örtük yazma olmasına rağmen). Dilin ayrılmış tuple sınıfları yoktur ve standart kitaplıkta herhangi birinin farkında değilim, bu nedenle giriş çiftleri liste olarak gösterilir. Olarak atanabilir 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()

Çevrimiçi Deneyin

Son 6 baytın tasarrufunu, bir Optionaldönüşün geçerli olduğuna ikna edebilecek herkese borçlandıracağım. Kendimi ikna edemedim.

Bu çözümün benim için ilginç kısımlarından biri, akışı akıştan almanın en ucuz yolunu belirlemekti. Ben kabul reduce, findFirstve min/ maxfakat hiçbiri sezgisel kısaydı findAny.

Ruby, 31 bayt

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

Tekli bir dizi döndürür.

JavaScript (ES6), 45 bayt

Bu dün gece geldi sonra Neil daha iyi bir JS çözümü beni dövdü fark ettim; Ben de yine de sonrası düşündüm.

Dize ve tamsayılarla çalışır.

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

Prolog (SWI) , 43 bayt

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

Çevrimiçi deneyin!

C # (.NET Core) , 101100 + 18 bayt

birkaç baytın azaltılmasına yardımcı olan Grzegorz Puławski'ye teşekkür ederiz.

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

Çevrimiçi deneyin!

C # (.NET Çekirdek), 122 121 , 120 bayt

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

Çevrimiçi deneyin!

Kabuk , 10 bayt

→ḟo=⁰←S+m↔

Çevrimiçi deneyin!

Ungolfed / Açıklama

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

Not : Yukarıdaki örnek, yalnızca okunabilirlik amacıyla tamsayılar üzerinde çalışır, türün kendisi önemli değildir (karşılaştırabildiğiniz sürece).

Swift 4 , 43 bayt

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

Çıktı, boş (ortak bulunamadı) veya tek bir öğeye (ortak) sahip bir dizidir.

Test senaryoları:

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 bayt

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

QBIC listelerde ve gruplarda güçlü değildir. Yukarıdaki kod abir komut satırı parametresi olarak alınır ve daha sonra tuples için çiftler halinde kullanıcı girişi ister. Boş bir eleman verildiğinde çıktı alır b.

Örnek çalışma

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

Meta

açıklama

{           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

Alternatif sürüm, 22 bayt

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

Bu temel olarak daha uzun versiyonla aynıdır, ancak bir eşleşme bulduğunda hemen kapanır. Bunu alternatif olarak listeledim, çünkü erken çıkması nedeniyle tüm tuples'ları bu programa giremezsiniz.

Mathematica, 50 bayt

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

Çevrimiçi deneyin!

Yığılmış , 21 bayt

[:$revmap,KeyArray\#]

Çevrimiçi deneyin! Bu yığından girdi alır ve çıktıyı yığının üzerinde bırakır. Genişletilmiş, şöyle görünür:

[ : $rev map , KeyArray \ # ]

açıklama

Girelim (('sad' 'beep') ('boop' 'boop'))ve 'boop'girdi olarak. Ardından, böyle bir dizi şu şekilde oluşturulur :$revmap,:

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

Yani, dizinin bir kopyası haritadır, her üye ters çevrilir ve ikisi birlikte birleştirilir. KeyArraysırayla, verilen değerlerden bir karma yapar:

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

Ardından, \arama dizesini yığının en üstüne getirir ve anahtarı KeyArray öğesinden eşleşen KeyArray öğesinden alır #. Bu yalnızca bir değer döndürür, bu nedenle KeyArray'daki yinelenen anahtarın endişelenmesine gerek yoktur.

Diğer yaklaşımlar

32 bayt: (yığıntan giriş, STDOUT'a çıkış) [@x:$revmap,uniq[...x=$out*]map]

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

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

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

Excel, 18 Bayt

Olarak girdi alır Anonim Excel çalışma kitabı Formül <Lookup Value>aralığından A1, <Key Array>aralığından B:Bve <Def Array>dizi C:Carama hücreye arama değeri ile ilişkili tanımlama değerini ve çıktılar

=VLOOKUP(A1,B:C,2)

Örnek G / Ç mümkün olduğunda dahil edilmelidir