Générer des paires d'équipes anonymes

J'ai dû, pour un cours avec des étudiantes et des étudiants de session 5 au programme Techniques de l'informatique du Collège Lionel-Groulx, anonymiser des travaux pour les redistribuer de manière à ce que chaque équipe ait en main une version anonyme du travail d'une autre équipe.

Le code que j'ai écrit pour y arriver suit. Si ça peut vous être utile...

J'ai limité mes outils à une gamme d'outils standards de C++ 17

#include <random>
#include <iostream>
#include <vector>
#include <numeric>
#include <cassert>
#include <string>
#include <algorithm>
#include <iterator>

J'ai écrit un algorithme none_equal(a,b) qui suppose deux conteneurs a et b de même taille (avec C++ 20, j'aurais pu valider qu'il s'agit de conteneurs à l'aide de concepts), et retourne true seulement si les éléments aux mêmes positions sont tous différents (p. ex. : le premier élément de a diffère du premier élément de b, le deuxième élément de a diffère du deuxième élément de b, etc.)

Raffinement possible : si on remplace C par deux types C0 et C1 par exemple, on pourra comparer des valeurs logées dans des conteneurs de types différents, mais il faudra ajuster légèrement la structure de la boucle.

template <class C>
   bool none_equal(const C &a, const C &b) {
      assert(a.size() == b.size());
      for(auto p = begin(a), q = begin(b); p != end(a); ++p, ++q)
         if(*p == *q)
            return false;
      return true;
   }

Enfin, le programme principal suppose N équipes et générera des noms de la forme A02-A0, A02-B0, ..., A02-Z0, A02-A1, A02-B1, ... (le A02 est parce que le travail se nommait Activité 02).

Ensuite, l'algorithme est simple : on copie ces noms dans un autre conteneur, et on brasse ce dernier tant et aussi longtemps qu'il restera une équipe qui se voit assignée son propre travail. Avec un petit N, ça fonctionne presque toujours du premier coup.

Raffinement : le littéral 26 est pour la taille de l'alphabet. On pourrait utiliser une constante à cette fin, p. ex. :

enum { TAILLE_ALPHABET = 'z'-'a'+1 };

int main() {
   using namespace std;
   enum { N = 28 };
   mt19937 prng{ random_device{}() };
   vector<string> pre(N), post;
   generate(begin(pre), end(pre), [n=0]() mutable {
      char c = 'A' + (n % 26);
      return ("A02-"s + c) + to_string(n++ / 26);
   });
   copy(begin(pre), end(pre), back_inserter(post));
   shuffle(begin(post), end(post), prng);
   while(!none_equal(pre, post))
      shuffle(begin(post), end(post), prng);
   for(auto p = begin(pre), q = begin(post); p != end(pre); ++p, ++q)
      cout << *p << " recoit " << *q << endl; 
}