Enumérer les arrangements possibles d'un tableau

Soyez le premier à donner votre avis sur cette source.

Snippet vu 12 675 fois - Téléchargée 7 fois

Contenu du snippet

/// <summary>Représente la méthode qui est appelé lorsqu'une permutation est trouvée</summary>
/// <typeparam name="T">Type des éléments</typeparam>
/// <param name="values">Tableau contenant les éléments</param>
public delegate void PermutationHappenHandler<T>(T[] values);

/// <summary>Énumère les arrangements possibles d’un tableau</summary>
/// <typeparam name="T">Type des éléments</typeparam>
/// <param name="values">Tableau contenant les éléments</param>
/// <param name="permutationHappen">Délégué appelé à chaque permutation trouvé</param>
public static void Permutation<T>(T[] values, PermutationHappenHandler<T> permutationHappen) {
  if (values == null)
    throw new ArgumentNullException("values");
  PermutationRec<T>(values, 0, values.GetUpperBound(0), permutationHappen);
}

/// <summary>Énumère les arrangements possibles d’un tableau</summary>
/// <typeparam name="T">Type des éléments</typeparam>
/// <param name="values">Tableau contenant les éléments</param>
/// <param name="start">Index de l'élément de départ</param>
/// <param name="permutationHappen">Délégué appelé à chaque permutation trouvé</param>
public static void Permutation<T>(T[] values, int start, PermutationHappenHandler<T> permutationHappen) {
  if (values == null)
    throw new ArgumentNullException("values");
  if (start < values.GetLowerBound(0) || start > values.GetUpperBound(0))
    throw new ArgumentOutOfRangeException("start");
  PermutationRec<T>(values, start, values.GetUpperBound(0), permutationHappen);
}

/// <summary>Énumère les arrangements possibles d’un tableau</summary>
/// <typeparam name="T">Type des éléments</typeparam>
/// <param name="values">Tableau contenant les éléments</param>
/// <param name="start">Index de l'élément de départ</param>
/// <param name="length">Nombre d'éléments à prendre en compte</param>
/// <param name="permutationHappen">Délégué appelé à chaque permutation trouvé</param>
public static void Permutation<T>(T[] values, int start, int length, PermutationHappenHandler<T> permutationHappen) {
  if (values == null)
    throw new ArgumentNullException("values");
  if (start < values.GetLowerBound(0) || start > values.GetUpperBound(0))
    throw new ArgumentOutOfRangeException("start");
  if (length < 1 || length > values.Length - start)
    throw new ArgumentOutOfRangeException("length");
  PermutationRec<T>(values, start, start + length - 1, permutationHappen);
}

private static void PermutationRec<T>(T[] values, int startpos, int endpos, PermutationHappenHandler<T> permutationHappen) {
  T tmp;
  if (permutationHappen != null)
    permutationHappen(values);
  for (int i = startpos; i <= endpos; i++) {
    for (int j = i + 1; j <= endpos; j++) {
      tmp = values[i];
      values[i] = values[j];
      values[j] = tmp;
      PermutationRec(values, i + 1, endpos, permutationHappen);
      values[j] = values[i];
      values[i] = tmp;
    }
  }
}


// Exemple d'utilisation

static void Main(string[] args) {

  Permutation<int>(new int[] { 1, 2, 3, }, new PermutationHappenHandler<int>(PermutationHappen<int>));
  // Sortie :
  // 123
  // 213
  // 231
  // 321
  // 312
  // 132

  Permutation<char>(new char[] { '[', 'a', 'b', 'c', ']', }, 1, 3, new PermutationHappenHandler<char>(PermutationHappen<char>));
  // Sortie :
  // [abc]
  // [bac]
  // [bca]
  // [cba]
  // [cab]
  // [acb]

}

static void PermutationHappen<T>(T[] values) {
  for (int i = 0; i < values.Length; i++)
    Console.Write(values[i].ToString());
  Console.WriteLine();
}

Compatibilité : C# 1.x, C# 2.x, C# 3.x

Disponible dans d'autres langages :

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.