Archivos y Registros

Algoritmos y Estructuras de Datos

Company

LOGO

Agenda

1. Registros y Archivos
2. Problema 1
3. Problema 2
4. Problema 3

Un problema
Se tienen (ya existen) los archivos:

FACTURA.DAT, que almacena para un

grupo de facturas los siguientes datos:
Nmero de factura, Nombre del cliente y RUC
del cliente.
DETALLE. DAT, que almacena los detalles
de cada una de las facturas del archivo
FACTURA.DAT, los cuales consisten en:
Nmero de factura, Nombre o Descripcin del
producto, Nmero de unidades y Precio
unitario del producto.

Un problema
El monto facturado (de una factura) puede
corresponder a la adquisicin de productos
diversos, debido a esto, un mismo Nmero de
factura puede aparecer ms de una vez en el
archivo DETALLE.DAT.
Se pide presentar por cada factura los
siguientes datos: Nmero de factura, Nombre
del cliente, Monto a facturar y los productos que
figuran en su detalle (Nombre del producto,
Nmero de unidades y Precio unitario).

Plan de Accin
Definir estructuras para la Factura y el Detalle de
Facturas

Generar archivos de prueba (*)

Recorrer el archivo de facturas

Para cada factura en el archivo, ubicar los

correspondientes registros en el detalle y calcular
el monto a facturar.

Cerrar los archivos.

Definir Estructuras
Factura

Estructura factura
Definir numero_factura como Entero;
Dimension nombre_cliente[30];
Definir nombre_cliente como Caracter;
Dimension ruc_cliente[10];
Definir ruc_cliente como Caracter;
FinEstructura

Detalle
de
Factura

Estructura detalle
Definir numero_factura como Entero;
Dimension descripcion_producto[30];
Definir descripcion_producto como Caracter;
Definir numero_unidades como Entero;
Definir precio_unitario como Real;
FinEstructura

Cargar Facturas
SubProceso crear_archivo_facturas()
Definir archivo_facturas como Archivo;
Definir contador como Entero;
Dimension lista_facturas[2];
Definir lista_facturas como factura;
lista_facturas[0].numero_factura <- 1;
lista_facturas[0].nombre_cliente <- "Hugo";
lista_facturas[0].ruc_cliente <- "123"; //Lo mismo para el resto
Abrir "facturas.dat" como archivo_facturas para Escribir;

Para contador <-0 Hasta 1 Hacer

Escribir archivo_facturas, contador, lista_facturas[contador];
FinPara
Cerrar archivo_facturas;
FinSubProceso

Mdulo Principal
Proceso Principal

Definir archivo_facturas como Archivo;

Definir archivo_detalles como Archivo;
Definir una_factura como factura;

Definir un_detalle como detalle;

Definir contador_facturas como Entero;
Definir contador_detalle como Entero;
Abrir "factura.dat" como archivo_facturas para Lectura;
Abrir "detalle.dat" como archivo_detalles para Lectura;
//Recorrer archivos
Cerrar archivo_detalles;
Cerrar archivo_facturas;

FinProceso

Mdulo Principal
numero_facturas <- LDA(archivo_facturas) / tamao_de(factura);
numero_detalles <- LDA(archivo_detalles)/tamao_de(detalle);
Para contador_facturas <- 0 Hasta numero_facturas - 1 Hacer

Leer archivo_facturas, contador_facturas, una_factura;

Escribir una_factura.numero_factura, una_factura.nombre_cliente;
monto_a_facturar

<- 0.0;

Para contador_detalle <- 0 Hasta

numero_detalles - 1 Hacer

Leer archivo_detalles, contador_detalle, un_detalle;

Si un_detalle.numero_factura = una_factura.numero_factura Entonces

Escribir un_detalle.numero_unidades, un_detalle.precio_unitario;
monto_a_facturar <- monto_a_facturar +
un_detalle.numero_unidades * un_detalle.precio_unitario;
FinSi

FinMientras
Escribir monto_a_facturar;
FinMientras

Otro problema
Los siguientes archivos (que ya existen) guardan la
informacin relacionada con grupo de a lo ms 100
alumnos:
ALUMNO.DAT : Cdigo alumno (15 caracteres),
nombre completo (30 caracteres), Edad.
ALUMNO_NOTAS: Cdigo alumno (15 caracteres),
cdigo curso (15 caracteres), nota
Se pide presentar un listado ordenado alfabticamente
respecto al Nombre completo de aquellos alumnos que
han aprobado todos sus cursos.

Plan de accin
Definir estructuras para alumnos y notas

Determinar el nmero de cursos

desaprobados de cada alumno.

Si no tiene cursos desaprobados,

colocar la informacin en un repositorio
temporal

Ordenar y mostrar

Definir Estructuras
Alumno

Estructura alumno
Dimension codigo_alumno[15];
Definir codigo_alumno como Caracter;
Dimension nombre_completo[30];
Definir nombre_completo como Caracter;
Definir edad como Entero;
FinEstructura

Notas

Estructura notas_alumno
Dimension codigo_alumno[15];
Definir codigo_alumno como Caracter;
Dimension codigo_curso[15];
Definir codigo_curso como Caracter;
Definir nota_curso como Real;
FinEstructura

Estructura jerrquica

Mdulo
Principal
Obtener
cursos
desaprobados

Mostrar
reporte

Mdulo Principal
Proceso Principal
//Declarar variables
Abrir "alumnos.dat" como archivo_alumnos para Leer;
Abrir "alumno_notas.dat" como archivo_notas para Leer;
contador_aprobados <- 0;
contador_alumnos <- 0;
numero_alumnos <- LDA(archivo_alumnos) / tamao_de(alumno) ;
Mientras contador_alumnos < numero_alumnos

Hacer

Leer archivo_alumnos, contador_alumnos, un_alumno;

cursos_desaprobados <- obtener_cursos_desaprobados(un_alumno.codigo, archivo_notas);
Si cursos_desaprobados = 0 Entonces
alumnos_aprobados[contador_aprobados] <- un_alumno;
contador_aprobados <- contador_aprobados + 1;
FinSi
contador_alumnos <- contador_alumnos + 1;
FinMientras

mostrar_alumnos_aprobados(alumnos_aprobados, contador_aprobados);
Cerrar archivo_alumnos;
Cerrar archivo_notas;
FinProceso

Obtener cursos
desaprobados
Funcion cursos_desaprobados<-obtener_cursos_desaprobados(codigo_alumno, archivo_notas)
Definir cursos_desaprobados como Entero;
Definir una_nota como notas_alumno;
Definir contador_notas como Entero;
Definir numero_notas como Entero;
cursos_desaprobados <- 0;
numero_notas <- LDA(archivo_notas) / tamao_de(notas_alumno);
Para contador_notas <- 0 Hasta numero_notas - 1 Hacer
Leer archivo_notas, contador_notas, una_nota;
Si una_nota.codigo_alumno = codigo_alumno & una_nota.nota_curso < 10 Entonces
cursos_desaprobados <- cursos_desaprobados + 1;

FinSi
FinPara
FinFuncion

Ordenar y mostrar
SubProceso mostrar_alumnos_aprobados(alumnos_aprobados, numero_alumnos)
//Definir variables
esta_ordenado <- Falso;
Mientras ~esta_ordenado Hacer
esta_ordenado <- Verdadero;
Para contador_alumnos <- 0 Hasta numero_alumnos - 2 Hacer
un_alumno <- alumnos_aprobados[contador_alumnos];
otro_alumno <- alumnos_aprobados[contador_alumnos + 1];
Si un_alumno.nombre_completo > otro_alumno.nombre_completo Entonces
temporal <- alumnos_aprobados[contador_alumnos];
alumnos_aprobados[contador_alumnos] <- alumnos_aprobados[contador_alumnos + 1];
alumnos_aprobados[contador_alumnos + 1] <- temporal;
esta_ordenado <- Falso;
FinSi
FinPara
FinMientras
//Recorrer el arreglo y mostrar su contenido
FinSubProceso

ltimo problema
Se tienen los siguientes archivos fsicos:

JUGADOR.DAT
MUNDIALES.DAT

Se pide presentar un reporte indicando

por cada jugador: Cdigo de jugador y
total de goles convertidos fuera de los
mundiales.

Nota: El archivo JUGADOR.DAT almacena

el total de goles convertidos por un jugador ya
sea dentro o fuera de un mundial.

ltimo problema
Cdigo Jugador

Total de Goles

AB101

10

CD015

20

AB201

MD111

Cdigo Jugador

Ao

Total de Goles

AB201

1970

CD015

1990

AB201

1980

CD015

2002

Plan de accin
Para cada jugador, obtener el nmero
de goles convertidos en los mundiales

Calcular el nmero de goles obtenidos

fuera de los mundiales

Escribir esta informacin en otro

archivo.

Mostrar la informacin del ltimo

archivo generado.

Definir Estructuras
Goles por
jugador

Estructura jugador
Dimension codigo_jugador[6];
Definir codigo_jugador como Caracter;
Definir goles como Entero;
FinEstructura

Goles del
jugador
en
mundiales

Estructura mundial
Dimension codigo_jugador[6];
Definir codigo_jugador como Caracter;
Definir agno como Entero;
Definir goles como Entero;
FinEstructura

Estructura jerrquica

Mdulo
Principal

Obtener goles
en mundiales

Mostrar
reporte

Mdulo Principal
Proceso principal
Definir archivo_jugadores como Archivo;
Definir archivo_mundiales como Archivo;
Definir archivo_reporte como Archivo;
Definir un_jugador como jugador;

Definir goles_en_mundiales como Entero;

Definir contador_jugadores como Entero;
Definir numero_jugadores como Entero;
Abrir "jugador.dat" como archivo_jugadores para Leer;
Abrir "mundiales.dat" como archivo_mundiales para Leer;

Abrir "reporte.dat" como archivo_reporte para Escribir;

//Crear el archivo de reporte y mostrar su contenido
Cerrar archivo_jugadores;
Cerrar archivo_mundiales;
Cerrar archivo_reporte;
FinProceso

Mdulo Principal
Proceso principal
//Definir variables y abrir archivos
numero_jugadores <- LDA(archivo_jugadores) / tamao_de(jugador);
Para contador_jugadores <- 0 Hasta numero_jugadores - 1 Hacer
Leer archivo_jugadores, contador_jugadores, un_jugador;
goles_en_mundiales <- obtener_goles_en_mundiales(
un_jugador.codigo_jugador, archivo_mundiales);
un_jugador.goles <- un_jugador.goles - goles_en_mundiales;

Escribir archivo_reporte, contador_jugadores, un_jugador;

FinPara
mostrar_reporte(archivo_reporte);
//Cerrar archivos
FinProceso

Goles en mundiales
Funcion goles_en_mundiales <- obtener_goles_en_mundiales(codigo_jugador,
archivo_mundiales)

Definir goles_en_mundiales como Entero;

Definir un_mundial como mundial;
Definir numero_mundiales como Entero,
Definir contador_mundiales como Entero;
goles_en_mundiales <- 0;
numero_mundiales <- LDA(archivo_mundiales) / tamao_de(mundial);
Para contador_mundiales <- 0 Hasta numero_mundiales - 1 Hacer
Leer archivo_mundiales, contador_mundiales, un_mundial;
Si codigo_jugador = un_mundial.codigo_jugador Hacer
goles_en_mundiales <- goles_en_mundiales + un_mundial.goles;
FinSi
FinPara
FinFuncion

Mostrar reporte
SubProceso mostrar_reporte(archivo_reporte)
Definir un_jugador como jugador;
Definir numero_jugadores como Entero;
Definir contador_jugadores como Entero;
numero_jugadores <- LDA(archivo_reporte) / tamao_de(jugador);

Para contador_jugadores <- 0 Hasta numero_jugadores - 1 Hacer

Leer archivo_reporte, contador_jugadores, un_jugador;
Escribir un_jugador.codigo_jugador, un_jugador.goles;
FinPara
FinSubProceso