1
votes

Trouver toutes les listes de séquences possibles à partir d'une seule liste c #

je veux trouver tous les éléments de séquence possibles de la liste en utilisant c #

les nombres sont dans l'ordre incrémentiel si c'est une séquence je dois diviser le tableau

Exemple de tableau: int [] array = {1 , 2,3,5,6,8,9,10}

Sortie attendue sous forme de toutes les listes de séquences possibles: {1,2,3}, {5,6}, {8,9,10 }

Quelqu'un peut-il m'aider à ce sujet?

code

    for(int i=0;i<array.Length;i++)
    {
        if(array[i]== array[i+1])
        {
           // i want to get all possible sequence of elements
        }
    }

c# linq

1 commentaires

S'il manque Xn , vous devez vous séparer, non? Qu'avez-vous essayé et qu'est-ce qui ne fonctionne pas? Pourquoi obtenez-vous 2 votes positifs?

3 Réponses :

5
votes

    private static List<List<int>> FindSequence(int[] array)
    {
        var result = new List<List<int>>();
        var tempList  = new List<int>{array[0]};
        var lastResult = array[0];
        for (var i = 1; i < array.Length; i++)
        {
            if(lastResult + 1 == array[i])
                tempList.Add(array[i]);
            else
            {
                result.Add(tempList);
                tempList = new List<int> {array[i]};
            }
            lastResult = array[i];
        }
        result.Add(tempList);
        return result;
    }
I've used List<List<int>>, that could be changed to List<int[]> if you want to.

0 commentaires

0
votes

S'il y a une valeur max qui n'est pas très grande, et seulement pour zéro ou plus, j'utiliserais un tableau Aux auxArray [maxValue] de zéros, passer en revue le tableau de nombres une fois et mettre à jour toute la valeur crrent dans le auxArray à un. auxArray [tableau [i]] = 1; alors je passerais en revue le auxArray une fois et pour chaque 1 trouvé dans le tableau continue jusqu'à ce que vous atteigniez un zéro. et le groupe suivant commencera une fois que vous en aurez trouvé un autre.

exemple sur la façon de remplir le tableau:

arr[0,1,5,6];
auxArray[6] = {0};
for(i=0; i< 4; ++i)
{
   auxArray[array[i]] =1;
}

donc maintenant tout ce que vous avez à faire est une boucle for ( i = 0; i

Une autre façon de procéder est d'obtenir la valeur min suivante de le tableau des nombres. s'il est supérieur de un à la dernière valeur minimale, ils vont ensemble. sinon, commencez un nouveau lot de nombres.

Une troisième façon de procéder est de trier le tableau. puis passez en revue et vérifiez que la différence est de 1 pour le même groupe.

0 commentaires

1
votes

Encore une autre implémentation:

    public static IEnumerable<IEnumerable<int>> FindSequences(IEnumerable<int> input, int step = 1)
    {
        int currentIndex = -1;
        int sequenceStartIndex = -1;
        int lastValue = 0;
        foreach (int i in input)
        {
            ++currentIndex;

            if (currentIndex == 0)
            {
                sequenceStartIndex = 0;
                lastValue = i;
                continue;
            }

            if (lastValue + step != i)
            {
                yield return input.Skip(sequenceStartIndex).Take(currentIndex - sequenceStartIndex);
                sequenceStartIndex = currentIndex;
            }

            lastValue = i;
        }

        if (currentIndex > -1) //collection was not empty
        {
            yield return input.Skip(sequenceStartIndex).Take(currentIndex - sequenceStartIndex + 1);
        }
    }

[+] Permet la diffusion des résultats
[+] Fonctionne sur tout type de collection ou tableau
[+] Permet de définir des étapes personnalisées
[-] Implique plus d'itérations qu'une solution basée sur List

3 commentaires

Électeur à la baisse, pourriez-vous expliquer le raisonnement derrière votre vote?

N'a pas voté (vers le bas), mais le streaming des résultats ne nécessiterait-il pas que cette méthode soit asynchrone?

@MarkCiliaVincenti par streaming, je voulais dire récupération sur demande. Lorsque vous foreach le résultat d'un IEnumerable 'yield-returned', une nouvelle instance IEnumerator est créée, et il est possible que le IEnumerator est supprimé / collecté avant le dernier élément (par exemple lors de la sortie de la boucle sur une condition particulière). Dans ce cas, le reste des éléments n'aura pas à être récupéré.