Ayuda C++ suma de digitos hasta un solo digito.

[Morx]

Buenas!
Me preguntaba como podria hacer la suma de digitos de un numero hasta llegar a un numero de un solo digito.
EJEMPLO:
29.
La suma de sus dígitos 2 + 9 = 11.
La suma de los dígitos de 11 es 1 + 1 = 2.

Código [Seleccionar] Expandir

#include <iostream>

using namespace std;

int suma_digitos (int n);

int main()
{
    int n,resultado;

    cout << "Digite un numero: ";
    cin >> n;

    resultado = suma_digitos(suma_digitos(n));
    cout << resultado;

    return 0;
}

int suma_digitos(int n){
    int s=0;
    while (n>0){
        s = s+ n%10;
        n = n/10;
        cout << s;
        return s;}}


[MAFUS]

Con log10(x)+1 sabes de cuántos dígitos se compone x. Tendrás que repetir tu función hasta que ese valor sea 1.

Otra opción es que cuentes cuántas veces repites el bucle dentro de tu función.

[AlbertoBSD]

Veo que tu pregunta esta relacionada con el tema de primos absolutos, o por lo menos necesitas una funcion simiar que descomponga el numero en sus digitos y los sume.

Tal vez lo que necesitas es una funcion Recursiva, si no has visto ese tema, lo mas probable es que necesites hacerlo de forma Iterativa.

De hecho en tu ejemplo que pones, esta implicita la idea de recursion.

Código [Seleccionar] Expandir


resultado = suma_digitos(suma_digitos(n));


En tu ejemplo quieres que el resultado sea el valor de "suma_digitos" que a su vez tambien vuelve a llamar a "suma_digitos"


Dejo un ejemplo funcionan con metodo RECURSIVO. Lo deje con comentarios para puedas seguir un poco el codigo.

Código (c) [Seleccionar] Expandir


#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int suma_de_digitos_recursiva(int numero);

int main() {
int N = 99999999;
suma_de_digitos_recursiva(N);
}


int suma_de_digitos_recursiva(int numero) {
char temporal[20] = {0};
int suma = 0;
int len,i;
sprintf(temporal,"%i",numero); //Aqui "copiamos" el numero a una cadena de texto para poder iterar facilmente sobre cada digitio individual del numero
printf("Prosesando el numero %s\n",temporal);
len = strlen(temporal); //Sacamos la longitud del numero
if(len == 1) { //Si la longitud del numero es solo de uno ya no hacemos nada retornamos el numero
printf("Finalizamos, el numero tiene un solo digito\n");
return numero;
}
else { //Si la longitud es mayor que uno sumamos los digitos individuales
i = 0;
while(i < len) {
suma += temporal[i] - '0';
i++;
}
printf("La suma es %i\n",suma);
return suma_de_digitos_recursiva(suma);
}
}


Saludos

[CalgaryCorpus]

No es necesario usar funciones como log o convertir el numero a string, tampoco es necesaria la recursion.

Basta comparar el numero contra 10.
Si lo que llevas despues de calcular la suma de los digitos es menor que 10 (y mayor o igual que 0) entonces el numero es de longitud 1.

Algo asi:

Código (cpp) [Seleccionar] Expandir


int obtener_un_digito(int numero_inicial) { .  // numero_inicial >= 0
 int un_digito = numero_inicial;
 while(un_digito >= 10) {
     un_digito = suma_digitos(un_digito);
 }
 return un_digito;
}


     

[kub0x]

Bueno, ya llega el gracioso a decirte que matemáticamente basta con computar el módulo 9 dado que estás con raíces digitales.

[dijsktra]

Dejo un ejemplo funcionan con metodo RECURSIVO. Lo deje con comentarios para puedas seguir un poco el codigo.

Código (c) [Seleccionar] Expandir


...
int suma_de_digitos_recursiva(int numero) {
char temporal[20] = {0};
int suma = 0;
int len,i;
sprintf(temporal,"%i",numero); //Aqui "copiamos" el numero a una cadena de texto para poder iterar facilmente sobre cada digitio individual del numero
printf("Prosesando el numero %s\n",temporal);
len = strlen(temporal); //Sacamos la longitud del numero
if(len == 1) { //Si la longitud del numero es solo de uno ya no hacemos nada retornamos el numero
printf("Finalizamos, el numero tiene un solo digito\n");
return numero;
}
else { //Si la longitud es mayor que uno sumamos los digitos individuales
i = 0;
while(i < len) {
suma += temporal[i] - '0';
i++;
}
printf("La suma es %i\n",suma);
return suma_de_digitos_recursiva(suma);
}
}

...

2 COMENTARIOS:

• Aunque la solución sea correcta, parece que la función recursiva tiene a su vez, un bucle, que podriamos computar también recursivamente
• Yo pienso que los protocolos de entrada-salida hay que dejarlos al margen de las funciones de cómputo. Simplemente, ayuda a separar la I/0 del procesamiento

Propongo esta:

Código (c) [Seleccionar] Expandir


/*

NOTE: In this context, we can safely take log(0)=0 as an extension of ordinary log, for which 0 is undefined


P : N >= 0
fun sumDigits(int N) dev s
Q : s = \sum i : 0 <= i <= log(N) : (N/10^i)%10

INMERSION

FINAL APPROACH

P' = P and 0<= n <= N and ac = \sum i : 0 <= i <= log(N/n) : (N/10^i)%10
fun sumDigits(int n,int ac) dev s
Q' = Q[N/n]

Init call: n=N ac=0

case n=0 : return ac
case n>0 : return sumDigits(n/10,ac+n%10)


*/
#include <iostream>
using namespace std;
#define MAX 10000

int sumDigitsG(const int n, const int ac)
{
 if (n) return sumDigitsG(n/10,ac+n%10);
 return ac;
}

int sumDigits(const int N)
{
 return sumDigitsG(N,0);
}

/* Formalization for solveG omitted */

void solveG(const int N,int V[], int &num)
{
 if (N>=10) {
   V[num++]=sumDigits(N);
   solveG(V[num-1],V,num);
   return;
 }
 return;
}



int main(int argc, char **args)
{
 int V[MAX];
 int N;
 for ( ; cin >> N ; )
   {
     int num=0;
     solveG(N,V,num);
     for (int n=0; n<num ;n++)  cout << V[n] << " " ;
     cout << endl;
   }
}




Y algunos casos de prueba. Se da un número, y el programa da el vector con la suma de los digitos de ese, del que se obtiene... hasta llegar a una cigra

Código [Seleccionar] Expandir

g++ sumDigits2.cc -o main && ./main
13
4
1456
16 7
177777
36 9