Tarea:

Devuelve una matriz con todos los pares posibles entre los elementos de una matriz.

Ejemplo

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

Los pares pueden estar en cualquier orden siempre que se incluyan todas las combinaciones posibles y obviamente ["b","d"]sea ​​lo mismo ["d","b"].

Entrada

Matriz de elementos de cadena únicos compuestos por caracteres de la clase [a-z].

Salida

Matriz 2D que contiene todos los pares posibles de elementos de la matriz de entrada.

Casos de prueba

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: No pude encontrar un duplicado para este desafío. Si hay uno, avíseme con un comentario para dejar la pregunta.

Jalea , 2 bytes

Œc

Pruébalo en línea!

Haskell , 29 bytes

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

Pruébalo en línea! Ejemplo de uso: f ["a","b","c"]rendimientos [("a","b"),("a","c"),("b","c")].

Con el indicador, -XTupleSectionsesto se puede acortar a 27 bytes, sin embargo, el indicador debería contarse:

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

Pruébalo en línea!

Mathematica, 14 bytes

#~Subsets~{2}&

entrada

[{"a B C"}]

Haskell, 25 bytes

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

Pruébalo en línea!

Outer ( x) e inner ( y) recorren la lista de entrada y mantienen el par (x,y)solo si x < y.

05AB1E , 3 bytes

Código:

æ2ù

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación:

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

Toma entrada en el formulario

abcd

y salidas como

ad
ac
ab
bd
bc
cd

Explicación

Primero, AX<esc>agrega un an Xa la entrada para manejar la entrada de 2 longitudes, lo cual es necesario por razones que se aclararán en breve.

Luego viene la primera macro recursiva, de la forma qq...@qq@q. (Grabe macro q, vuelva a ejecutarse al final, finalice la grabación, luego ejecútese una sola vez). En el cuerpo de la macro, Ypduplica la línea actual, lsale de la macro si la línea tiene ahora un carácter y Xborra el primer personaje de la línea. Esto tiene el resultado final de producir

abcdX
abcX
abX
aX
X
X

Ignorando la Xs por ahora, todo lo que tenemos que hacer es convertir abcdX, por ejemplo, en ab / ac / ad / aX. Esto se consigue con la segunda macro recursiva, qr...@rq.

En esta macro, primero duplicamos la línea ( Yp), luego eliminamos todo menos los dos primeros caracteres moviendo dos ( ll) a la derecha y eliminando al final de la línea ( D). Dado que el cursor está ahora en el segundo carácter de la línea, kxeliminará el segundo carácter de la línea anterior, que es el que acaba de emparejarse con el primer carácter de la línea. Este proceso se repite comenzando nuevamente desde el principio de la línea ( h) tantas veces como sea necesario debido a la naturaleza recursiva de la macro.

Ahora es solo cuestión de ejecutar la macro en cada línea, lo que se puede lograr con :g/./norm@r(no estoy seguro de por qué esto se comporta de manera diferente :%norm@r, pero es suficiente decir que este último no funciona como se esperaba). Las líneas con Xse eliminan con :g/X/d, y las líneas en blanco al final a la izquierda como resultado de la construcción de la rmacro se limpian con dG.

Octava, 23 bytes

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

Pruébalo en línea!

Python 3 , 44 bytes

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

Pruébalo en línea!

Toma datos como parámetros de funciones individuales.

Brachylog , 5 bytes

{⊇Ċ}ᶠ

Pruébalo en línea!

Cómo 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)

lee la lista de stdin, devuelve una matriz donde las columnas son pares.

Pruébalo en línea!

Python, 53 bytes

2 bytes guardados gracias a @CalculatorFeline

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

Pruébalo en línea!

Octava , 49 48 bytes

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

Función anónima que evita el incorporado ( nchoosek).

Pruébalo en línea!

Explicación

x+j*x'usa la transmisión para construir una matriz de números complejos donde las partes reales e imaginarias son todos pares de puntos de código de la entrada x.

y=triu(...,1)mantiene la parte triangular superior excluyendo la diagonal, haciendo que el resto de elementos sea cero. El resultado se asigna a la variable y.

y=(...)(~~y)retiene los elementos distintos de cero en forma de un vector de columna, que se asigna a la variable y.

imag(...)y real(...)extraer las partes reales e imaginarias.

[... ... ''] convierte de nuevo a char para generar la salida.

Pari / GP , 34 bytes

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

Pruébalo en línea!

Python ≥ 2.7, 55 bytes

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

repl.it!

Perl 6 , 17 bytes

*.combinations(2)

Vaya, ese es un nombre de método largo.

Scala, 17 bytes

_.combinations(2)

Pyth , 7 4 bytes

^{-3 bytes gracias a Leaky Nun !}

.cQ2

Pruébalo en línea!

Ruby , 38 34 24 bytes

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

Gracias Seims por la idea que ahorró 10 bytes.

Pruébalo en línea!

JavaScript ES6, 52 bytes

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

Si hubiera una, flatMapeso ahorraría muchos bytes.

Python , 55 bytes

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

Pruébalo en línea!

Más tiempo que otras respuestas de Python, pero utiliza una técnica diferente, así que creo que vale la pena publicarlo.

Japt , 2 bytes

à2

Pruébalo ( -Qmarca solo para fines de visualización)

Python, 64 bytes

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

Octava, 38 bytes

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

Otra respuesta para evitar nchoosekincorporados.

Pruébalo en línea!

Clojure, 42 bytes

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

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

Publico mi respuesta hoy, pero obviamente prometo no aceptar mi propia respuesta:

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.@,)#\</#\

Pruébalo en línea!

Explicación

({~$#: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