Seminario Examen
-
Upload
alexis-sovero-camacuari -
Category
Documents
-
view
255 -
download
0
description
Transcript of Seminario Examen
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
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 codigo_alumno como Entero;
Definir nota como Real;
FinEstructura
Información de cursos
Estructura curso
Dimension codigo_curso[5];
Definir codigo_curso como Caracter;
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.
Estructura jerárquica
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
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)/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.