Petando la pila. Problemas y retos usando recursividad.

[eferion]

Iniciado por leosansan

Por cierto, habrás observado que sigo al pie de la letra tus recomendaciones en cuanto a que el nombre e las variables sea representativo. Salen unos códigos más largos pero reconozco que me están gustando su uso.

Un fuerte abrazo amigo eferion. NO me canso de repetir la suerte que tenemos de que estés por aquí por tus excelsos conocimientos de C++, por no hablar del C.

Creo que todos acabamos aprendiendo cosas nuevas visitando estos foros.

Desde luego puedo decir que me siento halagado por ser útil, eso quiere decir que todo el esfuerzo que invertí para acabar la carrera no ha sido en vano jejejeje.

Un fuerte abrazo

[Pantaláimon]

No es si se un operador ternario se pueda entender o no. El problema es que los operadores ternarios anidados son infumables de leer, sepas o no. Yo en su momento tuve que traducirlo a if-else para ver que equivalía a la solución de eferion

[amchacon]

Iniciado por leosansan

Tan solo he usado el operador condicional, creo que los usuarios deberían usarlo más para evitar tanto ef-else y sus llaves correspondientes. Pero observa que no he usado operadores a nivel de bit y/o desplazamientos, cosa que también podría haber usado como en su momento hizo kutcher. Pero eso me parece que se sale de los conocimientos generales. Pero un condicional......

Sí, pero es un operador ternario anidado, se ve muy raro y proclibe a errores.

Lo puedes dejar en un punto intermedio:

Código C++:

int unsigned comb ( unsigned n , unsigned k )
{
    if (k > n/2) return comb ( n , k );
    else 
      return ( k >= 1 ) ?  ( n  * comb (  n - 1 , k - 1 ) / k ) : 1 ;
}
 

Aunque tanto parentesis me sigue liando:

Código C++:

int unsigned comb ( unsigned n , unsigned k )
{
    if (k > n/2) return comb ( n , k );
    if (k >= 1)  return n  * comb (  n - 1 , k - 1 ) / k;
    return 1;
}
 

Me gusta más así, se puede ver caso por caso en cada linea.

[vangodp]

Tampoco es para tanto XDD:
( k > n / 2 ) ? ( comb ( n , k ) ) : ( k >= 1 ) ? ( n * comb ( n - 1 , k - 1 ) / k ) : 1
traducion...
k es mayor que n/2?
caso si! devuelve ( comb ( n , k ) )
caso no! es k mayor o igual a 1?
caso si!devuelve ( n * comb ( n - 1 , k - 1 ) / k )
caso no! devuelve 1

[leosansan]

Iniciado por vangodp

Tampoco es para tanto XDD:
( k > n / 2 ) ? ( comb ( n , k ) ) : ( k >= 1 ) ? ( n * comb ( n - 1 , k - 1 ) / k ) : 1
traducion...
k es mayor que n/2?
caso si! devuelve ( comb ( n , k ) )
caso no! es k mayor o igual a 1?
caso si!devuelve ( n * comb ( n - 1 , k - 1 ) / k )
caso no! devuelve 1

¡¡¡Este es mi fenómeno¡¡¡.

Como pueden ver en la sencilla explicación de vangodp no tienen mayor ciencia los operadores ternarios o condicionales.

¡¡¡Saluditos!!!

[vangodp]

Me gustan los operadores ternarios =). Sin embargo a las funciones recursivas me estan dando sudores. jajaja

[amchacon]

Iniciado por vangodp

Tampoco es para tanto XDD:
( k > n / 2 ) ? ( comb ( n , k ) ) : ( k >= 1 ) ? ( n * comb ( n - 1 , k - 1 ) / k ) : 1
traducion...
k es mayor que n/2?
caso si! devuelve ( comb ( n , k ) )
caso no! es k mayor o igual a 1?
caso si!devuelve ( n * comb ( n - 1 , k - 1 ) / k )
caso no! devuelve 1

Oh venga, me vas a decir que mi código no es más sencillo que el de leo xD

Cuanto mas sencillo, mas difícil es equivocarse.

[kutcher]

Buenas, al fin vuelvo a pasar por aquí

Solución al primer ejercicio:

Código C++:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
char* no_Rep(char *dst, int i, int len)
{
    int flag = 0;
    if (i < len)
    {
        dst[i] == dst[i - 1] ? (flag = 1) : (flag = 0);
        if (flag)
        {
            memmove(dst + i - 1, dst + i, len - i * sizeof(char));
            i -= 1, len -= 1;
        }
        no_Rep(dst, i + 1, len);
    }
    else
        dst[i] = '\0';
    return dst;
}
 
char* noRep(char* destino, const char* origen)
{
    strcpy(destino, origen);
    return no_Rep(destino, 1, strlen(destino));
}
 
int main(void)
{
    char cad[] = "abccccfabaddeff";
    char* destino = calloc(strlen(cad) + 1, sizeof(char));
 
    printf("%s\n", noRep(destino, cad));
 
    free(destino);
    return 0;
}
 

Solución al segundo ejercicio:

Código C++:

#include <stdio.h>
#include <math.h>
 
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
 
int dec[5];
 
int cant(int x, int t)
{
    if (x) 
       t +=  1 << (x % 10) * 6, cant(x / 10, t);
    else
        return t;
}
 
int comprobar(int min, int max, int x, int b, int t)
{
    if(min <= max)
    {
        b = x / min;
        if (min * b == x && ((min % 10) || (b%10))
            && t == cant(min, 0) + cant(b, 0) )
        {
            printf("%d = %d x %d ", x, min, b);
            return 1;
        }
        comprobar(min + 1, max, x, b, t);
    }
    else return 0;
}
 
int es_vampiro(int x)
{
    int min, max, b = 0, nd = log10(x) + 1, t = cant(x, 0);
    if (nd % 2) return 0;
 
    min = MAX(dec[nd/2-1], (x+dec[nd/2]-2)/(dec[nd/2]-1));
    max = MIN(x/min, sqrt(x));
 
    return comprobar(min, max, x, b, t);
}
 
int main(void)
{
    dec[0] = 1;
 
    for (int i = 1; i < 5; i++) dec[i] = dec[i - 1] * 10;
    printf("\n%d\n", es_vampiro(13078260));
 
    return(0);
}
 

Saludos

[leosansan]

Iniciado por vangodp

Me gustan los operadores ternarios =). Sin embargo a las funciones recursivas me estan dando sudores. jajaja

Y a mi me encantan. Me recuerdan a cuando daba clases y enseñaba un método diferente al usado normalmente por los alumnos pero de gran potencia que reducía los cálculos en en orden de diez. Al principio se resistían a dejar lo conocido pero al cabo de unas semana, y después de probarlo varias veces ya no había vuelta atrás: se quedaban con el nuevo método. Y es que lo nuevo y mejor cuesta al principio, pero una vez que le coges el tranquillo ya no lo sueltas. Estoy seguro que si algunos de los que han opinado en contra del operador condicional, incluido el encadenado, lo ponen en práctica cuatro o cinco veces ya no podrán prescindir de él.

Y respecto a las funciones recursivas amigo vangodp te aconsejo que empieces por algunas"suaves", poco a poco le oras cogiendo el truquillo. Aunque yo la verdad es que donde esté un for o parecido..........

Y hablando del operador condicional, ahí va el primer ejercicio de la segunda tanda ....

Código C++:

#include <stdio.h>
#include <string.h>
 
char* no_Rep ( char *dest , const char *orig , int i , int j ) {
  return (orig [i]=='\0') ? dest [j]='\0' : orig[i]!=orig[i-1] ? dest[j]=orig[i-1], no_Rep(dest,orig,i+1,j+1) : no_Rep(dest,orig,i+1,j),dest ; 
}
 
char* noRep(char* destino, const char* origen) {
  return no_Rep ( destino , origen , 1 , 0 ) ;
}
 
int main ( void ) {
  char origen [ ] = "abccccfabaddeff" , destino [ strlen ( origen ) + 1 ] ;
  return printf ( "%s ==> %s\n" , origen , noRep ( destino , origen ) ) , 0;
}
 

Aprovecho para corregir un pequeño detalle del segundo ejercicio que puse en primer lugar, el de las combinaciones, ya que tenía el tamaño de un array mal dimensionado:

Código C++:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int esVampiro ( int num ) ;
void variaciones_sin_repe ( char numero [ ] , int tam , int permutacioneS , char aux [ ] , char Npermutacion [ permutacioneS ][ tam + 1 ] , int n0 , int n ) ;
 
int main( void ) {
  int num = 13078260 ;
  return printf ( "\n!!! Como lo quiere Pantalaimon ( 0 - 1 ) !!! ==> : [%d]\n\n" , esVampiro ( num ) ) , 0 ;
}
 
int esVampiro (  num ) {
  int i , j , n , tam , permutacioneS = 1 , num0 = num ;
  for ( tam = 1 ; num0 ; tam++ , num0 /= 10 ) ;
  char numero [ tam + 1 ] ;
  if ( tam %2 == 0 )
    return puts ( "NO ES VAMPIRO por numero impar de cifras." ) , 0 ;
  itoa ( num , numero , 10 ) ;
  n = tam / 2 ;
  for( i = 1 , permutacioneS *= ( tam - 1 ) ; i <  n ; ++i , permutacioneS *= ( tam - 1) ) ;
  char aux [ tam + 1 ] , Npermutacion [ permutacioneS ][ tam + 1 ] ;
  variaciones_sin_repe ( numero , tam , permutacioneS , aux , Npermutacion , n, n ) ;
  for( i = 0 ; i < permutacioneS ; i++ )
    for( j = 0 ; j < permutacioneS ; j++ )
      if ( Npermutacion [ i ][ 0 ] == 0 && Npermutacion [ i ][ 0 ] == 0 )
        continue ;
      else if ( ( Npermutacion [ i ][ tam / 2 - 1 ] != 0 || Npermutacion [ i ][ tam / 2 - 1 ] != 0 ) && atoi ( Npermutacion [ i ] ) * atoi ( Npermutacion [ j ] ) == num  ) {
        return printf ( "\nES VAMPIRO: %d = %d * %d\n" , atoi ( Npermutacion [ i ] ) * atoi ( Npermutacion [ j ] ) , atoi ( Npermutacion [ i ] ) , atoi ( Npermutacion [ j ] ) ) , 1 ;
  }
  return puts ( "NO ES VAMPIRO" ) , 0 ;
}
 
void variaciones_sin_repe( char numero [ ] , int tam , int permutacioneS , char aux [ ] , char Npermutacion [ permutacioneS ][ tam + 1 ] , int n0 , int n ){
  int  i ;
  static int j = 0 , permutaciones = 1  ;
  if( n != 0 )
    for( i = 0 ; i < tam - 1 ; ++i ) {
      aux [ j ] = numero [ i ] ;
      ++j ;
      variaciones_sin_repe ( numero , tam , permutacioneS , aux, Npermutacion , n0 , n - 1 );
      --j;
    }
  else {
    aux [ n0 ] = '\0' ;
    strcpy ( Npermutacion [ permutaciones - 1 ] , aux ) ;
    permutaciones++ ;
  }
}
 

Y ya puestos edito mi segunda opción, toda ella recursiva les recuerdo, pero que ahora muestra los distintos colmillos caso de que los tenga el "vampiro":

Código C++:

#include <stdio.h>
#include <stdlib.h>
 
int cantidadDigitos ( int num ) ;
int esVampiro ( int numero ) ;
int obtenerNumMinimo ( int digitos ) ;
int obtenerNumMaximo ( int digitos )  ;
int probar ( int numero , int num_1 , int num_0 , int n_minimo , int n_maximo , int digitos , int DigitosNumero [ 10 ] ) ;
int DigitosNumero ( int digitosNumero [ 10 ], int numero , int flag )  ;
 
int main ( ) {
  int numero = 13078260 ; 
  return printf ( "\n!!! Como lo quiere Pantalaimon ( 0 - 1 ) !!! ==> : [%d]\n\n" , esVampiro ( numero ) ) , 0 ;
  return 0;
}
 
int cantidadDigitos ( int num ) {
  return ( num == 0 ) ? 0 : 1 + cantidadDigitos ( num / 10 ) ;
}
 
int obtenerNumMinimo ( int digitos ) {
  return ( digitos == 0 ) ? 1 : 10 * obtenerNumMinimo ( - 1 + digitos ) ;
}
 
int obtenerNumMaximo ( int digitos ) {
  return ( digitos == 0 ) ? 1 : 10 * obtenerNumMinimo ( - 1 + digitos ) ;
}
 
void inicializar_digitosNumero ( int digitosNumero [ 10 ] , int indice ) {
  if ( indice < 10 )
    digitosNumero [ indice ] = 0 , inicializar_digitosNumero ( digitosNumero , indice + 1 ) ;
}
 
int DigitosNumero ( int digitosNumero [ 10 ], int numero , int flag ) {
  if ( numero > 0 && flag == 0 )
    digitosNumero [ numero % 10 ]++ , DigitosNumero ( digitosNumero , numero / 10 , 0 ) ;
  else if ( numero > 0 && flag == 1 )
    digitosNumero [ numero % 10 ]-- , DigitosNumero ( digitosNumero , numero / 10 , 1 ) ;
  if ( digitosNumero [ numero % 10 ] < 0 )
    return  0 ;
  else return 1 ;
}
 
int ComprobarDigitos ( int digitosNumero [ 10 ] , int indice , int cont ) {
  if ( indice < 10 )
    if ( digitosNumero [ indice ] == 0 )
      return 1 + ComprobarDigitos ( digitosNumero , indice + 1 , cont + 1 ) ;
    else return
      ComprobarDigitos ( digitosNumero , indice + 1 , cont  ) ;
  return 0 ;
}
 
int esVampiro ( int numero ) {
  int  i , indice = 0 , n_maximo , n_minimo , numero_0 , numero_1 , digitos , digitosNumero [ 10 ] ;
  inicializar_digitosNumero ( digitosNumero , indice ) ;
  DigitosNumero ( digitosNumero , numero , 0 ) ;
  digitos = cantidadDigitos ( numero ) ;
  if ( digitos %2 != 0 )
    return puts ( "\n\n\tNO ES VAMPIRO por numero impar de cifras.\n\n" ) , 0 ;
  n_minimo = obtenerNumMinimo ( - 1 + digitos / 2 ) ;
  n_maximo = obtenerNumMaximo ( digitos / 2 ) ;
  numero_0 = numero_1 = n_minimo ;
  return probar ( numero , numero_1 , numero_0 , n_minimo , n_maximo , digitos , digitosNumero ) ;
}
 
 int probar ( int numero , int num_1 , int num_0 , int n_minimo , int n_maximo , int digitos , int digitosNumero [ 10 ]  ) {
  int  i , indice = 0 ;
  static int flag = 0  ;
  if ( num_1 < n_maximo - 1 && num_0 == n_maximo )
    num_0 = n_minimo , num_1 = numero / n_maximo  ;
  if ( num_0 == n_maximo - 1 && flag == 0 )
    return printf ( "\n\n\t%d NO ES VAMPIRO   flag = %d\n\n"  , numero , flag ) , 0 ;
  if ( num_0 == n_maximo - 1 && flag > 0 )
    return printf ( "\n\n\t%d ES VAMPIRO\n\n"  , numero ) , 1 ;
  if ( num_0 < n_maximo ){
    num_1 = numero / num_0  ;
    if ( num_0 * num_1 == numero  && num_0 > num_1 ) {
    inicializar_digitosNumero ( digitosNumero , 0  ) ;
    DigitosNumero ( digitosNumero , numero , 0 ) ;
    if ( num_0 * num_1 == numero  ) {
      DigitosNumero ( digitosNumero , num_0 , 1 ) ;
      DigitosNumero ( digitosNumero , num_1 , 1 ) ;
      if ( ComprobarDigitos ( digitosNumero , 0 , 0 ) == 10 && ( num_0 % 10 != 0 ||  num_1 % 10 != 0 ) )
        printf ( "\n\n\t%d = %d * %d\n\n" , numero , num_1 , num_0 ) , flag ++ ;
    }
  }
  return  probar ( numero , num_1  , 1 + num_0 , n_minimo , n_maximo , digitos , digitosNumero )  ;
 }
}
 

Ejemplo de la salida:

Código C++:

13078260 = 2070 * 6318
 
13078260 = 1863 * 7020
 
13078260 = 1620 * 8073
 
13078260 ES VAMPIRO
 

¡¡¡Saluditos!!!

[eferion]

Iniciado por leosansan

Estoy seguro que si algunos de los que han opinado en contra del operador condicional, incluido el encadenado, lo ponen en práctica cuatro o cinco veces ya no podrán prescindir de él.

La verdad es que se nota que tienes devoción por ese operador jejejeje.

Mi punto de vista personal es que es útil a veces, cuando hay que hacer una comparación sencilla... en otros tantos casos creo que es más rápido de entender un código con el clásico if.

Pero es como todo, son gustos. En mi caso:

* "auto" lo uso casi exclusivamente cuando trabajo con iteradores

Código C++:

std::map< std::string, std::string > mapa;
 
// Prefiero esto
for ( auto it = mapa.begin( ); it != mapa.end( ); ++it )
 
// A esto
for ( std::map< std::string, std::string >::iterator it = mapa.begin( );
      it != mapa.end( ); ++it )
 

* las lambdas las suelo reservar para operacines sencillas sobre contenedores:

Código C++:

std::vector< std::pair< int, std::string > > datos = { /* lo que sea */ };
const int numero = 5;
const std::string texto = "prueba";
 
// Prefiero esto
auto it = std::find_if( datos.begin( ), datos.end( ),
                        [numero,texto]( const std::pair< int, std::string > >& pareja )
                        { return pareja.first == numero && pareja.second == texto; } );
if ( it != datos.end( ) )
  // registro encontrado
 
// A esto
for ( auto it = datos.begin( ); it != datos.end( ); ++it )
{
  if ( it->first == numero && it->second == texto )
    // Registro encontrado
}
 

En este caso, soy consciente de que el código, por longitud, es más largo. Las ventajas que le veo son

• No me tengo que preocupar por los iteradores
• Es facil reconocer que con "find_if" estoy buscando un elemento en el vector
• La lambda es muy sencilla de entender

Debido a esto, creo que el código acaba siendo menos propenso a errores, sobretodo errores tontos de esos que te hacen perder alguna que otra hora hasta que das con ellos.

* El modificador "override" lo uso siempre.

Que el compilador me avise si una función en una clase hija no puede sobreescribir a ninguna función virtual en el padre no tiene precio, sobretodo en aplicaciones de tamaño medio/grande.

--------------------------

Bueno, son cosas que creo que se suelen ver en mis códigos. Como todo en esta vida, a algunos les parecerá mejor y a otros peor. En el fondo tampoco es un tema relevante. Cada uno tiene su propia forma de codificar y, siendo sincero, prefiero veinte condicionales ternarios anidados que algunas de las perlas que me suelo encontrar en mi día a día.

[HackmanC]

Hola,

Iniciado por leosansan

En realidad no se trata de permutaciones sino de variaciones. ...

Entre que son peras y son manzanas me tire por las conjugatorias. Ya en serio, el concepto teórico de las permutaciones, variaciones y combinaciones, sin y con repetición, y sin y con orden lo tengo claro. El problema es que no encuentro la forma de generar la secuencia exacta de una forma optimizada, es decir, sin usar ciclos o mas recursiones/comparaciones de las necesarias.

Iniciado por Pantaláimon

... Dejo este código por si queréis hacer tests: ...

Gracias, me sirvió bastante para hacer algunas pruebas. Aunque ahora pude comprobar que la secuencia de permutaciones es correcta, y los números los comprueba bien, todavía me queda la duda que tenga algún error.


Bueno, entonces así que las permutaciones serán, con el problema que seguramente la mitad de las operaciones las va a realizar de nuevo al transponer los dígitos al otro bando, por ejemplo, 123x456 y 456x123. Al final se generan n! permutaciones, basado el algoritmo de Heap, aunque se generan mas del doble de recursiones.

Código C:

#include <stdio.h>
#include <stdlib.h>
 
int count(const int value, const int i) {
    return value == 0 ? i : count(value / 10, i + 1);
}
 
void split(const int value, int dst[], const int i) {
    if (value > 0 && i >= 0) {
        dst[i] = value % 10;
        split(value / 10, dst, i - 1);
    }
}
 
int join(int value, const int src[], const int end, const int begin, const int dec) {
    if (end >= begin) {
        value += src[end] * dec;
        return join(value, src, end - 1, begin, dec * 10);
    }
    return value;
}
 
void swap(int dst[], const int a, const int b) {
    int t = dst[b]; dst[b] = dst[a]; dst[a] = t;
}
 
int esvampiro3(const int value, int src[], const int digits) {
    int value1 = join(0, src, (digits / 2) - 1, 0, 1);
    int value2 = join(0, src, digits - 1, (digits / 2), 1);
 
    printf("%.4d x %.4d\n", value1, value2);
 
    if (value1 * value2 == value && !(value1 % 10 == 0 && value2 % 10 == 0)) {
        return 1;
    }
 
    return 0;
}
 
int esvampiro2(const int value, int src[], int c[], const int digits, int i) {
    if(i < digits) {
        if (c[i] < i) {
            swap(src, i, i % 2 ? c[i] : 0);
            if (esvampiro3(value, src, digits)) {
                return 1;
            }
            c[i]++;
            i = 1;
        } else {
            c[i] = 0;
            i++;
        }
        return esvampiro2(value, src, c, digits, i);
    }
    return 0;
}
 
int esvampiro(const int value, int src[], int c[], const int digits, int i) {
    if (esvampiro3(value, src, digits)) {
        return 1;
    }
    return esvampiro2(value, src, c, digits, i);
}
 
int esVampiro(int num) {
    int i;
    int digits = count(num, 0);
    int n[digits];
    int c[digits];
 
    split(num, n, digits - 1);
    for (i = 0; i < digits; i++) {
        c[i] = 0;
    }
 
    if (digits % 2 == 0) {
        return esvampiro(num, n, c, digits, 1);
    }
 
    return 0;
}
 
int main(int argc, char** argv) {
    printf("%d\n", esVampiro(939658));
    return (EXIT_SUCCESS);
}
 

Saludos,

ps:

Aparte de que, al parecer, me estoy quedando medio cegatón, anteriormente mencioné que la había comprobado contra la base de datos, lo volví a comprobar y el resultado era 120, no 720 como había indicado anteriormente. Por eso no se salían las cuentas. Ya mas despacio use el formato condicional de Excel para comprobar que los números no se repetían, en lugar de la base de datos.

[kutcher]

Lo modifico de forma que también encuentre otros colmillos si es que existen:

Código C++:

#include <stdio.h>
#include <math.h>
 
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
int dec[5] = {1, 10, 100, 1000, 10000};
 
int cant(int num, int t)
{
    if (num) t +=  1 << (num%10) * 6, cant(num / 10, t);
    else return t;
}
int comprobar(int min, int max, int num, int b, int t, int es)
{
    if(min <= max)
    {
        b = num / min;
        if (min * b == num && ((min % 10) || (b%10))
            && t == cant(min, 0) + cant(b, 0) )
            printf("%d = %d x %d\n", num, min, b), es++;
        comprobar(min + 1, max, num, b, t, es);
    }else return es > 0 ? 1 : 0; 
}
int es_vampiro(int num)
{
    int min, max, b = 0, nd = log10(num) + 1, t = cant(num, 0);
    if (nd % 2) return 0;
    nd /= 2;
    min = MAX(dec[nd - 1], (num + dec[nd] - 2)/(dec[nd] - 1));
    max = MIN(num/min, sqrt(num));
    return comprobar(min, max, num, b, t, 0);
}
int main(void)
{
    printf("\n<%d>\n", es_vampiro(13078260));
    return(0);
}
 

Saludos

[leosansan]

A la vista de los últimos códigos no me ha quedado más remedio que adelgazar mi último código en ¡¡¡ 40 líneas ¡¡¡ así como el número de argumentos de las funciones:

Código C++:

#include<stdio.h>
#include <math.h>
 
int DigitosNumero ( int digitosNumero [ 10 ], int numero , int flag ) {
  if ( numero > 0 && flag == 0 )
    digitosNumero [ numero % 10 ]++ , DigitosNumero ( digitosNumero , numero / 10 , 0 ) ;
  else if ( numero > 0 && flag == 1 )
    digitosNumero [ numero % 10 ]-- , DigitosNumero ( digitosNumero , numero / 10 , 1 ) ;
  else return 1 ;
}
 
int ComprobarDigitos ( int digitosNumero [ 10 ] , int indice , int cont ) {
  if ( indice < 10 )
    return ( digitosNumero [ indice ] == 0 ) ? 1 + ComprobarDigitos ( digitosNumero , indice + 1 , cont + 1 ) : ComprobarDigitos ( digitosNumero , indice + 1 , cont  ) ;
  return 0 ;
}
 
void inicializar_digitosNumero ( int digitosNumero [ 10 ] , int indice ) {
  if ( indice < 10 )
    digitosNumero [ indice ] = 0 , inicializar_digitosNumero ( digitosNumero , indice + 1 ) ;
}
 
int probar ( int numero , int num_1 , int nMin , int nMax , int flag ) {
  int num_2 = 0 , digitosNumero [ 10 ] ;
  if ( num_2 < nMax - 1 && num_1 == nMax )
    num_1 = nMin , num_2 = numero / nMax  ;
  if ( num_1 < nMax ){
    num_2 = numero / num_1  ;
    if ( num_1 * num_2 == numero  && num_1 > num_2 ) {
    inicializar_digitosNumero ( digitosNumero , 0  ) , DigitosNumero ( digitosNumero , numero , 0 ) ;
    DigitosNumero ( digitosNumero , num_1 , 1 ) , DigitosNumero ( digitosNumero , num_2 , 1 ) ;
    if ( ComprobarDigitos ( digitosNumero , 0 , 0 ) == 10 && ( num_1 % 10 != 0 ||  num_2 % 10 != 0 ) )
      printf ( "\n\n\tSI ES VAMPIRO ==> %d = %d * %d\n\n" , numero , num_2 , num_1 ) , flag ++ ;
  }
  return ( num_1 < nMax - 1 ) ? probar ( numero , 1 + num_1 , nMin , nMax , flag ): ( flag == 0 ) ? printf ( "\n\n\t%d NO ES VAMPIRO\n\n"  , numero  ) , 0 : 1 ;
 }
}
 
int esVampiro( int numero ) {
  int  ndigits = log10 ( numero ) , nMin = pow ( 10 , ndigits / 2 ) , nMax = 10 * nMin  ;
  if ( --ndigits %2 != 0 )
    return puts ( "\n\n\tNO ES VAMPIRO por numero impar de cifras.\n\n" ) , 0 ;
  return probar ( numero , nMin , nMin , nMax , 0 ) ;
}
 
int main ( void ) {
  return  printf ( "\n!!! Como lo quiere Pantalaimon ( 0 - 1 ) !!! ==> : [%d]\n\n" , esVampiro ( 13078260  ) ) , 0 ;
}
 

¡¡¡Saluditos!!!

[HackmanC]

Hola,

Iniciado por Pantaláimon

No es si se un operador ternario se pueda entender o no. El problema es que los operadores ternarios anidados son infumables de leer, sepas o no....

Adicionalmente hay un par de detalles a tomar en cuenta, en algunos casos el código que genera el compilador es el mismo que usando if/then/else. Otro caso es que algunas herramientas de revisión de código, en otros lenguajes, tiene establecido la prohibición del uso del operador ternario; es decir, si se usa el operador no pasa el control de calidad del código.

Prohibirle el uso del operador ternario a un programador en C/C++ creo que es herejía, pero en otros lenguajes, en algunos casos, es común prohibirlo. Como ya mencioné, en algunos casos, no aporta mucho sino complejidad innecesaria.

Saludos,

[Pantaláimon]

Hola!

Iniciado por leosansan

Yo lo que le propondría a Pantaláimon que alterne Retos de recursividad con otros de mayor libertad. Creo que eso mantendría más activo el tema y se apuntarían más usuarios que en este caso no tienen conocimientos y/o practica suficiente del tema de recursividad y no pueden intervenir. En cambio si se alternan con otros que no sean estrictamente de recursividad seguro que se apuntarían, lo que redundaría en una mayor actividad participativa en el tema.

Como ejemplo, echo de menos la intervención de personas como eferion y amchacon, entre otros, en el último reto. Así que amigo Pantaláimon abre el espectro de problemas, tampoco te vamos a exigir que los supervises, para eso ya estamos los demás usuarios. Tu podrías ser el moderador/supervisor de lo que se vaya proponiendo. aunque tampoco niego el que algún usuario proponga Retos interesantes. amchacon lo intentó pero a mí lo de las listas y árboles como que no, pero otros temas podrían ser interesantes.

Yo tengo en cartera algunos Retos que podrían ser más que interesantes si Pantaláimon lo admite. Hasta entonces me reservo, no quiero fastidiarle su tema.

A mi me parece bien, si creéis que conllevará más participación por mi genial. Si tenéis algún problema interesante quizá me lo podéis decir por privado, discutimos minucias, y yo el viernes me encargaría de redactarlo y pongo quien lo ha propuesto para no quitaros mérito

De todos modos tengo la impresión de que mucha más gente no va a haber por esa situación. Quizá vangodp o dehm se acaben animando. Pero el problema parece ser más de tiempo a disponer que no de conocimientos, pues los problemas iniciales son fáciles. Lo que sucede es que un 99% de gente pasa fugazmente por estos foros para que le resuelvan algún problema y luego desaparece. Así que quizá con paciencia el 1% restante que se incorpora a estos foros les guste este hilo y acaben participando.

Recojo también la opinión de Hackman:

Iniciado por Hackman

Realmente es una muy buena idea, habrá que ver si Pantaláimon tiene los recursos necesarios, el tiempo, la dedicación, etc., aunque yo quería evitar eso, y por eso escribí que mi código no estaba optimizado ni especializado, aunque como podrán ver mas arriba, explico que para comprobarlo hice bastantes pruebas.

El problema en mi caso, principalmente es la legibilidad del código, si optimizo cualquiera de las propuestas el código va a ser incomprensible, inclusive para mi mismo (el lenguaje C es bastante obscuro en si mismo); mientras que como está actualmente es bastante claro y mas de algo podrá aprender alguien que tenga un nivel de conocimiento menor.

Claro, a mi en cierto modo, lo interesante de este hilo es también aprender de lo que escriben los demás. Algunas de mis intervenciones han ido en ese sentido, explicando mis soluciones o el algoritmo de complejidad logarítmica para la potencia de kutcher. De todas maneras también entiendo, como dijo eferion que tiene cierto aliciente conseguir el código más eficiente. Y prefiero este tipo de competitividad al de competir por ver quien escribe un código en menos líneas (como estoy viendo en los últimos posts). Pues esta última si que lleva claramente a hacer el código más incomprensible.

Entonces, para llegar a una solución de compromiso entre la competitividad y el aprender, propongo una serie de medidas.
1) Para comparar códigos, me comprometo a medir tiempos de ejecución para los problemas de cierta complejidad (contarNegativos o los juegos de cadenas supongo que no hace falta). A ver si mañana tengo tiempo y publico los tiempos de ejecución para ciertos rangos de numeros de las funciones promedioCollatz y esVampiro.
2) Ahora bien, con el fin de aprender, me gustaría que también hubiera un ambiente de aprendizaje y colaboración. Es decir, si una persona hace un código más eficiente, que no tenga manías en explicar qué "trucos" ha usado. Pues quizá sumando los trucos usados por uno y otro quizá podemos crear soluciones más eficientes, aprender de todos. Pues sentirse parte de un éxito colectivo tampoco está mal, ¿no?
3) Para reducir la tendencia a que los códigos se tornen oscuros, compilaré los códigos en modo optimizado:

Código BASH:

g++ -O3 programa.cpp -o programa
 

Para que códigos no corran más rápido por usar operadores de bits o aritmética entera, un bucle u otro, etc etc... y así priorizando la eficiencia algorítmica frente a los pequeños detalles que siempre se puede encargar de optimizar un compilador.

Cualquier cosa para ir mejorando el tema idme diciendo.

Un saludo!

[Pantaláimon]

Por cierto, me ha dejado sin palabras la función de kutcher:

Código C:

int cant(int num, int t)
{
    if (num) t +=  1 << (num%10) * 6, cant(num / 10, t);
    else return t;
}
 

No sabía que el return se podía elidir sin que el compilador se queje. la rama del if no devuelve ningún valor pero funciona! ¿Alguna referencia al respecto? Estoy buscando ellipsis return C pero no encuentro nada.

Edit: veo que si compilo en gcc con la etiqueta -Wall me salen warnings en el código. De todas maneras me pregunto si esto tiene un comportamiento válido en C o depende del compilador.

[amchacon]

Iniciado por Pantaláimon

Por cierto, me ha dejado sin palabras la función de kutcher:

Código C:

int cant(int num, int t)
{
    if (num) t +=  1 << (num%10) * 6, cant(num / 10, t);
    else return t;
}
 

No sabía que el return se podía elidir sin que el compilador se queje. la rama del if no devuelve ningún valor pero funciona! ¿Alguna referencia al respecto? Estoy buscando ellipsis return C pero no encuentro nada.

Edit: veo que si compilo en gcc con la etiqueta -Wall me salen warnings en el código. De todas maneras me pregunto si esto tiene un comportamiento válido en C o depende del compilador.

Ese comportamiento es ilegal. La función devolverá basura.

[Pantaláimon]

Pero mágicamente con mi compilador gcc funciona. Al igual que la función comprobar.

[kutcher]

Iniciado por Pantaláimon

No sabía que el return se podía elidir sin que el compilador se queje. la rama del if no devuelve ningún valor pero funciona! ¿Alguna referencia al respecto? Estoy buscando ellipsis return C pero no encuentro nada.

Edit: veo que si compilo en gcc con la etiqueta -Wall me salen warnings en el código. De todas maneras me pregunto si esto tiene un comportamiento válido en C o depende del compilador.

En realidad eso en C tiene un comportamiento indefinido ¿Por que funciona? funciona en la mayoría de los casos porque cant almacena su valor de retorno en la posición utilizada para devolver valores (el registro AX en la CPU) debido a esto en la llamada a la función se encuentra un valor de retorno. Aunque la función no devuelve explícitamente un valor.

Sin embargo, esto se debe evitar no sé en que estaba pensando al hacerlo xD pues ahora quisiera rectificarme:

Código C++:

#include <stdio.h>
#include <math.h>
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
 
int dec[5] = { 1, 10, 100, 1000, 10000 };
int cant(int num, int t)
{
    if (!num) return t;
    t +=  1 << (num % 10) * 6;
    return cant(num / 10, t);
}
int comprobar(int min, int max, int num, int b, int t, int es)
{
    if(min > max) return es > 0 ? 1 : 0; 
    b = num / min;
    if (min * b == num && ((min % 10) || (b%10)) && t == cant(min, 0) + cant(b, 0))
        printf("%d = %d x %d\n", num, min, b), es++;
    return comprobar(min + 1, max, num, b, t, es);
}
int es_vampiro(int num)
{
    int min, max, b = 0, nd = log10(num) + 1, t = cant(num, 0);
    if (nd % 2) return 0;
    nd /= 2;
    min = MAX(dec[nd - 1], (num + dec[nd] - 2)/(dec[nd] - 1));
    max = MIN(num/min, sqrt(num));
    return comprobar(min, max, num, b, t, 0);
}
int main(void)
{
    printf("\n<%d>\n", es_vampiro(13078260));
    return(0);
}
 

Saludos

[Pantaláimon]

Buenas!

Para tener el código que habéis ido proponiendo más centralizado a la par que pueda poner en cada directorio su eficiencia, y que vosotros podáis ir reclamando si hago trampa o no en su medición, me gustaría subir vuestras soluciones en un repositorio de github donde haría referencia sobre la autoría de cada código y haría referencia al hilo donde se ha escrito.

Si estáis de acuerdo confirmádmelo por privado.

Un saludo!

[eferion]

Es un poquito más largo que los últimos que habéis puesto... dado que ya todos habíais puesto vuestras versiones he intentado diferenciarme un poco de lo que se estaba haciendo hasta ahora.

Código C++:

#define SWAP(a,b) { int c = *a; *a = *b; *b = c; }
 
const int _factor[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000 };
 
typedef struct _data
{
  int length;
  int digits[15];
  int* endPtr;
} Data;
 
void toArray( int number, Data* data )
{
  if ( number > 0 )
  {
    *data->endPtr = number % 10;
    ++data->endPtr;
    ++data->length;
    toArray( number/10, data );
  }
}
 
int factorial( int n )
{
  if ( n == 2 )
    return 2;
  else
    return n * factorial( n - 1 );
}
 
int toInt( int* first, int* last, const int* factor )
{
  if ( first != last )
  {
    if ( *first )
      return *first * *factor + toInt( first + 1, last, factor + 1 );
    else
      return toInt( ++first, last, factor + 1 );
  }
  else
    return 0;
}
 
void reverse( int* first, int* last )
{
  if ( first <= --last )
  {
    SWAP( first, last );
    reverse( ++first, last );
  }
}
 
int* findLessThan( int* cursor, int* toCompare )
{
  if ( *--cursor > *toCompare )
    return cursor;
 
  return findLessThan( cursor, toCompare );
}
 
void permutation( int* first, int* last, int* cursor )
{
  int* lastCursor = cursor--;
 
  if ( *cursor < *lastCursor )
  {
    int* ptr = findLessThan( last, cursor );
    SWAP( cursor, ptr );
    reverse( lastCursor, last );
  }
  else if ( cursor != first )
    permutation( first, last, cursor );
  else
    reverse( first, last );
}
 
bool es_vampiro( int num, Data* data, int maxPermutaciones )
{
  int* mid = &data->digits[ data->length / 2 ];
  int int1 = toInt( data->digits, mid, _factor );
  int int2 = toInt( mid, data->endPtr, _factor );
 
  if ( ( *data->digits || *mid ) && int1 * int2 == num )
    return true;
 
  if ( --maxPermutaciones )
  {
    permutation( data->digits, data->endPtr, data->endPtr - 1 );
    return es_vampiro( num, data, maxPermutaciones );
  }
 
  return false;
}
 
int es_vampiro( int num )
{
  Data data;
  data.length = 0;
  data.endPtr = data.digits;
  toArray( num, &data );
 
  if ( data.length % 2 )
    return 0;
 
  return es_vampiro( num, &data, factorial( data.length ) )? 1 : 0;
}
 

Un saludo.

[kutcher]

Iniciado por Pantaláimon

Buenas!
Para tener el código que habéis ido proponiendo más centralizado a la par que pueda poner en cada directorio su eficiencia, y que vosotros podáis ir reclamando si hago trampa o no en su medición, me gustaría subir vuestras soluciones en un repositorio de github donde haría referencia sobre la autoría de cada código y haría referencia al hilo donde se ha escrito.

Si estáis de acuerdo confirmádmelo por privado.

Un saludo!

Por mi parte estoy de acuerdo creo que seria lo mas conveniente para mantener el orden y de paso ahora que vuelvo a leer el enunciado la cuestión era retornar uno o cero según el numero dado sea o no vampiro no imprimirlo:

Código C++:

#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
 
int dec[] = { 1, 10, 100, 1000, 10000, 100000 };
int cant(int num, int t)
{
    if (!num) return t;
    t +=  1 << (num % 10) * 6;
    return cant(num / 10, t);
}
int comprobar(int min, int max, int num, int b, int t)
{
    if(min >= max) return 0;
    b = num / min;
    if (min * b == num && ((min % 10) || (b%10))
        && t == cant(min, 0) + cant(b, 0))
        return 1;
    return comprobar(min + 1, max, num, b, t);
}
int es_vampiro(int num)
{
    int min, max, b = 0, nd = log10(num)+1, t = cant(num, 0);
    if (nd % 2) return 0;
    nd /= 2;
    min = MAX(dec[nd - 1], (num + dec[nd] - 2)/(dec[nd] - 1));
    max = MIN(num/min, sqrt(num));
    return comprobar(min, max, num, b, t);
}
int main(void)
{
    printf("\n%d\n", es_vampiro(1001795850));
    return 0;
}
 

Saludos

[HackmanC]

Hola,

Iniciado por Pantaláimon

... Para tener el código que habéis ido proponiendo más centralizado a la par que pueda poner en cada directorio su eficiencia, y que vosotros podáis ir reclamando si hago trampa o no en su medición, ...

En ese caso tendré que hacer algunas modificaciones al código, para optimizarlo por lo menos un poco. Pero aprovechando que en el anterior todavía dejé un ciclo en el main y un array variable, de una vez aprovecho para corregirlo.

Con esas modificaciones esta sería mi solución al reto:

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int count(const int value, const int i) {
    return value ? count(value / 10, i + 1) : i;
}
 
void split(const int value, int *dst) {
    if (value > 0) {
        *dst = value % 10;
        split(value / 10, dst - 1);
    }
}
 
int join(int value, const int src[], const int end, const int begin, const int dec) {
    if (end - 3 >= begin) {
        value += (src[end - 3] * dec * 1000) + (src[end - 2] * dec * 100) + (src[end - 1] * dec * 10) + (src[end] * dec);
        return join(value, src, end - 4, begin, dec * 10000);
    } else {
        if (end - 2 >= begin) {
            value += (src[end - 2] * dec * 100) + (src[end - 1] * dec * 10) + (src[end] * dec);
            return join(value, src, end - 3, begin, dec * 1000);
        } else {
            if (end - 1 >= begin) {
                value += (src[end - 1] * dec * 10) + (src[end] * dec);
                return join(value, src, end - 2, begin, dec * 100);
            } else {
                if (end >= begin) {
                    value += src[end] * dec;
                    return join(value, src, end - 1, begin, dec * 10);
                }
            }
        }
    }
    return value;
}
 
void swap(int dst[], const int a, const int b) {
    int t = dst[b]; dst[b] = dst[a]; dst[a] = t;
}
 
int esvampiro3(const int value, int src[], const int digits) {
    int value1 = join(0, src, (digits / 2) - 1, 0, 1);
    int value2 = join(0, src, digits - 1, (digits / 2), 1);
 
    /* printf("%.4d x %.4d\n", value1, value2); */
 
    if (value1 * value2 == value && !(value1 % 10 == 0 && value2 % 10 == 0)) {
        return 1;
    }
 
    return 0;
}
 
int esvampiro2(const int value, int src[], int c[], const int *digits, int i) {
    if(i < *digits) {
        if (c[i] < i) {
            swap(src, i, i % 2 ? c[i] : 0);
            if (esvampiro3(value, src, *digits)) {
                return 1;
            }
            c[i]++;
            i = 1;
        } else {
            c[i++] = 0;
        }
        return esvampiro2(value, src, c, digits, i);
    }
    return 0;
}
 
int esvampiro(const int value, int src[], int c[], const int *digits, int i) {
    if (esvampiro3(value, src, *digits)) {
        return 1;
    }
    return esvampiro2(value, src, c, digits, i);
}
 
int esVampiro(int num) {
    int digits = count(num, 0);
    int memspc = digits * sizeof(int);
 
    int *n = malloc(memspc);
    int *c = malloc(memspc);
 
    split(num, n + (digits - 1));
    memset(c, 0, memspc);
 
    if (digits % 2 == 0) {
        return esvampiro(num, n, c, &digits, 1);
    }
 
    free(c);
    free(n);
 
    return 0;
}
 
int main(int argc, char** argv) {
    printf("%d\n", esVampiro(1001795850));
    return (EXIT_SUCCESS);
}
 

Espero que no se me haya pasado algún error,
Saludos,

[leosansan]

No me dí cuenta de que podía inicializar un array al declaralro. Con esa corrección me ahorro una función y creo que es más eficiente:

Código C++:

#include<stdio.h>
#include <math.h>
 
int DigitosNumero ( int digitosNumero [ 10 ], int numero , int flag ) {
  if ( numero > 0 && flag == 0 )
    digitosNumero [ numero % 10 ]++ , DigitosNumero ( digitosNumero , numero / 10 , 0 ) ;
  else if ( numero > 0 && flag == 1 )
    digitosNumero [ numero % 10 ]-- , DigitosNumero ( digitosNumero , numero / 10 , 1 ) ;
  else return 1 ;
}
 
int ComprobarDigitos ( int digitosNumero [ 10 ] , int indice , int cont ) {
  if ( indice < 10 )
    return ( digitosNumero [ indice ] == 0 ) ? 1 + ComprobarDigitos ( digitosNumero , indice + 1 , cont + 1 ) : ComprobarDigitos ( digitosNumero , indice + 1 , cont  ) ;
  return 0 ;
}
 
int probar ( int numero , int num_1 , int nMin , int nMax , int flag ) {
  int i , num_2 = 0 , digitosNumero [ 10 ] = {0};
  if ( num_2 < nMax - 1 && num_1 == nMax )
    num_1 = nMin , num_2 = numero / nMax  ;
  if ( num_1 < nMax ){
    num_2 = numero / num_1  ;
    if ( num_1 * num_2 == numero  && num_1 > num_2 ) {
    DigitosNumero(digitosNumero, numero , 0), DigitosNumero(digitosNumero , num_1 , 1), DigitosNumero(digitosNumero , num_2 , 1) ;
    if ( ComprobarDigitos ( digitosNumero , 0 , 0 ) == 10 && ( num_1 % 10 != 0 ||  num_2 % 10 != 0 ) )
      printf ( "\n\n\tSI ES VAMPIRO ==> %d = %d * %d\n\n" , numero , num_2 , num_1 ) , flag ++ ;
  }
  return ( num_1 < nMax - 1 ) ? probar ( numero , 1 + num_1 , nMin , nMax , flag ): ( flag == 0 ) ? printf ( "\n\n\t%d NO ES VAMPIRO\n\n"  , numero  ) , 0 : 1 ;
 }
}
 
int esVampiro( int numero ) {
  int  ndigits = log10 ( numero ) , nMin = pow ( 10 , ndigits / 2 ) , nMax = 10 * nMin  ;
  return ( --ndigits %2 != 0 ) ? puts ( "\n\n\tNO ES VAMPIRO por numero impar de cifras.\n\n" ) , 0 : probar ( numero , nMin , nMin , nMax , 0 ) ;
}
 
int main ( void ) {
  return  printf ( "\n!!! Como lo quiere Pantalaimon ( 0 - 1 ) !!! ==> : [%d]\n\n" , esVampiro ( 13078260 ) ) , 0 ;
}
 

¡¡¡Saluditos!!!

[eferion]

Iniciado por leosansan

Código C++:

int DigitosNumero ( int digitosNumero [ 10 ], int numero , int flag ) {
  if ( numero > 0 && flag == 0 )
    digitosNumero [ numero % 10 ]++ , DigitosNumero ( digitosNumero , numero / 10 , 0 ) ;
  else if ( numero > 0 && flag == 1 )
    digitosNumero [ numero % 10 ]-- , DigitosNumero ( digitosNumero , numero / 10 , 1 ) ;
  else return 1 ;
}
 

No te faltan ahí unos "return"??

[leosansan]

Iniciado por eferion

No te faltan ahí unos "return"??

EDITO: Pues creo que no ya que llamo a la función y voy dividiendo por 10 hasta que numero = 0 y ahí entra en acción el return 1.



¡¡¡Saluditos!!!

[eferion]

el return está en el último else, si el código entra en, por ejemplo, el primer if, se llama de forma recursiva a DigitosNumero... pero únicamente el último tendrá el return, el resto de llamadas no tendrán escrito su correspondiente return.

Yo esperaría encontrar algo así:

Código C:

int DigitosNumero ( int digitosNumero [ 10 ], int numero , int flag ) {
  if ( numero > 0 && flag == 0 )
    return digitosNumero [ numero % 10 ]++ , DigitosNumero ( digitosNumero , numero / 10 , 0 ) ;
  else if ( numero > 0 && flag == 1 )
    return digitosNumero [ numero % 10 ]-- , DigitosNumero ( digitosNumero , numero / 10 , 1 ) ;
  else return 1 ;
}
 

o así:

Código C:

int DigitosNumero ( int digitosNumero [ 10 ], int numero , int flag ) {
  int to_return = 1;
  if ( numero > 0 && flag == 0 )
    digitosNumero [ numero % 10 ]++ , to_return = DigitosNumero ( digitosNumero , numero / 10 , 0 ) ;
  else if ( numero > 0 && flag == 1 )
    digitosNumero [ numero % 10 ]-- , to_return = DigitosNumero ( digitosNumero , numero / 10 , 1 ) ;
  return to_return;
}
 

Aun así no termino de acostumbrarme a eso de separar las instrucciones por coma en vez de por punto y coma... manías que tiene uno :)

[leosansan]

Iniciado por eferion

el return está en el último else, si el código entra en, por ejemplo, el primer if, se llama de forma recursiva a DigitosNumero... pero únicamente el último tendrá el return, el resto de llamadas no tendrán escrito su correspondiente return.

Yo esperaría encontrar algo así:

Aun así no termino de acostumbrarme a eso de separar las instrucciones por coma en vez de por punto y coma... manías que tiene uno :)

Tal vez me expliqué mal. Está es la cuestión:

Código C++:

if ( numero > 0 && flag == 0 )
     digitosNumero [ numero % 10 ]++ , DigitosNumero ( digitosNumero , numero / 10 , 0 ) ;
 

Si entra en el if es porque "numero es mayor de cero ( y flag también ) y lo que hace el if es incrementar el array y a continuación invoca a la función recursiva con el valor de "numero" dividido entre 10 y sucesivamente es invocada "hasta" que "numero" es es cero, momento en que si que actúa el return 1, pero no antes.

Un fuerte saludo amigo eferion y gracias por mirar con tanto detenimiento el código, gracias y desde ya ¡¡¡ Felices Fiestas ¡¡¡.

¡¡¡Saluditos!!!

[Pantaláimon]

Hola,

Realmente no funciona así como explicas, leosan. Y si compilas en modo estricto de dará aviso de que no retornas valor. El problema es el siguiente
Mientras el valor es mayor que 0 llamas recursivamente a la función DigitosNumero, y cuando vale 0 retorna el valor -y aquí viene tu fallo de comprensión- crees que cuando retorna el valor sale de todas las funciones y se va al main. Eso no es así, solo sale de la función actual y vuelve al punto después de la anterior llamada recursiva. Por eso es necesario escribirlo como lo hace eferion.

Inténtalo pensar un poco y lo entenderás. Yo cuando empecé con recursividad también tenía este fallo de concepto.

Un saludo!

[leosansan]

Captado y me lo aplico..

Saludos.

EDITO: Pues ahora en modo -Wall y -pedantic, y añadiendo un return al final de la función "probar", que ese si que me faltaba, no me lanza ya ningún tipo de warnigs:

Código C++:

int DigitosNumero ( int digitosNumero [ 10 ], int numero , int flag ) {
  if ( numero > 0 && flag == 0 )
     digitosNumero [ numero % 10 ]++ , DigitosNumero ( digitosNumero , numero / 10 , 0 ) ;
  else if ( numero > 0 && flag == 1 )
    digitosNumero [ numero % 10 ]-- ,  DigitosNumero ( digitosNumero , numero / 10 , 1 ) ;
  return 1 ;
}
 

Código C++:

Process terminated with status 0 (0 minute(s), 0 second(s))
0 error(s), 0 warning(s) (0 minute(s), 0 second(s))