DEFINICIÓN:
Módulo: Un módulo que se
supone que representa una función
lógica es una secuencia
léxicamente continúa de instrucciones que se
encuentra limitado por elementos de fronteras y además
se caracteriza por disponer de un nombre o
identificador
Módulo: Es aquél que está
constituido por una o varias instrucciones físicamente
contiguas y lógicamente encadenadas, las cuales se
pueden referenciar mediante un nombre y pueden ser llamadas
desde diferentes puntos de un programa.
Un módulo puede ser:
- Un programa
- Una función
- Una subrutina (o procedimiento)
La modularidad se basa en la descomposición de
un problema en una serie de sub problemas;
dividiéndolo en módulos que resultan de segmentar
el problema en funciones
lógicas que son perfectamente diferenciadas. Esta
división exige la presencia de un módulo
denominado módulo de base o principal a objeto de que
controle y se relacione con los demás.
Es una técnica de programación que todavía se
utiliza tanto para la construcción de algoritmos
computacionales básicos así como apoyo al
desarrollo
de sistemas de
gestión (en el diseño de diagramas
modulares).
La salida del módulo debe ser función
de la entrada, pero no de ningún estado
interno. En la creación de los módulos deben
cumplirse tres aspectos básicos:
descripción, rendimiento y
diseño.
En la descripción se definen las
funciones y objetivos
del programa. Para obtener el máximo
rendimiento se ha
de comprobar que el programa realice el proceso
aprovechando al máximo todos los recursos
de los que dispone. En cuanto al diseño, se debe comprobar
la estructura
que sigue el módulo, así como la estructura de
los datos y la
forma de comunicaciones entre los diversos y diferentes
módulos.
Conforme se extiende el tamaño de los
algoritmos, se hace más difícil su
revisión, actualización y/o
corrección.
Una política
común para solventar este problema consiste en la
modularización. Esto significa que el algoritmo se
fragmenta en partes llamadas módulos. En realidad, es un
método
de diseño que tiende a dividir el problema, de forma
lógica, en partes perfectamente diferenciadas que pueden
ser analizadas, programadas y puestas a punto
independiente.
- Objetivos:
- Descomponer el sistema en
módulos:
– Los grupos deben
maximizar el enlace y minimizar el acoplamiento.
- Determinar las relaciones entre
módulos:
– Identificar y especificar las dependencias entre
módulos.
– Determinar la forma de comunicación entre módulos
(variables
llamadas a funciones, memoria
compartida, paso de mensajes)
- Especificar las interfaces de los
módulos:
– Facilita la prueba independiente entre los
módulos.
– Mejora la
comunicación e integración del grupo
- Características:
- Permite reducir la complejidad global del sistema
descentralizado; ejm. Divide y vencerás. - Mejora la escalabilidad y la productividad
(los módulos pueden desarrollarse independientemente por
varias personas)
- Principios para asegurar diseños
modulares:
- Soporte de lenguaje
para unidades modulares.
Los módulos deben corresponder a unidades
sintácticas del lenguaje utilizado.
- Pocas interfaces:
Cada módulo debe comunicarse con tan pocos como
sea posible.
- Interfaces pequeñas (Acoplamiento
débil):
Si dos módulos se comunican, deben intercambiar
la menor información posible..
- Interfaces explícitas:
Cuando dos módulos se comunican, debe estar
claro en el texto de uno
o de ambos.
- Ocultación de la
información:
Toda la información sobre un módulo
debe ser privada al módulo, a menos que se haya
declarado específicamente como
pública.
Algunas ventajas de utilizar módulos
son:
Un programa modular es fácil de mantener | |
Un programa modular es más fácil | |
Un programa modular es más fácil | |
Posibilita el uso repetitivo de las rutinas en |
Desventajas del uso de
módulos:
No se dispone de algoritmos formales de | |
La programación modular requiere |
Segmento: El
segmento a diferencia del módulo se caracteriza porque
no dispone de un nombre o identificador
METODOLOGÍA DESCENDENTE:
(TOP – DOWN)
Proceso mediante el cual un problema se descompone
en una serie de niveles o pasos sucesivos de refinamiento
(stipwise). La metodología descendente consiste en
efectuar una relación entre las sucesivas etapas de
estructuración, de modo que se relacionen unas con
otras mediante entradas y salidas de
información.
Es decir se descompone un problema en etapas o
estructuras jerárquicas, de modo que se
puede considerar cada estructura desde dos puntos de
vista;
¿Qué hace?
Para ver el
gráfico seleccione la opción "Descargar" del
menú superior
¿Cómo lo hace?
Para ver el
gráfico seleccione la opción "Descargar" del
menú superior
El diseño descendente se puede
ver:
Para ver el
gráfico seleccione la opción "Descargar" del
menú superior
Clasificación:
Variable Local: Aquella que está
declarada y definida dentro de un sub programa, en el sentido
de que está dentro de ese sub programa y es distinta de
las variables con el mismo nombre declaradas en cualquier parte
del programa principal. El significado de una variable se
confina al procedimiento en el que está declarada.
Cuando otro sub programa utiliza el mismo nombre, se refiere a
una posición diferente en memoria.
El uso de variables locales tiene muchas ventajas.
En particular, hace a los sub programas independientes con la
comunicación entre el programa principal y los sub
programas manipulados estructuralmente a través de la
lista de parámetros.
Una variable local a un sub programa, no tiene
ningún significado en otros sub programas. Si un sub
programa asigna un valor a
una de sus variables locales, este valor no es accesible a
otros programas, es decir, no pueden utilizar este
valor.
Variable Global: Aquella que está
declarada para el programa o algoritmo principal del que
dependen todos los sub programas
Esta variable tiene la ventaja de compartir
información de diferentes sub programas sin una
correspondiente entrada en la lista de
parámetros
Un procedimiento o sub rutina, es un sub programa
que ejecuta un proceso específico. Ningún valor
esta asociado con el nombre del procedimiento, por
consiguiente no puede ocurrir en una expresión. Un
procedimiento se llama escribiendo su nombre Ejm. SORT para
indicar que un procedimiento denominado SORT se va a
usar.
Cuando se invoca el procedimiento los pasos que los
define se ejecuta y a continuación se devuelve el
control al
programa que le llamó.
PROCEDIMIENTO VS FUNCION
Los procedimientos y funciones son sub programas,
cuyo diseño y misión
son similares, sin embargo existen unas diferencias
esenciales entre ellos:
- Un procedimiento es llamado desde el algoritmo o
programa principal, mediante su nombre y una lista de
parámetros actuales o bien con la instrucción
llamar_a (call). Al llamar al procedimiento se detiene
momentáneamente el programa que se está
realizando y el control pasa al procedimiento llamado,
después de que las acciones del
procedimiento se ejecutan, se regresa a la acción
inmediata siguiente a la que se llamó. - Las funciones devuelven un valor, los procedimientos
pueden devolver 0, 1 ó n valores y en
forma de lista de parámetros. - El procedimiento se declara igual que la
función, pero su nombre no está asociado a
ninguno de los resultados que obtiene.
Las funciones son bloques de instrucciones que tienen
por objeto el alcanzar un resultado que sustituirá a la
función en el punto de invocación (las funciones
devuelven un resultado).
Cada función se evoca utilizando su nombre en una
expresión con los argumentos actuales o reales encerrados
entre paréntesis.
Para hacer una referencia a una función se invoca
mediante un nombre y en caso de existir, una lista de
parámetros actuales necesarios (argumentos). Los
argumentos deben coincidir en cantidad, tipo y orden con los de
la función que fue definida. La función devuelve un
valor único.
Las funciones a que se hace referencia, se conocen como
funciones de usuario puesto que son definidas por él mismo
y permiten su uso en forma idéntica a las funciones
estándares.
Para coordinar e iniciar el procesamiento, se utiliza un
módulo principal que es colocado al final del
algoritmo.
Una llamada a la función implica los
siguientes pasos:
- A cada parámetro formal se le asigna el valor
real de su correspondiente parámetro actual. - Se ejecuta el cuerpo de acciones de la
función. - Se devuelve el valor de la función al nombre
de la función y se retorna al punto de
llamada.
Declaración de funciones
función nombre_función
(par1, par2,par3,…) : tipo_del_resultado
Inicio
acción1
acción2
:nombre_función
Resultado_Obtenido
Fin
Donde:
par1,par2 ….
Lista de parámetros formales o argumentos.
nombre_función
Nombre asociado
de la función, que será un nombre de
identificador válido.
acción1,
acción2,..
Instrucciones que constituyen la definición de las
función, y que debe contener una acción sola
de asignación que asigne un valor al nombre de la
función.
Ejemplo:
Obtener el sexto carácter
de un nombre y si dicho carácter no existe, se
asumirá un asterisco como tal.
Función
SEXTO(n:string):carácter
Inicio
si longitud(n) >= 6 entonces
SEXTO Subcadena(n,6,1)
en caso contrario
SEXTO ‘*’
Fin
Invocación a las funciones
Una función puede ser llamada sólo
mediante referencia de la forma siguiente:
nombre_función (lista de parámetros
actuales)
Donde:
nombre_función Función
que llama.
Lista de param. actuales
Constantes, variables,
expresiones, valores de funciones, nombres de funciones o
procedimientos.
Una llamada a la función implica los
siguientes pasos:
A cada parámetro formal se le asigna el valor
real de su correspondiente parámetro actual (esta
correspondencia se verá más tarde y se denomina
llamada por valor).
Se ejecuta el cuerpo de acciones de la
función.
Se devuelve el valor de la función y se
retorna al punto de llamada.
Ejercicio:
* Calcular la potencia
de un número.
Funcion POTENCIA(x,n :entero):
entero
Inicio
Y=1
Desde i = 1 hasta abs(n) hacer
y = y*x
fin Desde
si n < 0 entonces
y =1/y
Fin si
POTENCIA = y
Fin
USO DE LOS
PARÁMETROS: FORMALES – NORMALES O
ARGUMENTOS
PASO DE PARAMETROS
Existen diferentes métodos
para el paso de parámetros a subprogramas, un mismo
programa puede producir diferentes resultados bajo diferentes
sistemas de paso de parámetros.
Los parámetros se clasifican de la siguiente
manera:
1. Entradas:
Las entradas proporcionan valores desde el programa que llama y
que se utilizan dentro de un procedimiento. En los subprogramas
función las entradas son los argumentos en
el sentido tradicional.
2. Salidas: Las salidas
producen los resultados del subprograma; de nuevo si se utiliza
el caso una función, mientras que con procedimientos
pueden calcularse cero, una o varias salidas.
3. Entradas/Salidas: Un solo
parámetro se utiliza para mandar argumentos a un programa
y para devolver resultados.
Los métodos más empleados para realizar el
paso de parámetros son:
- Paso por valor (parámetro
valor).
Se utiliza en muchos lenguajes de
programación (pascal, basic,
modula-2, algol, etc), debido a su analogía con los
argumentos de una función, donde los valores se
proporcionan en el orden de cálculo de
resultados. Los parámetros se tratan como variables
locales y los valores iniciales se proporcionan copiando los
valores de los correspondientes argumentos.
Los parámetros formales (locales a la
función), reciben como valores iniciales los valores de
los parámetros actuales y con ello se ejecutan las
acciones descritas en el subprograma.
La llamada por valor no devuelve información al
programa que llama.
- Paso por referencia o dirección (parámetro
variable).
Se utiliza cuando se requiere que ciertos
parámetros sirvan como parámetros de salida, es
decir, devuelvan los resultados a la unidad o programas que
llama. La unidad que llama pasa a la unidad llamada la
dirección del parámetro actual (que está en
el ámbito de la unidad llamante). Una referencia al
correspondiente parámetro formal se trata como una
referencia a la posición de memoria, cuya dirección
se ha pasado. Entonces una variable pasada como parámetro
real es compartida, es decir, se puede modificar directamente por
el subprograma. Si el parámetro actual es una
expresión, el subprograma recibe la dirección de la
posición temporal que contiene el valor de la
expresión.
La arquitectura
es el elemento estable ante los cambios en el ciclo de
vida de los módulos; la clave está en
separar interfaces de implementaciones.
La separación entre interfaces e
implementación:
- Aísla de los cambios.
- Sirve de mecanismo (compilable) de unión entre
arquitectura e implementación. - El papel de la
arquitectura es proporcionar información de
diseño a los desarrolladores, para que éstos
puedan hacer cambios y correcciones a los módulos, sin
romper la arquitectura. - En cada escala de un
sistema modular, se puede definir una arquitectura y una
implementación: - La implementación es la realización de
los componentes modulares. - La arquitectura es la abstracción que define
las interfaces entre componentes.
PLANTEAR Y SOLUCIONAR EJERCICIOS APLICANDO
MODULARIDAD:
Para ver el gráfico seleccione la
opción "Descargar" del menú superior
Puede definirse un programa en términos
recursivos, como una serie de pasos básicos, o paso
base (también conocido como condición de
parada), y un paso recursivo, donde vuelve a llamarse
al programa. En un computador, esta serie de pasos recursivos
debe ser finita, terminando con un paso base. Es decir, a
cada paso recursivo se reduce el número de pasos que
hay que dar para terminar, llegando un momento en el que no
se verifica la condición de paso a la recursividad. Ni
el paso base ni el paso recursivo son necesariamente
únicos.
Por otra parte, la recursividad también puede
ser indirecta, si tenemos un procedimiento P que llama a otro
Q y éste a su vez llama a P. También en estos
casos debe haber una condición de parada.
Existen ciertas estructuras cuya definición
es recursiva, tales como los árboles, y los algoritmos que utilizan
árboles suelen ser en general recursivos.
La funcion FACTORIAL de N expresada en
términos recursivos sería:
entero funcion factorial(E entero: n)
inicio
si (n = 0)
retornar 1
sino
retornar (n * factorial(n-1) )
fin_si
fin_funcion
_______________________________
RECURSIVIDAD
El concepto de
recursividad es muy importante en la programación
funcional, y se puede definir " Como el proceso de resolver
un problema reduciéndolo a uno ó más
subproblemas que son idénticos en su estructura al
problema original y más simple de
resolver."
Una vez que sea subdividido el problema original, se
utilizará la misma técnica de
descomposición para subdividir cada uno de estos
subproblemas en otros que son menos complejos, hasta que los
subproblemas llegan a ser tan simples que se pueden resolver
sin realizar más subdivisiones, y la solución
general del problema se obtiene juntando todos los
componentes resueltos.
Una función o procedimiento que se puede
llamar a sí misma se llama recursivo. La recursividad
es una herramienta muy potente en algunas aplicaciones, sobre
todo de cálculo. La recursión puede ser
utilizada como una alternativa a la repetición o
estructura repetitiva.
La razón de que existan lenguajes que admitan
la recursividad se debe a la existencia de estructuras
específicas tipo pilas (stack)
para este tipo de procesos y
memorias
dinámicas.
La recursividad es una manera elegante, intuitiva y
concisa de plantear una solución, y es uno de los
pilares de la programación funcional. Pero no quiere
decir que sea un sistema eficiente, es decir, que el
número de operaciones
que hay que hacer sea inferior que si se utiliza otra forma
de resolverlo, como seria mediante una estructura repetitiva.
Al contrario la recursividad es cara y exige un mayor
procesamiento.
Ejemplo:
//Función Fibonacci recursiva
FIB (X):
Inicio_Fibonacci
Si (X = 0 ó X = 1) entonces
FIB = X
Si no
FIB = FIB (X-1) + FIB (X-2)
Fin_si
Fin_Fibonacci
//Función Fibonacci no recursiva
FIB (X):
Inicio_Fibonacci
Si (X = 0 ó X = 1) entonces
FIB = N
Si no
A = 0
B = 1
Para (i = 2; i <= X; i++)
C = A + B
A = B
B = C
Fin_para
FIB = C
Fin_si
Fin_Fibonacci
A.- Arreglos de Registros:
1._ Ingresar 10 fechas y mostrar cuantas pertenecen al
mes de "Octubre".
Inicio
fecha = Registro
día: entero
mes: entero
año: entero
Fin _ registro
fechas[10]: fecha
i, C← 0: entero
para (i=1; i<=10; i++)
Ingresar fechas[i].fecha.día
Ingresar fechas[i].fecha.mes
Ingresar fechas[i].fecha.año
Fin _ para
para (i=1; i<=10; i++)
si (fechas[i].fecha.mes=10) entonces
C ← C+1
Fin _ si
Fin _ para
si C=0 entonces
Mostrar "Número de fechas:", C
Fin _ si
Fin.
B.- Registros con
Arreglos:
Cliente
Código | Nombre y Apellido | Saldos Mensuales | Total |
1 2 3 4 5 …..12 | |||
CA01 | |||
CA02 | |||
Inicio
Cliente = Registro
Cod[6]: caracter
Nom _ Ape[30]: caracter
saldos[12]: real
Total: real
Fin _ Registro
clientes[15]: cliente
i, j: entero
S ← 0: entero
Para (i=1; i<=5; i++)
Ingresar clientes[i].cliente.cod
Ingresar clientes[i].cliente.Nom _ Ape
S ← 0
Para (j=1; j<=12; j++)
Repetir
Ingresar Clientes[i].cliente.saldos[j]
Hasta (clientes[i].cliente.saldos[j]>=0)
S ← S+ clientes[i].cliente.saldos[j]
Fin _ para
clientes[i].cliente.total ← S
Fin _ para
Fin
C.- Registros Anidados
Cod | Apellido | Nombre | Dirección | Fecha-Nacim. | ||||
calle | número | distrito | D | M | A | |||
Inicio
Fecha = Registro
D: entero
M: entero
A: Entero
Fin _ Registro
Dir = Registro
Calle[15]: caracter
Num: entero
Distrito[15]: caracter
Fin _ Registro
Persona = Registro
Cod: entero
Ape[15]: caracter
Nom[15]: caracter
Dirección: dir
Fecha – Nac: fecha
Fin _ Registro
Personas[20]: persona
i: entero
para (i=1; i<=20; i++)
personas[i].persona.cod
← i
Ingresar personas[i].persona.Ape
Ingresar personas[i].persona.Nom
Ingresar
personas[i].persona.dirección.dir.calle
Ingresar
personas[i].persona.dirección.dir.Num
Ingresar
personas[i].persona.dirección.dir.distrito
Ingresar personas[i].persona.fecha –
Nac.D
Ingresar personas[i].persona.fecha –
Nac.M
Ingresar personas[i].persona.fecha –
Nac.A
Fin _ para
Fin
Ponemos este material al alcance de todos aquellos que
necesitan una guía o material de consulta o
referencia.
Mediante el desarrollo de este trabajo se ha logrado
desarrollar y entender el curso de Estructura de
Datos.
Conocedores que su realización nos han permitido
el aprendizaje
en los diferentes temas y están contribuyendo al cambio de
nuestra manera de vivir, con ello nuestra formación
profesional.
La conclusión a lo que se ha llegado con el
desarrollo de este importante curso en nuestra carrera, es a
poder
estructurar un programa, lo que posteriormente nos
facilitará el trabajo en
los cursos
venideros; utilizando para esto la lógica computacional y
la estructuración; llegando a lograr comprender de esta
manera que existen muchas soluciones a
los problemas planteados tanto aplicados a ejemplos como a la
vida real.
IX. RECOMENDACIONES
- Recomendamos mediante el desarrollo de este trabajo a
que los alumnos que se forman para en la carrera de Ingeniería Informática y de Sistemas u otras afines,
pongan el interés
y empeño necesario en sus actividades
académicas. - Hacemos una invocación a los Directivos y
Docentes de esta nueva carrera profesional iniciada en esta
parte del país para que se preocupen en atender las
necesidades y exigencias que tiene para su total
desarrollo. - Recomendamos de igual forma a los Directivos de la
Central en la ciudad de Chiclayo para que implemente el
material bibliográfico sobre esta carrera, con textos
actualizados y modernos.
- Estructura de Datos I
Luis Joyanes Aguilar
- Problemas de Álgebra
y como resolverlos.
Juan C. Ramos L. & Armando Tori L. 1998
- Programación Genérica
Lola Cárdenas Luque 2000 – 2003
- Arreglos, Cadenas y Estructuras
Lorena Irazunia Reyes Ceja
Alan Hidalgo Vargas 2003
- Diccionario Enciclopédico
Océano
Ediciones Océano 1998
- Análisis y Diseño de
Sistemas Informáticos.
J. Monzón F – David Spencer
Ed. Gomez – Lima 1994
- Diccionario de Computación Ingles –
Español
Ed. Mac Graw – Hill
Alan Freeman – 1994
- Estructura Lógica y Diseño de
Programas
Alan Cohen – Ed. Paraninfo 1994
- Como Programar Microcomputadoras
William Barden, Jr.
Ed. Urmo S.A. – 1982
http://200.21.198.39/asignaturas/846921/contenidos/turorialc3/node3.html
http://www.elrincondel
programador.com
1.- Diseñar un algoritmo que permita crear un
registro
Agenda de direcciones cuyos registros constan de los siguientes
campos:
Nombre, Dirección, Ciudad, Teléfono, Edad
Luego deberá permitirme ordenarlo en forma
ascendente (método de burbuja) por medio de los nombres
para posteriormente ingresar un nuevo registro, y ubique este en
el lugar correspondiente, de acuerdo al orden en que le
toque.
INICIO
Agenda = Registro
Nombre [40] : Caracter
Dirección [50] : Caracter
Ciudad [30] : Caracter
Teléfono : Entero
Edad : Entero
Fin_registro
Agendas[100] : Agenda
Auxiliar[1] : Agenda
i,j,k,m : Entero
Resp : Bolean
Resp = Verdadero
Mientras (Resp =Verdadero) Hacer
Para (i=1 ; i<=100 ; i++ )
Ingresar Agendas[i].Agenda.Nombre
Ingresar Agendas[i].Agenda.Direccion
Ingresar Agendas[i].Agenda.Ciudad
Ingresar Agendas[i].Agenda.Telefono
Ingresar Agendas[i].Agenda.Edad
Fin_Para
Mientras (k Diferente de Null) Hacer
Agendas[i].Agenda.Nombre
m = m + 1
Fin_Mientras
Para (i=1 ; i<m ; m++)
Para (j=i+1 ; j<=m ; j++)
Si (Agendas[i].Agenda.Nombre >
Agendas[j].Agenda.Nombre) Entonces
Auxiliar[1].Agenda.Nombre =
Agendas[i].Agenda.Nombre
Auxiliar[1].Agenda.Direccion =
Agendas[i].Agenda.Direccion
Auxiliar[1].Agenda.Ciudad =
Agendas[i].Agenda.Ciudad
Auxiliar[1].Agenda.Telefono =
Agendas[i].Agenda.Telefono
Auxiliar[1].Agenda.Edad =
Agendas[i].Agenda.Edad
Agendas[i].Agenda.Nombre =
Agendas[j].Agenda.Nombre
Agendas[i].Agenda.Direccion =
Agendas[j].Agenda.Direccion
Agendas[i].Agenda.Ciudad =
Agendas[j].Agenda.Ciudad
Agendas[i].Agenda.Telefono =
Agendas[j].Agenda.Telefono
Agendas[i].Agenda.Edad =
Agendas[j].Agenda.Edad
Agendas[i].Agenda.Nombre =
Auxiliar[1].Agenda.Nombre
Agendas[i].Agenda.Direccion =
Auxiliar[1].Agenda.Direccion
Agendas[i].Agenda.Ciudad =
Auxiliar[1].Agenda.Ciudad
Agendas[i].Agenda.Telefono =
Auxiliar[1].Agenda.Telefono
Agendas[i].Agenda.Edad =
Auxiliar[1].Agenda.Edad
Fin_Si
Fin_Para
Fin_Para
Mensaje("Desea Ingresar otro Registro" Yes /
No)
Si (Yes) Entonces
Resp = Verdadero
Sino
Resp = Falso
Fin si
Fin_Mientras
FIN
2.- Un director de un colegio desea obtener de 20
alumnos los siguientes datos:
- Dado la identificación del alumno se
deberá obtener la máxima nota del alumno
correspondiente y su respectivo nombre. - Nota media por curso (5 cursos)
- Nota media del colegio.
- Mayor nota promedio por alumno y si existen varios
alumnos con la misma nota deberá visualizarse cada uno
de ellos. - Cuantos alumnos aprobados y desaprobados
exiten
INICIO
Alumno = Registro
Nombre [50] : Caracter
NotaCur1 : Real
NotaCur2 : Real
NotaCur3 : Real
NotaCur4 : Real
NotaCur5 : Real
Fin_registro
Alumnos [20] : Alumno
i, j, : Entero
xNotaMax, : Rea
xTotalCur1, xTotalCur2, xTotalCur3, xTotalCur4,
xTotalCur5 : Real
xPromedio, xMayorProm, xMayorProm2 : Real
xTotalColegio : Real
xNombre, : Carácter
‘Ingresar datos del
alumno
Para (i = 1; i <= 20; i++)
Ingresar Alumnos [i].Alumno.Nombre
Ingresar Alumnos [i].Alumno.NotaCur1
Ingresar Alumnos [i].Alumno.NotaCur2
Ingresar Alumnos [i].Alumno.NotaCur3
Ingresar Alumnos [i].Alumno.NotaCur4
Ingresar Alumnos [i].Alumno.NotaCur5
Fin_Para
‘Identificar alumno y mostrar
datos
Ingresar xNombre
Para (i=1, i<=20, i++)
Si Alumnos[i].Alumno. Nombre = xNombre
Entonces
xNotaMax = Alumnos[i].Alumno.NotaCur1
Si xNotaMax < Alumnos[i].Alumno.NotaCur2
Entonces
xNotaMax = Alumnos[i].Alumno.NotaCur2
Fin_Si
Si xNotaMax < Alumnos[i].Alumno.NotaCur3
Entonces
xNotaMax = Alumnos[i].Alumno.NotaCur3
Fin_Si
Si xNotaMax < Alumnos[i].Alumno.NotaCur4
Entonces
xNotaMax = Alumnos[i].Alumno.NotaCur4
Fin_Si
Si xNotaMax < Alumnos[i].Alumno.NotaCur5
Entonces
xNotaMax = Alumnos[i].Alumno.NotaCur5
Fin_Si
Mostrar xNotaMax
Mostrar Alumnos[i].Alumno.Nombre
Fin_Si
Fin_Para
‘Nota media por
curso
xTotalCur1=0
xTotalCur2=0
xTotalCur3=0
xTotalCur4=0
xTotalCur5=0
Para (i = 1; i<=20, i++)
xTotalCur1=xTotalCur1 +
Alumnos[i].Alumno.NotaCur1
xTotalCur2=xTotalCur2 +
Alumnos[i].Alumno.NotaCur2
xTotalCur3=xTotalCur3 +
Alumnos[i].Alumno.NotaCur3
xTotalCur4=xTotalCur4 +
Alumnos[i].Alumno.NotaCur4
xTotalCur5=xTotalCur5 +
Alumnos[i].Alumno.NotaCur5
Fin_Para
Mostrar xTotalCur1/20
Mostrar xTotalCur2/20
Mostrar xTotalCur3/20
Mostrar xTotalCur4/20
Mostrar xTotalCur5/20
‘Nota media del
Colegio
xTotalColegio=0
Para (i = 1;i<=20,i++)
xTotalColegio=xTotalColegio +
Alumnos[i].Alumno.NotaCur1
xTotalColegio=xTotalColegio +
Alumnos[i].Alumno.NotaCur2
xTotalColegio=xTotalColegio +
Alumnos[i].Alumno.NotaCur3
xTotalColegio=xTotalColegio +
Alumnos[i].Alumno.NotaCur4
xTotalColegio=xTotalColegio +
Alumnos[i].Alumno.NotaCur5
Fin_Para
Mostrar xTotalColegio/100
‘Mayor nota promedio por
alumno
xMayorProm = 0
Para (i =1; i<=20, i++)
xMayorProm2 = (Alumnos[i].Alumno.NotaCur1 +
Alumnos[i].Alumno.NotaCur2 +
Alumnos[i].Alumno.NotaCur3 +
Alumnos[i].Alumno.NotaCur4 +
Alumnos[i].Alumno.NotaCur5)/ 5
Si xMayorProm<xMayorProm2 Entonces
xMayorProm = xMayorProm2
Fin_Si
Fin_Para
Para (j = 1; j <= 20, j++)
xMayorProm2 = (Alumnos[i].Alumno.NotaCur1 +
Alumnos[i].Alumno.NotaCur2 +
Alumnos[i].Alumno.NotaCur3 +
Alumnos[i].Alumno.NotaCur4 +
Alumnos[i].Alumno.NotaCur5)/ 5
Si xMayorProm = xMayorProm2 Entonces
Mostrar xMayorProm
Mostrar Alumnos[i].Alumno.Nombre
Fin_Si
Fin_Para
‘Total aprobados y
desaprobados
xTotalAprob = 0
xTotalDesaprob = 0
Para (i = 1; i <= 20; i++)
xPromedio = (Alumnos[i].Alumno.NotaCur1 +
Alumnos[i].Alumno.NotaCur2 +
Alumnos[i].Alumno.NotaCur3 +
Alumnos[i].Alumno.NotaCur4 +
Alumnos[i].Alumno.NotaCur5) / 5
Si xPromedio >= 10.5 Entonces
xTotalAprob = xTotalAprob + 1
Sino
xTotalDesaprob = xTotalDesaprob + 1
Fin_Si
Fin_Para
Mostrar xTotalAprob
Mostrar xTotalDesaprob
FIN
3.- Diseñar un algoritmo que permita controlar
para 5 libros los
siguientes datos:
Título, Autos,
Editorial, Año de edición, Número de
páginas.
Luego se permitirá el ingreso de un año
determinado y el algoritmo deberá mostrarme todos aquellos
libros que pertenezcan a este año y cuyas páginas
estén entre 600 y 1400 páginas.
INICIO
Libro =
Registro
Titulo [30] : Caracter
Autor [40] : Caracter
Editorial [40] : Caracter
AñoEdicion : Entero
NumPaginas : Entero
Fin_Registro
Libros [5] = Libro
i : Entero
xAnio : Entero
Para (i=1; i<=5; i++)
Ingresar Libros[i].Libro.Titulo
Ingresar Libros[i].Libro.Autor
Ingresar Libros[i].Libro.Editorial
Ingresar Libros[i].Libro.AñoEdicion
Ingresar Libros[i].Libro.NumPaginas
Fin_Para
Ingresar xAnio
Para (i=1; i<=5; i++)
Si(Libros[i].Libro.AñoEdicion = xAnio)
Entonces
Si (600 < Libros[i].Libro.NumPaginas <1400)
Entonces
Mostrar Libros[i].Libro.Titulo
Mostrar Libros[i].Libro.Autor
Mostrar Libros[i].Libro.Editorial
Mostrar Libros[i].Libro.AñoEdicion
Mostrar Libros[i].Libro.NumeroPaginas
Fin_Si
Fin_Si
Fin_Para
FIN
4.- Diseñar un algoritmo que me permita aceptar
la forma en que los datos de un DNI (Documento Nacional de
Identidad)
están controlados. Los datos que un DNI tiene
son:
Número del DNI, Apellido paterno, apellido
materno, nombres, fecha de nacimiento, sexo, estado
civil, fecha de inscripción, fecha de emisión,
fecha de caducidad, departamento, provincia, distrito, calle y
número, grupo de
votación y un campo lógico que determine si la
persona desea donar órganos.
INICIO
Fecha = Registro
Dia : Entero
Mes : Entero
Año : Entero
Fin_Registro
Ubicación = Registro
Departam[50] : Carácter
Provincia[50] : Carácter
Distrito[50] : Carácter
Calle[50] : Carácter
Numero : Entero
Fin_Registro
Persona = Registro
Numero[8] : Caracter
ApePaterno[40] : Caracter
ApeMaterno[40] : Carácter
Nombres[40] : Carácter
FechaNac : Fecha
Sexo: Boolean
EstadoCivil[10] : Carácter
FechaInsc : Fecha
FechaEmis : Fecha
FechaCaduc : Fecha
Dirección : Ubicacion
GrupoVotac[6] : Caracter
DonacOrg : Boolean
Edad : Entero
Sexo : Boolean
Fin_Registro
Personas[100000] = Persona
I, xReg : Entero
xReg=0
Hacer
Mostrar "1. Ingresar datos"
Mostrar "2. Mostrar datos"
Mostrar "3. Salir"
Mostrar "Ingrese opción : "
Hacer
Ingresar zOpcion
Hasta (xOpcion>=1 And xOpcion<=3)
Según_sea xOpcion hacer
1: Inicio
xReg=xReg+1
Ingresar Personas[xReg].Persona.Numero
Ingresar Personas[xReg].Persona.ApePaterno
Ingresar Personas[xReg].Persona.ApeMaterno
Ingresar Personas[xReg].Persona.Nombres
Ingresa r
Personas[xReg].Persona.FechaNac.Fecha.Dia
Ingresar
Personas[xReg].Persona.FechaNac.Fecha.Mes
Ingresar
Personas[xReg].Persona.FechaNac.Fecha.Año
Ingresar Personas[xReg].Persona.Sexo
Ingresar Personas[xReg].Persona.EstadoCivil
Ingresar
Personas[xReg].Persona.FechaInsc.Fecha.Dia
Ingresar
Personas[xReg].Persona.FechaInsc.Fecha.Mes
Ingresar
Personas[xReg].Persona.FechaInsc.Fecha.Año
Ingresar
Personas[xReg].Persona.FechaEmis.Fecha.Dia
Ingresar
Personas[xReg].Persona.FechaEmis.Fecha.Mes
Ingresar
Personas[xReg].Persona.FechaEmis.Fecha.Año
Ingresar
Personas[xReg].Persona.FechaCaduc.Fecha.Dia
Ingresar
Personas[xReg].Persona.FechaCaduc.Fecha,Mes
Ingresar
Personas[xReg].Persona.FechaCaduc.Fecha,Año
Ingresar
Personas[xReg].Persona.Direccion.Ubicación.Departam
Ingresar
Personas[xReg].Persona.Direccion.Ubicación.Provincia
Ingresar
Personas[xReg].Persona.Direccion.Ubicación.Distrito
Ingresar
Personas[xReg].Persona.Direccion.Ubicación.Calle
Ingresar
Personas[xReg].Persona.Direccion.Ubicación.Numero
Ingresar Personas[xReg].Persona.DonacOrg
Fin
2: Inicio
Para ( i=1; i<=xReg; i++)
Mostrar Personas[xReg].Persona.Numero
Mostrar Personas[xReg].Persona.ApePaterno
Mostrar Personas[xReg].Persona.ApeMaterno
Mostrar Personas[xReg].Persona.Nombres
Mostrar
Personas[xReg].Persona.FechaNac.Fecha.Dia
Mostrar
Personas[xReg].Persona.FechaNac.Fecha.Mes
Mostrar
Personas[xReg].Persona.FechaNac.Fecha.Año
Mostrar Personas[xReg].Persona.Sexo
Mostrar Personas[xReg].Persona.EstadoCivil
Mostrar
Personas[xReg].Persona.FechaInsc.Fecha.Dia
Mostrar
Personas[xReg].Persona.FechaInsc.Fecha.Mes
Mostrar
Personas[xReg].Persona.FechaInsc.Fecha.Año
Mostrar
Personas[xReg].Persona.FechaEmis.Fecha.Dia
Mostrar
Personas[xReg].Persona.FechaEmis.Fecha.Mes
Mostrar
Personas[xReg].Persona.FechaEmis.Fecha.Año
Mostrar
Personas[xReg].Persona.FechaCaduc.Fecha.Dia
Mostrar
Personas[xReg].Persona.FechaCaduc.Fecha,Mes
Mostrar
Personas[xReg].Persona.FechaCaduc.Fecha,Año
Mostrar
Personas[xReg].Persona.Direccion.Ubicación.Departam
Mostrar
Personas[xReg].Persona.Direccion.Ubicación.Provincia
Mostrar
Personas[xReg].Persona.Direccion.Ubicación.Distrito
Mostrar
Personas[xReg].Persona.Direccion.Ubicación.Calle
Mostrar
Personas[xReg].Persona.Direccion.Ubicación.Numero
Mostrar Personas[xReg].Persona.DonacOrg
Fin_Para
Fin
Fin_Según_Sea
Hasta (xOpcion=3)
FIN
5.- Diseñar un algoritmo que imprima todos los
nombres, apellidos y edades de todos los varones nacidos entre
dos fechas ingresadas desde el teclado. Para
lo cual deberá tener en cuenta el siguiente
esquema:
Persona.
Código | Apellidos | Nombres | Fecha de nacimiento | Edad | Sexo | ||
Día | Mes | Año | |||||
INICIO
Fecha = Registro
Dia : Entero
Mes : Entero
Año : Entero
Fin_Registro
Persona = Registro
Codigo [4] :
Caracter
Apellidos [40] : Caracter
Nombres [40] : Caracter
FechaNac : Fecha
Edad : Entero
Sexo : Boolean
Fin_Registro
Personas [100] = Persona
i : Entero
Para (i=1; i<=5; i++)
Ingresar Personas[i].Persona.Codigo
Ingresar Personas[i].Persona.Apellidos
Ingresar Personas[i].Persona.Nombres
Ingresar
Personas[i].Persona.FechaNac.Fecha.Dia
Ingresar
Personas[i].Persona.FechaNac.Fecha.Mes
Ingresar
Personas[i].Persona.FechaNac.Fecha.Año
Ingresar Personas[i].Persona.Edad
Ingresar Personas[i].Persona.Sexo
Fin_Para
Ingresar xDiaIni
Ingresar xMesIni
Ingresar xAñoIni
Ingresar xDiaFin
Ingresar xMesFin
Ingresar xAñoFin
Para (i=1; i<=5; i++)
Si (xAñoIni >=
Personas[i].Persona.FechaNac.Fecha.Año <=
xAñoFin Entonces
Si (xMesIni >= Personas[i].Persona.FechaNac.Fecha.Mes
<= xMesFin Entonces
Si (xDiaIni >=
Personas[i].Persona.FechaNac.Fecha.Dia <= xDiaFin
Si Ingresar Personas[i].Persona.Sexo= Verdadero
Entonces
Mostrar Personas[i].Persona.Nombres
Mostrar Personas[i].Persona.Apellidos
Mostrar Personas[i].Persona.Edad
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Para
6.- Ingresar y mostrar los datos del siguiente
esquema:
Alumno:
Código | Nombres | Apoderado | |||
N° Doc | Apellidos | Nombres | Vinculo Fam. | ||
INICIO
Apoderado = Registro
NumDoc[8] : Carácter
ApeApod[50] : Carácter
NomApod[50] : Carácter
VinculoFam[50] : Carácter
Fin_Registro
Alumno = Registro
Codigo[5] : Carácter
ApeAlum[50] : Caracter
NomAlum[50] : Caracter
Apod : Apoderado
Fin_Registro
Alumnos[100] = Alumno
I, xReg : Entero
xReg=0
Hacer
Mostrar "1. Ingresar datos"
Mostrar "2. Mostrar datos"
Mostrar "3. Salir"
Mostrar "Ingrese opción : "
Hacer
Ingresar zOpcion
Hasta (xOpcion>=1 And xOpcion<=3)
Según_sea xOpcion hacer
1: Inicio
xReg=xReg+1
Ingresar Personas[xReg].Persona.Numero
Ingresar Personas[xReg].Persona.ApePaterno
Ingresar Personas[xReg].Persona.ApeMaterno
Ingresar Personas[xReg].Persona.Nombres
Ingresa r
Personas[xReg].Persona.FechaNac.Fecha.Dia
Ingresar
Personas[xReg].Persona.FechaNac.Fecha.Mes
Ingresar
Personas[xReg].Persona.FechaNac.Fecha.Año
Ingresar Personas[xReg].Persona.Sexo
Ingresar Personas[xReg].Persona.EstadoCivil
Ingresar
Personas[xReg].Persona.FechaInsc.Fecha.Dia
Ingresar
Personas[xReg].Persona.FechaInsc.Fecha.Mes
Ingresar
Personas[xReg].Persona.FechaInsc.Fecha.Año
Ingresar
Personas[xReg].Persona.FechaEmis.Fecha.Dia
Ingresar
Personas[xReg].Persona.FechaEmis.Fecha.Mes
Ingresar
Personas[xReg].Persona.FechaEmis.Fecha.Año
Ingresar
Personas[xReg].Persona.FechaCaduc.Fecha.Dia
Ingresar
Personas[xReg].Persona.FechaCaduc.Fecha,Mes
Ingresar
Personas[xReg].Persona.FechaCaduc.Fecha,Año
Ingresar
Personas[xReg].Persona.Direccion.Ubicación.Departam
Ingresar
Personas[xReg].Persona.Direccion.Ubicación.Provincia
Ingresar
Personas[xReg].Persona.Direccion.Ubicación.Distrito
Ingresar
Personas[xReg].Persona.Direccion.Ubicación.Calle
Ingresar
Personas[xReg].Persona.Direccion.Ubicación.Numero
Ingresar Personas[xReg].Persona.DonacOrg
Fin
2: Inicio
Para ( i=1; i<=xReg; i++)
Mostrar Personas[xReg].Persona.Numero
Mostrar Personas[xReg].Persona.ApePaterno
Mostrar Personas[xReg].Persona.ApeMaterno
Mostrar Personas[xReg].Persona.Nombres
Mostrar
Personas[xReg].Persona.FechaNac.Fecha.Dia
Mostrar
Personas[xReg].Persona.FechaNac.Fecha.Mes
Mostrar
Personas[xReg].Persona.FechaNac.Fecha.Año
Mostrar Personas[xReg].Persona.Sexo
Mostrar Personas[xReg].Persona.EstadoCivil
Mostrar
Personas[xReg].Persona.FechaInsc.Fecha.Dia
Mostrar
Personas[xReg].Persona.FechaInsc.Fecha.Mes
Mostrar
Personas[xReg].Persona.FechaInsc.Fecha.Año
Mostrar
Personas[xReg].Persona.FechaEmis.Fecha.Dia
Mostrar
Personas[xReg].Persona.FechaEmis.Fecha.Mes
Mostrar
Personas[xReg].Persona.FechaEmis.Fecha.Año
Mostrar
Personas[xReg].Persona.FechaCaduc.Fecha.Dia
Mostrar
Personas[xReg].Persona.FechaCaduc.Fecha,Mes
Mostrar
Personas[xReg].Persona.FechaCaduc.Fecha,Año
Mostrar
Personas[xReg].Persona.Direccion.Ubicación.Departam
Mostrar
Personas[xReg].Persona.Direccion.Ubicación.Provincia
Mostrar
Personas[xReg].Persona.Direccion.Ubicación.Distrito
Mostrar
Personas[xReg].Persona.Direccion.Ubicación.Calle
Mostrar
Personas[xReg].Persona.Direccion.Ubicación.Numero
Mostrar Personas[xReg].Persona.DonacOrg
Fin_Para
Fin
Fin_Según_Sea
Hasta (xOpcion=3)
FIN
7.- Una empresa desea
conocer de sus trabajadores lo siguiente:
código, apellidos, nombres, área y
departamento en el que labora, cargo que ocupa, condición
del trabajador (activo, jubilado, otra condición), fecha
que ingreso a laborar, n° de documento de identidad, grupo
sanguíneo, dirección y número de carga
familiar con la que el trabajador cuenta.
INICIO
Fecha = Registro
Dia : Entero
Mes : Entero
Año : Entero
Fin_Registro
Trabajador = Registro
Codigo [5] : Carácter
ApeTrabaj[50] : Caracter
NomTrabaj[50] : Caracter
Area[50] : Caracter
Departamento[50] : Caracter
Cargo[50] : Carácter
CondicTrabaj[50] : Caracter
FechaIng : Fecha
DocumIdent[8] : Carácter
GrupoSang[8] : Carácter
Direccion[8] : Carácter
NumCargaFam[8] : Carácter
Fin_Registro
Trabakadpres[100] = Trabajador
I, xReg : Entero
xReg=0
Hacer
Mostrar "1. Ingresar datos del trabajador"
Mostrar "2. Mostrar datos del trabajador"
Mostrar "3. Salir"
Mostrar "Ingrese opción : "
Hacer
Ingresar zOpcion
Hasta (xOpcion>=1 And xOpcion<=3)
Según_sea xOpcion hacer
1: Inicio
xReg=xReg+1
Ingresar Trabajadores [xReg].
Trabajador.Codigo
Ingresar
Trabajadores[xReg].Trabajador.ApeTrabaj
Ingresar
Trabajadores[xReg].Trabajador.NomTrabaj
Ingresa r Trabajadores[xReg].
Trabajador.Area
Ingresar
Trabajadores[xReg].Trabajador.Departamento
Ingresar Trabajadores[xReg].Trabajador.Cargo
Ingresar
Trabajadores[xReg].Trabajador.CondicTrabaj
Ingresar
Trabajadores[xReg].Trabajador.Fecha.FechaIng
Ingresar
Trabajadores[xReg].Trabajador.DocumIdent
Ingresar
Trabajadores[xReg].Trabajador.CondicTrabaj
Ingresar
Trabajadores[xReg].Trabajador.GruopSang
Ingresar
Trabajadores[xReg].Trabajador.Direccion
Ingresar
Trabajadores[xReg].Trabajador.NumCargaFam
Fin
2: Inicio
Para ( i=1; i<=xReg; i++)
Mostrar Trabajadores [xReg].
Trabajador.Codigo
Mostrar
Trabajadores[xReg].Trabajador.ApeTrabaj
Mostrar
Trabajadores[xReg].Trabajador.NomTrabaj
Mostrar Trabajadores[xReg].
Trabajador.Area
Mostrar
Trabajadores[xReg].Trabajador.Departamento
Mostrar Trabajadores[xReg].Trabajador.Cargo
Mostrar
Trabajadores[xReg].Trabajador.CondicTrabaj
Mostrar
Trabajadores[xReg].Trabajador.Fecha.FechaIng
Mostrar
Trabajadores[xReg].Trabajador.DocumIdent
Mostrar
Trabajadores[xReg].Trabajador.CondicTrabaj
Mostrar
Trabajadores[xReg].Trabajador.GruopSang
Mostrar
Trabajadores[xReg].Trabajador.Direccion
Mostrar
Trabajadores[xReg].Trabajador.NumCargaFam
Fin_Para
Fin
Fin_Según_Sea
Hasta (xOpcion=3)
FIN
8.- Solucionar el siguiente esquema de una boleta de
venta.
Boleta
Número | Cliente | Dirección | Fecha | Total | ||
Día | Mes | Año | ||||
Detalle
Número | Cantidad | Detalle | P. Unitario | Total |
INICIO
Fecha = Registro
Dia : Entero
Mes : Entero
Año : Entero
Fin_Registro
Boleta = Registro
Num[5] : Carácter
Cliente[50] : Caracter
Direccion[50] : Caracter
FechaBol : Fecha
TotalBol : Real
Fin_Registro
Detalle = Registro
Num[5] : Carácter
Cantidad[50] : Caracter
Detalle[50] : Caracter
PrecioUni : Real
TotalDeta : Real
Fin_Registro
Boletas[20] = Boleta
Detalles[160] = Detalle
i, xRegD, xCant : Entero
xPrecioUni, xTotalBoleta : Real
xDatoOk : Boolean
xRpta : Caracter
xRegD=0
Hacer
Mostrar "1. Ingresar boletas"
Mostrar "2. Mostrar boletas"
Mostrar "3. Salir"
Mostrar "Ingrese opción : "
Hacer
Ingresar zOpcion
Hasta (xOpcion>=1 And xOpcion<=3)
Según_sea xOpcion hacer
1: Inicio
Para ( i=1; i<=20; i++)
Ingresar Boletas[i].Boleta.Codigo
Ingresar Boletas[i].Boleta.Num
Ingresar Boletas[i].Boleta.Cliente
Ingresa r
Boletas[i].Boleta.Dirección
xDatoOk=False
Mientras xDatoOk=False Hacer
Ingresar
Boletas[i].Boleta.Fechabol.Fecha.Dia
Si Boletas[i].Boleta.Fechabol.Fecha.Dia =Dato
Numerico Entonces
Si
(1<=Boletas[i].Boleta.Fechabol.Fecha.Dia<=31
Entonce
xDatoOk=True
Fin_Si
Fin_Si
Fin_Mientras
xDatoOk=False
Mientras xDatoOk=False Hacer
Ingresar
Boletas[i].Boleta.Fechabol.Fecha.Mes
Si Boletas[i].Boleta.Fechabol.Fecha.Mes = Dato
Numerico Entonce
Si
(1<=Boletas[i].Boleta.Fechabol.Fecha.Mes<=12)
Entonces
xDatoOk=True
Fin_Si
Fin_Si
Fin_Mientras
xDatoOk=False
Mientras xDatoOk=False Hacer
Ingresar
Boletas[i].Boleta.Fechabol.Fecha.Año
Si Boletas[i].Boleta.Fechabol.Fecha.Año
=Dato Numerico Entonce
Si
(0<=Boletas[i].Boleta.Fechabol.Fecha.Año<=9999)
Entonces
xDatoOk=True
Fin_Si
Fin_Si
xRpta=Si
xCont=1
xTotalBoleta=0
Mientras xRpta=Si And xCont<=8 hacer
xNumDeta=xNumDeta + 1
Ingresar
Detalles[xRegD].Detalle.Num=Boletas[i].Boleta.Num
Ingresar
Detalles[xRegD].Detalle.Cantidad
xCantidad=
Detalles[xRegD].Detalle.Cantidad
Ingresar
Detalles[xRegD].Detalle.Detalle
Ingresar
Detalles[xRegD].Detalle.PrecioUni
xPrecioUni=
Detalles[xRegD].Detalle.PrecioUni
Detalles[xRegD].Detalle.TotalDeta=xCantidad *
xPrecioUni
xTotalBoleta = xTotalBoleta + (xCantidad *
xPrecioUni)
Mostrar "Ingresar Nuevo detalle?
(Si/No):"
Ingresar xRpta
Fin_Mientras
Boletas[i].Boleta.TotalBol=xTotalBoleta
Fin_Para
‘***Realizar el ordenamiento por
metodo burbuja
‘***
Fin
2: Inicio
Para ( i=1; i<=20; i++)
Mostrar Boletas[i].Boleta.Codigo
Mostrar Boletas[i].Boleta.Num
Mostrar Boletas[i].Boleta.Cliente
Mostrar Boletas[i].Boleta.Direccion
Mostrar
Boletas[i].Boleta.Fechabol.Fecha.Dia
Mostrar
Boletas[i].Boleta.Fechabol.Fecha.Mes
Mostrar
Boletas[i].Boleta.Fechabol.Fecha.Año
Mostrar Boletas[i].Boleta.totalBol
Para (j=1; j<=160; j++)
Si Detalles[j].Num=Boletas.[i].Boleta.Num
Entonces
Mostrar Detalles[j].Detalle.Num
Mostrar Detalles[j].Detalle.Cantidad
Mostrar Detalles[j].Detalle.Detalle
Mostrar Detalles[j].Detalle.PrecioUni
Mostrar Detalles[j].Detalles.TotalDeta
Fin_Si
Fin_Para
Fin_Para
Fin
Fin_Según_Sea
Hasta (xOpcion=3)
FIN
IV. AGRADECIMIENTO
Nuestro agradecimiento a los Directivos y docentes de
esta casa Superior de Estudios por haberse preocupado para que en
esta zona del Nor Oriente Peruano exista más oportunidades
de superación académica de nivel
universitario.
En especial nuestro agradecimiento a todas las personas
que de manera desinteresada se involucraron en apoyarnos para
seguir adelante en nuestra formación universitaria que
hemos iniciado.
El equipo de trabajo.
El presente trabajo está dedicado a nuestras
familias, y a todas aquellas personas que nos apoyan y comprenden
para que salgamos adelante y cumplamos nuestra meta.
Autor:
Lozano Mejía Ansel Aladino
Vértiz Osores David Daniel
Vásquez Carrión, Malena
Celeste
Vásquez Zamora, Humberto
Estudiantes de Ingeniería Informática y
Sistemas
Universidad de Chiclayo – Filial Jaén
– Perú
 Página anterior | Volver al principio del trabajo | Página siguiente  |