|
| 1 | +# 202. Happy Number |
| 2 | + |
| 3 | +## Énoncé |
| 4 | + |
| 5 | +Écrivez un algorithme pour déterminer si un nombre `n` est heureux. |
| 6 | + |
| 7 | +Un **nombre heureux** est un nombre défini par le processus suivant: |
| 8 | + |
| 9 | +- En commençant par n'importe quel entier positif, remplacez le nombre par la somme des carrés de ses chiffres. |
| 10 | +- Répétez le processus jusqu'à ce que le nombre soit égal à 1, ou qu'il **boucle sans fin dans un cycle** qui n'inclut pas 1. |
| 11 | +- Les nombres pour lesquels ce processus **se termine par 1** sont heureux. |
| 12 | + |
| 13 | +Renvoie `true` si `n` est un nombre heureux, ou `false` sinon. |
| 14 | + |
| 15 | +## Exemple |
| 16 | + |
| 17 | +**Exemple 1:** |
| 18 | +**Input:** n = 19 |
| 19 | +**Output:** true |
| 20 | +**Explication:** |
| 21 | +1^2 + 9^2 = 82 |
| 22 | +8^2 + 2^2 = 68 |
| 23 | +6^2 + 8^2 = 100 |
| 24 | +1^2 + 0^2 + 0^2 = 1 |
| 25 | + |
| 26 | +**Exemple 2:** |
| 27 | +**Input:** n = 2 |
| 28 | +**Output:** false |
| 29 | + |
| 30 | +## Contraintes |
| 31 | + |
| 32 | +`1 <= n <= 2^31 - 1` |
| 33 | + |
| 34 | +## Note personnelle |
| 35 | + |
| 36 | +Pour aborder ce problème, j'ai développé deux fonctions distinctes. La première fonction calcule le nombre suivant, tandis que la seconde détecte les cycles et renvoie si `n` est un nombre heureux. |
| 37 | + |
| 38 | +Dans la première fonction, j'emploie une méthode de division successive par 10 pour extraire chaque chiffre du nombre. |
| 39 | + |
| 40 | +```cpp |
| 41 | +int next(int n) { |
| 42 | + int _n = 0; // Variable pour stocker le résultat |
| 43 | + |
| 44 | + // Boucle tant que le nombre n'est pas égal à zéro |
| 45 | + while (n != 0) { |
| 46 | + int digit = n % 10; // Obtient le dernier chiffre du nombre |
| 47 | + n -= digit; // Soustrait le dernier chiffre de n |
| 48 | + n /= 10; // Supprime le dernier chiffre de n |
| 49 | + _n += digit * digit; // Ajoute le carré du chiffre à _n |
| 50 | + } |
| 51 | + |
| 52 | + // Retourne la somme des carrés des chiffres |
| 53 | + return _n; |
| 54 | +} |
| 55 | +``` |
| 56 | +
|
| 57 | +Cette fonction affiche une complexité temporelle de `O(d)`, où `d` représente le nombre de chiffres de `n`, et une complexité spatiale de `O(1)`. |
| 58 | +
|
| 59 | +Ensuite, pour la détection de cycle, j'ai élaboré deux approches différentes. La première utilise un ensemble. |
| 60 | +
|
| 61 | +L'utilisation d'un ensemble permet de suivre les nombres déjà rencontrés, simplifiant ainsi la détection de cycle. |
| 62 | +
|
| 63 | +```cpp |
| 64 | +bool isHappy(int n) { |
| 65 | + // Crée un ensemble pour stocker les nombres déjà vus |
| 66 | + unordered_set<int> set{n}; |
| 67 | +
|
| 68 | + // Boucle tant que n n'est pas égal à 1 ou qu'un cycle est détecté |
| 69 | + while (n != 1) { |
| 70 | + // Calcule le prochain nombre dans la séquence |
| 71 | + n = next(n); |
| 72 | +
|
| 73 | + // Vérifie si le nombre est déjà présent dans l'ensemble |
| 74 | + if (set.contains(n)) { |
| 75 | + // Si c'est le cas, retourne false (cycle détecté) |
| 76 | + return false; |
| 77 | + } |
| 78 | + // Ajoute le nombre à l'ensemble |
| 79 | + set.insert(n); |
| 80 | + } |
| 81 | + // Si n atteint 1, le nombre est heureux |
| 82 | + return true; |
| 83 | +} |
| 84 | +``` |
| 85 | + |
| 86 | +En raison de la nature du problème, il est difficile d'estimer la complexité temporelle, car elle dépend de la nature du nombre d'entrée. La complexité spatiale est proportionnelle au nombre de termes de la suite avant un cycle. |
| 87 | + |
| 88 | +Une autre approche, utilisant la technique du lièvre et de la tortue, permet également de détecter le cycle sans recourir à un ensemble. |
| 89 | + |
| 90 | +Dans cette approche, la tortue (`slow`) avance d'une unité dans la séquence tandis que le lièvre (`fast`) avance de deux. L'itération s'arrête lorsque `slow == fast`. |
| 91 | + |
| 92 | +Illustrons cette approche avec un exemple: |
| 93 | +`n` a pour valeur de départ 19, les thermes de la suite sont les suivants: [19,82,68,100,1,...,1] |
| 94 | + |
| 95 | +Itération 1: |
| 96 | +slow = nums[1] = 82 |
| 97 | +fast = nums[2] = 68 |
| 98 | + |
| 99 | +Itération 2: |
| 100 | +slow = nums[2] = 68 |
| 101 | +fast = nums[4] = 1 |
| 102 | + |
| 103 | +Itération 3: |
| 104 | +slow = nums[3] = 100 |
| 105 | +fast = nums[6] = 1 |
| 106 | + |
| 107 | +Itération 4: |
| 108 | +slow = nums[4] = 1 |
| 109 | +fast = nums[8] = 1 |
| 110 | + |
| 111 | +`slow == fast`, on arrête l'itération, le cycle se termine avec `1` comme digit, alors 19 est heureux. |
| 112 | + |
| 113 | +```cpp |
| 114 | +bool isHappy(int n) { |
| 115 | + // Initialise deux pointeurs, un lent et un rapide |
| 116 | + int slow = next(n); // Pointeur lent, avance d'une étape à la fois |
| 117 | + int fast = next(next(n)); // Pointeur rapide, avance de deux étapes à la fois |
| 118 | + |
| 119 | + // Boucle jusqu'à ce que les pointeurs se rencontrent |
| 120 | + while(slow != fast){ |
| 121 | + slow = next(slow); // Avance le pointeur lent d'une étape |
| 122 | + fast = next(next(fast)); // Avance le pointeur rapide de deux étapes |
| 123 | + } |
| 124 | + |
| 125 | + // Si slow atteint 1, le nombre est heureux, sinon, il n'est pas heureux |
| 126 | + return slow == 1; |
| 127 | +} |
| 128 | +``` |
| 129 | +
|
| 130 | +Cette approche présente la même complexité temporelle que la précédente, mais une complexité spatiale de `O(1)`. |
| 131 | +
|
| 132 | +<img src="./imgs/runtime.png"/> |
| 133 | +<img src="./imgs/memory.png"/> |
0 commit comments