Descargar

Estructura de datos (página 2)

Enviado por vodd69

Partes: 1, 2

MODULARIDAD

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:

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.

  1. 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

  1. 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)
  1. 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 y modificar.

Un programa modular es más fácil de escribir y depurar (ejecutar, probar y poner a punto).

Un programa modular es más fácil de controlar. El desglose de un problema en módulos permite encomendar los módulos más complejos a los programadores más experimentados y los más sencillos a los programadores nóveles.

Posibilita el uso repetitivo de las rutinas en el mismo o en diferentes programas.

Desventajas del uso de módulos:

No se dispone de algoritmos formales de modularidad, por lo que a veces los programadores no tienen claras las ideas de los módulos.

La programación modular requiere más memoria y tiempo de ejecución.

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

 VARIABLES:

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

PROCEDIMIENTOS:

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:

  1. 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ó.
  2. Las funciones devuelven un valor, los procedimientos pueden devolver 0, 1 ó n valores y en forma de lista de parámetros.
  3. El procedimiento se declara igual que la función, pero su nombre no está asociado a ninguno de los resultados que obtiene.

FUNCIONES:

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:

  1. A cada parámetro formal se le asigna el valor real de su correspondiente parámetro actual.
  2. Se ejecuta el cuerpo de acciones de la función.
  3. 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.

ARQUITECTURA MODULAR:

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

 RECURSIVIDAD:

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

REGISTROS

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

VIII. CONCLUSIONES

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.

X. BIBLIOGRAFÍA

  • 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

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

ANEXOS

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

vodd69[arroba]hotmail.com

amistades[arroba]hotmail.com

Estudiantes de Ingeniería Informática y Sistemas

Universidad de Chiclayo – Filial Jaén – Perú

Partes: 1, 2
 Página anterior Volver al principio del trabajoPágina siguiente