logo

TechCodeview

Trouver la somme des chiffres d'un nombre jusqu'à ce que la somme devienne un seul chiffre

Essayez-le sur GfG Practice ' title=

Étant donné un entier n, nous devons trouver à plusieurs reprises la somme de ses chiffres jusqu'à ce que le résultat devienne un nombre à un chiffre.

Exemples :

Saisir: n = 1234
Sortir: 1
Explication:
Étape 1 : 1 + 2 + 3 + 4 = 10
Étape 2 : 1 + 0 = 1



Saisir: n = 5674
Sortir: 4
Explication:
Étape 1 : 5 + 6 + 7 + 4 = 22
Étape 2 : 2 + 2 = 4

Table des matières

[Approche naïve] En ajoutant des chiffres de manière répétitive

L'approche est axée sur le calcul du coût numérique t d'un nombre qui est le résultat de la somme répétée des chiffres jusqu'à obtenir une valeur à un chiffre. Voici comment cela fonctionne conceptuellement :



  1. Additionner les chiffres : Commencez par additionner tous les chiffres du nombre donné.
  2. Vérifiez le résultat : Si la somme est un nombre à un chiffre (c'est-à-dire inférieur à 10), arrêtez-vous et renvoyez-la.
  3. Répétez le processus : Si la somme est toujours supérieure à un chiffre, répétez le processus avec la somme des chiffres. Cela continue jusqu'à ce qu'une somme à un chiffre soit atteinte.
C++ 
// C++ program to find the digit sum by  // repetitively Adding its digits #include    using namespace std; int singleDigit(int n) {  int sum = 0;  // Repetitively calculate sum until  // it becomes single digit  while (n > 0 || sum > 9) {  // If n becomes 0 reset it to sum   // and start a new iteration.  if (n == 0) {  n = sum;  sum = 0;  }  sum += n % 10;  n /= 10;  }  return sum; } int main() {  int n = 1234;  cout << singleDigit(n);  return 0; }
C 
// C program to find the digit sum by  // repetitively Adding its digits #include  int singleDigit(int n) {  int sum = 0;  // Repetitively calculate sum until  // it becomes single digit  while (n > 0 || sum > 9) {  // If n becomes 0 reset it to sum   // and start a new iteration.  if (n == 0) {  n = sum;  sum = 0;  }  sum += n % 10;  n /= 10;  }  return sum; } int main() {  int n = 1234;  printf('%d' singleDigit(n));  return 0; }
Java 
// Java program to find the digit sum by  // repetitively Adding its digits class GfG {  static int singleDigit(int n) {  int sum = 0;  // Repetitively calculate sum until  // it becomes single digit  while (n > 0 || sum > 9) {  // If n becomes 0 reset it to sum   // and start a new iteration.  if (n == 0) {  n = sum;  sum = 0;  }  sum += n % 10;  n /= 10;  }  return sum;  }  public static void main(String[] args) {  int n = 1234;  System.out.println(singleDigit(n));  } }
Python 
# Python program to find the digit sum by  # repetitively Adding its digits def singleDigit(n): sum = 0 # Repetitively calculate sum until # it becomes single digit while n > 0 or sum > 9: # If n becomes 0 reset it to sum  # and start a new iteration if n == 0: n = sum sum = 0 sum += n % 10 n //= 10 return sum if __name__ == '__main__': n = 1234 print(singleDigit(n))
C# 
// C# program to find the digit sum by  // repetitively Adding its digits using System; class GfG {  static int singleDigit(int n) {  int sum = 0;  // Repetitively calculate sum until  // it becomes single digit  while (n > 0 || sum > 9) {  // If n becomes 0 reset it to sum   // and start a new iteration.  if (n == 0) {  n = sum;  sum = 0;  }  sum += n % 10;  n /= 10;  }  return sum;  }  static void Main() {  int n = 1234;  Console.WriteLine(singleDigit(n));  } }
JavaScript 
// JavaScript program to find the digit sum by  // repetitively Adding its digits function singleDigit(n) {  let sum = 0;  // Repetitively calculate sum until  // it becomes single digit  while (n > 0 || sum > 9) {  // If n becomes 0 reset it to sum   // and start a new iteration.  if (n === 0) {  n = sum;  sum = 0;  }  sum += n % 10;  n = Math.floor(n / 10);  }  return sum; } // Driver Code const n = 1234; console.log(singleDigit(n));

Sortir 
1

Complexité temporelle : O(journal10n) car nous parcourons les chiffres du nombre.
Espace auxiliaire : O(1)

caractère Java en chaîne

[Approche attendue] Utilisation d'une formule mathématique

Nous savons que chaque nombre du système décimal peut être exprimé comme la somme de ses chiffres multipliée par des puissances de 10. Par exemple, un nombre représenté par abcd peut s'écrire ainsi :

abcd = a*10^3 + b*10^2 + c*10^1 + d*10^0

Nous pouvons séparer les chiffres et réécrire cela comme suit :
abcd = a + b + c + d + (a*999 + b*99 + c*9)
abcd = a + b + c + d + 9*(a*111 + b*11 + c)

Cela implique que tout nombre peut être exprimé comme la somme de ses chiffres plus un multiple de 9.
Donc si on prend modulo avec 9 de chaque côté
abcd % 9 = (a + b + c + d) % 9 + 0

Cela signifie que le reste lorsque abcd est divisé par 9 est égal au reste où la somme de ses chiffres (a + b + c + d) est divisée par 9.



Si la somme des chiffres elle-même est composée de plus d'un chiffre, nous pouvons exprimer cette somme comme la somme de ses chiffres plus un multiple de 9. Par conséquent, prendre modulo 9 éliminera le multiple de 9 jusqu'à ce que la somme des chiffres devienne un nombre à un chiffre.

En conséquence, la somme des chiffres de n'importe quel nombre sera égale à son modulo 9. Si le résultat de l'opération modulo est zéro, cela indique que le résultat à un chiffre est 9.
Pour en savoir plus sur l'implémentation du code Référez-vous Racine numérique (somme numérique répétée) du grand entier donné