Programacin Dinmica

Seminario: Examen Final

Company

LOGO

Agenda

1. Algoritmos recursivos
2. Pilas
3. Colas
4. Listas Enlazadas

Primer problema
Para un nmero real x mayor que 1,
disee un algoritmo que empleando slo
las operaciones aritmticas bsicas (+, -, /,
*), permita calcular la raz cuadrada de x
con una aproximacin hasta las
milsimas.

Plan de accin
Generamos una aproximacin g para
el valor de la raz 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 aproximacin.

Estructura Jerrquica
Mdulo
Principal

Calcular raz
cuadrada
Verificar si la
aproximacin
es buena
Generar una
mejor
aproximacin

Mdulo 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 raz 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
aproximacin?
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

aproximacin
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 fsicos:

ALUMNOS.DAT: cod_alum(entero de 4
dgitos), Nomb (cadena de 30 caracteres),
Edad(entero).
CURSOS.DAT: cod_curso (cadena de 5
caracteres), cod_alum, nota_final (real).

Segundo problema (II)

Disee un algoritmo que permita:

Almacenar en los nodos de una Lista (Pila o

Cola): cdigo del curso, nmero 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 accin (a)

Necesitamos una lista para almacenar la
informacin 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 informacin
de inscritos y el promedio.

Definir Estructuras
Informacin
de alumnos

Nota del
alumno

Informacin
de cursos

Estructura alumno
Definir codigo_alumno como Entero;
Dimension nombre[30];
Definir nombre como Caracter;
Definir edad como Entero;
FinEstructura
Estructura nota_alumno
Dimension codigo_curso[5];
Definir codigo_curso como Caracter;
Definir codigo_alumno como Entero;
Definir nota como Real;
FinEstructura
Estructura curso
Dimension codigo_curso[5];
Definir codigo_curso como Caracter;
Definir alumnos_inscritos como Entero;
Definir *puntero_siguiente como curso;
FinEstructura

Estructura jerrquica
Mdulo
Principal
Registrar
informacin
de curso

Apilar

Mostrar
listado de
cursos

Depurar
cursos

Mdulo 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)/tamao_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 accin (a)

Sera MUCHO ms fcil 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 condicin.

Cada eliminacin modificar el Puntero

de Inicio de la Lista.

Estructura jerrquica
Mdulo
Principal
Registrar
informacin
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 ms 100 registros, se pide
disear un algoritmo que:

Almacene en un arreglo de registros los datos de

dicho archivo.
Permita crear una (sola) funcin RECURSIVA, que
reciba dicho arreglo de registros, la cantidad de
elementos almacenados y el cdigo de un alumno,
luego nos retorne el nmero de cursos que dicho
alumno tiene.

Plan de accin
Verificamos el ltimo elemento de
arreglo.
Si este elemento tiene el cdigo que
buscamos el incremento es 1. Si no, no
hay incremento.

El resultado es el incremento ms el
nmero de cursos del vector excluyendo
este ltimo elemento.
Hacer esto hasta que no queden
elementos que inspeccionar.

Estructura jerrquica

Mdulo
Principal

Obtener nmero
de cursos por
alumno

Mdulo Principal
Estructura nota_alumno
Dimension codigo_curso[5];
Definir codigo_curso como Caracter;
Definir codigo_alumno como Entero;
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)/tamao_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
Disee un algoritmo que empleando los
archivos de la pregunta 2, permita presentar un
reporte en donde se indique por cada curso:
cdigo del curso, nmero de inscritos, listado de
los alumnos inscritos (cdigo del alumno,
nombre y nota final) ordenado en forma
creciente respecto al cdigo 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