Carátula para entrega de prácticas

Facultad de Ingeniería Laboratorio de docencia

Laboratorios de computación
salas A y B
Profesor: M.I. Edgar Tista García

Asignatura: Estructura de Datos y Algoritmos 1

Grupo: 01

No de Práctica(s): 03

Integrante(s): Cote Valencia Alexis Daniel

No. de Equipo de Personal

cómputo empleado:

No. de Lista o Brigada: 11

Semestre: 2021-2

Fecha de entrega: 11 de Junio de 2021

Observaciones:

CALIFICACIÓN:
__________
Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

Objetivos del Laboratorio:

Utilizarás estructuras en lenguaje C para modelar tipos de dato abstracto e
implementarlos en las estructuras de datos lineales.
Objetivos de Clase:

ACTIVIDAD 1
Código de la guía de Laboratorio “Nodo Película”

Figura 1.1 Fragmento del código Nodo Película

Figura 1.2 Ejecución exitosa del código Nodo Película

Este código lo que hace es, en primer lugar crear una estructura llamada pelicula
para poder almacenar cadenas de caracteres y variables numéricas enteras, acto
seguido declara una función sin retorno (void) encargada de imprimir los datos a
almacenar de la estructura anterior, después se define una estructura de tipo
película (en este punto el código original tenía un error, se trataba de declarar una
estructura de tipo nodo, la estructura nodo no existía en ninguna parte por lo que al
momento de compilar el código mostraba error, para corregir eso se borraba la
palabra nodo y en su lugar agregábamos la palabra película); a continuación
comienza la función principal en la que se dan, por parte del mismo código, el
Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

nombre de los directores, en seguida se iguala la estructura película a la estructura

llenarDatosPelicula en la cual se reciben parámetros de entrada del tipo que se
encuentra en la primera estructura; ya dentro de la estructura llenarDatosPelicula lo
que se hace es declarar una variable de tipo película para poder ir almacenando los
datos de entrada que recibe la estructura llenarDatosPelicula.
Hecho lo anterior se llama a la función ImprimirDatosPelicula (de tipo void) la cual
se encargará de mostrarnos los datos almacenados en la estructura película; al
código original se le agregó la biblioteca stdlib.h para hacer uso de las funciones
del sistema (cls y pause) y darle una mejor presentación al archivo ejecutable,
también se agregaron, en ASCII, los caracteres especiales necesarios para una
impresión de pantalla adecuada.
ACTIVIDAD 2
Código de la guía de Laboratorio “Pila de Películas”

Figura 2.1 Fragmento del código Pila de Películas

Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

Figura 2.2 Ejecución exitosa el código Pila de Películas.

La finalidad de este código es prácticamente el mismo que el anterior, la diferencia

es que en este solamente se define una estructura llamada película, se definen dos
funciones (llenarArreglo e imprimirArreglo) y que el código no nos da la información
a almacenar, sino que nos pide a nosotros que ingresemos los datos de 2 películas,
para ellos en la función principal se define un arreglo de tipo película, acto seguido
hace llamado a la función llenarArreglo (de tipo void) en el que se va llenando con
un for la información de ambas películas; el inconveniente que tenía este código es
que si querías ingresar una película de dos palabras y/o su género de dos palabras
también, sólo leía la primera palabra y los siguientes datos se los saltaba por lo que
al imprimir las cosas imprimía la palabra faltante de película/género en los siguientes
espacios (vea Figura 2.3), para solucionar este problema se implementó el fgets y
al compilarlo pudimos ingresar palabras/géneros de más de una palabra; el mismo
problema lo tiene la parte de ingresar el nombre del director, lamentablemente esa
situación no se pudo llegar a una resolución. Por último, después de agregar los
datos, se llama a la función imprimirArreglo (de tipo void) para mostrar en pantalla
los datos de cada película iniciando por la 2da película; al igual que el anterior código
se hizo uso de la biblioteca stdlib.h para hacer uso de las funciones del sistema
(cls y pause) además de que se ocupó código ASCII para imprimir los caracteres
especiales de algunas palabras.
Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

Figura 2.3 Ejecución del código original Pila de Películas

ACTIVIDAD 3
Código de la práctica 1 “Ejercicio 1”

Figura 3.1 Fragmento de código del Ejercicio 1

Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1
Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

Figura 3.2 Ejecución exitosa del código del Ejercicio 1

En este código la finalidad es que el alumno, además de poner en práctica lo

aprendido en clase, pues hacer uso de las estructuras para poder ingresar datos
correspondientes a las mismas, esto mediante funciones; además de que debe ser
capaz de tener un nivel de abstracción para poder hacer listas con diferentes
aspectos.
A diferencia de los códigos anteriores, que eran un reto para su análisis pese que
ya estaban codificados, este resultó ser un mayor reto en la parte de su elaboración
y en la forma en que el alumno lo iba desarrollando parte por parte para llegar a su
ejecución exitosa; el código está comprendido en un total de 275 líneas de código,
5 estructuras, 9 funciones (incluyendo la función principal), 1 while, 1 switch, 11
ciclos for, ocupamos 12 veces recursividad, se ocuparon alrededor de 50
variables para poder lograr el objetivo deseado del ejercicio.
La primera parte que se realizó fue definir las estructuras en el orden correcto, de
tal manera que al momento de compilar el código y ejecutarlo no existiera error
alguno en la asignación de valores y uso de variables de tipo estructuras, las
estructuras necesarias son para almacenar los datos de los Militares, la siguiente
estructura es para almacenar los datos del Batallon (además contiene un arreglo
del tipo Militares), después una estructura en que la que se almacenará los datos
de la Division (además contiene un arreglo tipo batallón); también se declararon
otras 2 estructuras, una para poder almacenar el total de soldados por división
(Batallones) y otra para almacenar el total de batallones por división (division)
además de contener un arreglo de tipo Batallones. Hecho eso se inició por la función
principal (y conforme avanzábamos en el código íbamos declarando las funciones
Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

necesarias) en la que se declaró una variable de tipo entero para poder almacenar
el total de divisiones deseadas (divisiones_totales), también se declaró un arreglo
de tipo entero para poder ir almacenando el total de cada sección
total_datos_ingresados igualada a 0 (total de divisiones en la posición 0, total de
batallones en la posición 1 y el total de militares en la posición 2) y se declaró una
variable de tipo carácter para almacenar la opción a escoger en el menú de
opciones; cuando se almacena el total de divisiones a crear (divisiones_totales), en
seguida se crean dos arreglos, uno de tipo Division nombrado divisiones con
extensión del número de divisiones a rear y otro de tipo division nombrado
arreglo_almacenar con la misma extensión del anterior, el primer arreglo sirve para
poder ingresar a las distintas variables en las que se almacenarán los datos de los
militares, divisiones y/o de batallones, mientras que el segundo arreglo sirve para
almacenar las cantidades de soldados en cada batallón y las cantidades de
batallones en cada división; antes de ir la siguiente función igualamos
total_datos_ingresados[0] a la suma de total_datos_ingresados[0] con
divisiones_totales para tener un conteo de cuántas divisiones se han creado.
Acto seguido lo que se hace es llamar a una función denominada crearDivisión en
la que tendrá como parámetros de entradas los arreglos previamente mencionados
(el arreglo divisiones, el arreglo arreglo_almacenar y el arreglo
total_datos_ingresados) junto con la variable de tipo entero (divisiones_totales), ya
dentro de esta nueva función lo que se hace como primer paso es declarar otras 2
variables de tipo entero (un contador para un for “contador_divisiones” y uno para
almacenar el total de batallones “batallones_ingresar” en la División en la que nos
encontraremos con el for) y dos arreglo de tipo carácter en el que se almacenará el
nombre de la División (nombre_division) y su zona (Zona_division), igualamos el
arreglo total_datos_ingresados[1] a la suma de total_datos_ingresados[1] más
batallones_ingresar para tener un recuento de los batallones totales; iniciamos el
ciclo for con el contador igualado a cero aumentando en una unidad después de
cada ciclo hasta ser menor a divisiones_totales, en este for se iba preguntando los
datos respectivos a la División en la que nos encontrábamos y, al ser cadenas de
caracteres los datos a guardar, los almacenábamos en primera instancia en los
arreglos de caracteres mencionados anteriormente junto con la ayuda de las
funciones setbuf (sirve para limpiar el buffer de la terminal y no reconozco el primer
enter ingresado antes de la línea para almacenar en la variable) y fgets (nos permite
guardar una cadena de caracteres con espacios hasta encontrar un salto de línea)
para después, con la función strcpy, almacenarlos en la estructura según como
fuera necesario (divisiones[contador_divisiones].Zona por ejemplo); después de
haber almacenado los datos de la División se pregunta al usuario cuántos batallones
tendrá dicha división, el valor se almacena en la variable batallones_ingresar y en
el último renglón del for se llamó a una nueva función para crear los batallones
respectivos (crearBatallon), sus parámetros de entrada es la variable
batallones_ingresar, el contador contador_divisiones, el arreglo divisiones, el
arreglo arreglo_almacenar, el arreglo total_datos_ingresar.
Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

En la función crearBatallon lo primero que se hace es declarar dos variables de

tipo entero (contador_batallones y militares_ingresados) junto con dos arreglos de
tipo carácter (categoria_batallon y ubicacion_batallon), luego nos dirigimos a un
ciclo for en el que tendrá el contador_batallones iniciado en cero aumentando en
una unidad hasta ser menor a batallones_ingresar y dentro del for se preguntarán
los datos necesarios del Batallón, el primer dato es un dato numérico el que se
almacena directamente en la variable respectiva de la estructura Batallon, esto
mediante la asignación de la siguiente forma:
divisiones[contador_divisiones].batallon[contador_batallones].clave_identificacion
Dónde divisiones[contador_divisiones] hace referencia a la división en la que nos
encontramos, batallón[contador_batallones] apunta al batallón que estamos
modificando; los siguientes datos son cadenas de caracteres, para ello realizamos
lo mismo que se hizo en la función crearDivision pero con los arreglos
categoria_batallones y ubicacion_batallon para almacenarlos de la siguiente
manera (divisiones[contador_divisiones].batallon[contador_batallones].ubicacion
por ejemplo), en seguida se pregunta al usuario cuántos militares desea agregar en
el batallón actual y la respuesta la almacenamos en la variable militares_ingresados;
al final del for se llama a una nueva función llamada crearMilitar que tendrá como
parámetros de entrada militares_ingresados, contador_batallones,
contador_divisiones, divisiones, arreglo_almacenar.
En esta nueva función declaramos una variable entera contador_militares, junto con
2 arreglos de tipo carácter (Nombre_Militar y Grado_Militar); pasamos a un for
iniciando en contador_militares igual a 0 aumentando de una unidad hasta ser
menor a militares_ingresados y dentro de este for se preguntan los datos de los
militares, el primer dato a ingresar es la matrícula del militar (de tipo entero y se
almacena de la siguiente manera
divisiones[contador_divisiones].batallon[contador_batallones].militar[contador_milit
ares].matricula_militar) donde divisiones[contador_divisiones] hace referencia a la
división en la que nos encontramos, batallones[contador_batallones] que nos indica
en qué batallón nos encontramos y por último militar[contador_militares] nos apunta
al militar en el que estamos llenando sus datos. Para la parte de grado militar y del
nombre, siendo estos datos de tipo cadena de carácter, recurriremos a los mismos
pasos ocupados en las funciones anteriores (setbuf, fgets, strcpy) y los
almacenamos en sus respectivas variables
divisiones[contador_divisiones].batallon[contador_batallones].militar[contador_milit
ares].grado_militar (por ejemplo).
Terminado todo el llenado de los datos de las secciones del ejército (divisiones,
batallones, militares) nos regresamos a la función principal dónde se entrará a un
ciclo while en el que se imprimirá el menú con 6 opciones:
Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

a) Mostrar Divisiones - Se mostrarán el total de las Divisiones seguido de cada

división existente siendo numeradas, mostrando el nombre por división junto
con su Zona (Sur, Norte, Este, Oeste, Noreste, Sureste, etc.).
b) Mostrar Batallones – Se mostrará el total de Batallones existentes, en
seguida se imprimirán los batallones por División mostrando también la clave
de identificación del batallón, la categoría del mismo (infantería de Marina,
Artillería Pesada, etc.) y por último su ubicación (Centro de la República,
Moscow Rusia, etc.).
c) Mostrar Militares – Se mostrará el total de Militares existentes, en seguida se
imprimirán los militares por batallón de cada división mostrando en pantalla
la matrícula del militar, el nombre del mismo y el grado del militar (Cadete,
Cabo, Teniente Coronel, etc.).
d) Asignar Militar a Batallón – Nos permite agregar un militar a un batallón,
siendo este último seleccionado por el usuario y seleccionando la división en
la que se encuentra el batallón.
e) Asignar Batallón a División – Nos permite agregar un batallón a una división,
siendo seleccionada por el usuario, además de que se debe incluir militares
al batallón.
f) Salir – Termina el programa cerrándolo al final con un return 0.
En la parte de mostrar divisiones se llama una función llamada mostrarDivisiones
que tiene como parámetros de entrada divisiones_totales, divisiones,
total_datos_ingresados, arreglo_almacenar. Al inicio se declara una función de tipo
entero denominada mostrar_Divisiones la cuál nos servirá como contador, en
seguida se imprimen el total de Divisiones mediante la posición 0 del arreglo
total_datos_ingresados, después se usa un ciclo for iniciando en mostrar_Divisiones
igual a cero, aumentando en una unidad después de cada ciclo hasta llegar a ser
menor a divisiones_totales, dentro del for lo que se hace es imprimir los datos de
cada división mediante las variables del arreglo divisiones
(divisiones[mostrar_Divisiones].Nombre_division) dónde la variable
mostrar_divisiones servirá como índice del arreglo para poder desplazarnos en las
divisiones; una vez terminada la función, mediante el while se regresa a la parte del
menú para que el usuario haga nuevamente su selección.
En la opción de mostrar Batallones llama a una función llamada mostrar_Batallones
que tiene como parámetros de entrada divisiones_totales, divisiones,
total_datos_ingresados, arreglo_almacenar, y al inicio de la función se crean dos
variables de tipo entero mostrar_Divisiones y mostrar_Batallones, después lo que
se hace es imprimir el total de divisiones creadas mediante la posición uno del
arreglo total_datos_ingresados; acto seguido se ingresan a dos ciclos for, uno que
tiene como contador la variable mostrar_Divisiones iniciada en cero aumentando en
una unidad después de cada ciclo for hasta ser menor al número de
divisiones_totales, este for sirve para poder moverse dentro de la divisiones, el
segundo for tiene como contador la variable mostrar_Batallones iniciada en cero
Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

aumentando en una unidad hasta ser menor

arreglo_almacenar[mostrar_Divisiones].total_batallones (esta variable contiene el
total de Batallones por división, esto para hacer la impresión de batallones de
manera más precisa) para ir imprimiendo los datos de cada batallón por división
mostrando el número de batallón en la que nos encontramos y la división;
terminados los dos ciclos for y la función, el programa nos regresa al menú de
opciones.
En la opción de mostrar militares lo que se hace es mandar a llamar una nueva
función con nombre mostrarMilitares la cual recibe como parámetros de entrada
divisiones_totales, divisiones, total_datos_ingresados, arreglo_almacenar; al inicio
lo que se hace es declarar tres variables de tipo entero mostrar_Divisiones,
mostrar_Batallones, mostrar_Militares, éstas variables nos servirán de contadores
para los tres ciclos for que requerimos, pero antes de entrar a esa parte se imprimirá
una leyenda con los totales de militares existentes (sin importar el batallón en el que
se encuentren o la división); el primer for tendrá como contador la variable
mostrar_Divisiones inicializada en cero aumentando en una unidad hasta ser menor
divisiones_totales, el siguiente for tendrá como contador a la variable
mostrar_Batallones inicializada en cero aumentando en una unidad hasta ser menor
a arreglo_almacenar[mostrar_Divisiones].total_batallones (con el valor de la
variable encontrada en la posición actual de “mostrar_Divisiones” en el
“arreglo_almacenar” podemos ver el total de batallones en la división en la que nos
encontramos), por último en el tercer ciclo for tendrá como contador a la variable
mostrar_Militares inicializada en cero aumentando en una unidad hasta ser menor
arreglo_almacenar[mostrar_Divisiones].nuevos_batallones[mostrar_Batallones].nu
evos_soldados (esta última variable nos permiete ingresar a cada soldado den los
batallones de cada división) ya dentro del tercer for se imprimirán los datos de los
militares indicando el número del militar seguido del número del batallón al que
pertenece y al último el número de la división en el que se encuentra el batallón.
Una vez que termine todo lo anterior el programa nos permite regresar al menú para
poder escoger otra opción.
En la opción de Agregar Batallón a División lo que se hace es dirigirnos a una nueva
función llamada agrarBatallónADivision la cual tiene como parámetros de entrada
divisiones, arreglo_almacenar, total_datos_ingresados; primero se declaran 5
variables de tipo entero (agregar_batallon, nuevo_batallon, agregar_militar,
batallones_nuevos, n=1) y otros 2 arreglos de tipo carácter (nombre_Batallon y
ubicación_Batallon), después le preguntamos al usuario en qué división desea
agregar el nuevo batallón (el número 1, 2, 3, etc.) una vez realizado eso lo
almacenamos en la variable agregar_batallon, luego al número ingresado le
restamos una unidad (esto porque, como bien sabemos, C inicia todos sus arreglos
en la casilla 0 por lo tanto si el usuario elige la División 2, en realidad estará
escogiendo la posición 1 de arreglo_almacenar dónde se encuentra dicha División),
después lo que se hace es preguntar la cantidad de batallones que desea agregar
Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

el usuario a esa división y el número lo guardamos en la variable batallones_nuevos

para luego sumárselo a arreglo_almacenar[agregar_batallon].total_batallones que
es dónde se almacena el total de batallones en cada división (en este caso en el
batallón de la posición agregar_batallon), después agregamos a la variable
nuevo_batallon la cantidad de batallones de la división sin antes haberle agregado
la cantidad de batallones_nuevos, al arreglo total_datos_ingresar[1] le sumamos
batallones_nuevos esto para indicar que se están agregando nuevos batallones; en
seguida entramos a un ciclo for con contador nuevo_batallon aumentando en una
unidad hasta ser menor a arreglo_almacenar[agregar_batallon].total_batallones
(esto quiere decir que mientras el total de batallones que existían antes sea menor
al total de batallones que existen ahora, después de haber sumado los batallones
que se quieren agregar, el for se repetirá) dentro del for lo que hace es preguntar
los respectivos datos del batallón y los almacena en las variables correspondientes
(tal como se hizo en la función de crearBatallones) usando como índices
agregar_batallon y nuevo_batallon, acto seguido lo que hace es preguntar cuántos
soldados tendrá dicho batallón y la cantidad es almacenada en la variable
agregar_militar para que al final llame nuevamente a la función crearMilitar teniendo
con parámetros de entrada agregar_militar, nuevo_batallon, agregar_batallon,
divisiones, arreglo_almacenar y con esto poder agregar militares. Una vez
terminado todo eso nos regresa al menú principal y si escogemos la opción de
Mostrar Batallones/Mostrar Militares veremos en pantalla los Batallones/Militares
anteriormente creados junto con los agregados recientemente.
Al escoger la opción de Agregar Militar a Batallón lo primero que hace es dirigirnos
a una función con este nombre (agregarMilitarABatallon) que tiene como
parámetros de entrada divisiones, arreglo_almacenar, total_datos_ingresados, al
inicio de la función lo que hace es declarar 5 variables de tipo entero
(agregar_a_batallon, agregar_nuevo_militar, nuevos_militares, nuevo_militar, k=1)
estos para utilizarlos como contadores, como índices o para almacenar información,
también se crearán dos arreglos de tipos entero (nombre_nuevo_militar,
grado_nuevo_militar); hecho lo anterior lo que se hace es preguntar al usuario en
qué División va a agregar al militar y lo almacenamos en la variable
agrar_a_batallon, después preguntamos a qué batallón pertenecerá el militar para
almacenar el número en la variable agregar_nuevo_militar, en seguida
preguntaremos cuántos militares desea agregar el usuario y lo almacenamos en la
variable nuevos_militares; acto seguido lo que hacemos es, en número de militares
nuevos lo sumamos al arreglo total_datos_ingresados[2] que se encarga de llevar
registro de cuántos militares existen también ese número lo sumamos al arreglo
arreglo_almacenar[agregar_a_batallon].nuevos_batallones[agregar_nuevo_militar]
.nuevos_soldados que se encarga de llevar un registro de cuántos militares por
batallones y por divisiones existen, y antes de entrar al ciclo for igualamos el total
de militares (del batallón en el que queremos agregar militares) a la variable
nuevo_militar; el for tendrá como contador esta última variable que irá aumentando
en una unidad hasta ser menor a
Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

arreglo_almacenar[agregar_a_batallon].nuevos_batallones[agregar_nuevo_militar]
.nuevos_soldados, dentro del for lo que se hará es preguntar los datos respectivos
del militar y se almacenarán en las variables como se hizo en la función crearMilitar
sólo que se usa como índice las variables agregar_a_batallon,
agregar_nuevo_militar, nuevo_militar y una vez concluido todo lo anterior nos
regresa al menú de opciones, si escogemos la parte de Mostrar Militares aparecerán
en pantalla el nuevo número de militares totales junto con todos los militares
anteriormente creados y los nuevos militares creados señalando el batallón en el
que se encuentran y su respectiva división.
Para finalizar si se escoge la opción Salir lo que hará será cerrar el programa por
completo y si selecciona cualquier otra opción no mencionada en el menú le pedirá
de favor que escoja una de las ya establecidas regresándolo al menú.
Cote Valencia Alexis Daniel Grupo 1 Estructuras de Datos y Algoritmos 1

CONCLUSIONES
Toda la práctica presento ser un verdadero reto en todos sus aspectos, en primer
lugar por la parte del tema visto (estructuras) ya que no es un tema nada fácil de
comprender debido a que se necesita un gran nivel de abstracción para poder saber
como relacionar las estructuras con los datos que deseamos almacenar además de
cómo podemos relacionarlos con otras funciones o hacer uso de la recursividad en
otras estructuras.
Por otro lado la comprensión de los códigos del manual de prácticas (de la guía de
laboratorio) fue en cierta forma complicado, esto debido a que no se explicaba a
fondo qué era lo que se quería lograr o cuál era su objetivo a cumplir además de
que al momento de declarar varias variables y cambiarles el nombre dentro de las
funciones el alumno se llegaba a confundir, por otro lado al momento de ejecutar el
segundo código se encontró con un error de declaración debido a que decía que no
existía el arreglo “nodo” cosa que no comprendía a qué se refería y al momento de
buscar en libros de programación y en internet logré saber que nodo se llamaba a
una “estructura recursiva” y pude hacer el cambio necesario sin embargo pienso yo
que estaría bien que el profesor explicara eso en la clase o algunos que otros
conceptos que los libros manejan con otro nombre.
En la parte del código del ejercicio dejado por el profesor desde mi punto de vista
fue excelente ya que nos obligó a usar mucho nuestro razonamiento al igual que
nos obligaba a tener un pensamiento abstracto de cómo se relacionaban los datos,
por ejemplo para un batallón puede existir n-militares pero para un militar sólo existe
una división, para una división existen n-batallones que a su vez existen n-militares
pero por cada militar existe un batallón y por cada batallón existe un militar; esta
forma de ver la relación entre datos, si no me equivoco, la ocupan en la materia de
Base de Datos por lo que nos ayuda a ir forjando nuestras habilidades para esa
clase.
Por otro lado desde mi punto de vista el tiempo que nos dejó el profesor, suponiendo
que el paro de labores no se hubiese acatado o no se hubiese dado, era
extremadamente poco debido a que simplemente el tiempo de análisis de cómo
debe funcionar el programa y de cómo tengo que relacionar los datos llevaba
bastante tiempo y, para que después de implementarlo hubiera un error o el camino
que se siguió para resolver el problema no fuera el más optimo o el correcto, que al
final nos marcara error el compilador o nos diéramos cuenta que no sirve como
nosotros esperábamos por lo que desde mi punto de vista hubiera sido mejor dejar
dos semanas de trabajo.
En la parte de los objetivos de clase y los objetivos de laboratorio se cumplieron en
su totalidad sin problema alguno, además de que hemos ido implementando todo lo
aprendido durante el curso y durante la materia de Fundamentos de Programación