Affichage du poids d'un chiffre

**Mrstark** · 01/04/2014, 12h07

Bonjour , je dois créer un algorithme (en utilisant seulement des variables type numérique) qui permet de saisir un nombre entier naturel et qui affiche le poids d'un chiffre en partant de la droite . par exemple :

Je saisis Exemple :

Si le nombre saisi est :

7377683

L’affichage doit donner :

3 : 0 5

6 : 2

7 : 3 4 6

8 : 1

7377683

Je suis donc parti sur un tableau , modulo et division successive :

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
#include <iostream>
using namespace std;
 
int main() {
    int tableau[9];
	int i;
    int nombre1;
	int nombre2;
	int nombre3;
	unsigned long int nombre;
	cout << "Entrez un nombre";
	cin >> nombre;
 
	nombre1 = nombre % 10;
    tableau[0] = nombre1;
    tableau[1] = 1;
    while (nombre>10){
 
		nombre = nombre / 10;
		nombre2 = nombre % 10;
        cout << nombre2 << "\n" ;
 
		for (i=1; i < 9; i++){
		        tableau[i]= nombre2 ;
		}
 
 
    }
 
    cout <<  tableau[0] << "\n" ;
    cout <<  tableau[1] << "\n" ;
    cout <<  tableau[2] << "\n" ;
    cout <<  tableau[3] << "\n" ;
    cout <<  tableau[4] << "\n" ;
    cout <<  tableau[5] << "\n" ;
    cout <<  tableau[6] << "\n" ;
    cout <<  tableau[7] << "\n" ;
    cout <<  tableau[8] << "\n" ;
    cout <<  tableau[9] << "\n" ;
 
    cout << "Entrez un nombre";
		cin >> nombre;
 
}

Le probleme est que le tableau ne se remplit qu'avec la derniere valeur de nombre2 , je ne comprends pas.

Je suis parti sur ça aussi :

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
#include <iostream>
using namespace std;
 
int main() {
    int nombre3=0;
	int i =0;
    int nombre1;
	int nombre2;
	unsigned long int nombre;
	cout << "Entrez un nombre";
	cin >> nombre;
 
	nombre1 = nombre % 10;
    cout << nombre1 << ":"<< "0" << "\n";
 
    while (nombre>10){
 
		nombre = nombre / 10;
		nombre2 = nombre % 10;
        i++;
		cout << nombre2 <<  ":"  << i <<"\n";
 
 
    }
 
    cout << "Entrez un nombre";
		cin >> nombre;
 
}

l'Algorithme fonctionne mais je ne sais pas comment faire pour effacer les doublons ... Je pourrais passer par des conditions mais pour ça il faudrait que ma variable nombre2 stocke toutes les valeurs prises dans des variables indépendantes. Comment faire ? Merci de votre aide

**Kaamui** · 01/04/2014, 13h18

Bonjour,

C'est exactement ce que tu lui demandes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
while (nombre>10){
 
		nombre = nombre / 10;
		nombre2 = nombre % 10;
        cout << nombre2 << "\n" ;
 
		for (i=1; i < 9; i++){
		        tableau[i]= nombre2 ;
		}
//[...]
}

traduction "tant que nombre > 10, nombre2 devient = à nombre module 10, puis tu me mets ce nombre2 dans toutes les cases de mon tableau allant de 1 à 8."

**k1000** · 01/04/2014, 13h24

Bonjour,

Envoyé par Mrstark

Si le nombre saisi est :

7377683

L’affichage doit donner :

3 : 0 5

6 : 2

7 : 3 4 6

8 : 1

7377683

Je suis donc parti sur un tableau , modulo et division successive :

Essentiellement, vu l'affichage que tu veux à la fin, j'aurais plutôt dit un tableau de listes (tu utilises 2 dimensions pour afficher ta solution).

Le probleme est que le tableau ne se remplit qu'avec la derniere valeur de nombre2 , je ne comprends pas.

C'est pas étonnant, tu remplis ton tableau avec nombre2 à chaque tour de boucle :

Code :

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

1
2
3
4
 
		for (i=1; i < 9; i++){
		        tableau[i]= nombre2 ;
		}

Je suis parti sur ça aussi :

l'Algorithme fonctionne mais je ne sais pas comment faire pour effacer les doublons ... Je pourrais passer par des conditions mais pour ça il faudrait que ma variable nombre2 stocke toutes les valeurs prises dans des variables indépendantes. Comment faire ? Merci de votre aide

Le plus simple serait que tu reprennes la conception de l'algo : supposons que tu prenne le nombre chiffre par chiffre comme tu sembles vouloir le faire, comment en déduirais-tu la réponse ? Comment stockerais-tu les poids de tes chiffres, pour ne l'afficher qu'à la fin ? Pose ta bonne structure de donnée et ta méthode manuelle, et ça ira mieux

Bonne journée

**Mrstark** · 01/04/2014, 13h52

Envoyé par Kaamui

Bonjour,

C'est exactement ce que tu lui demandes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
while (nombre>10){
 
		nombre = nombre / 10;
		nombre2 = nombre % 10;
        cout << nombre2 << "\n" ;
 
		for (i=1; i < 9; i++){
		        tableau[i]= nombre2 ;
		}
//[...]
}

traduction "tant que nombre > 10, nombre2 devient = à nombre module 10, puis tu me mets ce nombre2 dans toutes les cases de mon tableau allant de 1 à 8."

Comment je peux faire pour stocker toute les valeurs prises par nombre2 dans un tableau ? Je vois pas du tout...

**white_tentacle** · 01/04/2014, 14h31

Comme cela t’a été dit, il te faut plutôt un tableau… de tableaux.

En effet, un tableau d’entiers te permet seulement de stocker la dernière position. Pour en stocker plus d’une, il te faut un autre tableau, de taille variable celui-ci. Et ça, en C++, ça s’appelle std::vector.

**Mrstark** · 01/04/2014, 15h20

J'en suis arrivé à faire ceci :

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
//============================================================================
// Name        : poids.cpp
// Author      : 
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
 
#include <iostream>
using namespace std;
 
int main() {
    int tableau[9];
	int i;
    int nombre1;
	int nombre2;
	int nombre3;
	int nombre4;
	int nombre5;
	int nombre6;
	int nombre7;
	int nombre8;
	int nombre9;
	unsigned long int nombrediv17;
	unsigned long int nombrediv16;
	unsigned long int nombrediv15;
	unsigned long int nombrediv14;
	unsigned long int nombrediv13;
	unsigned long int nombrediv12;
	unsigned long int nombrediv11;
	unsigned long int nombrediv10;
	unsigned long int nombre;
	cout << "Entrez un nombre";
	cin >> nombre;
 
	nombre1 = nombre % 10;
    tableau[0] = nombre1;
 
    nombrediv10 = nombre / 10;
	nombre2 = nombrediv10 % 10;
    tableau[1]= nombre2 ;
 
    nombrediv11 = nombrediv10 / 10;
    nombre3 = nombrediv11 % 10;
    tableau[2]= nombre3 ;
 
    nombrediv12 = nombrediv11 / 10;
    nombre4 = nombrediv12 % 10;
    tableau[3]= nombre4 ;
 
    nombrediv13 = nombrediv12 / 10;
    nombre5 = nombrediv13 % 10;
    tableau[4]= nombre5 ;
 
    nombrediv14 = nombrediv13 / 10;
    nombre6 = nombrediv14 % 10;
    tableau[5]= nombre6 ;
 
    nombrediv15 = nombrediv14 / 10;
    nombre7 = nombrediv15 % 10;
    tableau[6]= nombre7 ;
 
    nombrediv16 = nombrediv15 / 10;
    nombre8 = nombrediv16 % 10;
    tableau[7]= nombre8 ;
 
    nombrediv17 = nombrediv16 / 10;
    nombre9 = nombrediv17 % 10;
    tableau[8]= nombre9 ;
 
 
    for (i=0 ; i <9 ; i++){
    	if (tableau[i]>0 ) {cout << tableau[i] <<":"<< i<< "\n";}
 
 
    }
 
    cout << "Entrez un nombre";
		cin >> nombre;
 
}

maintenant il faut que j'arrive a supprimer les doublons , comment faire pour verifier si une valeur existe déjà dans un tableau ?

**white_tentacle** · 01/04/2014, 16h37

Tu pars dans une (très) mauvaise direction. Tu n’as pas besoin d’autant de variables.

En fait, tu as seulement besoin des choses suivantes :
- le « tableau » de résultat final, qui contient, pour chaque chiffre, les différentes positions auxquelles on les a trouvées dans le nombre donné (en réalité, un tableau de tableau)
- le chiffre courant, qui serait par exemple le chiffre le plus à droite
- le nombre courant, c’est à dire le nombre initial auquel on enlève successivement chacun des chiffres courants.

Normalement, tu n’as pas besoin de plus que ça.

Essaie déjà d’écrire l’algorithme en français, avec des mots, en partant de ces données, en réfléchissant bien aux différentes opérations que tu dois effectuer (des choses comme « rajouter un élément dans la liste » sont des opérations tout à fait valable), comment tu isoles chaque chiffre. Une fois que tout ça sera clair, tu pourras coder ton algorithme en C++.

**Mrstark** · 01/04/2014, 16h50

un tableau de tableau c'est un tableau à deux dimensions ?

**foetus** · 01/04/2014, 17h32

Voici l'algo ... en C

Il te reste à:

Faire du C++
Remplacer ma liste chainée par un vector (ou autre collection adéquate)
Remplacer le int* dans ma structure par un vector (ou autre collection adéquate)
Optimiser que ce soit la mémoire (je fais trop d'allocations), que le parcours de ma liste chainée
Trier les index et les nombres
Supprimer les fuites mémoires et autres joyeusetés
Refaire [éventuellement] la saisie et l'indexation du chiffre en entrée

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#include<stdlib.h>
#include<stdio.h>
 
 
// One element of the list
struct elt {
    struct elt* next;
    int* indexes_list;
 
    unsigned char digit;
    int occurrence;
};
 
 
void destroy_list(struct elt** list) {
    if ((*list) != NULL) {
        struct elt* tmp = (*list);
 
        do {
            (*list) = tmp->next;
            free(tmp->indexes_list);
            free(tmp);
            tmp = (*list);
        } while(tmp != NULL);
    }
 
    (*list) = NULL;
}
 
 
void algo(int number, struct elt** list) {
    destroy_list(list);
 
    struct elt* tmp = NULL;
    int* tmp_indexes_list = NULL;
    int nb = number, index = 0;
    unsigned char digit = 0;
 
//  Find the index max
    while(nb >= 10) {
        nb = (nb / 10);
        index++;
    }
 
    index++;
 
//  For each digit in number 
    for(;index > 0; index--) {
        digit = (number % 10);
        number = (number / 10);
 
//      Print the digit found and its index
        printf("Find %d (%d)\n", digit, index);
 
        tmp = (*list);
 
//      Does the digit found is already in the list?
        while((tmp != NULL) && (tmp->digit != digit)) {
            tmp = tmp->next;
        }
 
        if (tmp != NULL) {
//      The digit is in the list: Recopy the list of index [the collection has one more index], add the new index [the current index] and update the occurrence
            tmp_indexes_list = (int*) malloc( sizeof(int) * (tmp->occurrence + 1) );
            tmp_indexes_list[0] = index;
 
            for(nb = 1; nb <= tmp->occurrence; nb++) {
                tmp_indexes_list[nb] = tmp->indexes_list[nb - 1];
            }
 
            tmp->occurrence++;
            free(tmp->indexes_list);
            tmp->indexes_list = tmp_indexes_list;
            tmp_indexes_list = NULL;
        } else {
//      The digit is not in the list: create and init a new element and insert it in the list
            tmp = (struct elt*) malloc( sizeof(struct elt) );
            tmp->digit = digit;
            tmp->occurrence = 1;
            tmp->indexes_list = (int*) malloc( sizeof(int) );
            tmp->indexes_list[0] = index;
            tmp->next = (*list);
            (*list) = tmp;
        }
    }
}
 
 
int main() {
    int number = 7377683;
 
    struct elt* list = NULL;
 
//  Init the list
    algo(number, &list);
 
    struct elt* tmp = list;
    int nb = 0;
 
//  Clear the print
    printf("\n");
 
//  Print the list
    while(tmp != NULL) {
        printf("Digit: %d, occurence: %d\n%d", tmp->digit, tmp->occurrence, tmp->indexes_list[0]);
 
        for(nb = 1; nb < tmp->occurrence; nb++) {
            printf(" - %d", tmp->indexes_list[nb]);
        }
 
        printf("\n");
        tmp = tmp->next;
    }
 
//  Destroy the list
    destroy_list(&list);
 
    return 0;
}

Édit: J'ai mis le tri des index et la destruction de ma liste chaînée

Édit 2: Des commentaires

Édit 3: Mise à jour du découpage du nombre

**Mrstark** · 01/04/2014, 18h09

Merci mais ton algo me complique la vie plus qu'autre chose lol je préfère avoir une piste sur quoi faire en c++ . Bon je n'y arrive pas , je vais rendre l'algorithme avec les doublons , je vais devenir fou sinon . Merci à tous pour votre aide.

**Iradrille** · 01/04/2014, 19h06

Envoyé par Mrstark

en utilisant seulement des variables type numérique

Hello,

Il y à deux façons de faire, soit avec un tableau de std::list, soit avec un tableau de int (ou plutôt unsigned int) et quelques opération bit à bit -> un int peut être vu comme un tableau de booléen. Il est possible de ne pas avoir de tableau, au prix d'une dizaine de lignes.

Faut voir à quelle point la contrainte "seulement des variables type numérique" doit être respectée.

Les deux solutions utilisent le même principe et tiennent en moins de 30 lignes, ou ~40 sans tableau : découper le nombre (division / modulo) et ajouter la position de chaque chiffre à une liste (push_back ou opération bit à bit : "or" pour ajouter, "and" pour lire).

As-tu le droit d'utiliser des tableaux ? std::list ?

Attention aussi à tes tableaux

Code :

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

1
2
3
int tableau[9];
// ...
cout <<  tableau[9] << "\n" ;

Tu accèdes ici au 10eme élément du tableau, qui n’existe pas !

**foetus** · 01/04/2014, 22h23

C++ truc de fainéant; il te trie ta collection [il faut dire que ce sont des int]

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#include <iostream>
#include <list>
#include <map>
 
 
class Elt {
public:
 
    Elt() {
        indexes_list = NULL;
    }
 
 
    Elt(int first_index) {
        indexes_list = new std::list<int>(1, first_index);
    }
 
 
    ~Elt() {
        if (indexes_list != NULL) {
            delete indexes_list;
            indexes_list = NULL;
        }
    }
 
 
public:
 
    void add_index(int index) {
//      Useless Test: the default constructor is never called
//      if (indexes_list != NULL) {
            indexes_list->push_front(index);
//      } else {
//          indexes_list = new std::list<int>(1, index);
//      }
 
    }
 
 
    void print() {
        if ((indexes_list == NULL) || (indexes_list->empty())) return;
 
        std::list<int>::iterator it = indexes_list->begin();
        std::cout << "occurence: " << indexes_list->size() << std::endl << (*it);
        it++;
 
        for (;it != indexes_list->end(); ++it) {
            std::cout << " - " << (*it);
        }
 
        std::cout << std::endl;
    }
 
 
private:
 
    std::list<int>* indexes_list;
};
 
 
 
// Type List
// Maybe create a class List
typedef std::map<unsigned char, Elt*> List;
 
 
 
void list_remove_all(List& list) {
    if (!list.empty()) {
        for(std::map<unsigned char, Elt*>::iterator it = list.begin(); it != list.end(); ++it) {
            delete ((Elt*) it->second);
            list[it->first] = NULL;
        }
 
        list.erase(list.begin(), list.end());
    }
}
 
 
 
void algo(int number, List& list) {
    list_remove_all(list);
 
    Elt* tmp = NULL;
    int nb = number, index = 0;
    unsigned char digit = 0;
 
    while(nb >= 10) {
        nb = (nb / 10);
        index++;
    }
 
    index++;
 
    for(;index > 0; index--) {
        digit =  (number % 10);
        number = (number / 10);
 
        std::cout << "Find " << (int) digit << " (" << index << ")" << std::endl;
 
        tmp = list[digit];
 
        if (tmp != NULL) {
            tmp->add_index(index);
        } else {
            list[digit] = new Elt(index);
        }
    }
}
 
 
 
int main() {
    int number = 7377683;
 
    List list;
 
    algo(number, list);
 
    std::cout << std::endl;
 
    for(std::map<unsigned char, Elt*>::iterator it = list.begin(); it != list.end(); ++it) {
        std::cout << "Digit: " << (int) it->first << ", ";
        ((Elt*) it->second)->print();
    }
 
    list_remove_all(list);
}

Édit: Mise à jour du découpage du nombre et remplissage de la classe Elt [qui est inutile, quoique on ne sait jamais

]

**Mrstark** · 01/04/2014, 22h51

Même comme ça je comprends pas tout lol il y a beaucoup de truc en trop comme l'occurence et le find . je peux pas rendre un truc que j'ai pas compris moi même , je viens de commencer . En plus ton algo affiche le "poids" des chiffre en partant de la gauche et en commençant par 1 alors que ça devrait être de la droite et commencer par 0

**foetus** · 01/04/2014, 23h04

Envoyé par Mrstark

Même comme ça je comprends pas tout lol il y a beaucoup de truc en trop comme l'occurence et le find . je peux pas rendre un truc que j'ai pas compris moi même , je viens de commencer . En plus ton algo affiche le "poids" des chiffre en partant de la gauche et en commençant par 1 alors que ça devrait être de la droite et commencer par 0

Si j'ai fait le code en C++ c'est parce que tu ne comprends le C

Comment veux-tu coder en C++ si tu ne comprends pas un algo en C "niveau 0"

Pour le poids, truc très difficile

: 4 lignes à commenter et un -- à changer

PS: avec les std::map il y a une petite facilité - subtilité

**Iradrille** · 02/04/2014, 00h33

@foetus: ta classe Elt est inutile, et tu as une utilisation assez dangereuse de map : une map qui contient des ressources allouées sur le tas et qui gère leur durée de vie (une map de pointeurs donc), c'est un cas typique d'utilisation de pointeurs intelligents (unique_ptr).
Mais dans ton cas, aucune raison d'avoir des pointeurs.

Concernant l'algo, pas besoin non plus de map, les seuls éléments utiles de la STL sont : cin, cout et éventuellement des list (ou vector).
Un simple tableau de list/vector suffit.

**foetus** · 02/04/2014, 01h52

Envoyé par Iradrille

@foetus: ta classe Elt est inutile, et tu as une utilisation assez dangereuse de map : une map qui contient des ressources allouées sur le tas et qui gère leur durée de vie (une map de pointeurs donc), c'est un cas typique d'utilisation de pointeurs intelligents (unique_ptr).
Mais dans ton cas, aucune raison d'avoir des pointeurs.

Concernant l'algo, pas besoin non plus de map, les seuls éléments utiles de la STL sont : cin, cout et éventuellement des list (ou vector).
Un simple tableau de list/vector suffit.

Effectivement tu as raison

La classe Elt est inutile. J'étais parti du C et lorsqu'on retire le nombre d’occurrence et le chiffre, il ne reste que la liste.
Pour la peine, j'ai changé l'encapsulation de la liste (en privé) et rajouter un constructeur et une méthode

En utilisant "std::map<int, std::list<int> > list" [ou approchant], il ne va plus rester guère de code

L'utilisation de la map est dangereuse: il y a 100 lignes, c'est ultra-gérable

Après utiliser un unique_ptr c'est un peu too much pour 100 lignes.
Par contre, effectivement j'ai été au plus simple [toujours en partant du C], et je n'ai pas fait de tests sans pointeur.

Mais cela ce sont des questions à se poser

Sinon, je trouve qu'utiliser un map n'est pas inutile, et même c'est la bonne collection

: on n'a pas de redondance et on associe bien une valeur avec une liste.
D'autant plus que la map facilite l'ajout [via le opérateur[] ] et la recherche d'un chiffre

[et elle trie les chiffres, mais à vérifier]

Mais ce sont toujours des questions à se poser pour "optimiser" l'algo

**Iradrille** · 02/04/2014, 02h49

Envoyé par foetus

L'utilisation de la map est dangereuse: il y a 100 lignes, c'est ultra-gérable

Mouais, il n'y à que 100 lignes et c'est déjà un sacré bordel.
Pourquoi avoir

Code :

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

1
2
3
4
5
struct Elt {
   std::list<int> *elts;
};
 
std::map<int, Elt*> m;

Au lieu de simplement

Code :

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

std::map<int, std::list<int>> m;

Les clefs sont des nombres entre 0 et 9, donc un tableau marche aussi bien.

Code :

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

1
2
3
std::list<int> tab[10]; // ou vector, les deux marchent
// ou
std::array<std::list<int>, 10> tab;

Comme une map c'est trié par "clef" (l'indice), on à l'opérateur [], on peut itérer dessus de la même façon et pas de redondance.
Le coût mémoire de 10 list/vector vides ne justifie pas la création d'objets sur le tas. (Et c'est encore moins justifié avec l'utilisation de map vu qu'il n'y à pas d'objets inutiles de créés).
Une map est aussi utilisable, mais est loin d'être obligatoire et comme l'OP à du mal avec cet exo, autant éviter de le compliquer inutilement.

**foetus** · 02/04/2014, 03h40

Effectivement je me suis troué sur "il n'y a que 10 chiffres"

J'étais parti de mon algo en C qui décomposait ce qui fallait faire: création d'une liste [chaînée] de liste, découpage du nombre avec recherche du chiffre trouvé pour mettre à jour la liste des index, parcours pour afficher et destruction.
Avec "révision" d'une liste chainée (bête comme chou) et des pointeurs (très simple pas d’arithmétique).

Mais en définitive cet exercice est "moisi"

on utilise une collection de base de façon simple [même pas besoin des itérateurs], pas de pointeurs on laisse faire le "C++", l'algo c'est 3 lignes [parce qu'on accède via le chiffre] dans une boucle et l'affichage c'est 2 for imbriqués

En somme un bon bout de code que l'on peut quasi copier/ coller tel quel en Javascript

**white_tentacle** · 02/04/2014, 08h02

Le but de l’exercice, c’est d’apprendre. En l’occurrence, en donnant une solution toute faite, et qui plus est qui fait appel à des notions que l’op n’a pas, tu ne l’aides pas spécialement. Sinon, la « bonne » collection, ce serait plutôt une multimap.

Mais pour l’op, un tableau de std::vector ira très bien, s’il a le droit de les utiliser. Sinon, un tableau à 2 dimensions de taille fixe 10x10, par exemple, initialisé à 0, fera l’affaire (la longueur max d’un int 32 bits étant 10 chiffres en décimal, on évite la complexité des redimensionnements dynamiques).

**Bousk** · 02/04/2014, 09h27

Perso je partirai sur un simple tableau de 10 éléments pour chaque chiffre et pour le reste il s'agit de faire des divisions entières et modulo 10 donc rien de compliqué..

Code :

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

1
2
3
4
5
6
7
8
9
10
11
std::vector< std::vector<unsigned int> > CountNumbers(unsigned int _uiNb)
{
   std::vector< std::vector<unsigned int> > vec(10);
   unsigned int i = 0;
   while (_uiNb)
   {
      vec[_uiNb%10].push_back(i++);
      _uiNb /= 10;
   }
   return vec;
}

Affichage du poids d'un chiffre

C++

Discussions similaires

Partager

Partager