Final Algoritmos y Estructura de Datos 2-12-06

Una empresa de ferrocarriles desea realizar un programa que arme las formaciones de los
trenes que va a necesitar para la temporada que viene. Para ello cuenta con un archivo de vagones
disponibles, con el siguiente diseño:

1.1 código de vagón ( longint)

1.2 tipo de vagon (‘C’: comedor, ‘P’: pulman, ‘T’: turista, ‘M’: coche cama)

La necesidad a cubrir es de 8 formaciones, enumeradas de 1 a 8, dispuestas de la siguiente manera:

3 formaciones cada una con un vagon comedor, 2 vagones pulman y 3 vagones turista

3 formaciones cada una solamente con 6 vagones turista

2 formaciones cada una con un vagon comedor, 3 vagones pulman y 2 vagones coche cama

Se pide desarrollar la representación gráfica de un algoritmo que grabe un archivo solo si se

puede satisfacer lo solicitado, donde en las formaciones deben ir primero los vagones tipo pulman,
seguido por el vagón comedor y luego los restantes, con el siguiente diseño:

a.1 número de formación

a.2 tipo de vagon a.3 código de vagón
a.4 tipo de vagon a.5 código de vagón
a.6 tipo de vagon a.7 código de vagón
a.8 tipo de vagon a.9 código de vagón
a.10 tipo de vagon a.11 código de vagón
a.12 tipo de vagon a.13 código de vagón

 Recursos y Restricciones:

Utilizar procedimientos y funciones en el desarrollo del algoritmo

Optimización: dado que el uso de ciclos afecta el tiempo de ejecución de un proceso, se
evaluará la eficiencia en el uso de los mismos.

Memoria para arrays: 32 bytes.

Memoria para estructuras dinámicas: 56 nodos x 9 bytes

Memoria en disco: lugar suficiente para el nuevo archivo

Accesos a disco: un solo acceso a cada registro de los archivos

Utilizar nombres significativos para los identificadores, dibujo de las estructuras a utilizar
rotulando cada elemento, tamaño, breve leyenda de cómo se generan y estado inicial, respetar
esos nombres para utilizarlos en el algoritmo.

Observaciones
Letra clara, trazo fuerte y tamaño apreciable para que lo pueda leer un tercero.
Escribir una carilla por hoja rotulando c/u. de ellas con su Apellido, Nombre y Nro. Página x de y.

Duración del examen: 1 hora

 Estructuras

Matriz[8*4] formación * tipo de vagones donde cada elemento es un contador de vagones de ese
tipo en esa formación 8 * 4 * 1 byte = 32 bytes

Tipo de vagón
Pulman Comedor Turista Camarote
1 2 3 4
1 2 1 3 0
2 2 1 3 0
Formación

3 2 1 3 0
4 0 0 6 0
5 0 0 6 0
6 0 0 6 0
7 3 1 0 2
8 3 1 0 2
byte byte byte byte

Lista de formación con sublista de vagones

Lista Número Puntero a sublista Sgte 8 nodos de 9 bytes c/u

formación vagones Lista ordenada por número de formación
1 byte 4 bytes 4 bytes

Sublista vagones ordenado según criterio se pide orden

Tipo de vagon o Código vagon Sgte.
columna matriz
1 byte 4 bytes 4 bytes
6 Nodos de 9 bytes en cada de sublista

Total de nodos (8 de la lista + 8 * 6 de sublista)= 56 nodos de 9 bytes c/u

Estrategia
• Asignar y abrir archivos
• Inicializar matriz con valores y formatear lista con de 8 con número de formación de 1 a, e
inicializar un contador con el valor 48
• Recorrer archivo de vagones mientras no sea fin de archivo y el contador no llegue a 0
o Leer registro
o Determinar columna según tipo de vagon leido
o Recorrer columna de la matriz buscando algún elemento > 0 y determinar fila
 Si lo encuentra decrementar el elemento, decrementar el contador, e insertar
vagón en la sublistalista que cuelga del nodo que tenga nro. de formación igual
a la fila determinada, según orden pedido (número de columna)
• Si el contador = 0
o Recorrer lista y sublista armando un registro por cada formación y grabar. Liberar
nodos
• Cerrar archivos
• Fin
 Final Algoritmos y Estructura de Datos 7-03-06

Una entidad financiera desea mejorar los tiempos de los programas que realizan consultas a las
transacciones monetarias de sus clientes. Cuenta con un archivo maestro de transacciones MAETRANS.dat,
ordenado cronológicamente, con el siguiente diseño:

a.1 Cuit del cliente a.2 Otros datos a.3 posición al registro de la a.4 posición al registro de la
( longint ) ( 100 caracteres ) transacción anterior del cliente. transacción siguiente del cliente.
Inicialmente posee un valor -1 Inicialmente posee un valor -1
(longint) (longint)

Se solicita desarrollar la metodología necesaria para implementar un programa que actualice los
campos posición al registro de la transacción anterior y siguiente (campos a.3 y a.4) del archivo maestro, de tal
manera que las transacciones de un mismo cliente queden enlazadas entre sí cronológicamente. El campo
anterior de la primera transacción y el campo siguiente de la última transacción de cada cliente deberán
contener el valor -1.
Eejmplo:
Archivo antes del proceso Archivo después del proceso
n° reg Cuit Otros datos Ant sgte n° reg Cuit Otros Datos Ant Sgte
0 1111 *********** -1 -1 0 1111 *********** -1 2
1 3333 *********** -1 -1 1 3333 *********** -1 5
2 1111 *********** -1 -1 2 1111 *********** 0 3
3 1111 *********** -1 -1 3 1111 *********** 2 7
4 2222 *********** -1 -1 4 2222 *********** -1 6
5 3333 *********** -1 -1 5 3333 *********** 1 -1
6 2222 *********** -1 -1 6 2222 *********** 4 8
7 1111 *********** -1 -1 7 1111 *********** 3 -1
8 2222 *********** -1 -1 8 2222 *********** 6 -1

Desarrolle y utilice el procedimiento

InsertarClaveOrdenadaEnArray(Var Vector:Tvector;Var N:byte; Clave:longint; Var I: byte; Var Bol:

boolean);

donde el procedimiento recibe como parámetros un array de registros, la cantidad de elementos que contiene
información válida, y un campo Clave del mismo tipo que la clave del registro del array, busque y/o inserte sin
repetición la clave en el registro del array ordenado ascendente por el campo Clave del registro. Retorne los
parámetros actualizados, la posición donde lo encontró o donde lo insertó, y el parámetro Bol en true si lo
encontró, y false si fue insertado.

 Recursos, Restricciones y Observaciones:

Duración del examen: 1 hora 30 minutos

Programa Principal: debe constar solamente de invocaciones a módulos.

Optimización: siendo que el uso de ciclos afecta el tiempo de ejecución de un proceso, se
evaluará la eficiencia en el uso de los mismos.

Cantidad máxima de clientes: 2000

Memoria para arrays: 16.000 bytes.

Memoria para estructuras dinámicas: 0 bytes

Memoria en disco: sin disponibilidad.

Accesos a disco: Dos accesos para lectura y dos accesos para grabar a cada registro del archivo
maestro.

Utilizar nombres significativos para los identificadores, dibujo de las estructuras a utilizar rotulando
cada elemento, tamaño, breve leyenda de cómo se generan y estado inicial, respetar esos nombres para
utilizarlos en el algoritmo. Letra clara, fuerte y tamaño apreciable para que lo pueda leer un tercero.
Escribir una carilla por hoja rotulando en c/u. de ellas su Apellido, Nombre y Nro. Página x de y.
Estructura de datos

Array de cuit de cliente

1 Cuit del cliente Campo posición para ir almacenando las
(longint) posiciones intermedias a los registros de las
transacciones del cliente en el archivo
maestro (longint)
2
.
.
2000
4 bytes 4 bytes

2000 * (4+4) = 2000*8 = 16.000 bytes

Estrategia
• Asignar y abrir archivo
• Inicializar en 0 (cero) tope de array de clientes
• Inicializar una variable posicionaleer en 0 (cero)
• Recorrer secuencialmente archivo MAETRANS.dat
o Leer registro
o Invocar procedimiento InsertarClaveOrdenadaEnArray con registro.cuit
o Si la variable boolean está en false y según la ubicación del cliente en el array
o Asignar al campo posición del array el valor de la variable posicionaleer
o Si la variable boolean está en true y según la ubicación del cliente en el array
o Al campo anterior del registro leído asignarle el valor del campo posición del array
o Ejecutar un seek al archivo con el valor de posicionaleer
o Grabar el registro
o Ejecutar un seek al archivo con el valor del campo posición del array
o Leer el registro
o Al campo siguiente del registro leído asignarle el valor de la variable posicionaleer
o Ejecutar un seek al archivo con el valor del campo posición del array
o Grabar el registro
o Al campo posición del array asignarle el valor de la variable posicionaleer
o Incrementar posicionaleer
o Ejecutar un seek al archivo con el valor de posicionaleer
• Cerrar archivo
• Fin
 Final Algoritmos y Estructura de Datos 21-02-06

Una empresa constructora cuenta con información de sus necesidades mensuales de materiales para sus
proyectos en ejecución, las cuales surgen de los cálculos de cada uno de los mismos. Tal información está
contenida en los siguientes archivos:
a) NECEMAT.DAT, agrupados sus registros por Código de Proyecto no ordenados, en cada registro están
la/las cantidades que se necesitan de cada material en el proyecto, con el siguiente diseño:

a.1 a.2 a.3 18 campos consecutivos con las cantidades necesarias de cada mes
Código de Proyecto Código de Material a.3.1 cantidad a.3.2 cantidad a.3.18 cantidad
……
( 5 caracteres ) ( 10 caracteres ) necesaria del Mes1 necesaria del Mes2 necesaria del Mes 18
…..
(word) (word) (word)
Los campos con las cantidades necesarias pueden conterner un 0 (cero) si ese mes no está prevista la compra de
ese material, o un valor mayor a 0 (cero) sí está previsto. Los proyectos no tienen una duración mayor de 18
meses, cada uno tiene su propia duración en meses y su fecha de inicio, a partir de la cual se considera el Mes
1, Mes2, …., Mes n, siendo n los meses de duración del proyecto.

b) PROYECT.DAT, ordenado por Código de Proyecto, con un registro por cada uno de sus no más de 100 proyectos en
ejecución, con el siguiente diseño:

b.1 Código de Proyecto b.2 Meses de Duración b.3 Fecha de Inicio b.4 Otros Datos
( 5 caracteres ) ( 1..18 ) ( ddmmaaaa ) ( 95 caracteres )
Todos los Proyectos tienen en el archivo de necesidades de materiales (NECEMAT.DAT) su correspondiente
conjunto de registros.

Se solicita desarrollar la metodología necesaria para implementar un programa que:

1) Emita un listado correspondiente al mes de la fecha de proceso, ordenado por Código de Proyecto y
Código de Material (ascendente en ambas claves), discriminando los materiales a comprar para cada
proyecto en ese mes, con el siguiente formato:
Listado de Compras correspondiente al Mes mm/aaaa
Código de Proyecto XXXXX
Código de Material Cantidad
XXXXX 99999
XXXXX 99999
2) Emita un segundo listado, para el departamento de Compras, con los materiales a comprar para todos los
proyectos, ordenado ascendente por Código de Material, con la cantidad TOTAL de cada material, según el
siguiente formato:
Compras Totales por Material a realizar en el Mes mm/aaaa
Código de Material Cantidad
XXXXX 99999
XXXXX 99999
3) Para el desarrollo del algoritmo:

Aplicar el procedimiento de Pascal Getdate (anio,mes,dia,diasem) para la obtención de la fecha
del sistema , donde los parámetros son de tipo word.

Desarrollar y aplicar una función que retorne la cantidad de meses transcurridos entre la fecha
de inicio del proyecto y la fecha de proceso.
NumeroDeElemento ( FechaInicioProyecto, FechaProceso: longint ): byte;
 Recursos, Restricciones y Observaciones:
Programa Principal: debe constar solamente de invocaciones a módulos. Optimización: siendo que el uso
de ciclos afecta el tiempo de ejecución de un proceso, se evaluará la eficiencia en el uso de los
mismos. Memoria para arrays: 1100 bytes. Memoria para estructuras dinámicas: 300 * nodo de 17 bytes
* 100. Teniendo en cuenta que todos los proyectos pueden necesitar hasta 300 materiales distintos, optimice el
uso de este recurso, liberando espacio antes de ocupar nuevo, cuando se estime necesario. Memoria en disco:
sin disponibilidad. Accesos a disco: Un acceso a cada registro de ambos archivos para lectura. Utilizar
nombres significativos para los identificadores, dibujo de las estructuras a utilizar rotulando cada
elemento, tamaño, breve leyenda de cómo se generan y estado inicial, respetar esos nombres para
utilizarlos en el algoritmo. Letra clara, fuerte y tamaño apreciable para que lo pueda leer un tercero.
Escribir una carilla por hoja rotulando en c/u. de ellas su Apellido, Nombre y Nro. Página x de y.
Estructura de datos

Array de Proyectos
1 CodigoProyecto NumeroElemento Lista
VectorMeses Lista de materiales a comprar en cada proyecto según mes del proceso
2
lista ordenada ascendente por código de material
.
CodigoMaterial Cantidad necesaria del mes de Sgte.
.
proceso
100
11 bytes 2 byte 4 bytes
6 bytes byte 4 bytes Nodo lista 17 bytes

100 * (6+1+4) = 100 bytes

ListaConCantidadesAcumuladas
lista ordenada ascendente por código de material
CodigoMaterial Acumulado de cantidades Sgte.
necesarias del mes de proceso
11 bytes 2 byte 4 bytes
Nodo lista 17 bytes
Estrategia

• Asignar y abrir archivos

• Obtener fecha de proceso
• Recorrer secuencialmente archivo PROYECT.DAT y por cada registro:
o Invocar funcion que calcula el número de elemento según fecha de proceso y fecha del proyecto
o Almacenar en array de proyecto código de proyecto, valor que retorna la función, e inicializar
puntero a la lista ( insertar ordenado por código de proyecto o almacenar y luego ordenar)
• Recorrer secuencialmente archivo NECEMAT.DAT con corte de control por código de proyecto y
por cada registro leido:
o Buscar código de proyecto en array ( una sola vez según corte de control)
o Por cada registro que corresponda al mismo proyecto ubicarse en el array de cantidades
necesarias del registro leído utilizando como índice el número de elemento. Si la cantidad es
mayor a cero armar nodo y colgar del array de lista.
• Recorre array, por cada proyecto recorrer lista de materiales, suprimir los nodos, emitir listado 1. Por
cada nodo suprimido buscar código de material en la segunda lista si existe el material acumular
cantidad de lo contarrio crear un nuevo nodo (o utilizar nodo anterior sin supresión) y almacenar
información.
• Recorre la segunda lista y emitir listado del punto 2, liberando los nodos
• Cerrar archivos
• Fin
 Final Algoritmos y Estructura de Datos 06-12-05

El zoológico de la Ciudad de Bs. As. cuenta con el siguiente archivo que contiene información de los
zoológicos del mundo y de la Argentina.
a) ZOOMUNDO.DAT, ordenado ascendente por código de zoológico, con un registro por cada especie que se encuentra
en cada zoológico del mundo con el siguiente diseño:
a.1 código de zoológico ( 7 caracteres) a.2 código especie-animal ( 9 dígitos)

Los códigos de los zoológicos y de las especies son determinados internacionalmente y se utilizan para su
reconocimiento con las siguientes reglas:
• El primer carácter del código de zoológico corresponde al continente: ‘F’: África, ‘A’: América, ‘S’:
Asia, ‘E’: Europa, ‘O’: Oceanía.
• El último dígito del código de la especie es un cero si este código se refiere a una especie en extinción.
El código que corresponde al zoológico de la Ciudad de Bs. As. es ‘AARGCBA’.
Esta entidad solicita desarrollar la metodología necesaria para implementar un programa que:
1. Emita el siguiente listado ordenado por código de especie ascendente, con las especies faltantes en el
zoológico de la Ciudad de Bs.AS, y liste los zoológicos del mundo y de nuestro país que puedan proveer
estas especies faltantes.
Se consideran especies faltantes:
 Aquellas que nuestro zoológico no tiene, pero existen en otros zoológicos.
Faltantes de especies del Zoológico de la Ciudad de Bs. As.
Código de especie: 999999999
Código de zoológico con especie existente
xxxxxxx
xxxxxxx
Código de especie: 999999999
Código de zoológico con especie existente
xxxxxxx
xxxxxxx

2. Grabar un archivo ESPEXTIN.DAT con un registro por cada especie en extinción, máximo 100,
incluyendo a la Argentina, con el siguiente diseño:

2.1 código especie-animal en extinción ( 9 dígitos) 2.2.1 cantidad total de la especie en África (byte)
2.2.2 cantidad total de la especie en América (byte) 2.2.3 cantidad total de la especie en Asia (byte)
2.2.4 cantidad total de la especie en Europa (byte) 2.2.5 cantidad total de la especie en Oceanía (byte)

3. Utilice una función que dada una cadena de caracteres retorne el primer carácter de la misma:
Function Continente(cadena:Tstring10):char;

Recursos, Restricciones y Observaciones:

ZOO_MUNDO = {x / x es zoológico del mundo}.
ZOO_BA = {AARGCBA} (zoológico de la Ciudad de Buenos Aires).
ESP_BA = {x / x es especie de ZOO_BA}.
ZOO_RESTO = ZOO_MUNDO – ZOO_BA.
ESP_RESTO = {x / x es especie de ZooResto}.
k = Cantidad de registros de ZOOMUNDO.DAT ∈ ZOO_BA
• Memoria para estructuras dinámicas:
#ESP_BA nodos x 8 b. + [#ESP_RESTO + (fileSize(ZOOMUNDO) – k)] nodos x 12 b.
Es decir, Cantidad de especies del Zoo de la Ciudad de Bs. As por nodos de 8 bytes + ( Cantidad de especies
del Resto del Mundo + Cantidad de registros de ZOOMUNDO - Cantidad de registros pertenecientes a la
Ciudad de Bs. As) por nodos de 12 bytes
• Memoria para arrays: 900 bytes. • Accesos a disco: Un solo acceso a cada registro del archivo.
Utilizar nombres significativos para los identificadores, dibujo de las estructuras a utilizar rotulando cada
elemento, tamaño, breve leyenda de cómo se generan y estado inicial, respetar esos nombres para utilizarlos en
el algoritmo. Letra clara, fuerte y tamaño apreciable para que lo pueda leer un tercero. Escribir una carilla por
hoja rotulando en c/u. de ellas su Apellido, Nombre y Nro. Página x de y.
Estructuras de datos

Lista de especies con sublista de zoológico del mundo excepto Bs. As.

ListaMundo Código Puntero a sublista Sgte Nodo lista 12 bytes ordenada por especie
especie zoológico
NODO1 4 bytes 4 bytes 4 bytes

Sublista zoologicos no se pide orden

Código de zoológico Sgte.
8 bytes 4 bytes
Nodo2 de sublista 12 bytes

Lista de especies del zoológico de la ciudad de Bs. As.

ListaBA lista especies de CBA ordenada por especie

Código de especie Sgte.
4 bytes 4 bytes
Nodo lista 8 bytes

Array de especies en extinción

1 Cod especie Cant África Cant América Cant Asia Cant Europa Cant Oceanía
2
.
.
100
longint byte byte byte byte byte

100 * (4+1+1+1+1+1) = 900

También se podría utilizar un array de 100 especies con una matriz de 100*5 para contener las cantidades de los
5 continentes

Estrategia

• Asignar y abrir archivos

• Inicializar puntero a listaMundo y listaBA, inicializar array de especies en extinción
• Recorrer secuencialmente archivo de Zoológicos y por cada registro
o Si el zoológico es ‘AARGCBA’ insertar especie en listaBA
o De lo contrario buscar e insertar especie y zoológico en listaMundo
o Si la especie del registro leído esta en extinción cargar especie en array de registro sin repetición
y contar según continente, invocando a la función
• Apareo de listaBA con listaMundo por código de especie
o Si el código de especie de la listaMundo es menor a la especie de la listaBA listar nodos de la
sublista según diseño punto 1 y avanzar en listaMundo
o Si el código de las especies de ambas lista son iguales avanzar en ambas lista
o Si el código de especie de la listaMundo es mayor a la especie de la listaBA avanzar en listaBA
• Recorrer array de registros de especies en extinción y grabar archivo del punto 2
• Liberar listas y sublistas
• Cerrar archivos
• Fin
 Final de Algoritmos y Estructura de Datos 04/03/05

Una empresa fabrica varios productos y cada producto lleva una gama de colores pintados (máximo
10 colores diferentes ). La empresa dispone de pinturas de varios colores en su almacén y un mismo
color está disponible para varios productos. Se desea obtener la información necesaria para comenzar
con el proceso de pintura. La información disponible se encuentra en los siguientes archivos:

A. PRODUCCION.DAT: con los datos de los productos a pintar, sin ningún orden, y cada
producto tiene tantos registros como su gama de colores (máx.10 colores), con el siguiente diseño
de registro:
A1) Código de producto ( 6 dígitos ) A2) Código de color ( 8 caracteres )
B. ALMACEN.DAT: con los datos de la disponibilidad de pinturas en el almacén, pueden no
encontrarse todos los colores, sin ningún orden, no son más de 200 colores, con el siguiente diseño
de registro:
B1) Código de color ( 8 caracteres )

Se pide: Diseñar las estructuras, la estrategia y el algoritmo del programa que permita:
1) Desarrolle y aplique la función CantidadIgualColores(ListaA,ListaB:tlista) : byte; que retorne
la cantidad de nodos de la ListaA cuya información sea exactamente igual a la información de
los nodos de la listB.

2) Emita un listado con los productos que se puedan empezar a pintar (se puede empezar a pintar
un producto si se dispone en el almacén de por lo menos uno de los colores que lleva el
producto), ordenado descendente por cantidad de colores disponibles en el almacén, con el
siguiente formato
LISTADO DE PRODUCTOS PARA EMPEZAR A PINTAR
Códigos de Productos con 10 colores disponibles en el almacén

999999
999999
Códigos de Productos con 9 colores disponibles en el almacén
999999
............................................................................................................

Códigos de Productos con 1 color disponible en el almacén

999999
999999
3) Generar un archivo GAMASIGUALES.DAT con un registro por cada combinación de
colores que se repitió en forma exacta entre los distintos productos, con el siguiente registro:

3.1) GamaColores ( 10 elementos de tipo String[8] )

Si la gama de colores es inferior a 10 completar los elementos con carácter blanco
Ejemplo: rojo, azul, verde = azul, verde, rojo <> rojo, verde, azul, amarillo

Recursos, Restricciones y Observaciones :

Memoria estática: 40 bytes para arrays.
Memoria para estructuras dinámicas: nodos máximo de 14 bytes.
Memoria en disco: suficiente para generar el archivo GAMASIGUALES.DAT.
Accesos a disco: solo 1 acceso a cada registro de los archivos disponibles.
Utilizar nombres significativos para los identificadores, dibujo de las estructuras a utilizar rotulando cada
elemento, tamaño, breve leyenda de cómo se generan y estado inicial, respetar esos nombres para utilizarlos en
el algoritmo. Escribir una carilla por hoja rotulando en c/u de ellas su Apellido, Nombre y Nro.Página x de y.
Lista de colores ordenada por código de color nodo de 13 bytes

Codigo color 8 Puntero sgte

caract 9 bytes 4 bytes

Lista de productos nodos de 13 bytes ordenada por cod de producto

Sublista ordenada por código de color

Cod de prod Cant de nodos sublista Puntero Puntero sgte

longint 4bytes 1 byte sublista 4 bytes 4 bytes

Codigo color 8 Sgte sublista

caract 9 bytes 4 bytes

Array de pilas para ordenar productos por cantidades de colores disponibles en el almacén (punto 2) 4 bytes x10
elementos = 40 bytes, nodo de 8 bytes

1 Pila 4 bytes
2 Codigo producto longint 4 Sgte sublista 4 bytes
bytes
3
.
.
10.
.

• Recorrer arhivo de almacén y por cada registro insertar un nodo en la lista de colores, ordenada
por color.
• Recorre archivo de productos y por registro buscar e insertar nodo en lista de productos
(ordenada por código de producto), incrementar en nodo de produtco contador de nodos de
sublista e insertar subnodo de color en sublista del producto ordenada por color.
• Para el punto 2 recorrer lista de productos y por cada nodo:
o Invocar función cantidadigualcolores con puntero a sublista del producto y puntero a
lista de colores
o Si la cantidad de iguales es distinta a cero insertar producto en array de pila según
cantidad de iguales ( valores posibles de 1 a 10)
o Avanzar sgte nodo de producto
• Una vez finalizado el proceso recorrer array , sacar nodos de las pilas y listar según diseño
punto 2
• Para el punto 3 recorrer lista de productos y por cada nodo:
o Inicializar señal de gamas iguales
o Recorrer a partir del nodo siguiente hasta el final de la lista
o buscar nodos de productos que contenga las misma cantidad de subnodos que el nodo
inicial e invocar a la función cantidadigualcolores con la sublista del nodo inicial y la
sublista del nodo que encontre.
o Si las condiciones se cumplen dejar una señal de gama de colores repetidas y eliminar
nodo de producto encontrado con su sublista
o Avanzar al siguiente nodo, si llegue al final de la lista y la señal de gamas de colores
repetidas esta encendida armar registro del archivo punto 3 y grabar
o Volver a comenzar el proceso desde el siguiente nodo
• Fin.

Nota:
 Para el punto tres es indistinto eliminar los nodos de la lista de productos y sublista de colores
de los que fueron procesados, o dejar una marca para no volver a procesar ese producto (por ejemplo
código de producto negativo), o en el nodo del producto declarar un campo más con una marca que
indica que su gana de colores ya fue analizada y grabada.
 Final Algoritmos y Estructura de Datos 3-12-04

El Departamento de Sistemas de UTN requiere de un proceso para verificar las solicitudes de excepciones
de correlatividades de materias de 5to año de la carrera Ingeniería en Sistemas de Información. Las solicitudes
son aceptadas si la materia solicitada pertenece a 5to año, y al alumno le faltan solo 30 hs/semanales de
cursada para finalizar la carrera. El alumno puede solicitar excepción para una única materia, de lo
contrario todas sus solicitudes son rechazadas. Para ello se cuentan con los siguientes archivos:

a) MATERIAS: desordenado, máximo 60 registros, en donde cada registro representa una materia de la
carrera.
a.1) Código materia (longint) a.2) Nombre de la materia (30 car.)
a.3) Horas por semana (byte) a.4) Año de la materia (byte)

b) ANTECEDENTES: ordenado por Legajo del alumno, con un registro por legajo, con el siguiente diseño:
b.1) Legajo (longint) b.2) Otros datos (150 caracteres)
b.3) información sobre las 40 materias de la carrera
b.3.1) Codigo de materia (longint) b.3.2) aprobó trabajos prácticos o aprobó final ( ‘T’, ‘F’ o un blanco)
b.3.3) Codigo de materia (longint) b.3.4) aprobó trabajos prácticos o aprobó final ( ‘T’, ‘F’ o un blanco)
........................................................... ...................................................................................................................
b.3.79) Codigo de materia (longint) b.3.80) aprobó trabajos prácticos o aprobó final ( ‘T’, ‘F’ o un blanco)

c) SOLICITUDES: desordenado, donde cada registro representa una solicitud de excepción de correlatividad,
con el siguiente diseño.
a.1) Número de expediente (10 caracteres) a.2) Legajo (longint) a.3) Código materia (longint)

d) Tope de horas cursadas que el alumno necesita para recibirse, que se ingresará una sola vez por teclado

Se pide realizar la metodología necesaria para desarrollar un programa que:

1) Desarrollar y aplicar un procedimiento Observaciones que reciba como parámetro un número de
observación (1..4) y devuelva un parámetro de tipo string de 50 caracteres que contenga alguno de las siguientes
leyendas según la observación: 1:‘Materia solicitada no pertenece a 5to año’, 2:‘Faltan mas de 30 horas de
cursada’, 3:‘Legajo con más de una solicitud’, 4:‘Legajo erroneo’.

2) Desarrollar y aplicar la función HorasCursadas que recibe como parámetros la estructura que contiene la
información de las materias de la carrera, y el registro del archivo de Antecedentes de un alumno y retorna la
cantidad de horas que el alumno lleva cursada de tipo word.

3) Emita un listado con los legajos de las solicitudes aceptadas con el siguiente diseño:
Solicitudes Aceptadas
N° Expediente Legajo
xxxxxxxxxx 999999999

4) Grabe un archivo de Observaciones con el siguiente diseño y ordenado por legajo:

4.1) Número de expediente (10 caracteres) 4.2) Legajo (longint) a.3) Mensaje de Observación (50 caracteres)

Recursos, restricciones:
Mem. estática p/arreglos: 600 bytes. Mem. en disco: suficiente para el archivo de Observaciones. Se permite
un solo acceso a c/registro para los archivos a) y c), y una sola Búsqueda Binaria en el archivo b) por legajo..
Mem. dinámica: Filesize(Solicitudes) x 21 bytes.
Realizar dibujo de las estructuras de datos adecuadamente rotuladas con identificadores que representen su
significado, cálculo del espacio en memoria, como se construyen. Algoritmo; Estrategia. No usar variables
globales en los módulos.