CI 2126 Práctica 3 Solución pdf

Texto completo

(1)Universidad Simón Bolívar Departamento de Computación y Tecnologías de la Información CI2126 Computación II. Solución de la Práctica 3: Recursión 1 ) Escriba una función recursiva en C que invierta una cadena de caracteres. Solución I (Método 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; } Solución II (Recursividad de Cola) #include <stdio.h> #include <string.h> void reverse(char*, int, int);.

(2) 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); } Solución 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 palíndrome si se cumple que al invertirlo se obtiene la misma secuencia de caracteres. Escriba la definición recursiva y una función en lenguaje C que retorne TRUE si p es un palídrome y FALSE en caso contrario..

(3) #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 función recursiva que verifique si S2 se encuentra en S1. En caso de encontrarse devuelva la posición dentro del string S1 donde comienza S2 en caso contrario devuelva el mensaje "No encontrado".. 4) Escriba una función iterativa y otra recursiva que convierta un número decimal a binario..

(4) #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 función iterativa y otra recursiva en C que multiplique dos matrices (a*b), donde a es de tamaño (n*m) y b es de tamaño (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;.

(5) 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]);.

(6) } } } 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 función recursiva para calcular el Máximo Común Divisor (MCD) de dos números n1 y n2, utilizando la siguiente definición :  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. .

(7) #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) {.

(8) 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; }.

(9) 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 tamaño mxn como la posición i,j que contiene al mínimo valor de la fila i que corresponde al máximo 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 posición 2,2 (mínimo valor de la fila 2 que corresponde al máximo valor de la columna 2). Escriba una función en C que.

(10) 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. }, }, }, }, }, }, }, }, }, }, }, }, }. Además debe recibir una posición (i,j) que refleja la posición 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 través 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. */ */ */ */ */.

(11) /* 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) {.

(12) 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 también * 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. */.

(13) /* 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"); }.

(14)