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!
Acá va el archivo implementaciones.c que contiene la implementacion de todas las funciones llamadas en el main
Un aporte para comenzar en el foro!
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]
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]
#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!