Download - 11 Archivos y Registros-Problemas
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
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
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