Bonjour,

Je suis entrain de créer un petit programme qui nécessite de calculer toutes les combinaisons possible pour N éléments différents. Je m'explique, imaginons cet ensemble :
1,2,3
Je souhaiterai calculer toutes les combinaisons, c'est a dire :
1,1,1
1,1,2
1,1,3
1,2,3
[...]
3,3,3

Biensur le nombre N d'éléments n'est pas fixe. Auriez vous un algorithme me permettant de faire cela ou simplement une piste pour m'indiquer dans quelle direction chercher ?

Merci d'avance.

PS: j'ai oublié de préciser qu'il ne s'agit pas toujours de chiffres mais également de caractères.

[EDIT]
J'ai finalement trouvé, pour ceux qui chercheraient :

public class CombinUtils
{
    public static IEnumerable<IEnumerable<T>> Combine<T>(IEnumerable<T> list, int count)
    {
        if (count == 0)
        {
            yield return new T[0];
        }
        else
        {
            int startingElementIndex = 0;
            foreach (T startingElement in list)
            {
                IEnumerable<T> remainingItems = AllExcept(list);

                foreach (IEnumerable<T> combinationOfRemainder in Combine(remainingItems, count - 1))
                {
                    yield return Concat<T>(
                        new T[] { startingElement },
                        combinationOfRemainder);
                }
                startingElementIndex += 1;
            }
        }
    }
    // Enumerates over contents of both lists.
    public static IEnumerable<T> Concat<T>(IEnumerable<T> a, IEnumerable<T> b)
    {
        foreach (T item in a) { yield return item; }
        foreach (T item in b) { yield return item; }
    }

    // Enumerates over all items in the input
    public static IEnumerable<T> AllExcept<T>(IEnumerable<T> input)
    {
        foreach (T item in input)
        {
            yield return item;
        }
    }
}

Il s'agit d'une modification du code disponible ici permettant a la base de calculer les permutation et non les combinaisons.