Discussion :

[Mrstark]

Je préférerai une solution avec un tableau à deux dimension . mais déja dans mon premier code j'arrive pas a remplir mon tableau avec un while ? après j'aurai juste a rechercher les valeurs communes ?

[Bousk]

Transformer le code pour utiliser un tableau classique n'a rien de sorcier, on ne va pas réaliser l'exercice à ta place.

[foetus]

Juste pour dire qu'on peut utiliser un unsigned char pour un chiffre

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.

Je ne l'aide pas oui et non. Dans un sens lorsque tu vois la solution donnée par Bousk, tu veux aider comment
Moi j'étais parti sur une aide en C++ (sans donner de réponse), et en définitive il n'y a qu'une boucle
Surtout que l'algo est ultra-simplifié parce que les index vont de droite à gauche et commence à 0: on ne peut pas faire moins

Et effectivement le multimap est la « bonne » collection
Mais j'étais parti sur une liste de liste [ou assimilé]

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).

Fais attention ces index commencent à zéro. Il faut initialiser avec une valeur supérieure à 10

[Iradrille]

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

Sinon, la « bonne » collection, ce serait plutôt une multimap.

Perso je partirai sur un simple tableau de 10 éléments

Et personnellement, le premier truc qui m'est venu en tête c'est un tableau d'entier avec des opération bits à bits.

C'est marrant de voir comment face à un exo simple, on à tous une idée différente de solution (toutes possibles).

[Bousk]

Et personnellement, le premier truc qui m'est venu en tête c'est un tableau d'entier avec des opération bits à bits

Pas bête un simple entier utilisé en bitset pour les positions

Ca ferait ça je crois

Code :

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

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

[foetus]

Un multimap ce n'est pas terrible

1. Les clefs sont triées mais pas les valeurs qui arrivent par ordre d'insertion [avec mon gcc à moi au moins]
2. On perd l'association 1 clef <-> plusieurs index

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>
#include <map>
 
 
int main() {
    int number = 7377683;
 
    std::multimap<unsigned char, short> list;
 
    int tmp = number, reverse_number = 0;
    short max_index = 0, index = 0;
    unsigned char digit = 0;
 
    while(tmp >= 10) {
        reverse_number = ((reverse_number * 10) + (tmp % 10));
        tmp = (tmp / 10);
        max_index++;
    }
 
    max_index++;
    reverse_number = ((reverse_number * 10) + tmp);
 
    for(tmp = reverse_number, index = 1; index <= max_index; index++) {
        digit =  (tmp % 10);
        tmp = (tmp / 10);
 
        std::cout << "Find " << (int) digit << " (" << index << ")" << std::endl;
 
        list.insert( std::pair<unsigned char, short>(digit, index) );
    }
 
    digit = 10; // Fake value
 
    for(std::multimap<unsigned char, short>::iterator it = list.begin(); it != list.end(); ++it) {
        if (digit == it->first) {
            std::cout << " - " << it->second;
        } else {
            std::cout << std::endl << "Digit: " << (int) it->first << std::endl << it->second;
            digit = it->first;
        }
    }
 
    return 0;
}