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;
}
 

...
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);
	}
}
 

• 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

/*
 
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;
    }
}
 
 

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