seminario examen

Company

LOGO

Programación Dinámica

Seminario: Examen Final

Agenda

1. Algoritmos recursivos

2. Pilas

3. Colas

4. Listas Enlazadas

Primer problema

Para un número real x mayor que 1,

diseñe un algoritmo que empleando sólo

las operaciones aritméticas básicas (+, -, /,

*), permita calcular la raíz cuadrada de x

con una aproximación hasta las

milésimas.

Plan de acción

Generamos una aproximación g para el valor de la raíz cuadrada de x.

Calculamos x/g.

Si x/g está lo suficientemente cerca de g, g es nuestra respuesta.

Si no lo es, necesitamos generar una mejor aproximación.

Estructura Jerárquica

Módulo Principal

Calcular raíz cuadrada

Verificar si la aproximación

es buena

Generar una mejor

aproximación

Módulo Principal

Proceso principal

Definir resultado como Real;

Definir valor_ingresado como Real;

Repetir

Leer valor_ingresado;

Hasta que valor_ingresado > 1;

resultado <- calcular_raiz_cuadrada(valor_ingresado, 1);

Escribir resultado;

FinProceso

Calcular raíz cuadrada

Funcion resultado <- calcular_raiz_cuadrada(un_numero,

aproximacion)

Definir resultado Como Real;

Si estamos_cerca(un_numero, aproximacion) Entonces

resultado <- aproximacion;

Sino

resultado <- calcular_raiz_cuadrada(un_numero,

generar_aproximacion(un_numero, aproximacion));

FinSi

FinFuncion

¿Es una buena

aproximación?Funcion resultado <- estamos_cerca(un_numero, aproximacion)

Definir resultado Como Logico;

Definir diferencia como Real;

resultado <- Falso;

diferencia <- un_numero/aproximacion - aproximacion;

Si diferencia < 0 Entonces

diferencia <- -1 * diferencia;

FinSi

Si diferencia <= 0.001 Entonces

resultado <- Verdadero;

FinSi

FinFuncion

Generar una nueva

aproximación

Funcion resultado <- generar_aproximacion(

un_numero, aproximacion)

Definir resultado como Real;

resultado <- (un_numero/aproximacion +

aproximacion) / 2;

FinFuncion

Probemos

Segundo problema (I)

Se tiene (ya existen) los siguientes

archivos físicos:

ALUMNOS.DAT: cod_alum(entero de 4

dígitos), Nomb (cadena de 30 caracteres),

Edad(entero).

CURSOS.DAT: cod_curso (cadena de 5

caracteres), cod_alum, nota_final (real).

Segundo problema (II)

Diseñe un algoritmo que permita:

Almacenar en los nodos de una Lista (Pila o

Cola): código del curso, número de alumnos

inscritos y el promedio de las notas finales de

los inscritos en dicho curso.

Eliminar de la Lista creada en a) aquellos

nodos cuyos promedios de notas finales es

menor a 6.

Plan de acción (a)

Necesitamos una lista para almacenar la información de cursos.

Recorremos los registros del archivo.

En caso se trate de un curso no registrado, agregamos el elemento a la lista.

En caso se trate de un curso que ya está en la lista, actualizamos la información de inscritos y el promedio.

Definir Estructuras

Información de alumnos

Estructura alumno

Definir codigo_alumno como Entero;

Dimension nombre[30];

Definir nombre como Caracter;

Definir edad como Entero;

FinEstructura

Nota del alumno

Estructura nota_alumno

Dimension codigo_curso[5];

Definir codigo_curso como Caracter;


Definir nota como Real;

FinEstructura

Información de cursos

Estructura curso



Definir alumnos_inscritos como Entero;

Definir *puntero_siguiente como curso;

FinEstructura

Estructura jerárquica

Módulo Principal

Registrar información

de curso

Apilar

Mostrar listado de

cursos

Depurar cursos

Módulo Principal

Proceso principal

Definir archivo_notas como Archivo;

Definir *puntero_lista como curso;

Definir una_nota como nota_alumno;

Definir numero_notas como Entero;

Definir contador_notas como Entero;

puntero_lista <- NULO;

Abrir "cursos.dat" como archivo_notas para Lectura;

numero_notas <- LDA(archivo_notas)/tamaño_de(nota_alumno);

Para contador_notas <- 0 Hasta numero_notas - 1 Hacer

Leer archivo_notas, contador_notas, una_nota;

actualizar_curso(una_nota, puntero_lista);

FinPara

depurar_lista(puntero_lista);

mostrar_lista(puntero_lista);

Cerrar archivo_notas;

FinProceso

Actualizar curso

SubProceso actualizar_curso(una_nota por Valor, puntero_lista por Referencia){

Definir *puntero_actual como curso;

Definir existe_el_curso como Logico;

Definir suma_notas como Real;

Definir numero_inscritos como Entero;

existe_el_curso = Falso;

puntero_actual = puntero_lista;

Mientras puntero_actual <> NULO Hacer

Si puntero_actual->codigo_curso = una_nota.codigo_curso Entonces

suma_notas <- puntero_actual->promedio_final * puntero_actual->alumnos_inscritos

+ una_nota.nota;

numero_inscritos <- puntero_actual->alumnos_inscritos + 1;

puntero_actual->promedio_final <- suma_notas / numero_inscritos;

puntero_actual->alumnos_inscritos <- numero_inscritos;

existe_el_curso <- Verdadero;

FinSi

puntero_actual <- puntero_actual->puntero_siguiente;

FinMientras

Si ~existe_el_curso Entonces

apilar(puntero_lista, una_nota.codigo_curso, 1, una_nota.nota);

FinSi

FinSubProceso

Apilar

SubProceso apilar(puntero_pila por Referencia, codigo_curso,

alumnos_inscritos, promedio_final)

Definir *puntero_nuevo como curso;

reservar(puntero_nuevo);

puntero_nuevo->codigo_curso <- codigo_curso;

puntero_nuevo->alumnos_inscritos <- alumnos_inscritos;

puntero_nuevo->promedio_final <- promedio_final;

puntero_nuevo->siguiente <- puntero_pila;

puntero_pila <- puntero_nuevo;

FinSubProceso

Plan de acción (a)

Sería MUCHO más fácil depurar cursos si la lista estuviera ordenada.

Ordenaremos la Lista Enlazada mediante Ordenamiento por Burbuja.

Recorremos la lista removiendo todos los nodos que no cumplan la condición.

Cada eliminación modificará el Puntero de Inicio de la Lista.


Módulo Principal

Registrar información

de curso

Apilar

Mostrar listado de

cursos

Depurar cursos

Ordenar Lista

Remover cursos

SubProceso depurar_lista(puntero_lista por Referencia)

Definir *auxiliar como curso;

auxiliar <- NULO;

ordenar_lista(puntero_lista);

Mientras puntero_lista <> NULO & puntero_lista->promedio_final < 6 Hacer

auxiliar <- puntero_lista;

puntero_lista <- puntero_lista->puntero_siguiente;

liberar(auxiliar);

FinMientras

FinSubProceso

Ordenamiento por burbuja

SubProceso ordenar_lista(puntero_lista)

Definir esta_ordenado como Entero;

Definir auxiliar como curso;

esta_ordenado <- Falso;

Mientras ~esta_ordenado Hacer

esta_ordenado <- Verdadero;

Mientras puntero_lista <> NULO & puntero_lista->puntero_siguiente <> NULO Hacer

Si puntero_lista->promedio_final > (puntero_lista->puntero_siguiente)->promedio_final Entonces

auxiliar.codigo_curso <- puntero_lista->codigo_curso;

puntero_lista->codigo_curso <- (puntero_lista->puntero_siguiente)->codigo_curso;

puntero_lista->puntero_siguiente)->codigo_curso <- auxiliar.codigo_curso;

//Hacer esto para el resto de campos de la estructura

esta_ordenado <- Falso;

FinSi

puntero_lista <- puntero_lista->puntero_siguiente;

FinMientras

FinMientras

FinSubProceso

Mostrar lista

SubProceso mostrar_lista(puntero_actual)

Si puntero_actual = NULO Entonces

Escribir "La lista no tiene elementos";

Sino

Mientras puntero_actual <> NULO Hacer

Escribir puntero_actual->codigo_curso,

puntero_actual->alumnos_inscritos,

puntero_actual->promedio_final;

puntero_actual <- puntero_actual->puntero_siguiente;

FinMientras

FinSi

FinSubProceso

Tercer problema

Suponiendo que el archivo CURSOS.DAT de la

pregunta 2 tiene a lo más 100 registros, se pide

diseñar un algoritmo que:

Almacene en un arreglo de registros los datos de

dicho archivo.

Permita crear una (sola) función RECURSIVA, que

reciba dicho arreglo de registros, la cantidad de

elementos almacenados y el código de un alumno,

luego nos retorne el número de cursos que dicho

alumno tiene.

Plan de acción

Verificamos el último elemento de arreglo.

Si este elemento tiene el código que buscamos el incremento es 1. Si no, no hay incremento.

El resultado es el incremento más el número de cursos del vector excluyendo este último elemento.

Hacer esto hasta que no queden elementos que inspeccionar.


Módulo Principal

Obtener número de cursos por

alumno

Módulo Principal

Estructura nota_alumno




Definir nota como Real;

FinEstructura

Proceso principal

Dimension vector_notas[100];

Definir vector_notas como nota_alumno;

Definir archivo_notas como Archivo;

Definir una_nota como nota_alumno;

Definir contador_notas como Entero;

Definir numero_notas como Entero;

Abrir "cursos.dat" como archivo_notas para Lectura;

numero_notas <- LDA(archivo_notas)/tamaño_de(nota_alumno);

Para contador_notas <- 0 Hasta numero_notas - 1 Hacer

Leer archivo_notas, contador_notas, una_nota;

vector_notas[contador_notas] <- una_nota;

FinPara

Escribir obtener_numero_cursos(vector_notas, numero_notas, 1235);

Cerrar archivo_notas;

FinProceso

Contar cursos

Funcion numero_cursos <- obtener_numero_cursos(vector_notas, numero_elementos, codigo_alumno)

Definir incremento como Entero;

Definir ultimo_registro como nota_alumno;

numero_cursos <- 0;

Si numero_elementos > 0 Entonces

incremento <- 0;

ultimo_registro <- vector_notas[numero_elementos - 1];

Si ultimo_registro.codigo_alumno = codigo_alumno Entonces

incremento <- 1;

FinSi

numero_cursos <- obtener_numero_cursos(vector_notas, numero_elementos - 1, codigo_alumno)

+ incremento;

FinSi

FinFuncion

Cuarto Problema

Diseñe un algoritmo que empleando los

archivos de la pregunta 2, permita presentar un

reporte en donde se indique por cada curso:

código del curso, número de inscritos, listado de

los alumnos inscritos (código del alumno,

nombre y nota final) ordenado en forma

creciente respecto al código del alumno. Al final

de cada curso debe aparecer la mayor y menor

nota, y la edad promedio de los inscritos en

dicho curso.

¡Mucha suerte!

A day may come when the courage of men

fails… but it is not THIS day – Aragorn

seminario examen

Documents