Examen Final - 75.40. Algoritmos y Programacion I - Fecha 2007-07-05

Cátedra: Guarna
Fecha: 1ra Oportunidad - 1er Cuatrimestre 2007
Día: 05/07/2007

1) Temas a evaluar: operaciones entre archivos secuenciales. ( 2 puntos – 20’ ) Se cuenta con dos archivos A.DAT y BAJAS.DAT . El archivo A tiene la siguiente estructura:

• Clave (entero)
• Datos (string de 100 posiciones)

El archivo de BAJAS, solamente tiene el campo Clave. Los archivos son de acceso secuencial. El archivo A está ordenado por clave, en cambio, el archivo BAJAS está desordenado. Se pide generar un archivo C.DAT (también secuencial y ordenado) que no tenga los registros que están dados de baja.

2) Temas a evaluar: act. archivo directo – archivos de texto – manejo de índices - Abstracción. ( 4 puntos – 40’ ) Se cuenta con dos archivos A.DAT y B.DAT ambos con la siguiente estructura:

• Clave (entero)
• Datos (string de 100 posiciones)

El archivo A es de acceso secuencial / directo, las claves no coinciden con la posición del registro y tampoco están ordenadas. El archivo B es sólo de acceso secuencial, ordenado por clave. Se pide actualizar el campo Datos del archivo A con el del archivo B, si no se encontrara la clave a actualizar se guardará en un archivo de texto CSV (valores separados por comas) LOG.TXT ese registro, deberá quedar ordenado por clave. Optimizar el algoritmo, con ese fin generar un índice re utilizando una unidad que ya tienen. Esta unidad tiene la siguiente interfaz: Type tIndice;

	Procedure GenerarIndice ( var Indice: tIndice; var archivo: tArchivo;  var n: integer); 
	{ Carga un índice del archivo, n es el tamaño lógico del índice }
	Function Buscar ( var Indice: tIndice; clave: integer; n: integer ) : integer;
	{ Busca la clave en el índice, si no está devuelve -1, si la encuentra devuelve la posición }
														

3) Temas a evaluar: units. ( 1 punto – 10’ ) Definir una unidad que maneje el tipo de dato tPuntoR3 y que conste de las siguientes primitivas:

• CargarPunto ( X ) { Carga en X un punto de R3 }
• Imprimir ( X ) { Imprime el punto con la forma: ( x , y , z ) }
• Distancia ( X , Y ) { Devuelve la distancia del punto X al punto Y }

ANSI C

4) Temas a evaluar: Ansi C – punteros - recursividad. ( 2 puntos – 20’ ) Definir, en ANSI C, una función recursiva, que reciba por parámetros: un puntero a un entero (la dirección de memoria del primer elemento de un array) y un entero (el tamaño lógico del array). Esta función tiene que devolver la sumatoria de los elementos del array.

PREGUNTAS TEÓRICAS

5) Temas a evaluar: Clase Especial ( 1 punto – 10’ )

1. Explique cuál es la ventaja de Pascal como lenguaje de programación para los cursos de primer año ¿Cuál es la ventaja principal de C?
2. ¿En qué consiste la documentación interna y externa? ¿Por qué debería documentar un programa de las dos maneras?

Program ej1;
{ Defino tipos }
Type 
	tReg = record
			clave: integer;
			datos: string[100];
		End;
	tArch = file of tReg;
	{ Sirve tanto para el archivo A como para el C }
 
	tArchBajas = file of integer;	{ Sólo tiene el campo clave, se podría usar también un reg }
 
{*******************************************************************************}
var
clave : integer;
encontrado: boolean;
reg: tReg;
archA, archC : tArch;
archB : tArchBajas;
 
{*******************************************************************************}
 
{ Comienza el pgm ppal }
Begin
	{Asignación de archivos}
	Assign(archA,´A.DAT´);
	Assign(archB,´BAJAS.DAT´);
	Assign(archC,´C.DAT´);
 
	{ Abro archivos }
	Reset(archA);		{ Para lectura }
	Rewrite(archC); 	{ Creo y abro para escribir }
 
	{ Empiezo a recorrer el archivo A. Tener en cuenta que está ordenado y quiero que C también quede ordenado }
	While (not EOF(archA)) do
	Begin
		Read(archA,reg); 	{ Leo un reg }
		Encontrado := false;
		{ Abro el archivo BAJAS porque está desordenado y tengo que recorrerlo todo }
		Reset(archB);
 
 
 
		{ Busco si está dado de baja }
		While (not EOF(archB)) do
		Begin
			Read(archB,clave);
			If (clave = reg.clave) { Está dado de baja }
				Encontrado := true;
			{ else no hago nada }
		End;
 
		{ Salió del ciclo anterior, ya sea porque se terminó el archivo o porque lo encontró }
		If ( not encontrado ) then
			Write(archC, reg);
		{ sino no hago nada (lo salteo) }
 
	End;
 
	{ Cierro los archivos }
	Close(archA);
	Close(archB);
	Close(archC);
End.

Program ej2;
 
Uses indice; { utilizo la unidad ya creada }
 
{ Defino tipos }
Type 
	tReg = record
			clave: integer;
			datos: string[100];
		End;
	tArch = file of tReg;
	{ Sirve tanto para el archivo A como para el B }
 
 
{*******************************************************************************}
Var
	Indice: tIndice;	{ tipo de variable definida en la unit }
	n, pos : integer;
	regLog: string[110];	{ Para albergar los datos, el número y la coma }
	regA, regB: tReg;
	archA, archC : tArch;
	archLog : text;
 
{*******************************************************************************}
 
{ Comienza el pgm ppal }
Begin
	{Asignación de archivos}
	Assign(archA,´A.DAT´);
	Assign(archB,´B.DAT´);
	Assign(archLog,´LOG.TXT´);
 
	{ Abro archivos }
	Reset(archA);		{ Para lectura y escritura }
	Reset(archB);		{ Para lectura }
	Rewrite(archLog); 	{ Creo y abro para escribir }
 
	{ Genero el índice con el procedimiento (método) definido en la unit }
	GenerarIndice(indice,  archA, n);
 
 
	{ Empiezo a recorrer el archivo B. Tener en cuenta que está ordenado }
	While (not EOF(archB)) do
	Begin
		Read(archB,regB); 	{ Leo un reg }
		Pos := Buscar ( indice, regB.clave, n );
 
		If ( Pos = -1)  then { No se encontró, tiene que ir al archivo log }
		Begin
			Str (reg.clave, regLog);			{ Paso la clave a una cadena }
			regLog := regLog + ´,´ + reg.datos;	{ Agrego coma y datos }
			writeln(archLog, regLog);		{ Grabo en el archivo Log }
		end
		else	{ Tengo que actualizar }
		begin
			seek(archA,pos);	{ posiciono }
			write(archA,regB);	{ grabo en A el nuevo registro }
		end;
 
	End;
 
	{ Cierro los archivos }
	Close(archA);
	Close(archB);
	Close(archLog);
End.

{ La podían hacer con vectores o con registros }
Unit punto;	{ Versión con vectores }
 
Interface
	tPuntoR3 = array [1..3] of real;
 
	Procedure CargarPunto (var X: tPuntoR3);	{ Asigna un punto de R3 }
	Procedure Imprimir( X: tPuntoR3);		{ Imprime un punto de R3 }
	Function Distancia ( X,Y: tPuntoR3 ) : real;	{ Devuelve la dist entre dos puntos de R3 }
 
Implementation
 
	Procedure CargarPunto (var X: tPuntoR3);
	Begin
		Writeln (´Ingrese las coordenadas del nro separadas por espacios´);
		Readln( X[1], X[2] , X[3] );
	End;
 
	Procedure Imprimir( X: tPuntoR3);
	Begin
		Writeln(´(´,X[1],`,`, X[2] ,`,`, X[3],`)`);
	End;
 
	Function Distancia ( X,Y: tPuntoR3 ) : real;
	Begin
		Distancia := sqrt (sqr ((Y[1]-X[1])) + sqr ((Y[2]-X[2])) + sqr ((Y[3]-X[3])));
	End;
 
End.