Encontrar a soma dos dígitos de um número até que a soma se torne um único dígito
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 = 1Entrada: 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
- [Abordagem Esperada] Usando Fórmula Matemática
[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:
- Some os dígitos : Comece adicionando todos os dígitos do número fornecido.
- Confira o resultado : Se a soma for um número de um único dígito (ou seja, menor que 10), pare e retorne-o.
- 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++ 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(log 10 n) 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 + 0Isso 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
