/*
 ************************************************************
 *
 * Programme : melangeur.cpp
 *
 * Ecrit par : Natim
 *
 * Resume :    Ce programme lit une chaine de caractère et
 *             mélange les mots quelle contient en laissant
 *             la ponctuation en place.
 *
 * Date :      14/11/2005
 *
 *************************************************************
 */

#include <iostream>                  // Pour la gestion de l'entré/sortie via cin
                                     // et cout
#include <cstring>                   // Fonction qui permet la gestion des string
#include <ctime>                     // Pour les besoins de time et
                                     // l'initialisation de rand
#include <cstdlib>                   // Pour les besoins de srand et rand


using namespace std;                 // Espace de nommage standard


//--------------------------//
// Prototypes des fonctions //
//--------------------------//

string separeMots(string chaineLue);
/* Cette fonction sépare la chaineLue en mots et
les mélangent s'il y a lieu. Elle retourne une
chaine avec les lettres des mots mélangés */

string melangeMots(string motLue);
/* Cette fonction prend en paramètre un mot
et le mélange */

void alea(int min, int max, int tableau[]);
/* Renvoie un tableau dans lequels les nombres
entre min et max sont classés aléatoirement */

int main(){
  srand(time(NULL));                 // Initialisation de RAND_MAX pour la
                                     // fonction rand()

  char   caract;                     // Caractère lu
  string chaineLue = "";             // Chaine de caractère qui se remplit du
                                     // Caractère lu

  cout << "Entrez le texte à mélanger :" << endl ;
  cout << "-------------------------------" << endl;
  cout << "Pour terminer la saisie, appuyez sur entrée puis faites CTRL+D" << endl;
  cout << "-------------------------------" << endl;

  /*-----------------------------------------------//
  //  Lecture de la chaine de caractère à mélanger //
  //-----------------------------------------------//
  // On selectionne les caractères tapés 1 par 1   //
  // Tant que la personne ne termine pas la saisie //
  // avec CTRL+D, on continue de lire la chaine    //
  // de caractère et on rajoute le caractère lue   //
  // à la fin de la chaine du type string          //
  //-----------------------------------------------*/

  cin.get(caract);
  while(cin.good()){
    chaineLue.push_back(caract);
    cin.get(caract);
  }
  //-----------------------------------------------// 
  //        Affichage de la chaine mélangée        //
  //-----------------------------------------------// 
  cout << endl << "__________________________________" << endl;
  cout << endl;
  cout << "Le texte mélangé est :" << endl;
  cout << "-------------------------------" << endl;
  cout << separeMots(chaineLue) << endl;
}



/************************************************************
 *
 * Fonction    : separeMots
 *
 * Parametres  : string chaineLue    (Chaine à mélanger)
 *
 * Retour      : string chaineEcrite (Chaine mélangée)
 *
 * Description : Cette fonction parse, la chaineLue et
 *               elle sépare les mots. Elle retourne
 *               chaineEcrite qui contient les mots
 *               mélangé et la ponctuation
 *
 ************************************************************
 */

string separeMots(string chaineLue){
  string chaineEcrite = "";          // Définition de la chaine retournée
  string mot          = "";          // Définition du mot courant
  int    i;                          // Définition du compteur de boucle for()

  /*------------------------------------------------//
  //               Separation des mots              //
  //------------------------------------------------//
  // Pour tous les caractères de la chaine, on      //
  // teste si le caractère est une lettre           //
  // majuscule, minuscule ou spéciale (accent,      //
  // cédille). Dans ce cas, on ajoute la lettre     //
  // Dans la chaine mot qui contient le mot courant //
  // Sinon, ce caractère fait partie de la          //
  // ponctuation. On ajoute donc le mot courant à   //
  // à la fin de la chaine en le mélangeant         //
  // et on rajoute ensuite le caractère courant.    //
  //------------------------------------------------*/

  for (i = 0; i < chaineLue.length(); i++){
    if(((chaineLue[i] >= 65 && chaineLue[i] <= 90)   ||
        (chaineLue[i] >= 97 && chaineLue[i] <= 122)) ||
         chaineLue[i] < 0){
      mot.push_back(chaineLue[i]);
    }else{
      if(mot.length() >= 1){
        chaineEcrite += melangeMots(mot);
        mot = "";
      }
      chaineEcrite.push_back(chaineLue[i]);
    }
  }
  /*------------------------------------------------//
  // A la fin de la chaineLue, s'il y a un mot de   //
  // défini, on le rajoute à la fin de la           //
  // chaineEcrite                                   //
  //------------------------------------------------*/
  if(mot.length() >= 1){
    chaineEcrite += melangeMots(mot);
  }
  return chaineEcrite;
}



/************************************************************
 *
 * Fonction    : melangeMots
 *
 * Parametres  : string motLu    (mot à mélanger)
 *
 * Retour      : string retour   (mot mélangé)
 *
 * Description : Cette fonction mélange le mot passé
 *               en paramètre et le retourne mélangé
 *
 ************************************************************
 */

string melangeMots(string motLu){
  int    debut, fin;                 // Borne de mélange selon si le mot à + de 3
                                     // lettres ou non
  int    i;                          // Compteur de lettre
  string retour="";                  // Chaine retournée
  int    tbl[22];                    // Tableau des indices classés aléatoirement.
                                     // En français, les mots font tous moins de
                                     //24 lettres.
  /*------------------------------------------------//
  //               Melange des mots                 //
  //------------------------------------------------//
  // On commence par tester si le mot est plus      //
  // ou moins grand que 3 caractères.               //
  // En fonction, on déclare que les lettres à      //
  // melanger se situe entre debut et fin           //
  //------------------------------------------------*/
  if(motLu.length() > 3){
    debut = 1;
    fin   = motLu.length() - 2;
    retour.push_back(motLu[0]);      // Le premier caractère reste fixe
  }else{
    debut = 0;
    fin   = motLu.length() - 1;
  }

  /*------------------------------------------------//
  //        Classement aléatoire des lettres        //
  //------------------------------------------------//
  // On remplit un tableau dans lequel les indices  //
  // des lettres sont rangés aléatoirement          //
  // Ces indices iront entre debut et fin           //
  //------------------------------------------------*/
  alea(debut, fin, tbl);

  /*------------------------------------------------//
  //    On ajoute les lettres en fin de chaine      //
  //------------------------------------------------//
  // Avec le tableau d'indice ainsi généré, on      //
  // ajoute les lettres à la fin de la chaine       //
  //------------------------------------------------*/
  for(i = 0; i <= (fin - debut); i++){
    retour.push_back(motLu[tbl[i]]);
  }
  if(motLu.length() > 3)
    retour.push_back(motLu[fin + 1]);// On n'oublie pas de rajouter la derniere
                                     // lettre des mots de plus de 3 lettres
  return retour;
}



/*****************************************************************
 *
 * Fonction    : alea
 *
 * Parametres  : int min      ( Borne inférieure de l'intervale )
 *               int max      ( Borne supérieure de l'intervale )
 *               int *tableau ( Tableau vide qui contiendra les )
 *                            ( indices classés                &nbsp;)
 *
 * Retour      : rien
 *
 * Description : Cette fonction remplit le tableau en y mettant
 *               tous les entiers compris entre min et max dans
 *               un ordre aléatoire
 *
 ******************************************************************
 */

void alea(int min, int max, int *tableau)
{
  bool ok;                          // Drapeau qui définit si le nombre n'est
                                    // pas déjà dans le tableau
  int  i, j;                        // Compteurs de boucle for()

  /*------------------------------------------------//
  //  Génération du tableau d'indice aléatoirement  //
  //------------------------------------------------//
  // On verifie que la borne supérieure (max) et    //
  // bien supérieure à la borne inférieure. Dans le //
  // cas inverse, on inverse max et min. On choisit //
  // ensuite un nombre aléatoirement entre min et   //
  // max. Et on le mets dans le tableau.            //
  // Si ce nombre n'est pas déjà dans le tableau,   //
  // on continu jusqu'à ce que tous les indices     //
  // soit entrés dans le tableau                    //
  //------------------------------------------------*/

  if (max >= min){
    i = 0;
    while(i <= (max - min)){
      tableau[i] = (int) (min + ((float) rand() / RAND_MAX * (max - min + 1)));
      ok = true;
      if (i > 0){
        for (j = 0; j < i; j++){
          if (tableau[i] == tableau[j]){
            ok = false;
            break;
          }
        }
      }
      if(ok){
        i++;
      }
    }
  }else{
    alea(max, min, tableau);
  }
}

<?php
        $texte = POST['texte'];
        $mots = shuffle(preg_split("`[\.;,:]*\s+[\.;,:]*`",$texte));
        echo "texte entré : <pre>$texte</pre><br/>\n";
        echo "texte sortant : <pre>"
        foreach($mot in $mots)
                echo "$mot ";
        echo "</pre>\n";
?>