logo

TechCodeview

Encontrar a soma dos dígitos de um número até que a soma se torne um único dígito

Experimente no GfG Practice ' title=

Dado um número inteiro n, precisamos encontrar repetidamente a soma de seus dígitos até que o resultado se torne um número de um único dígito.

Exemplos:

Entrada: n = 1234
Saída: 1
Explicação:
Etapa 1: 1 + 2 + 3 + 4 = 10
Etapa 2: 1 + 0 = 1



Entrada: n = 5674
Saída: 4
Explicação:
Etapa 1: 5 + 6 + 7 + 4 = 22
Etapa 2: 2 + 2 = 4

Índice

[Abordagem ingênua] adicionando dígitos repetidamente

A abordagem está focada no cálculo do roo digital t de um número que é o resultado da soma repetida dos dígitos até que um valor de um único dígito seja obtido. Veja como funciona conceitualmente:



  1. Some os dígitos : Comece adicionando todos os dígitos do número fornecido.
  2. Confira o resultado : Se a soma for um número de um único dígito (ou seja, menor que 10), pare e retorne-o.
  3. Repita o processo : Se a soma ainda for maior que um dígito, repita o processo com a soma dos dígitos. Isso continua até que uma soma de um dígito seja alcançada.
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));

Saída 
1

Complexidade de tempo: O(log10n) enquanto estamos iterando sobre os dígitos do número.
Espaço Auxiliar: O(1)

[Abordagem Esperada] Usando Fórmula Matemática

Sabemos que todo número no sistema decimal pode ser expresso como a soma de seus dígitos multiplicados por potências de 10. Por exemplo, um número representado como ABCD pode ser escrito da seguinte forma:

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

Podemos separar os dígitos e reescrever isso como:
abcd = a + b + c + d + (a*999 + b*99 + c*9)
abcd = a + b + c + d + 9*(a*111 + b*11 + c)

Isto implica que qualquer número pode ser expresso como a soma dos seus algarismos mais um múltiplo de 9.
Então, se pegarmos o módulo com 9 de cada lado
abcd% 9 = (a + b + c + d)% 9 + 0

Isso significa que o resto quando abcd é dividido por 9 é igual ao resto onde a soma dos seus dígitos (a + b + c + d) é dividida por 9.



Se a soma dos dígitos consistir em mais de um dígito, podemos ainda expressar essa soma como a soma de seus dígitos mais um múltiplo de 9. Consequentemente, tomar o módulo 9 eliminará o múltiplo de 9 até que a soma dos dígitos se torne um número de um único dígito.

Como resultado, a soma dos dígitos de qualquer número será igual ao seu módulo 9. Se o resultado da operação do módulo for zero, indica que o resultado de um dígito é 9.
Para saber sobre a implementação do código, consulte Raiz digital (soma digital repetida) do número inteiro grande fornecido