[SOLUCIONADO] funciones recursivas

[vangodp]

Bueno... Anoche estube contestando un post por internet y se trataba de funciones recursivas

No tengo mucha practica con eso pero logre hacer un ejercicio que para mi ha sido algo duro jaja, pero logre hacer lo que postare mas abajo.

El usuario habia pedido que dado un numero como 3183 de 4 digitos.
comaparase cada digito con el ultimo y si fuera mayor o igual, se multiplicara por el seguiente.

El numero 3183 seria n = 3*8*3 que daria 72. El 1 se desecha ya que no es mayor que el ultimo.

Mi pregunta es....
¿Hay alguna forma mas facil de hacer que la que hice yo? Lo digo por que con recursivas no tengo NPI XDDD

Código C++:

#include <iostream>
using namespace std;
 
int f ( int n ) {
    static int op = 0;
    static int a;
    static int u;
    
    if ( op == 0 ) {
        op++;
        a = 1;
        u = n % 10;
    }
    
    if ( n > 0 ) {
        if ( n % 10 >= u ) {
            a = a * ( n % 10 );
            f ( n = n / 10 );
        } else {
            cout << "Desechando la ultima posicion de n: " << n % 10 << ". Es menor que static u: " << u << endl;
            n = n / 10;
            cout << "n ahora contiene " << n << ", y se envia a f() para seguir multiplicando..." << endl;
            f ( n );
        }
        
        
    }
    
    cout << "Retornando: " << a << endl;
    return a;
}
 
int main() {
    //funciona con numeros mayores que 4 digitos... lo que quepa en un int vamos XDDD, pero no poner numeros muy grandes o puedes literalmente causar un stackoverflow XD
    
    int n =  3183;  // <---cambie aqui para ver diferentes resultados.
    cout << f ( n ) << endl;
 
    cin.ignore(); //pausa el programa
    return 0;
}
 

¿Y ademas cual es la ventaja de usar eso?
Suerte chicos

[eferion]

Una aproximación:

Código C++:

int f( int numero )
{
  int cifras = (int)log10( numero );
  if ( cifras == 0 )
    return 0;
 
  int ultimo = numero % 10;
  int primero = numero / pow( 10, cifras );
 
  numero -= primero * pow( 10, cifras );
 
  int to_return = f( numero );
 
  if ( primero >= ultimo )
  {
    if ( to_return != 0 )
      to_return *= primero;
    else
      to_return = primero;
  }
 
  return to_return;
}
 

[leosansan]

Iniciado por vangodp

Bueno... Anoche estube contestando un post por internet y se trataba de funciones recursivas

No tengo mucha practica con eso pero logre hacer un ejercicio que para mi ha sido algo duro jaja, pero logre hacer lo que postare mas abajo.

El usuario habia pedido que dado un numero como 3183 de 4 digitos.
comaparase cada digito con el ultimo y si fuera mayor o igual, se multiplicara por el seguiente.

El numero 3183 seria n = 3*8*3 que daria 72. El 1 se desecha ya que no es mayor que el ultimo.

Mi pregunta es....
¿Hay alguna forma mas facil de hacer que la que hice yo? Lo digo por que con recursivas no tengo NPI XDDD
......................
¿Y ademas cual es la ventaja de usar eso?
Suerte chicos

Ventajas respecto a un ciclo más bien pocas ya que hay que estar invocando a la función una y otra vez, cosa que en un ciclo simple te lo ahorras. Como ejercicio no está mal.

Te dejo en el código un par de cout para que veas como trabaja. Si se los pones en tu código veras que está trabajando de más y es por la falta de los return.

Código C++:

#include <iostream>
using namespace std;
 
int f ( int n ) {
    static int a = 1 , u = n % 10 ;
    if ( n > 0 ) {
        if ( n % 10 >= u ) 
            a = a * ( n % 10 ) , cout << "a =  " << a << endl;               
        else 
            cout << "Desechando la ultima posicion de n: " << n % 10 << ". Es menor que static u: " << u << endl 
            , cout << "n ahora contiene " << n / 10 << ", y se envia a f() para seguir multiplicando..." << endl;
        return f ( n / 10 );
    }
    cout << "Retornando: " << a << endl;
    return a;
}
 
int main() {
    int n =  3183;  
    cout << f ( n ) << endl;
    cin.ignore(); 
    return 0;
}
 

Un fuerte saludo vangodp

¡¡¡Saluditos!!!

[eferion]

Sabía que si me ponía a explicar alguien me acababa pisando la respuesta... por eso puse primero el código jejeje.

Poco que añadir a lo aportado por leosansan

Quizás, comentar que la mayor ventaja de usar recursividad es que no se van a pisar las variables entre diferentes ciclos. En un bucle, sin embargo, tienes que andar con cuidado si necesitas guardar resultados intermedios.

[vangodp]

gracias compañeros... voy estudiar vuestros codigos para ver si me ilumino algo sobre el tema jeje.


Edit: eferion.. algo me falla en tu código que me retorna 24?
Me puedes comentar algo tu codigo =)

[eferion]

Pequeño fallo, no leí lo de que había que multiplicar el resultado por el valor del último dígito :)

Ya aprovecho para dejar solo un return en la función.

Código C++:

int f( int numero )
{
  int to_return = numero;
 
  int cifras = (int)log10( numero );
  if ( cifras > 0 )
  {
    int ultimo = numero % 10;
    int primero = numero / pow( 10, cifras );
 
    numero -= primero * pow( 10, cifras );
 
    to_return = f( numero );
 
    if ( primero >= ultimo )
      to_return *= primero;
  }
 
  return to_return;
}
 

[fightmx]

Otra posible solución:

Código C++:

#include <iostream>
using namespace std;
 
int createProduct(int n){
    if(n < 10)return n;
    int last = n % 10;
    int curr = (n /= 10) % 10;
    return ((curr >= last)? curr : 1) * createProduct((n/10)*10 + last);
}
 
int main() {
    cout << createProduct(3183) << endl;
    return 0;
}
 

No es una buena idea utilizar variables estáticas en funciones recursivas, finalmente no dejan de ser variables globales con visibilidad a nivel de función, por lo que si hubieran llamadas concurrentes lo más probable es que no se obtendría el resultado esperado.

[vangodp]

Peazo de codigo fightmx. XDD
Te lo has dejado en nada. jejeje
Gracias por compartir.
Nunca las utiliso a las estaticas, pero debido a mi poca(por no decir ninguna) exp con recursivas no sabia lo que poner. Me queda que practicar algo.
suerte! (y)

[leosansan]

Iniciado por fightmx

No es una buena idea utilizar variables estáticas en funciones recursivas, finalmente no dejan de ser variables globales con visibilidad a nivel de función, por lo que si hubieran llamadas concurrentes lo más probable es que no se obtendría el resultado esperado.

Todo estriba en el uso adecuado de las mismas, por algo forma parte del estándar de C.

Y puestos a prescindir de las variables estáticas, por qué no prescindir de las que no lo son:

Código C++:

#include <iostream>
using namespace std;
 
int f ( int n ) {
    if ( n < 10 ) return n ;
    return  ( ( ( n / 10 ) % 10 ) >= ( n % 10 ) ?  ( ( n / 10 ) % 10 ) : 1 ) * f ( ( n / 100 ) * 10 + n % 10 ) ;
}
 
int main() {
    cout << f ( 315283 ) << endl ;
     return 0 ;
}
 

Espero que no se me haya ido la olla .

¡¡¡Saluditos!!!

[eferion]

leosansan, aún se puede compactar un poquito más para hacerlo "más legible" :D

Código C++:

#define DIV(n) (n / 10)
#define MD(n)  (n % 10)
#define MUL(n) (n * 10)
#define MOD(n) MD( DIV( n ) )
#define MUD(n) MUL( DIV( n ) )
 
int f ( int n )
{
  if ( n < 10 ) return n ;
  return  ( MOD(n) >= MD(n) ?  MOD(n) : 1 ) * f ( MUD(DIV(n)) + MD(n) ) ;
}
 

[leosansan]

Iniciado por eferion

leosansan, aún se puede compactar un poquito más para hacerlo "más legible" :D

Comprenderás que "eso" era lo menos que esperaba del Rey de las macros.

¡¡¡Saluditos!!!

[kutcher]

Iniciado por eferion

leosansan, aún se puede compactar un poquito más para hacerlo "más legible" :D

La verdad aun puede compactarse bastante no entiendo porque complicarse con tantas operaciones %:

Código C++:

#include <stdio.h>
 
int f(int n)
{
  if (n < 10) return n;
  return (n % 10) * f(n / 10);
}
 
int main(void)
{
    printf("%d", f(3183));
    return(0);
}
 

Saludos

[eferion]

Prueba con 3283 y lo entenderás. El resultado debería seguir siendo 72

[kutcher]

Iniciado por eferion

Prueba con 3283 y lo entenderás. El resultado debería seguir siendo 72

XD ya me di cuenta

En ese caso lo dejo con la correspondiente modificación:

Código C++:

#include <stdio.h>
 
int f(int n, int u)
{
  if (n < 10) return n;
  return (n % 10 >= u ? n % 10 : 1) * f(n / 10, u);
}
 
int main(void)
{
    printf("%d", f(3283, 3283 % 10));
    return(0);
}
 

Saludos

[leosansan]

Iniciado por kutcher

XD ya me di cuenta

En ese caso lo dejo con la correspondiente modificación:
.................................................

Peta con 3284 y es debido al return de n que hay que modificarlo:

Código C++:

#include <stdio.h>
 
int f ( int num , int ultimoDigito ) {
  if ( num < 10 ) return ( num >= ultimoDigito ) ? num : 1 ;
  return ( ( num % 10 ) >= ultimoDigito ? num % 10 : 1 ) * f ( num / 10 , ultimoDigito ) ;
}
 
int main ( void ) {
    int numero = 31258364 ;
    printf ( "%d" , f ( numero , numero % 10 ) ) ;
    return(0);
}
 

¡¡¡Saluditos!!!

[vangodp]

Gracias a todos por sus ideas y ejemplos. (y)

[kutcher]

Iniciado por leosansan

Peta con 3284 y es debido al return de n que hay que modificarlo:

xD eso me pasa por no testear mis códigos, aprovecho de paso para dejar una ultima aproximación pero esta vez usando otra función recursiva de intermedio:

Código C++:

#include <stdio.h>
 
int f2( int n, int u )
{
    int d = n%10, r = d;
    if( d < u ) r = 1;
    if( n < 10 ) return r;
    return r * f2( n/10, u );
}
 
int f( int n )
{
    if ( n < 10 ) return n ;
    return n%10 * f2(n/10, n%10);
}
 
int main(void)
{
    printf("%d", f(3284));
    return(0);
}
 

Saludos

[leosansan]

Iniciado por vangodp

Gracias a todos por sus ideas y ejemplos. (y)

Pues ahí va otro.

Y a fuerza de resultar pesado una última opción ligeramente más breve que la última que expuse :

Código C++:

#include <stdio.h>
 
int f ( int num , int ultimoDigito ) {
  if ( ultimoDigito > num ) return 1  ;
  return ( ( (num ) % 10 ) >= ultimoDigito ? num % 10 : 1 ) * f ( num / 10 , ultimoDigito ) ;
}
 
int main ( void ) {
    int numero = 51258364  ;
    printf ( "%d" , f ( numero , numero % 10 ) ) ;
    return(0);
}
 

¡¡¡Saluditos!!!

[vangodp]

Que artistas soys. De grande quiere ser como vosotros =3

[dehm]

Desde luego yo me he quedado boquiabierto con las respuestas.

[leosansan]

Iniciado por dehm

Desde luego yo me he quedado boquiabierto con las respuestas.

Pues no se olviden de "picar" en "Este Mensaje me gusta".

¡¡¡Saluditos!!!

[dehm]

Cierto. Por mi parte, ya fluye el karma por el hilo

[leosansan]

Iniciado por dehm

Cierto. Por mi parte, ya fluye el karma por el hilo

Gracias amigo dehm por elevar mi karma. vamos mi autoestima.

¡¡¡Saluditos!!!