Práctica 8

Fundamentos de Informática. Primer Curso de Ingenieros Industriales
Práctica 8
Vectores, Cadenas y Matrices en C
Introducción
En esta práctica se pretende que el alumno practique el uso de vectores, cadenas de
caracteres y matrices en lenguaje C mediante un conjunto de ejercicios que deberá completar
parcialmente.
La práctica se realizará empleando el compilador Dev-C++ que ya fue descrito en el primera
práctica del cuatrimestre.
Desarrollo de la práctica
Al igual que en la práctica anterior, le proponemos ahora que trate de resolver las cuestiones
que a continuación se le plantean, todas ellas relacionadas con los contenidos que se
pretenden poner en práctica en esta ocasión.
Para ayudarle en la realización de las cuestiones se le proporciona una parte de código para
facilitarle el planteamiento de la solución.
La práctica se compone de 3 ejercicios diferentes. Para cada ejercicio se le proporciona el
molde de un programa que deberá completar con su código.
IMPORTANTE:
•
Debe respetar la estructura que se le propone sin omitir ninguna línea de código.
•
Una vez finalizados los ejercicios deberá entregar la solución a través del servidor de
docencia tal como se explica al final de este enunciado.
1
Fundamentos de Informática. Primer Curso de Ingenieros Industriales
Cuestión 1
Complete el código que se muestra a continuación para obtener el producto de dos matrices
dadas. Se pide que realice la multiplicación de matrices empleando dos funciones con
diferentes prototipos: la función multmat1 recibe las matrices como tablas bidimensionales de
tamaño fijo, mientras que la función multmat2 las recibe como un vector linealizado por filas.
A continuación se proporciona un programa de ejemplo que muestra el uso de estas funciones:
#include<stdio.h>
#define N 50
void multmat1(float A1[N][N],float B1[N][N],float resu1[N][N],int
filA,int colA,int colB);
void multmat2(float *A2,float *B2,float *resu2, int filA,int colA,int
colB);
main()
{
int
int
int
int
int
i,j;
filA=2;
colA=3;
filB=colA; /*Necesario para tener dimensiones compatibles*/
colB=2;
/*Declaración matrices método 1 */
float A1[N][N]={{1,2,3},{4,5,6}};
float B1[N][N]={{1,2},{3,4},{5,6}};
float resu1[N][N];
/*Declaración matrices método 2 */
float A2[N*N]={1,2,3,4,5,6};
float B2[N*N]={1,2,3,4,5,6};
float resu2[N*N];
/* Multiplicación método 1*/
multmat1(A1,B1,resu1,filA,colA,colB);
printf("\nResultado multiplicacion 1\n\n");
for(i=0;i<filA;i++)
{
for(j=0;j<colB;j++)
printf("%5.2f\t",resu1[i][j]);
printf("\n");
}
/* Multiplicación método 2*/
multmat2(A2,B2,resu2, filA,colA,colB);
printf("\nResultado multiplicacion 2\n\n");
for(i=0;i<filA;i++)
{
for(j=0;j<colB;j++)
printf("%5.2f\t", resu2[i*colB+j]);
printf("\n");
}
getch();
}
2
Fundamentos de Informática. Primer Curso de Ingenieros Industriales
El objetivo es proporcionar la definición de ambas funciones.
void multmat1(float A1[N][N],float B1[N][N],float resu1[N][N],int
filA,int colA,int colB)
{
/***************** ESCRIBA AQUÍ SU SOLUCIÓN **********/
/*****************************************************/
}
void multmat2(float *A2,float *B2,float *resu2,int filA, int colA,int
colB)
{
/***************** ESCRIBA AQUÍ SU SOLUCIÓN **********/
/*****************************************************/
}
3
Fundamentos de Informática. Primer Curso de Ingenieros Industriales
Cuestión 2
Complete el código que se muestra a continuación, y que tiene por objeto manipular una
cadena de caracteres que se introduce por teclado. El programa debe tomar dicha cadena y
transformarla de modo que cada palabra del texto aparezca invertida, pero respetado el orden
de las palabras. Es decir:
Si la cadena de caracteres introducida fuese “Esto es una prueba” el resultado
proporcionado será “otsE se anu abeurp”
El texto procesado debe depositarse en la misma cadena origen que pasa como argumento.
#include <stdio.h>
void inviertetexto(char *);
main()
{
int i;
char texto[100]; /*Espacio para el texto a tratar. Máximo N
caracteres*/
printf("\nIntroduzca texto a procesar: ");
gets(texto);
inviertetexto(texto);
printf("\nEl texto invertido es: %s\n",texto);
getch();
}
void inviertetexto(char *texto)
{
int p1,p2;
int i,cont;
char aux;
cont=0 ;
/***************** ESCRIBA AQUÍ SU SOLUCIÓN **********/
/*****************************************************/
}
4
Fundamentos de Informática. Primer Curso de Ingenieros Industriales
Cuestión 3
El SUDOKU (en japonés, “números solos”) es un pasatiempo en el que se trata de rellenar un
cuadrado de 9x9 con números del 1 al 9. El cuadrado está formado a su vez por 3 subcuadrados de 3x3 casillas. Un Sudoku ya resuelto (es decir, con todas las casillas rellenas con
algún número del 1 al 9) es correcto si no hay ningún número repetido en cada una de las
columnas, filas y sub-cuadrados del mismo. El objetivo de los siguientes apartados es diseñar
una función en C, tal dado un Sudoku resuelto se determine si es correcto o no. El Sudoku está
almacenado en un vector de 81 componentes en el que se encuentran (ordenados por filas) los
números correspondientes a cada casilla. Para diseñar esta función se divide el problema en 5
funciones que resuelven una parte independiente.
0
1
2
3
4
5
6
7
8
0
1
5
2
3
4
5
6
7
8
8
1 3
3
1 2
4
6
4
1
4
3
1
2 4
3
1 2
4
6
9
8
3
4
Apartado 1
Desarrollar una función tal que dado un Sudoku resuelto y una casilla definida por su fila y
columna (suponemos que la primera fila y la primera columna se indican con el número
cero) comprueba si el número de esa casilla número se repite más de una vez en la fila a la
que pertenece. La función debe devolver “0” si el número de la casilla se repite más de una
vez. En caso contrario devuelve un “1”.
int sud_fil(int * M, int i, int j)
{
/***************** ESCRIBA AQUÍ SU SOLUCIÓN **********/
/*****************************************************/
}
Apartado 2
Desarrollar una función tal que función que dado un Sudoku resuelto y una casilla definida
por su fila y columna (suponemos que la primera fila y la primera columna se indican con el
número cero) comprueba si el número de esa casilla se repite más de una vez en la
columna a la que pertenece. La función debe devolver “0” si el número de la casilla se repite
más de una vez. En caso contrario devuelve un “1”.
int sud_col(int * M, int i, int j)
{
/***************** ESCRIBA AQUÍ SU SOLUCIÓN **********/
/*****************************************************/
}
5
Fundamentos de Informática. Primer Curso de Ingenieros Industriales
Apartado 3
Desarrollar una función tal que función que dado un Sudoku resuelto y una casilla definida
por su fila y columna (suponemos que la primera fila y la primera columna se indican con el
número cero) comprueba si el número de esa casilla se repite más de una vez en el subcuadrado al que pertenece. La función debe devolver “0” si el número de la casilla se repite
más de una vez. En caso contrario devuelve un “1”.
int sud_sub(int * M, int i, int j)
{
/***************** ESCRIBA AQUÍ SU SOLUCIÓN **********/
/*****************************************************/
}
Apartado 4
Desarrollar una función tal que función que dado un Sudoku resuelto y una casilla definida
por su fila y columna (suponemos que la primera fila y la primera columna se indican con el
número cero) comprueba si el número de esa casilla cumple todas las condiciones para que
el Sudoku sea correcto. La función debe devolver “0” si el número de la casilla se repite más
de una vez en la fila, la columna o el sub-cuadrado a los que pertenece o si no está
comprendido entre 1 y 9 (no cumple alguna condición). En caso contrario devuelve un “1” (si
cumple todas las condiciones). Esta función puede usar las funciones diseñadas
anteriormente.
int sud_cas(int * M, int i, int j)
{
/***************** ESCRIBA AQUÍ SU SOLUCIÓN **********/
/*****************************************************/
}
Apartado 5
Desarrollar una función tal que función que dado un Sudoku resuelto comprueba si es
correcto. La función debe devolver “0” si alguna casilla se repite más de una vez en la fila, la
columna o el sub-cuadrado a los que pertenece o si no está comprendida entre 1 y 9 (no
cumple alguna condición). En caso contrario devuelve un “1” (todas las casillas cumplen
todas las condiciones). Esta función puede usar las funciones diseñadas anteriormente.
int sud(int * M)
{
/***************** ESCRIBA AQUÍ SU SOLUCIÓN **********/
/*****************************************************/
}
6
Fundamentos de Informática. Primer Curso de Ingenieros Industriales
Nota: Para resolver este problema es importante poder comprobar que cada función esta
diseñada correctamente. A continuación se proporciona un programa de ejemplo que se
puede usar para realizar esta comprobación.
#include<stdio.h>
int sud_fil(int *
int sud_col(int *
int sud_sub(int *
int sud_cas(int *
int sud(int * M);
M,
M,
M,
M,
int
int
int
int
i,
i,
i,
i,
int
int
int
int
j);
j);
j);
j);
void main(void)
{
/*Sudoku resuelto (cambiarlo para probar diferentes casos)*/
int res;
int sudoku[81] = {1,4,5,3,2,7,8,9,6,
2,4,5,3,2,7,8,9,6,
3,4,5,3,2,7,8,9,6,
4,4,5,3,2,7,8,9,6,
5,4,5,3,2,7,8,9,6,
6,4,5,3,2,7,8,9,6,
7,4,5,3,2,7,8,9,6,
8,4,5,3,2,7,8,9,6,
9,4,5,3,2,7,8,9,6} ;
/*Comprueba si el elemento de la primera fila, segunda columna
es correcto*/
res = sud_cas(sudoku,0,0);
printf("%d \n",res);
/*Comprueba si el elemento de la primera fila, segunda columna
esta repetido en su columna */
res = sud_fil(sudoku,0,0);
printf("%d \n",res);
/*Comprueba si el sudoku es correcto*/
res = sud(sudoku);
printf("%d \n",res);
getch();
}
7
Fundamentos de Informática. Primer Curso de Ingenieros Industriales
Entrega de la práctica a través del servidor
Los resultados de todas la práctica se entregará usando el Servidor de Docencia. Para el
correcto funcionamiento de las siguientes páginas su navegador debe permitir cookies y la
ejecución de javascript. El servidor de docencia se encuentra situado en la siguiente dirección
http://bono.us.es/sdocencia/
La entrega de la práctica consiste en copiar el código de cada cuestión que se encuentra entre
las dos líneas de comentarios (en rojo) en el cuadro de respuestas correspondiente del
Servidor de Docencia. Hay que copiar el código una vez se haya comprobado el correcto
funcionamiento del programa.
Cada apartado tiene un espacio asignado dónde copiar el código correspondiente. Solo hay
que copiar el código que se encuentra entre las dos líneas de comentarios del molde
proporcionado en el enunciado.
Es especialmente importante que siga estas instrucciones si quiere que la práctica sea
evaluada apropiadamente.
8