Petando la pila. Problemas y retos usando recursividad.

[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!!!