Намиране на сбор от цифри на число, докато сумата стане едноцифрена

Намиране на сбор от цифри на число, докато сумата стане едноцифрена
Опитайте в GfG Practice

За дадено цяло число n трябва многократно да намираме сумата от неговите цифри, докато резултатът стане едноцифрено число.

Примери:

вход: n = 1234
Изход: 1
Обяснение:
Стъпка 1: 1 + 2 + 3 + 4 = 10
Стъпка 2: 1 + 0 = 1

вход: n = 5674
Изход: 4
Обяснение:
Стъпка 1: 5 + 6 + 7 + 4 = 22
Стъпка 2: 2 + 2 = 4

Съдържание

[Наивен подход] Чрез многократно добавяне на цифри

Подходът е фокусиран върху изчисляването на цифровата ру t на число, което е резултат от многократно сумиране на цифрите, докато се получи едноцифрена стойност. Ето как работи концептуално:

  1. Сумирайте цифрите : Започнете с добавяне на всички цифри на даденото число.
  2. Проверете резултата : Ако сумата е едноцифрено число (т.е. по-малко от 10), спрете и я върнете.
  3. Повторете процеса : Ако сумата все още е повече от една цифра, повторете процеса със сумата от цифри. Това продължава до достигане на едноцифрена сума.
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  ));   

Изход
1 

Времева сложност: O(дневник 10 n) докато обикаляме цифрите на числото.
Помощно пространство: О(1)

[Очакван подход] Използване на математическа формула

Знаем, че всяко число в десетичната система може да бъде изразено като сбор от неговите цифри, умножени по степени на 10. Например число, представено като abcd може да се напише по следния начин:

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

Можем да разделим цифрите и да пренапишем това като:
abcd = a + b + c + d + (a*999 + b*99 + c*9)
abcd = a + b + c + d + 9*(a*111 + b*11 + c)

Това означава, че всяко число може да бъде изразено като сбор от неговите цифри плюс кратно на 9.
Така че, ако вземем модул с 9 от всяка страна
abcd % 9 = (a + b + c + d) % 9 + 0

Това означава, че остатъкът, когато abcd се раздели на 9, е равен на остатъка, при който сумата от неговите цифри (a + b + c + d) се раздели на 9.

Ако самата сума от цифрите се състои от повече от една цифра, можем допълнително да изразим тази сума като сбор от нейните цифри плюс кратно на 9. Следователно вземането на модул 9 ще елиминира кратното на 9, докато сумата от цифри стане едноцифрено число.

В резултат сумата от цифрите на което и да е число ще бъде равна на неговия модул 9. Ако резултатът от операцията модул е ​​нула, това показва, че едноцифреният резултат е 9.
За да знаете за внедряването на кода, вижте Цифров корен (повтаряща се цифрова сума) на даденото голямо цяло число