(2*3)*(10+1)*10

2 * 3 = 6
10 + 1 = 11
6 * 11 = 66
66 * 10 = 660

Citation : Nanoc

Niveau 2

Quand on propose un tirage, on est pas assuré qu'on puisse bien atteindre le résultat souhaité, ce qui n'est pas pratique pour les gens qui jouent.
Le but est ici d'écrire un programme qui donne un tirage (résultat + les 6 nombres) qui assure qu'on puisse atteindre le résultat.

Citation : Nanoc

Mais j'avoue que je n'ai pas pensé à faire ça, ce qui complique pas mal l'exerice d'où le niveau 2.

Citation : Nanoc

Le but n'est pas ici de reproduire le jeu mais plutôt de reproduire le programme informatique qui aide le présentateur à vérifier que la solution est correcte.

Citation : Nanoc

Le but est de réaliser un programme qui cherche la solution du problème. Qui joue à la place de l'humain au jeu.

Citation : Nanoc

Le mot le plus long viendra

Citation : gymnopaul

Pourquoi pas recopier le dictionnaire ?

Citation : Hiura

Pourquoi pas prendre la liste des mot de OpenOffice ou autre?

Je parlais au second degré ...

Citation : Nanoc

Evidemment que ca dépend du dictionnaire. Mais pour un dictionnaire donné, on peut toujours comparer les programmes à la vitesse de recherche.
Parce que chercher une séquence aléatoire dans un fichier de 100'000 entrées c'est pas forcément évident à faire de manière efficace.

Citation : gymnopaul

Je parlais au second degré ...

T'inquiète, j'avais compris.

Citation : Lecureuil

Ou un interpréteur Malbolge ?

#include <iostream>
#include "chiffre.h"

using namespace std;

int main()
{
    Chiffre chiffre;

    chiffre.randomNbToDo();
    chiffre.randomNbCh();
    getchar();
    return 0;
}

#ifndef DEF_CHIFFRE
#define DEF_CHIFFRE

class Chiffre
{
    public:
        Chiffre();
        void randomNbToDo();
        void randomNbCh();

    private:
        int nbToDo;
        int nbChoose[5];
};

#endif

#include <iostream>
#include <time.h>

#include "chiffre.h"

using namespace std;

Chiffre::Chiffre()
{
}

void Chiffre::randomNbToDo()
{
    srand(time(NULL));

    int nbMax = 1000;
    nbToDo = (rand() % (nbMax)) + 1;
    cout << "Nombre a atteindre : " << nbToDo << endl;
}

void Chiffre::randomNbCh()
{
    int listePossible[] = {1,2,3,4,5,6,7,8,9,10,25,50,75,100};
    srand(time(NULL));

    for(int i = 0; i < 5; i++)
    {
        nbChoose[i] = (rand() % (listePossible)) + 1;
        cout << "Nombre choisi : " << nbChoose[i] << endl;
    }
}

-------------- Build: Release in Chiffres ---------------

Compiling: chiffre.cpp
C:\Users\Vincent\Desktop\Programmation\Exercices CMD\Chiffre et lettres\Chiffres\chiffre.cpp: In member function `void Chiffre::randomNbCh()':
C:\Users\Vincent\Desktop\Programmation\Exercices CMD\Chiffre et lettres\Chiffres\chiffre.cpp:28: error: invalid operands of types `int' and `int[14]' to binary `operator%'
Process terminated with status 1 (0 minutes, 0 seconds)
1 errors, 0 warnings

Nombre a atteindre : 79
Nombre choisi : 10
Nombre choisi : 8
Nombre choisi : 2293484  // ??
Nombre choisi : 8
Nombre choisi : 100

Solution du mois de juillet 2008

Solution complète

J'espère ne pas trop t'avoir dégouté avec mes explications mais je tenai à t'en faire part dans le cas ou te ne comprendrai pas mon algo voila Bonne lecture

//fichier main.cpp

#include <iostream>
#include <fstream>
#include <iomanip>
//#include <cctype>   // isspace()

using namespace std;

int  GereArguments(char argc ,char *argv[])           ;
bool IsSpace      (char C )                           ;
void Calcul       (const string & , ostream & = cout );
void AfficherAide (void);


int main(char argc,char*argv[])
{
    bool retour;
    try
    {
        retour = GereArguments(argc,argv);
    }
    catch(const string & e)
    {
        cerr << e;
        retour = EXIT_FAILURE;
    }
    return retour;
}

int  GereArguments(char argc ,char *argv[])
{
    if (argc > 4 || argc < 2)
    {
        AfficherAide();
        return EXIT_FAILURE;
    }
    string NomFichier = argv[1];

    if (argc > 2 )
    {
        string Argument2  = argv[2];
        if (Argument2 != "-d")
        {
            AfficherAide();
            return EXIT_FAILURE;
        }
        if (argc == 3) throw string("Veuillez preciser le nom du fichier de sortie\n");

        string FichierDeSortie = argv[3];

        ofstream FluxDeSortie(FichierDeSortie.c_str(),ios::out | ios::trunc);
        if (FluxDeSortie)
        {
            Calcul(NomFichier, FluxDeSortie);            
        }
        else
            throw string("Erreur dans l'ouverture du fichier destination : " + FichierDeSortie );
    }
    else
    {
        Calcul(NomFichier);
    }
    return EXIT_SUCCESS;
}

void Calcul (const string & FichierAnalyse, ostream & FluxDeSortie )
{
    ifstream FluxAnalyse (FichierAnalyse.c_str(), ios::in);

    if(FluxAnalyse)
    {
        cout << "Calcul en cour..." << endl   ;
        string Buffer                         ;

        unsigned int NbCaracEnTout     = 0    ;
        unsigned int NbCaracSansEspace = 0    ;
        unsigned int NbMots            = 0    ;
        unsigned int NbParagraphe      = 0    ;
        bool         PrecIsSpace       = true ;
        bool         PrecIsCR          = true ;
        bool         BufferEstVide            ;

        while ( getline(FluxAnalyse,Buffer) )
        {
            BufferEstVide = (Buffer == "");


            if ( BufferEstVide && !PrecIsCR )++NbParagraphe;

            PrecIsCR =  BufferEstVide;

            PrecIsSpace = true ;
            for (unsigned i = 0 ; i < Buffer.size() ; i++)
            {
                ++NbCaracEnTout;

                if ( IsSpace(Buffer[i]) )
                {

                    if ( 0 == i || i == Buffer.size()-1 || IsSpace( Buffer[i+1] ) )continue;
                    if (!PrecIsSpace) ++NbMots;

                }
                else
                {
                    ++NbCaracSansEspace;
                    PrecIsSpace = false ;
                }
             }
             if ( !BufferEstVide )++NbMots;

        }
        if (!PrecIsCR) ++NbParagraphe;


        FluxDeSortie << "+"          << setfill('-') << setw(40) << "+"
                     << setfill('-') << setw(8)      << "+"      << endl

                     << setfill(' ') << "| "    << left  << setw(37) << "Nombre de caracteres :"
                     << setfill(' ') << " | "   << right << setw(5) << NbCaracEnTout << " |"   << endl

                     << "| "    << left  << "Nombre de caracteres (hors espace) : "
                     << " | "   << right << setw(5 ) << NbCaracSansEspace << " |"   << endl

                     << "| "    << left  << setw(37) << "Nombre de mots :  "
                     << " | "   << right << setw(5 ) << NbMots << " |"   << endl

                     << "| "    << left  << setw(37) << "Nombre de paragraphes : "
                     << " | "   << right << setw(5 ) << NbParagraphe  << " |"   << endl

                     << "+" << setfill('-') << setw(40) << "+"
                     << setfill('-') << setw(8) << "+" << endl ;
    }
    else
               throw string("Erreur pour l'ouverture du fichier : "+ FichierAnalyse);

    if (FluxDeSortie != cout) cout  << "Calcul termine avec succes \n";
}



bool IsSpace (char C)
{
    return ( C == ' '  ||
             C == '\t' ||
             C == '\n' );
}

void AfficherAide (void)
{
    cout <<"Aide: \nCeci est un programme permettant de calculer differente statistiques a partir d'un "
           "fichier texte situe dans le repertoire courant de l'executable\n\n"
           "Commande : Statisqtique Nom_du_Fichier_A_Analyser\n\n"
           "Option   : -d Nom_du_Fichier_Ou_Sauver_Les_Resultats \n\n"
           "Exemple  : - Statistique test.txt --> Permet d'analyser le fichier test.txt\n"
           "           - Statistique test.txt -d temp.txt --> Analyse le fichier test.txt et stoque les resultats dans temp.txt \n";
}

Remarques sur les codes reçus

• C'est bien d'utiliser les manipulateurs de flux, mais c'est encore mieux de les utiliser tout le temps. Par exemple pour faire le cadre avec des "+".
• Lancer des exceptions, c'est très bien. Les rattraper et agir en conséquence (ici: afficher un messafe d'erreur) c'est encore mieux.