1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <time.h>
5. int main(void) {
6.     char alphabet[] = "0123456789abcdefghijklmnopqrstuvwxyz";  // les lettres à permuter
7.     int  size = 10; // taille du mot de sortie
8.     int *compteurs;    // car on ne peut allouer un buffer statique, size n'étant pas fixe
9.     compteurs = malloc(size * sizeof(int));
10.     if (compteurs) {
11. int alphamax = sizeof alphabet - 1;
12. int i;
13. clock_t start, end;
15. start = clock();
16. for (i = 0; i < size; ++i) { compteurs[i] = 0; } // les compteurs à 0
18. do {
19.     /* on ecrit le mot correspondant aux valeurs dans le tableau buffer */
20.     for (i = size - 1; i >= 0; --i) {
21.  putchar(alphabet[compteurs[i]]);
22.     }
23.     putchar('\n');
25.     /* boucle qui incrémente successivement les entiers de buffer */
26.     for (i = 0; i < size; ++i) {
27.  if (++compteurs[i] < alphamax) // on incrémente le compteurs courant et on arrete
28.      break;
29.  else
30.      compteurs[i] = 0;  // raz et incrémentation du compteur suivant autour de boucle
31.     }
33. } while (i < size);
34. end = clock();
35. free(compteurs);
36. printf("Temps ecoule: %f\n", ((end - start) / CLOCKS_PER_SEC));
37. return 0;
38.     }
39.     else {
40. printf("Pas assez de memoire pour allouer un tableau de %d entiers!\n", size);
41. return -1;
42.     }
43. }

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <time.h>
5. int main(void) {
6.     char alphabet[] = "0123456789abcdefghijklmnopqrstuvwxyz";  // les lettres à permuter
7.     int  size = 4; // taille du mot de sortie
8.     int *compteurs;    // car on ne peut allouer un buffer statique, size n'étant pas fixe
9.     compteurs = malloc(size * sizeof(int));
10.     if (compteurs) {
11. char *buffer = malloc(size + 1);
12. if (buffer) {
13.     int alphamax = sizeof alphabet - 1;
14.     int i;
15.     clock_t start, end;
17.     start = clock();
18.     for (i = 0; i < size; ++i) { compteurs[i] = 0; } // les compteurs à 0
19.     buffer[size] = 0; // \0 en fin de buffer
21.     do {
22.  /* on ecrit le mot correspondant aux valeurs dans le tableau buffer */
23.  for (i = 0; i < size; ++i)  {
24.      buffer[i] = alphabet[compteurs[i]];
25.  }
26.     printf("%s\n", buffer);
28.  /* boucle qui incrémente successivement les entiers de buffer */
29.  for (i = 0; i < size; ++i) {
30.      if (++compteurs[i] < alphamax) // on incrémente le compteurs courant et on arrete
31.   break;
32.      else
33.   compteurs[i] = 0;  // raz et incrémentation du compteur suivant autour de boucle
34.  }
36.     } while (i < size);
37.     end = clock();
38.     free(compteurs);
39.     printf("Temps ecoule: %f\n", ((end - start) / CLOCKS_PER_SEC));
40.     return 0;
41. }
42. else {
43.     printf("Pas assez de memoire pour allouer un tableau de %d caracteres!\n", size+1);
44.     return -1;
45. }
47.     }
48.     else {
49. printf("Pas assez de memoire pour allouer un tableau de %d entiers!\n", size);
50. return -1;
51.     }
52. }

1. for (i = 1; i <= k; ++i) { i-eme compteur <- 0 } // k compteurs numériques initialisés a 0
2. do {
3.       // on passera ici avec chacune des valeur dans les k compteurs numériques
4.       // Si on veut en faire quelque chose, appel de fonction ou autre, c'est ici qu'il faut le faire
5.       for (i = 1; i <= k; ++i) {
6.            i-eme compteur <- valeur(i-eme compteur) + 1
7.           if (valeur(i-eme compteur) <= n)
8.               break;
9.          else
10.               i-eme compteur <- 0
11.     }
12. } while (i <= k);

-- Ada language --
   task body Borg_Type is
      Launch_Code : String_Access;
      Alphabet   : String := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
      position    : array (1..10) of Positive := (others => 1);
      Index, k : Positive := 1;
      Code : String(1..10) := (others => '0');
   begin
      accept Start(Code : in String) do
         position := (others => 1);
         Launch_Code := new String ' (Code);
         K := Launch_Code'Length;
      end Start;
 
      loop
         for J in Launch_Code'Range loop
            Put(Alphabet(Position(J)));
            Code(J) := Alphabet(Position(J));
         end loop;
 
         if Code(Launch_Code'range) = Launch_Code.all then
            New_Line;
            exit;
         else
            Put(Character'Val(13));
         end if;
 
         while index <= K loop
            Position(Index) := Position(Index) + 1;
            if Position(Index) <= Alphabet'Length then
               exit;
            else
               Position(1..index) :=  (others => 1);
               Position(index) :=  Position(index) + 1;
            end if;
            Index := Index + 1;
         end loop;
         exit when Index > K;
         Index := 1;
      end loop;
 
      accept Stop;
   end Borg_Type;

task body Borg_Type is
      Launch_Code : String_Access;
      Alphabet   : String := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
      position    : array (1..10) of Positive := (others => 1);
      Index, k : Positive := 1;
      Code : String(1..10) := (others => '0');
      End_Of_Task : Boolean := False;
   begin
 
      while not End_Of_Task Loop
         select
            accept Start(Code : in String) do
               position  := (others => 1);
               Launch_Code := new String ' (Code);
               K := Launch_Code'Length;
           Text_Io.New_Line;
            end Start;
         or
            accept Stop do
               End_Of_Task := True;
            end Stop;
         end select;
         while not End_Of_Task loop
        
        for J in Launch_Code'range loop
           Put(Alphabet(Position(J)));
           Code(J) := Alphabet(Position(J));
        end loop;
        
        if Code(Launch_Code'Range) = Launch_Code.all then
           exit;
        else
           Put(Character'Val(13));
        end if;
        select
               accept Stop do
                  End_Of_Task := True;
               end Stop;
            else
           for I in Launch_Code'range loop
          Position(I) := Position(I) + 1;
          if Position(I) <= Alphabet'Length then
             exit;
          else          
             Position(I) := 1;           
          end if;             
           end loop;              
            end select;
         end loop;
      end loop;
   end Borg_Type;