Conseguir todas las combinaciones en una matriz

Question

Decir que tengo la siguiente matriz:

var arr = new[] { "A", "B", "C" }; 

¿Cómo puedo producir todas las posibles combinaciones que contienen sólo dos personajes y no hay dos iguales (por ejemplo AB sería el mismo que BA). Por ejemplo, utilizando la matriz por encima de ella produciría:

AB 
AC 
BC 

Tenga en cuenta que este ejemplo se ha simplificado. La matriz y la longitud de la cadena requerida serán mayores.

Realmente apreciaría si alguien pudiera ayudar.

Answer 1

Esto debería darle un punto de partida:
http://www.interact-sw.co.uk/iangblog/2004/09/16/permuterate
http://www.codeproject.com/KB/recipes/Combinatorics.aspx

Answer 2

Lets extenderlo, por lo que tal vez podemos ver el patrón:

string[] arr = new string[] { "A", "B", "C", "D", "E" }; 

//arr[0] + arr[1] = AB 
//arr[0] + arr[2] = AC 
//arr[0] + arr[3] = AD 
//arr[0] + arr[4] = AE 

//arr[1] + arr[2] = BC 
//arr[1] + arr[3] = BD 
//arr[1] + arr[4] = BE 

//arr[2] + arr[3] = CD 
//arr[2] + arr[4] = CE 

//arr[3] + arr[4] = DE 

veo dos bucles aquí.

• El primer bucle (exterior) va de 0 a 3 (arr.Length - 1)
• El segundo bucle (interior) va desde los bucles exteriores contador + 1 al 4 (arr.Length)

¡Ahora debería ser fácil traducir eso al código!

Answer 3

Desde orden no importa, estos son en realidad combinaciones y permutaciones no. En cualquier caso, hay un código de ejemplo here (desea que la sección titulada "Combinaciones (es decir, sin repetición)".

Answer 4

Lo que se busca es un doble bucle en la línea de la siguiente pseudo código.

for(int i = FirstElement; i<= LastElement; increment i) { 
    for(j = i; j<= lastElement; increment j) { 
     if(i != j) { 
      print (i, j) 
     } 
    } 
} 

Answer 5

public string[] Permute(char[] characters) 
{ 
    List<string> strings = new List<string>(); 
    for (int i = 0; i < characters.Length; i++) 
    { 
     for (int j = i + 1; j < characters.Length; j++) 
     { 
      strings.Add(new String(new char[] { characters[i], characters[j] })); 
     } 
    } 

    return strings.ToArray(); 
} 

Answer 6

Es la suma de 1 a n-1 o n (n-1)/2.

int num = n * (n - 1)/2; 

Obviamente se podría generalizar el n * (n - 1) con un par de factoriales para lo que sea que estés intentando hacer (sabio del tamaño de la secuencia).

Answer 7

Lo que está pidiendo son combinaciones, no permutaciones (este último término implica que el orden importa). De todos modos, es un uso clásico para la recursión. En pseudo-código:

def combs(thearray, arraylen, currentindex, comblen): 
    # none if there aren't at least comblen items left, 
    # or comblen has gone <= 0 
    if comblen > arraylen - currentindex or comblen <= 0: 
    return 
    # just 1 if there exactly comblen items left 
    if comblen == arraylen - currentindex: 
    yield thearray[currentindex:] 
    return 
    # else, all combs with the current item...: 
    for acomb in combs(thearray, arraylen, currentindex+1, comblen-1): 
    yield thearray[currentindex] + acomb 
    # ...plus all combs without it: 
    for acomb in combs(thearray, arraylen, currentindex+1, comblen): 
    yield acomb 

Answer 8

no quiso ensayar y no el más rápido, pero:

IEnumerable<String> Combine(String text, IEnumerable<String> strings) 
{ 
    return strings.Select(s => text + s).Concat(Combine(strins.Take(1).First(), strings.Skip(1)) 
} 

Llamar:

foreach (var s in Combine("" , arrayOfStrings)) 
{ 
    // print s 
} 

Answer 9

Has escrito una respuesta para una pregunta que resultó ser marcado como duplicado, señalando aquí.

var arr = new[] { "A", "B", "C" }; 

var arr2 = arr1.SelectMany(
    x => arr1.Select(
     y => x + y)); 

produjo la salida correcta cuando se enumeran en la consola en VS2013. SelectMany aplanará el IEnumerable interno generado desde el interior Select.