Universidad Simn Bolvar

Departamento de Computacin y Tecnologas de la

Informacin
CI2126 Computacin II

Solucin de la Prctica 3: Recursin

1 ) Escriba una funcin recursiva en C que invierta una cadena de caracteres.
Solucin I (Mtodo Iterativo)
#include<stdio.h>
int string_length(char*);
void reverse(char*);
main()
{
char string[100];
printf("Escribe una cadena\n");
gets(string);
reverse(string);
printf("La conversion es: \"%s\".\n", string);
return 0;
}
void reverse(char *string)
{
int length, c;
char *begin, *end, temp;
length = string_length(string);
begin = string;
end
= string;
for (c = 0; c < length - 1; c++)
end++;
for (c = 0;
{
temp
=
*end
=
*begin =
begin++;
end--;
}

c < length/2; c++)

*end;
*begin;
temp;

}
int string_length(char *pointer)
{
int c = 0;
while( *(pointer + c) != '\0' )
c++;
return c;
}
Solucin II (Recursividad de Cola)
#include <stdio.h>
#include <string.h>
void reverse(char*, int, int);

int main()
{
char a[100];
gets(a);
reverse(a, 0, strlen(a)-1);
printf("%s\n",a);
return 0;
}
void reverse(char *x, int begin, int end)
{
char c;
if (begin >= end)
return;
c
= x[begin];
x[begin] = x[end];
x[end]
= c;
reverse(x, ++begin, --end);
}
Solucin III (Recursividad de Cola)
#include <stdio.h>
#include <string.h>
void reverse(char*, int, int);
int main()
{
char a[100];
gets(a);
reverse(a, 0, strlen(a)-1);
printf("%s\n",a);
return 0;
}
void aux_reverse(char *x, int begin, int end)
{
char c;
if (end-begin <=0)
return;
else
c
= x[begin];
x[begin] = x[end];
x[end]
= c;
aux_reverse(x, ++begin, --end);
}
void reverse(char *x, int begin, int end)
{
if (begin >= end)
return;
else
aux_reverse(x, begin, end);
}

2) Sea p un arreglo de caracteres, p es un palndrome si se cumple que al invertirlo se

obtiene la misma secuencia de caracteres. Escriba la definicin recursiva y una
funcin en lenguaje C que retorne TRUE si p es un paldrome y FALSE en caso
contrario.

#include <stdio.h>
#include <string.h>
#define TRUE 1
#define FALSE 0
int checkear(char [], int);
int main()
{
char p[15];
int SINO;
printf("Introduzca una p para checkear si es palindrome\n");
scanf("%s", p);
SINO=checkear(p, 0);
if (SINO==TRUE)
printf("La palabra es palindrome\n");
else
printf("La palabra no es palindrome\n");
return 0;
}
int checkear(char p[], int indice)
{
int len = strlen(p) - (indice + 1);
if (p[indice] == p[len])
{
if (indice + 1 == len || indice == len)
{
return TRUE;
}
checkear(p, indice + 1);
}
else
{
return FALSE;
}
}

3) Dados dos strings S1 y S2 escriba una funcin recursiva que verifique si S2 se

encuentra en S1. En caso de encontrarse devuelva la posicin dentro del string S1
donde comienza S2 en caso contrario devuelva el mensaje "No encontrado".

4) Escriba una funcin iterativa y otra recursiva que convierta un nmero decimal a
binario.

#include<stdio.h>
long toBinario1(int);
long toBinario2(int);
int main(){
long BinarioNo;
int decimalNo;
printf("Introduzca un numero decimal: ");
scanf("%d",&decimalNo);
BinarioNo = toBinario1(decimalNo);
printf("\nIterativo =>>>El valor binario es: %ld",BinarioNo);
BinarioNo = toBinario2(decimalNo);
printf("\nRecursividad Directa ==>> El valor Binario: %ld",BinarioNo);
return 0;
}
//************* Metodo Iterativo *************************
long toBinario1(int decimalNo){
int d[20];
int i,j;

static long BinarioNo,resto,factor = 1;

while(decimalNo != 0){
resto = decimalNo % 2;
BinarioNo = BinarioNo + resto * factor;
factor = factor * 10;
decimalNo = decimalNo / 2;
}
return BinarioNo;
}
//***************** Recursividad de Cola ********************
long toBinario2(int decimalNo){
static long BinarioNo,resto,factor = 1;
if(decimalNo != 0){
resto = decimalNo % 2;
BinarioNo = BinarioNo + resto * factor;
factor = factor * 10;
toBinario2(decimalNo / 2);
}
return BinarioNo;
}

5) Escriba una funcin iterativa y otra recursiva en C que multiplique dos matrices
(a*b), donde a es de tamao (n*m) y b es de tamao (o*p).
#include<stdio.h>
#define MAX 10
void multiplicarMatrices1(int [MAX][MAX],int [MAX][MAX]);
void multiplicarMatrices2(int [MAX][MAX],int [MAX][MAX]);
int m,n,o,p;

int c[MAX][MAX];
int main(){
int a[MAX][MAX],b[MAX][MAX],i,j,k;
printf("Introduzca No. de Filas y Columnas de la Primera Matriz: ");
scanf("%d %d",&m,&n);
printf("Introduzca No. de Filas y Columnas de la Segunda Matriz: ");
scanf("%d %d",&o,&p);
if(n!=o){
printf("La multiplicacion de matrices es imposible");
printf("\nEl no. de columnas de la primera matriz debe ser el mismo no. de filas de la
segunda matriz");
}
else{
printf("Introduzca la primera matriz: ");
for(i=0;i<m;i++)
for(j=0;j<n;j++)
scanf("%d",&a[i][j]);
printf("Introduzca la segunda matriz: ");
for(i=0;i<o;i++)
for(j=0;j<p;j++)
scanf("%d",&b[i][j]);
printf("\nLa primera matriz es : \n");
for(i=0;i<m;i++){
printf("\n");
for(j=0;j<n;j++){
printf("%d\t",a[i][j]);
}
}
printf("\nLa segunda matriz es : \n");
for(i=0;i<o;i++){
printf("\n");
for(j=0;j<p;j++){
printf("%d\t",b[i][j]);
}
}
multiplicarMatrices1(a,b);
printf("\nMetodo Iterativo====>La multiplicacion de las dos matrices son: \n");
for(i=0;i<m;i++){
printf("\n");
for(j=0;j<p;j++){
printf("%d\t",c[i][j]);
}
}
multiplicarMatrices2(a,b);
printf("\nRecursividad Directa ====>La multiplicacion de las dos matrices son: \n");
for(i=0;i<m;i++){
printf("\n");
for(j=0;j<p;j++){
printf("%d\t",c[i][j]);

}
}
}
return 0;
}
// ******************** Metodo Iterativo *********************************
void multiplicarMatrices1(int a[MAX][MAX],int b[MAX][MAX]){
int sum,i=0,j=0,k=0;
while(i<m){ //row of first matrix
j=0;
while(j<p){ //column of second matrix
k=0;
sum=0;
while(k<n){
sum=sum+a[i][k]*b[k][j];
k++;
}
c[i][j]=sum;
j++;
}
i++;
}
}
//********************** Recursividad en Cola *****************************
void multiplicarMatrices2(int a[MAX][MAX],int b[MAX][MAX]){
static int sum,i=0,j=0,k=0;
if(i<m){ //row of first matrix
if(j<p){ //column of second matrix
if(k<n){
sum=sum+a[i][k]*b[k][j];
k++;
multiplicarMatrices2(a,b);
}
c[i][j]=sum;
sum=0;
k=0;
j++;
multiplicarMatrices2(a,b);
}
j=0;
i++;
multiplicarMatrices2(a,b);
}
}

6) Escriba una funcin recursiva para calcular el Mximo Comn Divisor (MCD) de
dos nmeros n1 y n2, utilizando la siguiente definicin :
MCD(n1, n2)=n2
si (n2<=n1 && n1 % n2==0)
MCD(n1, n2)= MCD(n2, n1) si (n1<n2)
MCD(n1, n2)= MCD(n2, n1%n2) en otros casos.

#include<stdio.h>
int MCD1(int x,int y);
int MCD2(int x,int y);
int main(){
int n1,n2,mcd;
printf("\nIntroduzca dos numeros: ");
scanf("%d %d",&n1,&n2);
mcd=MCD1(n1,n2);
printf("\nIterativo ==>>El MCD de %d y %d es: %d",n1,n2,mcd);
mcd=MCD2(n1,n2);
printf("\nRecursividad Directa==>>El MCD de %d y %d es: %d",n1,n2,mcd);
return 0;
}
//********** Metodo iterativo *********************
int MCD1(int x,int y){
int aux;
while (y>x || (x%y)!=0) {
if (x<y)
{
aux=y; y=x; x=aux;
}
else
{
aux=x; x=y; y=aux%y;
}
}
return y;
}
//************* Recursividad en Cola ****************
int MCD2(int x,int y){
if (y<x && x%y==0)
return y;
else if (x<y)
return (y, x);
else
return (y, x%y);
}

7) Escriba un programa recursivo para calcular la determinante de una matriz (n*n).

#include <stdio.h>
#define DIM 100
void MostrarMatriz(int Matriz[][DIM],unsigned int MAX);
void Leer_matriz(int a[][DIM],unsigned int MAX);
int CalcularDeterminante(int Matriz[][DIM],unsigned int MAX);
int main()
{
int Tamanyo;
int Matriz[DIM][DIM];
while(1)
{

printf("Indica el tamanyo de la matriz (0 PARA TERMINAR): ");

scanf("%d",&Tamanyo);
if (Tamanyo==0) break;
else if (Tamanyo < 2)
Tamanyo = 2;
printf("Inserta los elementos de la matriz: \n\n");
Leer_matriz(Matriz,Tamanyo);
printf("\n\n\n");
MostrarMatriz(Matriz,Tamanyo);
printf("\n\n\n");
printf("El determinante es: %d",CalcularDeterminante(Matriz,Tamanyo));
printf("\n\n\n");
}
return 0;
}
int CalcularDeterminante(int Matriz[][DIM], unsigned int MAX)
{
if (MAX == 2)
{
return (Matriz[0][0]*Matriz[1][1] - Matriz[0][1]*Matriz[1][0]);
}
else
{
int Actual = 0;
int k = 0;
int l,j,i;
int Numero = 0;
short Multriplicador;
int Buffer[DIM][DIM]; // Creo una nueva matriz para hacer los adjuntos
for (l = 0; l < MAX; l++) // Desarrollo por filas
{
for (j = 1; j < MAX; j++) // Creo una nueva matriz adjunta
{
for (i = 0; i < MAX; i++)
{
if (i != l)
{
Buffer[k][j-1] = Matriz[i][j];
k++;
}
}
k = 0;
}

if ( l % 2 != 0)
Multriplicador = -1;
else
Multriplicador = 1;
Numero += (Matriz[l][0]*CalcularDeterminante(Buffer,MAX-1)*Multriplicador);
}
return Numero;
}
}
void MostrarMatriz(int Matriz[][DIM],unsigned int MAX)
{
int j,i;
for (j = 0; j < MAX; j++)
{
printf("\n( ");
for (i = 0; i < MAX; i++)
printf("%d",Matriz[i][j]);

printf(") ");
}
}
void Leer_matriz(int a[][DIM],unsigned int MAX)
{
int i,j;
for (j = 0; j < MAX; j++)
for (i = 0; i < MAX; i++)
{
printf("Introduce el numero para la posicion (%d,%d) :",i,j);
scanf("%d",&a[j][i]);
}
}

8) Se define el punto de ensilladura de una matriz de tamao mxn como la posicin i,j
que contiene al mnimo valor de la fila i que corresponde al mximo valor de la
columna j. Por ejemplo, si la matriz es la siguiente (mxn=3x2):
1 5
14 9

8 6
La misma posee un punto de ensilladura en la posicin 2,2 (mnimo valor de la fila 2
que corresponde al mximo valor de la columna 2). Escriba una funcin en C que

escriba los valores de i y de j del punto de ensilladura de una matriz dada en el caso de
existir. En caso contrario debe devolver los valores -1,-1.

9) Elaborar un programa recursivo que reciba la siguiente matriz que simbolice un

laberinto, de manera que una casilla con valor L identifique a un Ladrillo (no pase) y
una casilla con el caracter E identifique un espacio o un camino libre (si paso).
lab[FILAS][COLUMNAS] =
{ { L, L, L, L, L, L,
{ E, E, E, L, E, L,
{ L, L, E, L, E, E,
{ L, E, E, E, E, L,
{ L, E, L, L, L, L,
{ L, E, E, E, L, E,
{ L, E, L, L, L, L,
{ L, E, E, E, E, E,
{ L, L, L, L, L, L,
{ L, E, E, E, E, E,
{ L, E, L, L, L, L,
{ L, E, E, L, E, E,
{ L, L, L, L, L, L,
};

L,
E,
E,
E,
E,
E,
L,
E,
L,
E,
L,
E,
L,

L,
L,
L,
L,
L,
L,
L,
E,
L,
E,
E,
E,
L,

L,
E,
E,
L,
E,
E,
E,
E,
L,
L,
E,
L,
L,

L,
L,
E,
L,
L,
L,
L,
E,
L,
E,
E,
E,
L,

L,
E,
E,
E,
E,
E,
E,
E,
L,
E,
L,
E,
L,

L,
E,
L,
L,
L,
L,
L,
E,
E,
E,
L,
L,
L,

L,
E,
E,
E,
E,
E,
L,
L,
L,
L,
L,
E,
L,

L,
L,
L,
L,
L,
E,
E,
E,
E,
L,
E,
E,
L,

L,
E,
E,
E,
L,
E,
L,
L,
L,
L,
L,
E,
L,

L,
E,
L,
L,
L,
E,
E,
E,
E,
L,
E,
E,
L,

L,
E,
E,
L,
E,
E,
E,
L,
E,
L,
E,
L,
L,

L,
E,
E,
E,
E,
L,
E,
L,
L,
L,
E,
L,
L,

L,
E,
L,
L,
L,
L,
E,
E,
E,
E,
E,
L,
L,

L,
E,
E,
E,
E,
E,
E,
L,
L,
L,
E,
E,
L,

L
L
L
L
L
L
L
L
L
L
L
E
L

},
},
},
},
},
},
},
},
},
},
},
},
}

Adems debe recibir una posicin (i,j) que refleja la posicin inicial dentro de la
matriz. El programa debe indicar si el laberinto, representado por la matriz, tiene
salida. La idea es hacer un programa que simule el recorrido dentro del laberinto a
travs de los caminos libres.
#include <stdio.h>
/* Constantes que definen la dimension del laberinto */
#define FILAS 13
#define COLUMNAS 21
/* Caracteres que se almacenan en las posiciones del laberinto:
/*
ASCII 219 es un cuadro relleno que se usa para las paredes
/*
' ' es un espacio en blanco, para los caminos libres
/*
'*' es la marca que senala las posiciones visitadas (camino).
/* El caracter ASCII 219 podria no visualizarse en Linux.
#define L 219
#define E ' '
#define MARCA '*'
/* Constantes logicas para valor de retorno de funciones */
#define V 1
#define F 0

*/
*/
*/
*/
*/

/* Matriz global que representa el laberinto. En la inicializacion, */

/* L representa un ladrillo en la pared y E un espacio en blanco
*/
int lab[FILAS][COLUMNAS]
{ { L, L, L, L, L, L,
{ E, E, E, L, E, L,
{ L, L, E, L, E, E,
{ L, E, E, E, E, L,
{ L, E, L, L, L, L,
{ L, E, E, E, L, E,
{ L, E, L, L, L, L,
{ L, E, E, E, E, E,
{ L, L, L, L, L, L,
{ L, E, E, E, E, E,
{ L, E, L, L, L, L,
{ L, E, E, L, E, E,
{ L, L, L, L, L, L,
};

=
L,
E,
E,
E,
E,
E,
L,
E,
L,
E,
L,
E,
L,

L,
L,
L,
L,
L,
L,
L,
E,
L,
E,
E,
E,
L,

L,
E,
E,
L,
E,
E,
E,
E,
L,
L,
E,
L,
L,

L,
L,
E,
L,
L,
L,
L,
E,
L,
E,
E,
E,
L,

L,
E,
E,
E,
E,
E,
E,
E,
L,
E,
L,
E,
L,

L,
E,
L,
L,
L,
L,
L,
E,
E,
E,
L,
L,
L,

L,
E,
E,
E,
E,
E,
L,
L,
L,
L,
L,
E,
L,

L,
L,
L,
L,
L,
E,
E,
E,
E,
L,
E,
E,
L,

L,
E,
E,
E,
L,
E,
L,
L,
L,
L,
L,
E,
L,

L,
E,
L,
L,
L,
E,
E,
E,
E,
L,
E,
E,
L,

L,
E,
E,
L,
E,
E,
E,
L,
E,
L,
E,
L,
L,

L,
E,
E,
E,
E,
L,
E,
L,
L,
L,
E,
L,
L,

L,
E,
L,
L,
L,
L,
E,
E,
E,
E,
E,
L,
L,

L,
E,
E,
E,
E,
E,
E,
L,
L,
L,
E,
E,
L,

L
L
L
L
L
L
L
L
L
L
L
E
L

},
},
},
},
},
},
},
},
},
},
},
},
}

/* Coordenadas de la entrada del laberinto */

int xe = 1;
int ye = 0;
/* Coordenadas de la salida del laberinto */
int xs = 11;
int ys = 20;
/*******************************************************************
* Funcion que despliega el laberinto en la pantalla.
*******************************************************************/
void desplegar() {
int i, j;
printf("\n");
for (i=0; i<FILAS; i++) {
for (j=0; j<COLUMNAS; j++) {
printf("%c", lab[i][j]);
}
printf("\n");
}
return;
}
/********************************************************************
* Analiza una posicion dentro del laberinto, especificada por la fila
* y columna recibidas como parametro, y deduce si es una posicion
* valida para recorrer. Basicamente debe verificar que no este fuera de
* los limites del laberinto, que no se trate de una posicion en la que
* hay pared, y que no se trate de una posicion previamente visitada.
********************************************************************/
int valida(int f, int c) {

int resultado = V;

/* Se supone inicialmente valida */

/* Controla si la posicion esta fuera del laberinto */

if ((f<0) || (f>=FILAS) || (c<0) || (c>=COLUMNAS))
resultado = F;
/* Controla si la posicion ya fue visitada o es muro */
if (lab[f][c] == MARCA || lab[f][c] == L)
resultado = F;
return(resultado);
}
/*******************************************************************
* Funcion recursiva que recorre el laberinto a partir de una posicion
* dada por la fila y columna pasadas como parametro y devuelve un valor
* booleano que indica si se logro llegar a la salida. El caso base de
* la recursividad (condicion de termino) es que las coordenadas
* correspondan con la salida del laberinto. En caso contrario, se
* procede a marcar la casilla y a intentar en las distintas direcciones
* (izquierda, derecha, arriba y abajo), asegurandose primero que en
* esa direccion haya una casilla valida (no ladrillo, no fuera del
* laberinto y no visitada). En caso en que ninguna direccion nos lleva
* a la salida, se desmarca la casilla actual (pues se va a retroceder)
* y se devuelve falso como valor de retorno. Las marcas sirven tambin
* para senalar la ruta que conforma la solucion, una vez encontrada.
********************************************************************/
int recorrer(int fil, int col) {
int listo = F;
/* Indica si se ha encontrado la salida */
/* Se marca la casilla como visitada */
lab[fil][col] = MARCA;
desplegar();
system("pause");
/* Se controla la condicion de termino de recursividad: */
/*
" Llegamos a la salida? "
*/
if (fil == xs && col == ys)
return(V);
if (listo==F && valida(fil,col-1)==V)
listo = recorrer(fil,col-1);
if (listo==F && valida(fil,col+1))
listo = recorrer(fil,col+1);
if (listo==F && valida(fil-1,col))
listo = recorrer(fil-1,col);
if (listo==F && valida(fil+1,col))
listo = recorrer(fil+1,col);

/* Intento a la izquierda */
/* Intento a la derecha */
/* Intento hacia arriba */
/* Intento hacia abajo */

/* Si no se logro resolver el laberinto desde esta posicion, se

*/

/* desmarca la casilla pues no sera parte de la solucion. En este */

/* caso se retornara falso lo que provocara que se retroceda.
*/
if (listo==F)
lab[fil][col] = E;
/* Se retorna V F dependiendo de si se encontro solucion */
return(listo); }
/********************************************************************
* Funcion principal para la resolucion del laberinto. Se despliega
* el laberinto antes y despues de resolverlo.
*******************************************************************/
main() {
int ok;

/* Para saber si se obtuvo solucion */

desplegar();
/* Despliega el laberinto sin resolver */
system("pause");
do{
printf("\nDame la fila de tu posicion inicial :"); scanf("%d",&xe);
printf("\nDame la columna de tu posicion inicial :"); scanf("%d",&ye);
if (lab[xe][ye] == L)
{
printf("En esta posicion hay un ladrillo, intenta de nuevo");
ok=F;
}
else ok=V;
}
while (ok==F);
/* Resuelve el laberinto desde la entrada: (xe,ye) */
ok = recorrer(xe,ye);
if (ok==F)
/* Si no se pudo resolver se envia un mensaje */
printf("\nLaberinto sin solucion\n");
desplegar();

/* Despliega el laberinto resuelto (con el camino) */

system("pause");
}