Discussion :

[theserialkiller10]

Bonjour,

Je m'appelle Arnaud je suis actuellement en premmière années de bts iris (Informatique et Réseau pour l'Industrie et les Services technique)

Nous avons des cours de langages en C++ pour le moment et je voudrais avoir quelques renseignement ?

J'utilise le logiciel C++ Builder 6

Allors je voudrais savoir quand on a un nombre "123" je voudrais metre les centaines dans un static text, idem pour les dizaines et les unités donc cela me fait trois zone de texte mais je ne c pas quel prototype utilisé...

Merci d'avance pour votre aide

Cordialement Arnaud.

[bogoss91]

Tu n'est pas obligé de récupérer ça dans un format texte :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int nombre = 123;
int unite = nombre % 10;
int dizaine = nombre / 10 % 10;
int centaine = nombre / 100 % 10;
 
std::cout << centaine << dizaine << unite << std::endl; // affichera "123"

J'espère que ça t'as aidé

[theserialkiller10]

Merci pour ton aide

J'avaid déja vu le principe avec la parite mais je ne penser pas qu'il fallais faire comme sa,

Cordialement Arnaud

[bogoss91]

Ben il n'y a pas vraiment LA technique divine. Tant que ça marche et que ça bouffe pas trop de ressources ni de temps, c'est bon.

[koala01]

Salut, et bienvenue sur le forum

Tu peux aussi envisager de travailler de manière un peu plus "générique":

En effet, si, pour l'instant, tu peux te contenter d'une séparation des centaines/dizaines/unités, tu risque d'avoir besoin, par la suite, d'avoir aussi les (dizaines de/centaines de) milliers, les millions, les milliards...

Le code reste facile à écrire sous la forme d'une simple boucle:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
/* soit nombre = ne nombre à séparer */
std::vector<int> separated;
do
{
   separated.push_back(nombre%10);
   nombre/=10;
}while(nombre>0);

Comme on peut estimer comme probable que cette séparation ait, pour but finale, d'obtenir une représentation en toute lettres, il faut reprendre les règles d'orthographe, ainsi qu'à certaines particularités

1. On utilise des traits d'union pour écrire les nombres composés plus petits que cent sauf autour du mot et
2. Le mot cent est invariable sauf
   
   1. quand il est précédé d'un nombre qui le multiplie et
   2. n'est pas suivi par un autre nombre cardinal.
3. Le mot vingt dans quatre-vingts (80) suit exactement la même règle que le mot cent
4. mille est invariable
5. million, milliard et les autres sont des noms communs, et suivent donc les règles orthographiques classiques (s s'il y en a plus d'un)
6. il existe des terme particuliers pour les valeurs comprises entre 11 et 16
7. On multiplie jusqu'à 999 fois maximum, au delà, on passe à un terme supérieur (il n'y a que le capitaine hadock qui dise "mille millions de..." ((®)Hergé))
8. le zéro ne se prononce que s'il est seul

On pourrait donc partir sur un code "générique" utilisant notre tableau prenant la forme de
(désolé, je suis belge, et par conséquent j'utilise septante pour 70 et nonante pour 90... en enviant les suisse qui utilise octante pour 80)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
static std::string unite[10]={"","un","deux","trois","quatre","cinq","six",
         "sept","huit","neuf"};
static std::string dixplus[7]={"dix","onze","douze","treize","quatorze","quinze","seize"};
static std::string dizaine[10]={"dix","vingt","trente","quarante","cinquante",
         "soixante","quatre-vingt","nonante"};
/* je m'arrete à 10 exposant 15... c'est déjà pas si mal :D (cf [7])*/
static std::string exposants[6]={"","mille","million","milliard","trilliard","quadrilliard"};
/* pourrait prendre les termes de "billion","trillion","quadrillion"..." */
/* il faut prendre le zero en compte cf([8])*/
if(separated.size()==1 && separated[0]==0)
{
    std::cout<<"zero ";
}
else
{
    /* on parcoure le tableau à reculons, en utilisant la place d'origine
     * de la valeur testée 
     */
    /* pour faciliter la suite */
    bool multiplied=false;
    for(size_t i=separated.size()-1;i>=0;i--)
    {
         /* on récupère la valeur, et on commence par gérer unités, dizaines
          * et centaines
          */
        int valeur=separated[i];
        multiplied= multiplied||valeur>0;
        switch (i%3)
        {
            case 0: /* c'est une unité */
                std::cout<< unites[valeur]<<" ";
                break;
            case 1: /* c'est une dizaine */
                /* dans bien des cas, l'unite devient importante */
                int temp=separated[i-1];
                if(valeur==1)/* cfr[6] */
                {
                    if(temp<7)
                    { 
                        std::cout<<dixplus[10+temp]<<" ";
                        i--;
                    }
                    else
                    {
                        std::cout<<dizaine[valeur]<<"-";
                    }
                }
                else if(valeur==8) /* cfr[3] */
                {
                      std::cout<<dizaine[valeur]
                          <<(temp==0 ? "s ":"-");
                }
                else /* règle générale */
                {
                    std::cout<<dizaine[valeur];
                    if(temp==0)
                        std::cout<<" ";
                    else if(temp==1)
                        std:: cout<<" et ";
                    else
                        cout<<"-";
                }
                break;
            case 2: /* gérer les centaines */
               int t1=separated[i-2]; /* unite */
               int t2=separated[i-1]; /* dizaine */
               if(valeur>1 && t1==0 && t2==0)/* (cf [2]) */
                   std::cout<<"cents ";
               else
                   std::cout<<"cent ";
                break;
            default: /* juste pour éviter l'avertissement du compilateur */
        }
        /* reste à gérer les exposants */
        if(i>3 && i%3==0) /* cf [4],[5] et [7] */
        {
             std::cout<<exposant[i/3]
                      <<( (i/3>1 && multiplied) ? "s ":" ";
             multiplied=false;
        }
    }
}

[theserialkiller10]

Merci de vos conseil

Le premier conseil me convient pour se que je dois faire,

la 2eme est intéressante certe plus complexe mais peu être utilisable par la suite je vous en remercie

Cordialement

Arnaud