C# cadena de dividir y combinar

Question

tengo una cadena que conatin 5 números como

'1,4,14,32,47' 

quiero hacer de esta cadena de 5 cuerdas de 4 número en cada uno

como:

'1,4,14,32' 
'1,4,14,47' 
'1,4,32,47' 
'1,14,32,47' 
'4,14,32,47' 

cuál es la manera más simple/más rápida de hacerlo

es la forma de convertir esto a la matriz desarmada cada vez Diferente y combinar de nuevo a la secuencia?

¿hay una manera simple de hacerlo?

gracias

Answer 1

¿Qué tal algo así como

string s = "1,4,14,32,47"; 
string r = String.Join(",", s.Split(',').Where((x, index) => index != 1).ToArray()); 

Answer 2

Uso string.Split() puede crear una matriz de cadenas. Haz un bucle a través de él, de modo que en cada iteración de bucle indiques qué elemento se debe omitir (en el primer pase, ignora el primer elemento, en el segundo pase, ignora el segundo elemento).

Dentro de ese bucle, cree una nueva matriz que contenga todos los elementos excepto la que desea omitir, luego use string.Join() para crear cada resultado.

Answer 3

Tenga una mirada en:

http://msdn.microsoft.com/en-us/magazine/ee310028.aspx Aquí encontrará un ejemplo en C# que dará el fondo correcta en combinaciones y permutaciones (así es como se llama lo que necesita). Hay código también, creo que es fácil de traducir en C#

Example of Code in C# (text in Italian but code in English)

Answer 4

su redacción es bastante confuso ... pero el ejemplo es lo suficientemente clara. solo split en comas, luego remove un índice, luego use string.Join (",", list); para poner de nuevo juntos ..

Answer 5

Para aquellos que necesitan un algoritmo más genérica, aquí es uno que da subconjuntos de longitud n de m elementos:

private void GetPermutations() 
{ 
    int permutationLength = 4; 
    string s = "1,4,14,32,47"; 
    string[] subS = s.Split(','); 
    int[] indexS = new int[permutationLength]; 

    List<string> result = new List<string>(); 
    IterateNextPerm(permutationLength, indexS, subS, result); 

    // Result will hold all your genberated data. 
} 

private void IterateNextPerm(int permutationLength, int[] pIndexes, string[] subS, List<string> result) 
{ 
    int maxIndexValue = subS.Count() - 1; 

    bool isCorrect = true; 
    for (int index = 0; index < permutationLength - 1; index++) 
    { 
     if (pIndexes[index] >= pIndexes[index + 1]) 
     { 
      isCorrect = false; 
      break; 
     } 
    } 

    // Print result if correct 
    if (isCorrect) 
    { 
     string strNewPermutation = string.Empty; 
     for (int index = 0; index < permutationLength; index++) 
     { 
      strNewPermutation += subS[pIndexes[index]] + ","; 
     } 
     result.Add(strNewPermutation.TrimEnd(',')); 
    } 

    // Increase last index position 
    pIndexes[permutationLength - 1]++; 

    // Check and fix if it's out of bounds 
    if (pIndexes[permutationLength - 1] > maxIndexValue) 
    { 
     int? lastIndexIncreased = null; 

     // Step backwards and increase indexes 
     for (int index = permutationLength - 1; index > 0; index--) 
     { 
      if (pIndexes[index] > maxIndexValue) 
      { 
       pIndexes[index - 1]++; 
       lastIndexIncreased = index - 1; 
      } 
     } 

     // Normalize indexes array, to prevent unnecessary steps 
     if (lastIndexIncreased != null) 
     { 
      for (int index = (int)lastIndexIncreased + 1; index <= permutationLength - 1; index++) 
      { 
       if (pIndexes[index - 1] + 1 <= maxIndexValue) 
       { 
        pIndexes[index] = pIndexes[index - 1] + 1; 
       } 
       else 
       { 
        pIndexes[index] = maxIndexValue; 
       } 
      } 
     } 
    } 

    if (pIndexes[0] < maxIndexValue) 
    { 
     IterateNextPerm(permutationLength, pIndexes, subS, result); 
    } 
} 

Yo sé que no es el más bonito de codificación, pero Lo he escrito en este momento en la última media hora, así que estoy seguro de que hay cosas para explorar allí.

¡Diviértete codificando!

Answer 6

var elements = string.Split(','); 

var result = 
Enumerable.Range(0,elements.Length) 
.Reverse() 
.Select(
i=> 
    string.Join("," 
    Enumerable.Range(0,i).Concat(Enumerable.Range(i+1,elements.Length - i - 1)) 
    .Select(j=>elements[j]).ToArray() // This .ToArray() is not needed in NET 4 
) 
).ToArray();