Tarefa:

Retorne uma matriz com todos os pares possíveis entre os elementos de uma matriz.

Exemplo

De a=["a", "b", "c", "d"];volta b=[["a","b"],["a","c"],["a","d"],["b","c"],["b","d"],["c","d"]].

Os pares podem estar em qualquer ordem, desde que todas as combinações possíveis estejam incluídas e obviamente ["b","d"]sejam iguais ["d","b"].

Entrada

Matriz de elementos string única compostas de caracteres da classe [a-z].

Resultado

2d array contendo todos os pares possíveis de elementos do array de entrada.

Casos de teste

input=["a","b","c"];
//output=[["a","b"],["a","c"],["b","c"]]

input=["a","b","c","d","e"];
//output=[["a","b"],["a","c"],["a","d"],["a","e"],["b","c"],["b","d"],["b","e"],["c","d"],["c","e"],["d","e"]]

Nota: Não foi possível encontrar uma duplicata para este desafio. Se houver, me avise com um comentário para deixar a pergunta.

Gelatina , 2 bytes

Œc

Experimente online!

Haskell , 29 bytes

f(a:b)=map((,)a)b++f b
f _=[]

Experimente online! Exemplo de uso: f ["a","b","c"]rendimentos [("a","b"),("a","c"),("b","c")].

Com o sinalizador, -XTupleSectionsisso pode ser reduzido para 27 bytes; no entanto, o sinalizador precisa ser contado:

f(a:b)=map(a,)b++f b
f _=[]

Experimente online!

Mathematica, 14 bytes

#~Subsets~{2}&

entrada

[{"a", "b", "c"}]

Haskell, 25 bytes

f l=[(x,y)|x<-l,y<-l,x<y]

Experimente online!

Externo ( x) e interno ( y) passam pela lista de entrada e mantêm o par (x,y)apenas se x < y.

05AB1E , 3 bytes

Código:

æ2ù

Usa a codificação 05AB1E . Experimente online!

Explicação:

æ      # Powerset of the input
 2ù    # Keep the items of length two

vim, 50 48

AX<esc>qqYplX@qq@qqrYpllDkxh@rq:g/./norm@r<cr>:g/X/d<cr>dG

Recebe entrada no formulário

abcd

e saídas como

ad
ac
ab
bd
bc
cd

Explicação

Primeiro, AX<esc>anexa um Xà entrada para manipular a entrada de 2 comprimentos, o que é necessário por razões que ficarão claras em breve.

Em seguida, vem a primeira macro recursiva, do formulário qq...@qq@q. (Grave a macro q, execute-se novamente no final, termine a gravação e execute-se uma vez.) No corpo da macro, Ypduplica a linha atual, linterrompe a macro se a linha tiver agora um caractere e Xexclui o primeiro caractere na linha. Isso tem como resultado final a produção

abcdX
abcX
abX
aX
X
X

Ignorando os Xs por enquanto, tudo o que precisamos fazer é transformar abcdX, por exemplo, em ab / ac / ad / aX. Isto é conseguido com a segunda macro recursiva qr...@rq,.

Nesta macro, duplicamos a linha ( Yp) e excluímos tudo, exceto os dois primeiros caracteres, movendo para a direita dois ( ll) e excluindo até o final da linha ( D). Como o cursor está agora no segundo caractere da linha, kxexcluirá o segundo caractere da linha anterior, que passa a ser o que acabou de emparelhar com o primeiro caractere da linha. Esse processo é repetido, iniciando novamente do início da linha ( h) quantas vezes for necessário, devido à natureza recursiva da macro.

Agora é apenas uma questão de executar a macro em todas as linhas, o que pode ser alcançado com :g/./norm@r(não sei por que isso se comporta de maneira diferente :%norm@r, mas basta dizer que a última não funciona conforme o esperado). As linhas com Xsão excluídas com :g/X/d, e as linhas em branco no final deixadas como resultado da construção da rmacro são limpas dG.

Oitava, 23 bytes

@(s)[nchoosek(+s,2) '']

Experimente online!

Python 3 , 44 bytes

f=lambda k,*s:[*s]and[[k,x]for x in s]+f(*s)

Experimente online!

Recebe entrada como parâmetros de função individuais.

Braquilog , 5 bytes

{⊇Ċ}ᶠ

Experimente online!

Como funciona

{⊇Ċ}ᶠ
    ᶠ   find all the possible outputs of the following predicate
 ⊇          the output is an ordered subset of the input
  Ċ         the output is a list with two elements

R , 18 bytes

combn(scan(,''),2)

lê a lista de stdin, retorna uma matriz onde as colunas são pares.

Experimente online!

Python, 53 bytes

2 bytes salvos graças a @CalculatorFeline

lambda a:[(x,y)for i,x in enumerate(a)for y in a[:i]]

Experimente online!

Oitava , 49 48 bytes

@(x)[imag(y=(y=triu(x+j*x',1))(~~y)) real(y) '']

Função anônima que evita o built-in ( nchoosek).

Experimente online!

Explicação

x+j*x'usa a transmissão para criar uma matriz de números complexos, onde as partes reais e imaginárias são todos pares de pontos de código da entrada x.

y=triu(...,1)mantém a parte triangular superior excluindo a diagonal, zerando o restante dos elementos. O resultado é atribuído à variável y.

y=(...)(~~y)mantém os elementos diferentes de zero na forma de um vector de coluna, que é atribuído a variável y.

imag(...)e real(...)extrair as partes reais e imaginárias.

[... ... ''] converte de volta em char para criar a saída.

Pari / GP , 34 bytes

a->concat([[[x,y]|y<-a,x<y]|x<-a])

Experimente online!

Python ≥ 2,7, 55 bytes

lambda l:list(combinations(l,2))
from itertools import*

repl.it!

Perl 6 , 17 bytes

*.combinations(2)

Ufa, esse é um nome de método longo.

Scala, 17 bytes

_.combinations(2)

Pitão , 7 4 bytes

^{-3 bytes graças a Leaky Nun !}

.cQ2

Experimente online!

Ruby , 38 34 24 bytes

->x{[*x.combination(2)]}

Obrigado Parece pela idéia que salvou 10 bytes.

Experimente online!

JavaScript ES6, 52 bytes

a=>a.map((x,i)=>a.slice(0,i).map(y=>[x,y])).slice(1)

Se houvesse um flatMapque economizaria muitos bytes.

Python , 55 bytes

f=lambda s:[(s[0],j)for j in s[1:]]+f(s[1:])if s else[]

Experimente online!

Mais do que outras respostas do Python, mas ele usa uma técnica diferente, então acho que vale a pena postar.

Japonês , 2 bytes

à2

Teste ( -Qsinalize apenas para fins de visualização)

Python, 64 bytes

f=lambda a:sum((list(zip(a, a[i:]))for i in range(1,len(a))),[])

Oitava, 38 bytes

@(s)s([[x y]=find(s|s'),y](y<x,[2 1]))

Outra resposta para evitar o nchoosekbuilt-in.

Experimente online!

Clojure, 42 bytes

#(set(for[i % j(remove #{i}%)](set[i j])))

Retorna um conjunto de conjuntos :)

Python, 74 bytes

f=lambda a:[(c,d) for i,c in enumerate(a) for j,d in enumerate(a) if i<j]

Javascript (ES 5), de 108 a 78 bytes

Hoje posto minha resposta, mas obviamente prometo não aceitar minha própria resposta:

x=input;
a=[];

for(n=0;n<(x.length-1);n++){for(i=n+1;i<(x.length);i++){a.push([x[n],x[i]]);}}

J , 17 bytes

({~$#:I.@,)#\</#\

Experimente online!

Explicação

({~$#:I.@,)#\</#\  Input: string S
               #\  Get the length of each prefix of S
           #\      Get the length of each prefix of S again
             </    Test using greater than (<) between each
         ,         Flatten
      I.@          Find the indices where the value is 1
   $               Shape of that table
    #:             Convert the indices to the base represented by the shape
 {~                Index into S at those values