Para que funcione tienes que distinguir 3 casos (te falta 1):
- Si inicio y fin son iguales -> return v[inicio]
- Si la diferencia entre inicio y fin es 1 -> return sumaDyV(v, inicio, inicio) + sumaDyV(v, fin, fin)
- Si la diferencia es mayor que 1 -> return sumaDyV(v, inicio, fin/2) + return sumaDyV(v, fin/2+1, fin)
Suerte.

int sumaDyV( int *vec, int inicio, int fin ) {
    if( inicio == fin ) {
        return vec[inicio];
    }
    const int half = (inicio + fin)/2;
    return sumaDyV(vec, inicio, half) + sumaDyV( vec, half +1, fin);
}

Dimension del vector: 5

Numero en la posicion 0: 2

Numero en la posicion 1: 2

Numero en la posicion 2: 2

Numero en la posicion 3: 2

Numero en la posicion 4: 3

Resultado: 11

#include <iostream>
using namespace std;
int sumaDyV( const int *vec, const int inicio, const int fin );
 
int main() {
    int N;
    cin>>N;
    int *vec = new int[N];
    for(int i = 0; i<N;i++)   cin>>vec[i];
    cout<<sumaDyV( vec, 0, N )<< endl;
    delete[] vec;
    return 0;
}
 
// Inmersion:
// P :   0 <= i <= j <= N
// Q :   n = \sum k : i<= k < j : V[k];
int sumaDyV( const int *V, const int i, const int j ) {
    if ( i == j )  return 0;
    if ((j - i) == 1)  return V[i];    
    const int half = (i + j)/2;
    return sumaDyV(V, i, half) + sumaDyV( V, half, j);
}

...
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 

• creo (no estoy seguro), que scanf no procesa el espacio ' ' como carácter, por lo que nunca evaluará espacios en la cadena.. Suponiendo que si, entonces
  
• o  bien isalpha(' ') es true, en cuyo caso existeLetra es true, y es evaluado por la parte positiva del primer condicional... En ese caso, la traza '    .' (5 espacios y un punto) da al menos 5 palabras, pues incrementa nPalabras 5 veces. Es esto correcto?
• o bien isalpha(' ') es false,en cuyo caso  nunca es evaluado por la condición del if, nPalabras no se incrementa. 'hola'  daría 0 palabras.
• ocurre que efectivamente, 'hola.' se incrementará en 1. Esto implica  que isalpha('.') es true.
  

Total palabras: 0
 

.
0
 
       .
0
 
,;.
0
 
,  ;    .
0
 
Hola.
1
 
Hola      .
1
 
        Hola   .
1
 
En un lugar de la Mancha, de cuyo nombre no quiero acordarme...
12
 
En    lugar             , de cuyo nombre no quiero          .
7
 
En un lugar.
3

Ahora vienen 7 espacios:       , con estos otros suman 12:     .
7

 
 
/*
 
 
  P : V[0..N) , N>= 0  
  Q : (c = # i, j: 0 <= i < j <= N : word(V, i, j)) 
 
      where 
word(V,n,m) : allesnb(n, m) and (n>0 - > V[n-1]=' ') and  (m<N- > V[m]=' ')
 
 
Snapshot invariant:
-------------------
 
 
 
 
 
 
   I : Q[N/n] 
       and 0 <= n <= N
      
 
   B : n<N
 
 
   C(n) = N - n  >= 0
 
   Init:
   -----
     n,c = 0,0
 
   Step:
   ------
     n= n + 1 (Clearly, quota decreases)
 
 
   Restore:
   --------
      c = c +\chi (V[n]! =' ' && (n=0 ||   V[n-1]==' '))
 
 
   Pseudo-code:
   ------------
 
   n,c= 0,0
   while  n < N
       c = c +\chi (V[n]! =' ' && (n=0 ||   V[n-1]==' ')) 
      n= n +1 
   end
   return c
 
   
O(N) since while;s body is in O(1) and f_iter in O(N)
       
*/
 
#include <iostream>
#include <algorithm> // max,min
#include <string> // to string, to use
 
 
using namespace std;
#define MAX 100000
 
 
/* See full development and derivation above*/
int solve(const char V[], const int N)
{
  int c,n;
  for(n=c=0;n<N;n++) 
       c +=(V[n]!=' ' && (!n ||   V[n-1]==' '));
  return c;
}
 
 
int main(int argc, char *arg[])
{
  int n,N;
  string V;
  for(;getline(cin, V) ;) 
      cout << solve(V. c_str() ,V.length() ) << endl;
  return 0;
}
 
 

#include <iostream>
#include <stdlib.h>
...
typedef struct tlista{
	pnodo inicio;
	int contador;
};
 
void inicia(tlista &lista);
void crear(pnodo &nuevo);
void agregar_inicio(tlista &lista, pnodo nuevo);
void agregar_final(tlista &lista, pnodo nuevo);
void agregar_orden(tlista &lista, pnodo nuevo);
pnodo quitar_inicio(tlista &lista);
pnodo quitar_final(tlista &lista);
pnodo quitar_nodo(tlista &lista, int valor);
bool buscar_nodo(tlista lista,int valor);
void mostrar(tlista lista);
}

void inicia(tlista &lista);
void agregar_inicio(tlista &lista, int valor);
void agregar_final(tlista &lista, int valor);
void agregar_orden(tlista &lista, int valor);
void quitar_inicio(tlista &lista);
void quitar_final(tlista &lista);
void quitar_valor(tlista &lista, int valor);
void mostrar(tlista lista);

float G2R(float g) {
    while(g > 360) {
        g -= 360;
    }
    return g*PI/180;
}

#define G2R(g) ((g%360)*PI/180)
 

 int g;
  for ( ; cin >> g ; )
 

0 90 180 270 360
          0 0.0000 0.0000
         90 1.5708 1.0000
        180 3.1416 0.0000
        270 4.7124 -1.0000
        360 0.0000 0.0000
0 -90 -180 -270 -360
          0 0.0000 0.0000
        -90 -1.5708 -1.0000
       -180 -3.1416 -0.0000
       -270 -4.7124 1.0000
       -360 0.0000 0.0000
0 1170 1260 1350 1440  # I.e  [0,90,180,270,360] + 360x3
          0 0.0000 0.0000
       1170 1.5708 1.0000
       1260 3.1416 0.0000
       1350 4.7124 -1.0000
       1440 0.0000 0.0000
0 -1170 -1260 -1350 -1440 
          0 0.0000 0.0000
      -1170 -1.5708 -1.0000
      -1260 -3.1416 -0.0000
      -1350 -4.7124 1.0000
      -1440 0.0000 0.0000

 sinus(x) = sum i : 0<= i : (((-1)^i)/(2i+1)!)*x^(2i+1)

#include <iostream>
#include <iomanip> // To format floats into screen
 
/* Uses Taylor formula to compute sin(x), x in gradiants
   
   sinus(x) = sum i : 0<= i : (((-1)^i)/(2i+1)!)*x^(2i+1)
 
   Any computer program makes a finite computation, hence
   we only add summands up to epsilon (in our case, 10^-4)
 
 */
 
#define PI 3.1416
#define G2R(g) (g*PI/180)
#define EPSILON 0.0001
#define ABS(x) ((x>=0)?x:-x)
 
using namespace std;
 
/* P: r given in radians */
float sinus(const float r)
{
  int n;
  float s,t;
  for(n=s=0,t=r; ABS(t) >= EPSILON ; n++)
    {
      s+=t;
      t = ((-1)*r*r*t)/((2*n+3.0)*(2*n+2.0));
    }
  return s;
}
 
 
int main(int argc, char *args[])
{
  float g;
  for ( ; cin >> g ; )
    {
      const float r = G2R(g);
      std::cout << std::fixed << std::setw( 11 ) << std::setprecision(4) 
		<< g << " " <<  r << " " << sinus(r) << endl;
    }
 
}

0 90 180 270 360 
     0.0000 0.0000 0.0000
    90.0000 1.5708 1.0000
   180.0000 3.1416 0.0000
   270.0000 4.7124 -1.0000
   360.0000 6.2832 0.0001
30 150 210 330
    30.0000 0.5236 0.5000
   150.0000 2.6180 0.5000
   210.0000 3.6652 -0.5000
   330.0000 5.7596 -0.5000
1200
  1200.0000 20.9440 5.4417

#include <sys/types.h>         
#include <sys/socket.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
 
int main()
{
  int packet_socket;
  if ((packet_socket = socket(AF_INET, SOCK_STREAM, 0))==-1)
    {
      perror("socket");
      exit(1);
    }
 
  if (close(packet_socket)==-1)
    {
      perror("close");
      exit(1);
    }
  exit(0);
}
 

(./main && echo "OK") || echo "NOK"

OK