Desafio
Dada uma lista arbitrária de duas tuplas e um único elemento em uma dessas tuplas, produza seu "parceiro", isto é, dado a
e [(i,j),...,(a,b),...,(l,m)]
, saída b
. Você pode assumir que todas as tuplas são únicas e que todos os elementos nas tuplas são cadeias. Além disso, assuma que você não possui os dois (x,y)
e (y,x)
.
Casos de teste
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"
Menos bytes ganha!
code-golf
array-manipulation
search
Nate Stemen
fonte
fonte
[a, b, c, d]
vez de[(a, b), (c, d)]
. Rasparia uma tonelada de bytes da minha resposta. : P(a,a)
especificamente e me disseram que isso não aconteceria . Nate chegou a editar a pergunta para especificar esse fato. No entanto, você adicionou um caso de teste com essa entrada e também editou a especificação revertendo essa decisão - por quê? Está quebrado um monte de respostas.Respostas:
Japonês, 6 bytes
Funciona com cadeias ou números inteiros.
Teste-o
Explicação
Entrada implícita de matriz
U
e sequência / número inteiroV
.Obtenha o primeiro elemento (subarray)
U
nesse ...Contém
V
.Remova
V
e retorne implicitamente a matriz de elemento único resultante.fonte
f
vez deæ
na época. Duh: Pæ
e tenta mexerf
! : DHaskell , 33 bytes
Experimente online!
Define um operador binário
!
, que assume como argumento à esquerda um valorx
do tipo τ e como argumento à direita uma lista de tuplas (τ, τ). O padrão de definição corresponde à cabeça(a,b)
e à caudac
da lista fornecida; sex==a
entãob
é retornado; sex==b
thena
for retornado; caso contrário, continuaremos procurando no restante da lista recorrendo.(Se não houver um "parceiro" na lista, isso falhará, porque não definimos o que
x![]
deveria ser.)fonte
JavaScript (ES6), 39 bytes
Toma a entrada e a matriz de matrizes como argumentos ao curry. A melhor versão não recursiva que eu pude fazer foi 44 bytes:
fonte
a=>b=>a.map(e=>b=e[1-e.indexOf(b)]||b)&&b
(a,b)=>
=>a=>b=>
de curry, mas a versão não recursiva começou a partir da versão recursiva, que foi curada porque eu pude salvar 2 bytes na chamada recursiva (o curry em si realmente custa um byte).MATL ,
41456 bytesExperimente online!
Entrada é uma matriz como
[{a;b},{c;d}]
. O Bytecount flutua fortemente enquanto o OP descobre o que é realmente permitido.Comecei com uma versão de 4 bytes que só podia lidar com cadeias de caracteres únicos, que era o único caso de teste no desafio original. Quando isso se mostrou inválido, criei uma versão muito longa de 14 bytes, que era agradável e hacky (verifique o histórico de revisões!), Me fez descobrir um bug e depois me tornei completamente desnecessário
Y=
, com entrada adequada , funcionou tão bem quanto meu original de 4 bytesy=P)
.fonte
Python 2 , 37 bytes
Experimente online!
Próton , 31 bytes
Experimente online!
(Essas duas respostas são tão parecidas que as estou postando juntas para evitar repfarming)
fonte
reversed
parareverse
no Proton para -1 byte. \ s: P Mais a sério,reverse
é um nome muito melhor, não? : PPerl 5 , 30 + 1 (-p) = 31 bytes
Experimente online!
fonte
Python 2 ,
594542 bytes-14 bytes graças a Emigna. -3 bytes graças a Maltysen.
Experimente online!
Ainda quero usar curry embora. ; -;
fonte
y+[1,-1][y%2]
. Só não achei que fosse pouco a pouco ... Obrigado!C ++, 179 bytes
C ++ com tipo de dados mapa, 162 bytes
Com o MSVC, o código compila mesmo que a última
return
instrução (return"";
) seja omitida. Torna o código 9 bytes mais leve, mas sair pelo final da função (ou seja, não sair por umareturn
instrução no loop) sem instruções de retorno causará um comportamento indefinido e não funcionará se a matriz tupla não contiver o elemento "key"fonte
PowerShell, 36 bytes
encontra o elemento que contém a intput e, em seguida, obtém o elemento 'other' excluindo a entrada, o PowerShell não possui o gerenciamento de matriz mais incrível, mas pode haver um recurso interno para isso de que não conheço.
fonte
("boop", "boop")
caso de teste.Röda , 30 bytes
Experimente online!
Explicação:
fonte
Mathematica
2724 bytesCases
seleciona elementos de uma lista que correspondem a um padrão. Quando usado com uma seta, os elementos correspondentes aos padrões podem ser transformados.Uso:
Explicação: Neste exemplo, depois de encontrar o primeiro argumento, 3, a função passa a
Cases[{3,x_}|{x_,3}:>x]
ser uma forma de operadorCases
que é aplicada ao segundo argumento,{{1, 2}, {3, 4}}
selecionando assim o companheiro de 3, seja na posição de abcissa ou ordenada. Notavelmente, essa função listará todos os companheiros se, de fato, o 1º argumento aparecer mais de uma vez no segundo argumento, ou seja, isso vai um pouco além das suposições da pergunta declarada.Os glifos envolventes devem ser chaveados. 3 bytes salvos com a sugestão "Currying" de @Notatree
fonte
Cases[{#,x_}|{x_,#}:>x]&
, utilizado como%[3][{{1,2},{3,4}}]
R , 47
42bytesExperimente online!
Funciona em uma matriz ou em um vetor reto. v = o valor da pesquisa, a = matriz de tupla.
fonte
Gelatina , 6 bytes
Um link diádico que pega a lista de parceiros à esquerda e o parceiro perdido à direita e retorna o parceiro.
Experimente online!
Quão?
fonte
(a,a)
e me disseram que não precisávamos lidar com isso). Tenho certeza de que poderia corrigi-lo, mas não tenho certeza se a especificação está como pretendia agora.Pitão -
1198 bytesExperimente online aqui .
fonte
Haskell ,
6562 bytesExperimente online!
Explicação
Isso usa span para encontrar a primeira instância em que
x
está contida na tupla. Ele pega o primeiro elemento da tupla, se não for igual, e o segundo, caso contrário.Haskell Lambdabot,
5956 bytesExperimente online!
Explicação
Isso usa
Data.List
afirst
função s para reduzir os bytes usados por(!!0).snd.span
, no entanto, porquefirst
retorna aMaybe
, precisamos adicionarJust
à nossa correspondência de padrões em#
.fonte
x!((a,b):c)|x==a=b|x==b=a|1<2=x!c
tem 33 bytes.05AB1E , 7 bytes
Experimente online!
Solução alternativa de 7 bytes
Experimente online!
fonte
˜D²k>è
para 6, a menos que haja um motivo específico para XOR'ing com 1?Lisp comum, 74 bytes
Experimente online!
fonte
Java 8, 78 bytes
Um lambda (com curry) de
Stream<List<String>>
para um lambda deString
paraString
(embora a digitação implícita ocorra para permitir que isso funcione para listas arbitrárias). O idioma não possui classes de tupla dedicadas e eu não conheço nenhuma na biblioteca padrão; portanto, os pares de entrada são representados como listas. Pode ser atribuído aFunction<Stream<List<String>>, Function<String, String>>
.Experimente Online
Vou creditar o salvamento dos últimos 6 bytes a qualquer pessoa que possa me convencer de que retornar um
Optional
é válido. Não consegui me convencer.Uma das partes interessantes desta solução para mim foi determinar a maneira mais barata de obter a saída do fluxo. Eu considerei
reduce
,findFirst
emin
/max
, mas nenhum foi menor que o intuitivofindAny
.fonte
Ruby, 31 bytes
Retorna uma matriz singleton.
fonte
JavaScript (ES6), 45 bytes
Cheguei com isso ontem à noite e notei que Neil havia me derrotado para uma solução JS melhor; achei que eu poderia postá-lo de qualquer maneira.
Funciona com cadeias e números inteiros.
fonte
Prolog (SWI) , 43 bytes
Experimente online!
fonte
C# (.NET Core),
101100 + 18 bytesthank you to Grzegorz Puławski helping reducing a couple of bytes.
Try it online!
C# (.NET Core),
122121120 bytesTry it online!
fonte
x=>y=>
is shorter than(x,y)=>
(Func<a, b, c>
becomesFunc<a, Func<b, c>>
and function callf(a, b)
becomesf(a)(b)
) - Great answer btw!using System.Linq;
versusnamespace System.Linq{}
)Husk, 10 bytes
Try it online!
Ungolfed/Explanation
Note: The above example works on integers just for the sake of readability, the type itself doesn't matter (as long as you can compare it).
fonte
Swift 4, 43 bytes
The output is an array, which is either empty (no partner found), or has a single element (the partner).
Test cases:
fonte
QBIC, 30 bytes
QBIC isn't strong on lists and tuples. The above code takes
a
as a command line parameter, then asks for user input in pairs for the tuples. When an empty element is given, it outputsb
.Sample run
Explanation
Alternative version, 22 bytes
This basically does the same as the longer version, but immediately quits when it finds a match. I've listed this as the alternative, because you can't input all tuples into this program given that it quits early.
fonte
Mathematica, 50 bytes
Try it online!
fonte
{'boop','boop'}
testcase.Stacked, 21 bytes
Try it online! This takes input from the the stack and leaves output on the stack. Expanded, this looks like:
Explanation
Let's take
(('sad' 'beep') ('boop' 'boop'))
and'boop'
as the input. Then, an array like so is constructed by:$revmap,
:That is, a copy of the array is map, each member is reversed, and the two are concatenated together.
KeyArray
in turn makes a hash out of the values given, like so:Then,
\
brings the search string to the top of the stack, and obtains the key from the KeyArray that matches with#
. This returns only one value, so the duplicate key in the KeyArray does not need to be worried about.Other approaches
32 bytes: (input from stack, output to STDOUT)
[@x:$revmap,uniq[...x=$out*]map]
36 bytes:
{%x[y index#+]YES 0# :y neq keep 0#}
38 bytes:
[@x:$revmap#,[KeyArray x#]map:keep 0#]
46 bytes:
[@x:KeyArray\$revmap KeyArray,[x#]map:keep 0#]
fonte
Excel, 18 Bytes
Anonymous Excel Workbook Formula that takes input as
<Lookup Value>
from rangeA1
,<Key Array>
from rangeB:B
and<Def Array>
from rangeC:C
, and outputs the value of the definition associated with the lookup value to the calling cellSample I/O shall be included when possible
fonte