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!
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
#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! ;D