Aporte Recursividad [C]

[Lebravom]

Buenas!

Soy nuevo en el foro, comienzo con un aporte de ejercicios de recursividad que realice en la facultad, hay muchos y variados espero puedan serle útiles a mas de uno o si hay errores me avisen así los vemos!

Son 2 archivos, main.c y implementaciones.c donde están detalladas los ejercicios y las funciones de cada uno comentadas para que se ejecute solo la descomentada.

Disculpen si es mucho código y conviene incluirlo mas como adjuntos!

Código [Seleccionar] Expandir


include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "implementaciones.c"
//#define F 20
//#define C 79
///EJERCICIO 1.16
int es_palindromo (char * i);
int es_palindromo_r (char * i, char * f);
char a_may(char);

///EJERCICIO 1.13 y 1.14
//Se tiene una matriz de char NxM donde pueden haber espacios o x que representan y delimitan lugares que no se puedenllegar. Imple,emntar una funcion recursiva que dadas las coordenadas de un casillero rellene los elementos permitidos del a matriz con el caracter #
/*
void pintar(char[F][C], int, int);
void imprimir(char [F][C]);
*/

///EJERCICIO 1.12
//Programar una funcion que reciba como parametro una longitud y a partir de este imprima todas las posibles combinaciones de letras minusculas de dicha longitud
/*
void imprimirCombinacion(unsigned int cantidad);
void combinacionRecursiva(unsigned int cantidad, char * arreglo, int i);
*/

///EJERCICIO 1.11
//Programar una funcion recursiva que ordene en forma creciente un areglo dinamico unidimensional de numeros enteros.
//Utilizar la funcion recursiva programada para retornar la posicion de memoria del valor minimo del arreglo.
//void ordenar(int vect[], int ind_izq, int ind_der);

///EJERCICIO 1.10
//A)Funcion recursiva que retorne el valor minimo de un arreglo unidimensional dinamico de numeros enteros, el 0 marca el final del arreglo;
//B)Funcion recursiva que retorne la direccion del valor minimo de un arreglo unidimensional de numeros enteros, el 0 marca el final del arreglo;
//unsigned int valor_minimo (int * arreglo, int * minimo);
//unsigned int direccion_minimo (int * arreglo, int * minimo);

///EJERCICIO 1.9
//Funcion recursiva que retorne el valor maximo de un arreglo unidimensional dinamico de numeros enteros, el 0 marca el final de los valores posibles;
//Funcion recursiva que retorne la direccion de memoria del valor maximo de un arreglo unidimensional dinamico de numeros enteros, el 0 marca el final de los valores posibles;
/*
int valor_maximo(int * arreglo, int * maximo);
unsigned int direccion_maximo ( int * arreglo, int * maximo);
*/

///EJERCICIO 1.8
//Crear una funcion recursiva que invierta un arreglo unidimensional de enteros de tal que su prototipo sea void invertir (int *,unsigned int);
/*
void invertir(int * arreglo, unsigned int cantidad);
*/

///EJERCICIO 1.7
//Programar una funcion recursiva para realizar la potenciacion de numeros enteros pero intentando optimizarla de modo de minimizar la cantidad de multiplicaciones totales realizadas.
/*
int potencia_optimizada(int numero1,int numero2);
*/

///Ejercicio 1.6
//Realizar una funcion recursiva que reciba como parametro un string (dado como puntero a char) que contiene un texto y que imprima dicho texto en forma inversa.
/*
void invertir_texto (char * texto,char * fin);
*/


///Ejercicio 1.4
//Crear una funcion recursiva que reciba como parametro un string (dado como puntero a char) que contiene un texto y que retorne la cantidad de caracteres que hay en dicha cadena.-
/*
unsigned int contar_caracteres (char * frase);
*/

///Ejercicio 1.5
//Crear una funcion recursiva que reciba como parametro un string (dado como un puntero a char) que contiene un texto y que retorne la cantidad de vocales que hay en este, el prototipo debe ser
//unsigned int contar_vocales (char*);
/*
unsigned int contar_vocales (char * frase);
*/

///Ejercicio 1.1 multiplicacion recursiva.-
/*
int multiplicacion_recursiva (int numero1, int numero2);
*/

///Ejercicio 1.2
//Hacer una funcion recursiva que retorne el cociente de dos numeros enteros(division entera) utilizando unicamente el operador de resta.
//Hacer otra funcion recursiva que retorne el resto de la division entera de dos numeros enteros utilizando unicamente el operador de resta.
/*
int cocienteEntero(int numero1,int numero2);
int restoEntero(int numero1, int numero2);
*/

///Ejercicio 1.3
//Programar una funcion recursiva que retorne la potencia de un numero real elevado a un numero entero.
/*
double potenciaRecursiva (double numero1, int numero2);
*/
int main()
{
   srand(time(NULL));
   ///Ejercicio 1.16


   char palindromo[]={"A rri BaL aBir rA"};
   char * i=palindromo;
   printf("%d",es_palindromo(palindromo));


   ///EJERCICIO 1.13 y 1.14
   /*
   unsigned int fila=1, columna=1;
           char arreglo[F][C]={"                                                 #############################",
                   "                                                 #                            ",
                   "                                                 #                            ",
                   "                                                 #                            ",
                   "                                                 #                            ",
                   "       ######                       ##########################################",
                   "      #     #                       #            #                 #          ",
                   "     #      #                        #           #                 #          ",
                   "    #       #                         #          #                 #          ",
                   "   #        #                          #         #                ##          ",
                   "  #         ######################################               # #          ",
                   " #                                    #                         #  #          ",
                   "#                                     #                        #   #          ",
                   "                                      #                       #    #          ",
                   "                                      #####################  #     #          ",
                   "                                                          # #      #          ",
                   "                                                          ##       #          ",
                   "                                                          #        #          ",
                   "                                                                   #          ",
                   "                                                                   ###########",
                   "                                                                              ",
                   "                                                                              ",
                   "                                                                              "};
                   imprimir(arreglo);
       pintar(arreglo, fila, columna);
       imprimir(arreglo);
   */

   ///EJERCICIO 1.12
   /*
   imprimirCombinacion(6);
   */

   ///EJERCICIO 1.11 Ordenamiento de arreglo
   /*
   int arreglo[]={9,8,7,6,5,4,3,2,1,0};
   int i;
   int * puntero=arreglo;
   ordenar(arreglo,0,9);

   for (i=0; i<10;i++)
   {
       printf("%d, ",arreglo[i]);
   }
   */

   ///EJERCICIO 1.10B Direccion del minimo de un arreglo.
   /*
   int arreglo[]={10,2,1,4,5,6,7,8,19,0};
   int * puntero=arreglo;
   int * minimo=puntero;
   printf("La direccion del valor minimo del arreglo es= %u ",direccion_minimo(puntero,minimo));
   */

   ///EJERCICIO 1.10A Valor minimo de un arreglo
   /*
   int arreglo[]={1,2,1,4,5,6,7,8,19,0};
   int * puntero=arreglo;
   int * minimo=puntero;
   printf("El valor minimo del arreglo es= %u ",valor_minimo(puntero,minimo));
   */

   ///EJERCICIO 1.9B Direccion del maximo de un arreglo
   /*
   int arreglo[]={1,2,1,4,5,6,7,8,9,0};
   int * puntero=arreglo;
   int * maximo=puntero;
   printf("La direccion del valor maximo del arreglo es= %u ",direccion_maximo(puntero,maximo));
   */

   ///EJERCICIO 1.9A Valor Maximo Arreglo
   /*
   int arreglo[]={1,2,1,4,5,6,7,8,19,0};
   int * puntero=arreglo;
   int * maximo=puntero;

   printf("El valor maximo del arreglo es= %u ",valor_maximo(puntero,maximo));
   */
   ///EJERCICIO 1.8 Invertir Arreglo
   /*
   int numeros[]={1,2,3,4,5,6,7,8,9};
   int * puntero=numeros;
   int i;
   unsigned int cantidad=9;

   printf("Los valores originales del arreglo son: ");
   for (i=0;i<cantidad;i++)
   {
       printf("%d, ",numeros[i]);
   }
   printf("\nLos valores nuevos del arreglo son: ");
   invertir(puntero,cantidad);

   for (i=0;i<cantidad;i++)
   {
       printf("%d, ",numeros[i]);
   }
   */
   ///EJERCICIO 1.7 Potencia optimizada
   /*
   int numero1=rand()%8+1;
   int numero2=rand()%8+1;
   printf("El numero 1 es: %d\n",numero1);
   printf("El numero 2 es: %d\n",numero2);
   printf("La potencia normal es: %g\n",pow(numero1,numero2));
   printf("La potencia optimizada es: %g ",potencia_optimizada(numero1,numero2));
   */

   ///Ejercicio 1.6 Invertir Arreglo Char
   /*
   char frase[]={"Esta es una frase de ejemplo"};
   char * puntero=frase;
   char * fin = frase;
   while (*fin != '\0')
   {
       fin++;
   }
   invertir_texto(puntero,fin);
   */

   ///EJERCICIO 1.4 CONTAR CARACTERES
   /*
   char frase[]={"Esta es una frase de ejemplo"};
   char * puntero=frase;
   printf("La cantidad de caracteres contenidas en la frase es de: %d",contar_caracteres(puntero));
   */

   ///EJERCICIO 1.5 CONTAR VOCALES
   /*
   char frase[]={"Esta es una frase de ejemplo"};
   char * puntero=frase;
   printf("La cantidad de vocales contenidas en la frase es de: %d",contar_vocales(puntero));
   */

   ///EJERCICIO 1.3 Potencia recursiva
   /*
   double numero1=-7.3;
   int numero2=-rand()%10;
   printf("%g\n",numero1);
   printf("%d\n",numero2);
   printf("El valor de la potencia para las dos variables es: %g\n",pow(numero1,numero2));
   printf("El valor de la potencia recursiva es: %g",potenciaRecursiva(numero1,numero2));
   */

   ///Ejercicio 1.1 producto recursivo, definicion de variables y prueba de valores.
   /*
   int numero1=-5;
   int numero2=rand()%10;
   printf("%d\n",numero1);
   printf("%d\n",numero2);
   //Ejercicio 1.1 llamado a la funcion recursiva con los valores que pueden ser cualquier numero positivo.
   printf("El valor de la multiplicacion para las dos variables es: %d\n",numero1*numero2);
   printf("El valor de la funcion recursiva para el producto es: %d\n",multiplicacion_recursiva(numero1,numero2));
   */

   ///Ejercicio 1.2 Llamado a funcion recursiva de division y resto.
   /*
   int numero1=rand()%100;
   int numero2=rand()%10+1;
   printf("El primer numero es: %d\n",numero1);
   printf("El segundo numero es: %d\n",numero2);
   printf("La division devuelve: %d\n",numero1/numero2);
   printf("El resto es: %d\n",numero1%numero2);
   printf("Recursivamente la division es: %d\n",cocienteEntero(numero1,numero2));
   printf("Recursivamente el modulo es: %d",restoEntero(numero1,numero2));
   */

   return 0;
}




Acá va el archivo implementaciones.c que contiene la implementacion de todas las funciones llamadas en el main

Código [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>

//#define F 20
//#define C 79
///Ejercicio 1.16

int es_palindromo (char * i)
{
   char * f;
   for (f=i;*f!='\0';f++);
   return es_palindromo_r(i,f-1);
}

int es_palindromo_r (char * i, char * f)
{
   if (f<=i)
   {
       return 1;
   }
   else if (a_may(*f) != a_may(*i) && *i != ' ' && *f != ' ')
   {
       return 0;
   }
   else
   {
       if(*i==' ')
       {
           return es_palindromo_r(i+1,f);
       }
       if(*f==' ')
       {
           return es_palindromo_r(i,f-1);
       }
       return a_may(*i)==a_may(*f) && es_palindromo_r(i+1,f-1);
   }
}

char a_may(char x)
{
   if (x >='a' && x <= 'z')
       return x-('a'-'A');
   return x;
}



///EJERCICIO 1.13 y 1.14
/*
void pintar(char mat[F][C], int x, int y)
{

   if(x<F && x>=0 && y<C-1 && y>=0 && mat[x][y]==' ')
   {
       mat[x][y]='X';
       pintar(mat, x, y+1);
       pintar(mat, x+1, y);
       pintar(mat, x, y-1);
       pintar(mat, x-1, y);
       pintar(mat, x+1, y+1);
       pintar(mat, x-1, y+1);
       pintar(mat, x-1, y-1);
       pintar(mat, x+1, y-1);
   }
}

void imprimir(char m[F][C])
{
   unsigned int i,j;

   for(i=0;i<F;i++)
   {
       for(j=0;j<C;j++)
       {
           printf("%c", m[i][j]);
           _sleep(5);
       }
       printf("\n");
   }

}
*/

///EJERCICIO 1.12
/*
void imprimirCombinacion(unsigned int cantidad)
{
   char * arreglo;
   arreglo=malloc(sizeof(char)*cantidad+1);
   arreglo[cantidad]='\0';
   combinacionRecursiva(cantidad,arreglo,0);
   free(arreglo);
}

void combinacionRecursiva(unsigned int cantidad, char * arreglo, int i)
{
   char c;
   if(cantidad!=0)
   {
       for (c='a';c<='z';c++)
       {
           arreglo[i]=c;
           combinacionRecursiva(cantidad-1,arreglo,i+1);
       }
   }
   else
   {
       printf("%s\n",arreglo);
   }
}
*/

///EJERCICIO 1.11
/*
void ordenar (int vect[], int ind_izq, int ind_der)
{
   int i, j;  //variables indice del vector
   int elem;  //contiene un elemento del vector
   i = ind_izq;
   j = ind_der;
   elem = vect[(ind_izq+ind_der)/2];
   do
   {
       while (vect[i] < elem) //recorrido del vector hacia la derecha
           i++;
       while (elem < vect[j]) // recorrido del vector hacia la izquierda
           j--;
       if (i <= j) // intercambiar
       {
           int aux; // variable auxiliar
           aux = vect[i];
           vect[i] = vect[j];
           vect[j] = aux;
           i++;
           j--;
       }
   }
   while (i <= j);
   if (ind_izq < j)
   {
       ordenar (vect, ind_izq, j);   //Llamadas recursivas
   }
   if (i < ind_der)
   {
       ordenar (vect, i, ind_der);
   }
}
*/
///IMPLEMENTACION 1.10B
/*
unsigned int direccion_minimo(int * arreglo, int * minimo)
{
   if ( *arreglo==0)
   {
       return minimo;
   }
   else if ( *minimo > *arreglo)
   {
       minimo=arreglo;
       direccion_minimo(arreglo+1,minimo);
   }
   else
   {
       direccion_minimo(arreglo+1,minimo);
   }
}
*/

///IMPLEMENTACION 1.10A
/*
unsigned int valor_minimo(int * arreglo, int * minimo)
{
   if ( *arreglo==0)
   {
       return *minimo;
   }
   else if ( *minimo > *arreglo)
   {
       minimo=arreglo;
       valor_minimo(arreglo+1,minimo);
   }
   else
   {
       valor_minimo(arreglo+1,minimo);
   }
}
*/

///IMPLEMENTACION 1.9B
/*
unsigned int direccion_maximo ( int * arreglo, int * maximo)
{
   if (*arreglo == 0)
   {
       return maximo;
   }
   else
   {
       if(*arreglo>*maximo)
       {
           maximo=arreglo;
           direccion_maximo(arreglo+1,maximo);
       }
       else
       {
           direccion_maximo(arreglo+1,maximo);
       }
   }
}
*/

///IMPLEMENTACION 1.9A
/*
int valor_maximo(int * puntero, int * maximo)
{
   if (*puntero == 0)
   {
       return *maximo;
   }
   else
   {
       if(*puntero>*maximo)
       {
           maximo=puntero;
           valor_maximo(puntero+1,maximo);
       }
       else
       {
           valor_maximo(puntero+1,maximo);
       }
   }
}
*/

///IMPLEMENTACION 1.8
/*
void invertir (int * puntero, unsigned int cantidad)
{
   int auxiliar;
   if(cantidad<=1)
   {
       return 0;
   }
   else
   {
       auxiliar=*(puntero+cantidad-1);
       *(puntero+cantidad-1)=*puntero;
       *puntero=auxiliar;
       invertir(puntero+1,cantidad-2);
   }
}
*/



///IMPLEMENTACION 1.7
/*
int potencia_optimizada(int numero1, int numero2)
{
   if(numero2==1)
   {
       return numero1;
   }
   else
   {
       if(numero2%2!=0)
       {
           return numero1*numero1*potencia_optimizada(numero1,(numero2-1)/2);
       }
       else
       {
           return numero1*potencia_optimizada(numero1,(numero2/2));
       }
   }
}
*/

///IMPLEMENTACION EJERCICIO 1.6
/*
void invertir_texto (char * texto,char * fin)
{
   if (texto==fin)
   {
       return 0;
   }
   else
   {
       fin--;
       printf("%c",*fin);
       invertir_texto(texto,fin);
   }
}
*/

///IMPLEMENTACION DE EJERCICIO 1.4
/*
unsigned int contar_caracteres(char * puntero)
{
   if (*puntero == '\0')
   {
       return 0;
   }
   else if (*puntero >= 'a' && *puntero <= 'z' || *puntero >= 'A' && *puntero <= 'Z')
   {
       return 1+contar_caracteres(puntero+1);
   }
   else
   {
       return contar_caracteres(puntero+1);
   }
}
*/

///Implementacion de ejercicio 1.5
/*
unsigned int contar_vocales (char * puntero)
{
   if(*puntero == '\0')
   {
       return 0;
   }
   else if (*puntero == 'a' || *puntero == 'e' || *puntero == 'i'|| *puntero == 'o' || *puntero == 'u' ||*puntero == 'A' || *puntero == 'E' || *puntero == 'I'|| *puntero == 'O' || *puntero == 'U' )
   {
       return 1+contar_vocales(puntero+1);
   }
   else
   {
       return contar_vocales(puntero+1);
   }
}
*/

///IMPLEMENTACION DE EJERCICIO 1.3

/*
double potenciaRecursiva (double numero1, int numero2)
{
   if (numero2==1)
   {
       return numero1;
   }
   else if(numero1!=0 && numero2 == 0)
   {
       return 1;
   }
   else if (numero1 == 0 && numero2 <=0)
   {
       return 0;
   }
   else if (numero2<0 && numero1 != 0)
   {
       return potenciaRecursiva(1/numero1,-numero2);
   }
   else
   {
       return numero1*potenciaRecursiva(numero1,numero2-1);
   }
}
*/

/// Implementacion de producto recursivo ejercicio 1.1.
/*
int multiplicacion_recursiva (int numero1, int numero2)
{
   if(numero2==0)
   {
       return 0;
   }
   else if (numero2<0)
   {
       return -numero1+multiplicacion_recursiva(numero1,numero2+1);
   }
   else
   {
       return numero1+multiplicacion_recursiva(numero1,numero2-1);
   }
}
*/

///Implementacion de ejercicio 1.2

/*int cocienteEntero(int numero1,int numero2)
{
   if (numero1==0 || numero2==0)
   {
       return 0;
   }
       if (numero1<numero2)
       {
           return 0;
       }
       else
       {
           return 1+cocienteEntero(numero1-numero2,numero2);
       }
}

int restoEntero(int numero1,int numero2)
{
   if (numero1==0 || numero2 == 0)
   {
       return 0;
   }
   else if (numero1<numero2)
   {
       return numero1;
   }
   else
   {
       return restoEntero(numero1-numero2,numero2);
   }
}
*/




Un aporte para comenzar en el foro!