Citation : lmghs

Je serais surpris qu'il n'ait pas connaissance de cette suite de bibliothèques qui booste notre productivité.

Citation : lmghs

vy l n har pynffr qr zêzr pbzcyrkvgé qnaf yn ovoyvbguèdhr fgnaqneq

Citation : Chlab_lak

Citation : lmghs

Je serais surpris qu'il n'ait pas connaissance de cette suite de bibliothèques qui booste notre productivité.

C'est bien tourné, tu aurais même pu dire que tu serais rationnellement surpris que Nanoc n'ait pas connaissance de cette suite de bibliothèques qui booste notre productivité .

Citation : Chlab_lak

Citation : lmghs

Je serais surpris qu'il n'ait pas connaissance de cette suite de bibliothèques qui booste notre productivité.

C'est bien tourné, tu aurais même pu dire que tu serais rationnellement surpris que Nanoc n'ait pas connaissance de cette suite de bibliothèques qui booste notre productivité .

Citation : lmghs

Mon crypteur est vim qui applique un tr de base. Et puis, quel est le sens de rotationner à 13 les caractères hors de la plage des 26 lettres standards ?

(nous ne sommes pas complètement HS, écrire tr ou rot pourraient être des exos pour ceux qui font du C ^^')

Citation : Nanoc

@Chlab_lak: Le seul défaut de la classe que tu proposes c'est que c'est pas un concept mathématique évident pour tout le monde. Mais il est vrai qu'il y a peu de différences.

Citation : gymnopaul

Citation : Goten

c'est juste du ROT13

Google ?

Solution du mois de septembre

Partie "Papier-Crayon"

POUR TOUS LES MOTS DU FICHIER
          SI la taille du mot > 9, on SAUTE au mot suivant

          POUR TOUTES LES LETTRES DU MOT
              SI la lettre n'est pas dans le tirage, on SAUTE au mot suivant
          FIN POUR TOUT

          On sauvegarde le mot
FIN POUR TOUT

Choix des structures de données

typedef std::vector<std::string> Tableau;

Programmation

//Fonction qui renvoit un entier au hasard entre min et max
unsigned int hasard(unsigned int min,unsigned int max)
{
    const double x = static_cast<double>(rand())/RAND_MAX;

    return static_cast<unsigned int>(x * (max-min))+ min;
}

//Fonction qui renvoit un entier au hasard entre min et max
unsigned int hasard(unsigned int min,unsigned int max)
{
    const double x = (double)(rand())/RAND_MAX;

    return (unsigned int)(x * (max-min))+ min;
}

//Les constantes du programme
const string VOYELLES = "aeiouy";
const string CONSONNES = "bcdfghjklmnpqrstvwxz";
const string DICTIONNAIRE = "liste_finale.txt";
const unsigned int NB_VOYELLES = VOYELLES.size();
const unsigned int NB_CONSONNES = CONSONNES.size();

//Les constantes du jeu
const unsigned int TAILLE_TIRAGE = 9;
const unsigned int NB_MINIMAL_VOYELLES = 2;

//Fonction qui renvoit un tirage aleatoire
string creerTirage()
{
    string tirage;
    char choix,tire;
    unsigned int nbVoyelles(0);

    //On cree un tirage de TAILLE_TIRAGE caracteres
    for (unsigned int i(0);i<TAILLE_TIRAGE;++i)
    {
        //Test pour le cas particulier ou il n'y a ps assez de voyelles
        if (i>=TAILLE_TIRAGE - NB_MINIMAL_VOYELLES + nbVoyelles && nbVoyelles<NB_MINIMAL_VOYELLES)
        {
            tire = VOYELLES[hasard(0,NB_VOYELLES)];
            cout << "Le tirage necessite un minimum de 2 voyelles" << endl;
            ++nbVoyelles;
        }
        else    //Cas normal
        {
            //On demande a l'utilisateur son choix
            cout << "Lettre numero " << i+1 << ": Consonne ou Voyelle [c/v] ?: " << flush;

            //On recupere son choix et on purge le flux au cas ou l'utilisateur a entre n'importe quoi
            cin >> choix;
            cin.clear();
            cin.ignore( numeric_limits<streamsize>::max(), '\n' );

            //Selon le choix, on tire la lettre voulue
            if (choix == 'c')
            {
                tire = CONSONNES[hasard(0,NB_CONSONNES)];
            }
            else if (choix == 'v')
            {
                tire = VOYELLES[hasard(0,NB_VOYELLES)];
                ++nbVoyelles;
            }
            else    //On affiche un message d'erreur si il faut
            {
                cout << "ERREUR: Choix interdit. Entrez 'c' ou 'v'" << endl;
                --i;  //On decremente i de sorte a redemander la meme lettre
                continue;
            }
        }

        //On affiche la lettre tiree et on l'ajoute au tirage
        cout << "Lettre tiree: " << tire << endl;
        tirage += tire;
    }
    //On renvoit le tirage
    return tirage;
}

//Fonction qui cherche le meilleur mot dans le dictionnaire et renvoit les solutions dans un tableau
Tableau chercher(const string& tirage)
{
    //On ouvre le fichier-dictionnaire en lecture
    ifstream fichier(DICTIONNAIRE.c_str());

    //On cree un tableau de chaines qui contiendra tous les mots corrects
    Tableau solution;

    //Nombre de lettres du mot le plus long actuellement trouve
    unsigned int motLePlusLong(0);

    //Le mot courant
    string mot;

    //On lit chaque mot du fichier
    while (getline(fichier,mot))
    {
        //On calcule nombre de lettres
        unsigned int nbLettres= mot.size();

        //On compte les tirets dans le mot
        unsigned int nbTirets(0);
        unsigned int posTiret(0);

        while(mot.find('-',posTiret) != string::npos)  //Tant qu'il y a un tiret dans le mot a partir de la position courante
        {
            posTiret = mot.find('-',posTiret)+1; //On recupere la position pour la prochaine recherche
            ++nbTirets;                          //Et on incremente le compteur
        }

        //On soustrait au nombre de lettres le nombre de tirets puisque le tirage n'a pas de tirets
        nbLettres-=nbTirets;

        //Si le mot a trop de lettres, on passe au suivant puisque il ne peut pas etre solution
        if (nbLettres > TAILLE_TIRAGE )
            continue;

        //On cree un tableau qui permet d'indiquer si chacune des lettres du tirage est utilisee
        bool utilisee[TAILLE_TIRAGE]={false};

        //On commence par supposer que l'on peut ecrire le mot a partir du tirage
        bool motvalide=true;

        //On parcourt les lettres du mot
        for ( unsigned int i=0; i<mot.size(); i++ )
        {
            //Si c'est un tiret on saute a la lettre suivante puisqu'on a pas de tiret dans le tirage
            if(mot[i] == '-')
                continue;

            //On commence par supposer que la lettre du mot n'est PAS dans le tirage
            bool lettrevalide=false;

            //On parcourt les lettres du tirage
            for (unsigned int j=0; j<tirage.size(); ++j )
            {
                //Si la lettre du tirage correspond a la lettre du mot ET qu'on a pas encore utilise cette lettre du tirage
                if ( mot[i]==tirage[j] && utilisee[j]==false )
                {
                    //On montre que la lettre a ete utilisee
                    utilisee[j]=true;
                    //Et on valide la lettre
                    lettrevalide=true;
                    //On sort de la boucle pour passer a la lettre suivante du mot
                    break;
                }
            }

            //Si une lettre est non-valide le mot est non valide donc on passe au mot suivant
            if ( !lettrevalide )
            {
                motvalide=false;
                break;
            }
        }

        //Si le mot est valide
        if (motvalide)
        {
            //Si on a un mot avec le meme nombre de lettres
            if (nbLettres == motLePlusLong)
            {
                solution.push_back(mot);  //On le stocke
            }
            else if (nbLettres > motLePlusLong) //Si le mot a plus de lettres
            {
                solution.clear(); //On vide le tableau
                solution.push_back(mot); //Et on met notre nouveau mot
                motLePlusLong = mot.size(); //On prend la taille du mot comme taille de reference
            }
            //Si il a moins de lettres, il nous interesse pas donc on le stocke pas
        }
    }

    //On renvoit le tableau de mots
    return solution;
}

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;

//Les constantes du programme
const string VOYELLES = "aeiouy";
const string CONSONNES = "bcdfghjklmnpqrstvwxz";
const string DICTIONNAIRE = "liste_finale.txt";
const unsigned int NB_VOYELLES = VOYELLES.size();
const unsigned int NB_CONSONNES = CONSONNES.size();

//Les constantes du jeu
const unsigned int TAILLE_TIRAGE = 9;
const unsigned int NB_MINIMAL_VOYELLES = 2;

//Un typedef pour simplifier la notation
typedef vector<string> Tableau;

//Fonction qui renvoit un entier au hasard entre min et max
unsigned int hasard(unsigned int min,unsigned int max)
{
    const double x = static_cast<double>(rand())/RAND_MAX;

    return static_cast<unsigned int>(x * (max-min))+ min;
}

//Fonction qui renvoit un tirage aleatoire
string creerTirage()
{
    string tirage;
    char choix,tire;
    unsigned int nbVoyelles(0);

    //On cree un tirage de TAILLE_TIRAGE caracteres
    for (unsigned int i(0);i<TAILLE_TIRAGE;++i)
    {
        //Test pour le cas particulier ou il n'y a ps assez de voyelles
        if (i>=TAILLE_TIRAGE - NB_MINIMAL_VOYELLES + nbVoyelles && nbVoyelles<NB_MINIMAL_VOYELLES)
        {
            tire = VOYELLES[hasard(0,NB_VOYELLES)];
            cout << "Le tirage necessite un minimum de 2 voyelles" << endl;
            ++nbVoyelles;
        }
        else    //Cas normal
        {
            //On demande a l'utilisateur son choix
            cout << "Lettre numero " << i+1 << ": Consonne ou Voyelle [c/v] ?: " << flush;

            //On recupere son choix et on purge le flux au cas ou l'utilisateur a entre n'importe quoi
            cin >> choix;
            cin.clear();
            cin.ignore( numeric_limits<streamsize>::max(), '\n' );

            //Selon le choix, on tire la lettre voulue
            if (choix == 'c')
            {
                tire = CONSONNES[hasard(0,NB_CONSONNES)];
            }
            else if (choix == 'v')
            {
                tire = VOYELLES[hasard(0,NB_VOYELLES)];
                ++nbVoyelles;
            }
            else    //On affiche un message d'erreur si il faut
            {
                cout << "ERREUR: Choix interdit. Entrez 'c' ou 'v'" << endl;
                --i;  //On decremente i de sorte a redemander la meme lettre
                continue;
            }

        }

        //On affiche la lettre tiree et on l'ajoute au tirage
        cout << "Lettre tiree: " << tire << endl;
        tirage += tire;
    }
    //On renvoit le tirage
    return tirage;
}

//Fonction qui cherche le meilleur mot dans le dictionnaire et renvoit les solutions dans un tableau
Tableau chercher(const string& tirage)
{
    //On ouvre le fichier-dictionnaire en lecture
    ifstream fichier(DICTIONNAIRE.c_str());

    //On cree un tableau de chaines qui contiendra tous les mots corrects
    Tableau solution;

    //Nombre de lettres du mot le plus long actuellement trouve
    unsigned int motLePlusLong(0);

    //Le mot courant
    string mot;

    //On lit chaque mot du fichier
    while (getline(fichier,mot))
    {
        //On calcule nombre de lettres
        unsigned int nbLettres= mot.size();

        //On compte les tirets dans le mot
        unsigned int nbTirets(0);
        unsigned int posTiret(0);

        while(mot.find('-',posTiret) != string::npos)  //Tant qu'il y a un tiret dans le mot a partir de la position courante
        {
            posTiret = mot.find('-',posTiret)+1; //On recupere la position pour la prochaine recherche
            ++nbTirets;                          //Et on incremente le compteur
        }

        //On soustrait au nombre de lettres le nombre de tirets puisque le tirage n'a pas de tirets
        nbLettres-=nbTirets;

        //Si le mot a trop de lettres, on passe au suivant puisque il ne peut pas etre solution
        if (nbLettres > TAILLE_TIRAGE )
            continue;

        //On cree un tableau qui permet d'indiquer si chacune des lettres du tirage est utilisee
        bool utilisee[TAILLE_TIRAGE]={false};

        //On commence par supposer que l'on peut ecrire le mot a partir du tirage
        bool motvalide=true;

        //On parcourt les lettres du mot
        for ( unsigned int i=0; i<mot.size(); i++ )
        {
            //Si c'est un tiret on saute a la lettre suivante puisqu'on a pas de tiret dans le tirage
            if(mot[i] == '-')
                continue;

            //On commence par supposer que la lettre du mot n'est PAS dans le tirage
            bool lettrevalide=false;

            //On parcourt les lettres du tirage
            for (unsigned int j=0; j<tirage.size(); ++j )
            {
                //Si la lettre du tirage correspond a la lettre du mot ET qu'on a pas encore utilise cette lettre du tirage
                if ( mot[i]==tirage[j] && utilisee[j]==false )
                {
                    //On montre que la lettre a ete utilisee
                    utilisee[j]=true;
                    //Et on valide la lettre
                    lettrevalide=true;
                    //On sort de la boucle pour passer a la lettre suivante du mot
                    break;
                }
            }

            //Si une lettre est non-valide le mot est non valide donc on passe au mot suivant
            if ( !lettrevalide )
            {
                motvalide=false;
                break;
            }
        }

        //Si le mot est valide
        if (motvalide)
        {
            //Si on a un mot avec le meme nombre de lettres
            if (nbLettres == motLePlusLong)
            {
                solution.push_back(mot);  //On le stocke
            }
            else if (nbLettres > motLePlusLong) //Si le mot a plus de lettres
            {
                solution.clear(); //On vide le tableau
                solution.push_back(mot); //Et on met notre nouveau mot
                motLePlusLong = mot.size(); //On prend la taille du mot comme taille de reference
            }
            //Si il a moins de lettres, il nous interesse pas donc on le stocke pas
        }
    }

    //On renvoit le tableau de mots
    return solution;
}

int main()
{
    //Initialisation du hasard
    srand(time(0));

    //Creation d'un tirage
    string tirage = creerTirage();
    cout << endl << "Tirage complet: " << tirage << "\n" <<  endl;

    //Recherche de solution a partir du tirage
    Tableau solution(chercher(tirage));

    //Si on a pas trouve de solution
    if (solution.empty())
    {
        cout << "Aucune solution trouvee pour ce tirage" << endl;
    }
    else
    {
        //Affichage du nombre de lettres de la solution
        cout << solution.size() << " solutions possible en " << solution[0].size() << " lettres: " << endl;

        //Affichage des solutions
        for (unsigned int i(0) ; i<solution.size();++i)
        {
            cout << i+1 << ") " << solution[i] << endl;
        }
    }

    return 0;
}