Carátula para entrega de prácticas

Facultad de Ingeniería Laboratorios de docencia

Laboratorio de Computación
Salas A y B

Profesor: Sáenz García Elba Karen

Asignatura: Estructura de Datos Y Algoritmos 1

Grupo: 4

No de Práctica(s): 4

Integrante(s): Dionicio Juárez Agustín

Reyes Castillo Christian

Palacios Cacique Esteffany Abigail

Ávila Sánchez Eduardo Benjamín

No. de Equipo de
cómputo empleado:

Semestre: 2 semestre

Fecha de entrega: 20 de agosto 2018

Observaciones:

CALIFICACIÓN: ________________
Introducción:

Cuando un programa se ejecuta sobre un sistema operativo existe un proceso previo llamado cargador que
suministra al programa un bloque contiguo de memoria sobre el cual ha de ejecutarse. El programa resultante
de la compilación debe organizarse de forma que haga uso de este bloque. Para ello el compilador incorpora
al programa objeto el código necesario. Las técnicas de gestión de la memoria durante la ejecución del
programa difieren de unos lenguajes a otros, e incluso de unos compiladores a otros. En este capítulo se
estudia la gestión de la memoria que se utiliza en lenguajes procedurales como FORTRAN, PASCAL, C,
MODULA-2, etc. La gestión de la memoria en otro tipo de lenguajes (funcionales, lógicos,...) es en general
diferente de la organización que aquí se plantea.

Como ya hemos visto el lenguaje de programación C posee la capacidad de poder asignar nuevos espacios
de memoria para variables bidimensionales, como los arreglos de caracteres el cual en momentos que el
programa se ejecuta no se sabe con certeza cuanto espacio ocupara una cadena de caracteres , dando así la
posibilidad de asignar memoria al arreglo , re dimensionar y posteriormente a liberarlo.
En este punto nos centraremos en las matrices dinámicas las cuales pueden cambiar su tamaño en tiempo de
ejecución si el usuario lo desea, esto es válido para arreglos unidimensionales, bidimensionales,
tridimensionales o multidimensionales. Teniendo en cuenta que las matrices bidimensionales son tablas con
las coordenadas (X,Y) pudiendo crecer tanto en las coordenadas X como en las Y, y en tridimensionales con
coordenadas cambiantes en (X,Y,Z) o multidimensionales con más coordenadas de tablas. Nos centraremos
en las bidimensionales que son las más útiles ya que se usa para el manejo de tablas con coordenadas (X,Y)
que varían en tiempo de ejecución.
Un arreglo de una dimensión es usado para representar elementos en una lista o secuencia de valores. En
algunos casos la relación entre elementos del arreglo no puede representarse en forma de lista. Un arreglo de
2 dimensiones es usado para representar elementos en una tabla con columnas y filas, se puede acceder a
cualquier elemento dentro del arreglo indicando el índice de la columna y la fila del arreglo.

Objetivos:

1. Utilizarás funciones en lenguaje C que permiten reservar y almacenar información de manera dinámica (en
tiempo de ejecución).

Desarrollo:

Actividad 1 (Para realizar en laboratorio)

Escribir un programa en ANSI C que encripte y desencripte una cadena de texto en mayúsculas introducida por la
entrada estándar, se debe indicar desde la entrada estándar el tamaño de la cadena para formar en tiempo de ejecución
un arreglo de caracteres.

La función main() debe tener la siguiente estructura:

main(){
char *texto;

int tamText;

printf("Introduce numero de caracteres a cifrar"); scanf("%d",&tamText);

texto=formacad(tamText); cifrar(texto,tamText);

printf("Texto cifrado %s",texto); descifrar(texto,tamText); printf("Texto Descifrado %s",texto); free(texto);

El encriptado consiste en hacer un desplazamiento de los caracteres como se muestra en la figura.

Para ello se puede sumar 5 a los caracteres de A- U, a-u y después para los caracteres de V-Z v.z restar 21 cada.

Ejercicio 1:Codigo

#include<stdio.h>

#include<stdlib.h>

char *formacad(int n);

void cifrar(char *text, int n);

void descifrar(char *text, int n);

int main ()

char *texto;

int tamText;

printf("Introduce numero de caracteres a cifrar:\n");

scanf("%d", &tamText);

texto=formacad(tamText);

cifrar(texto,tamText);

printf("Texto Cifrado: %s\n", texto);

descifrar(texto,tamText);

printf("Texto Descifrado: %s\n", texto);

free(texto);
 }

char *formacad(int n)

char *texto;

texto=(char*)malloc(n*sizeof(char));

printf("Introduce texto a cifrar\n");

scanf("%s", texto);

printf("Tu texto es: %s\n",texto);

return (texto);

void cifrar(char *text, int n)

int x;

for (x=0; x<n; x++)

if((*(text+x)>='A'&& *(text+x)<='U')||(*(text+x)>='a'&& *(text+x)<='u'))

*(text+x)+=5;

if((*(text+x)>'U'&& *(text+x)<='Z')||(*(text+x)>'u'&& *(text+x)<='z'))

*(text+x)-=21;

void descifrar(char *text, int n)

{

int x;

for (x=0; x<n; x++)

if((*(text+x)>='A'&& *(text+x)<='U')||(*(text+x)>='a'&& *(text+x)<='u'))

*(text+x)-=5;

if((*(text+x)>'U'&& *(text+x)<='Z')||(*(text+x)>'u'&& *(text+x)<='z'))

*(text+x)+=21;

Actividad 2 (Para realizar en laboratorio):

Elaborar un programa en ANSI C contenga una función que sume todos los elementos de un arreglo bidimensional de n
elementos formado en tiempo de ejecución. Debe existir también una función que forme el arreglo y otra que libere el
espacio en memoria.

La función main debe contener lo siguiente:

main() {

int n;

double *arreglo, suma;

printf(“Introduce el valor de n”); scanf(“%d”,&n);

arreglo=formaArreglo(n) sumaElementos(arreglo,n,&suma);

printf(“\nEl resultado de la suma es %lf”, suma); liberarArreglo(arreglo);

2:Codigo:

#include<stdio.h>

#include<stdlib.h>

double **formaArreglo(int n);

void sumaElementos(double **arreglo, int n, double *suma);

void liberarArreglo(double **p, int n);

main (){

int n;

double *arreglo, suma;

printf("Introduce el valor de n:\n");

scanf("%d", &n);

arreglo=formaArreglo(n);

sumaElementos(arreglo, n, &suma);

printf("El resultado de la suma es: %lf\n", suma);

liberarArreglo(arreglo, n);

double **formaArreglo(int n)
{

int i, j;

double **p;

p=(double**)calloc(n,sizeof(double*));

for (i=0; i<n; i++)

*(p+i)=(double*)malloc(n*sizeof(double));

for (j=0; j<n; j++)

*(*(p+i)+j)=2;

return p;

void sumaElementos(double **p, int n, double* suma)

int i, j;

for (i=0; i<n; i++)

for (j=0; j<n; j++)

*suma += *(*(p+i)+j);

void liberarArreglo(double **p, int n)

{
int i;

for (i=0; i<n; i++)

free(p[i]);

Actividad 3 (Para entregar en el reporte);

Elaborar un programa que multiplique elemento a elemento los números complejos en forma guardados en dos
arreglos unidimensionales de n elementos y almacenarlos en un tercero. Los arreglos se deben formar en tiempo de
ejecución y se debe utilizar una estructura para definir un tipo de dato complejo.

En el main() solo se deben hacen llamadas a funciones, es decir el llenado, la multiplicación , la impresión de los tres
arreglos y la liberación de memoria se hace mediante funciones.

Actividad 3: Código

#include<stdio.h>

#include<stdlib.h>

struct cis{

float radio;

float teta;

};

struct cis* Comp(int n);

struct cis multiComp(struct cis *p,int n);

void liberarComp(struct cis *p,int n);

int main(){

int n;

struct cis *comp, operacion;

printf("Cuantos complejos deseas usar?\n");

scanf("%d", &n);

comp = Comp(n);

operacion = multiComp(comp,n);

printf("La multiplicacion de los complejos es: %f CiS %f\n", operacion.radio, operacion.teta);

liberarComp(comp,n);

struct cis *Comp(int n){

int x;

struct cis *p;

p=(struct cis*)malloc(n*sizeof(struct cis));

if(p==NULL){

printf("No se creo espacio en memoria\n");

return p;

for(x=0;x<n;x++){

printf("Introduzca el radio de Z%i\n",x+1);

scanf("%f", &(p+x)->radio);

printf("Introduzca el angulo de Z%i(radianes)\n",x+1);

scanf("%f", &(p+x)->teta);

return p;

struct cis multiComp(struct cis *c,int n){

int x;

struct cis p;
for(x=0;x<n;x++){

p.radio *= (c+x)->radio;

p.teta += (c+x)->teta;

return p;

void liberarComp(struct cis *p,int n){

free(p);

Actividad 4 (Para entregar en el reporte):

Se requiere realizar el producto de dos matrices, de tal manera que estas sean formadas en tiempo de ejecución,
además deben existir en el main() la llamada a las funciones formaMatriz(), llenaMatriz(), multiplicaMatrices() y
MuestraMatriz()

No olvidar en el reporte agregar, el desarrollo (enunciados) con sus códigos y capturas de pantalla y conclusiones
individuales. Subir a la plataforma su reporte y sus códigos fuente de sus soluciones.

Actividad 4: Código

#include<stdio.h>

#include<stdlib.h>

float* formaMatriz(int n);

void llenaMatriz(float *matriz,int n);

float* multiplicaMatrices(float *a, float *b,int n);

void muestraMatrices(float *matriz,int n);

main(){

float *a,*b,*c;

int n;

printf("Bienvenido\nInserte el orden de las matrices NxN\n");

scanf("%i",&n);

a = formaMatriz(n);

llenaMatriz(a,n);

b = formaMatriz(n);
llenaMatriz(b,n);

printf("\n");

c = multiplicaMatrices(a,b,n);

printf("Las matrices son:\n");

muestraMatrices(a,n);

muestraMatrices(b,n);

printf("La matriz resultante es:\n");

muestraMatrices(c,n);

float* formaMatriz(int n){

float *matriz;

matriz = (float*)malloc(n*n*sizeof(float));

if(matriz == NULL)

printf("Advetencia, no se creÛ espacio en memoria\n");

return matriz;

void llenaMatriz(float *matriz,int n){

int x=0,y=0;

for(x=0;x<n;x++)

for(y=0;y<n;y++){

printf("Dame el dato [%i][%i]\n",x,y);

scanf("%f",(matriz+(x*n)+y));

float* multiplicaMatrices(float *a, float *b,int n){

float *matriz;

int x,y,z;

matriz = (float*)malloc(n*n*sizeof(float));

if(matriz == NULL)
printf("Advetencia, no se creÛ espacio en memoria\n");

for(x=0;x<n;x++)

for(y=0;y<n;y++){

*(matriz+(x*n)+y) = 0;

for(z=0;z<n;z++)

*(matriz+(x*n)+y) += (*(matriz+(x*n)+z))*(*(matriz+(z*n)+y));

return matriz;

void muestraMatrices(float *matriz,int n){

int x,y;

for(x=0;x<n;x++){

for(y=0;y<n;y++)

printf("%.2f\t",*(matriz+(x*n)+y));

printf("\n");

printf("\n\n");

Conclusiones:

Reyes Castillo Christian:

Al realizar la práctica primero hubo complicaciones ya que ara esta utilizamos Linux y fue un poco complicado
al principio entender sus comandos, se reforzó lo visto en clase como reservar espacios en memoria a través
de los apuntadores, utilizamos números complejos, matrices con su llenado, sumado, liberado respectivo,
utilizamos nuevamente arreglos bidimensionales y ciframos, desciframos un texto con características
específicas, una práctica un poco larga, pero buena para reforzar el conocimiento visto en clase.

Dionicio Juárez Agustín:

En esta práctica se ha presentado la técnica de la optimización de código, como un medio de mejora del
código objeto producido por un compilador. Dicha mejora va a ser evaluada en una reducción del tamaño de
código objeto generado y, sobre todo, en una mayor velocidad de ejecución del programa objeto. Una vez
presentados los diversos tipos de optimización que se pueden presentar en un compilador, se ha dedicado
una especial atención al análisis global de las ecuaciones de flujo de datos. Hubo algunas complicaciones en
el laboratorio debido a que se trabajó en Linux

Palacios Cacique Esteffany Abigail:

Durante esta práctica reforcé lo anterior visto en clase como son las reservas de memoria en tiempo de
ejecución ocasionando que nuestro programa sea más eficiente y eficaz.

Ávila Sánchez Eduardo Benjamín:

Se vio nuevamente Linux, sus comandos, sé reforzo mucho casi todos los temas vistos en clase y se
emplearon de una manera muy específica y se usó la memoria en tiempo de ejecución además de temas
como matrices, etc., una práctica larga, pero eficiente para que los programas sean más compactos y
eficientes.