Company

LOGO

Archivos y Registros

Algoritmos y Estructuras de Datos

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:

Número 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:

Número de factura, Nombre o Descripción del

producto, Número de unidades y Precio

unitario del producto.

Un problema

El monto facturado (de una factura) puede

corresponder a la adquisición de productos

diversos, debido a esto, un mismo Número de

factura puede aparecer más de una vez en el

archivo ‘DETALLE.DAT’.

Se pide presentar por cada factura los

siguientes datos: Número de factura, Nombre

del cliente, Monto a facturar y los productos que

figuran en su detalle (Nombre del producto,

Número de unidades y Precio unitario).

Plan de Acción

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

FacturaEstructura 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

Módulo 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

Módulo Principal

numero_facturas <- LDA(archivo_facturas) / tamaño_de(factura);

numero_detalles <- LDA(archivo_detalles)/tamaño_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

información relacionada con grupo de a lo más 100

alumnos:

‘ALUMNO.DAT’ : Código alumno (15 caracteres),

nombre completo (30 caracteres), Edad.

‘ALUMNO_NOTAS’: Código alumno (15 caracteres),

código curso (15 caracteres), nota

Se pide presentar un listado ordenado alfabéticamente

respecto al Nombre completo de aquellos alumnos que

han aprobado todos sus cursos.

Plan de acción

Definir estructuras para alumnos y notas

Determinar el número de cursos desaprobados de cada alumno.

Si no tiene cursos desaprobados, colocar la información en un repositorio temporal

Ordenar y mostrar

Definir Estructuras

AlumnoEstructura alumno

Dimension codigo_alumno[15];

Definir codigo_alumno como Caracter;

Dimension nombre_completo[30];

Definir nombre_completo como Caracter;

Definir edad como Entero;

FinEstructura

NotasEstructura 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 jerárquica

Módulo Principal

Obtener cursos

desaprobados

Mostrar reporte

Módulo 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) / tamaño_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

desaprobadosFuncion 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) / tamaño_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 físicos:

JUGADOR.DAT

MUNDIALES.DAT

Se pide presentar un reporte indicando

por cada jugador: Código 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

Código Jugador Total de Goles

AB101 10

CD015 20

AB201 5

MD111 0

Código Jugador Año Total de Goles

AB201 1970 1

CD015 1990 3

AB201 1980 1

CD015 2002 5

Plan de acción

Para cada jugador, obtener el número de goles convertidos en los mundiales

Calcular el número de goles obtenidos fuera de los mundiales

Escribir esta información en otro archivo.

Mostrar la información 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 jerárquica

Módulo Principal

Obtener goles en mundiales

Mostrar reporte

Módulo 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

Módulo Principal

Proceso principal

//Definir variables y abrir archivos

numero_jugadores <- LDA(archivo_jugadores) / tamaño_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) / tamaño_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) / tamaño_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