Modo compacto | Modo extendido

55 en 17 posts · 20-09-2013 12:58

(17-09-2013 14:13)ericlifs escribió: Aca les dejo una foto de lo que aparecía en el ejercicio 1)c) en el final:

Eric!

Fijate si este dibujito que subí antes te ayuda a entender lo que hay que hacer. Te da la esquina superior izquierda y la inferior derecha de una zona (la que esta sombreada) y quiere que calcules el promedio de toda esa zona.

Eric!

(18-09-2013 20:30)lemenz escribió: A mi me quedo algo asi... disculpen que las suba de una pagina... es que no tengo idea de como subirlas del ordenador y bueno... tampoco me supieron decir...

Si encuentran algun error no duden en gritar!

Saludos!

http://www.subirimagenes.net/i/130919012829381191.jpg
http://www.subirimagenes.net/i/130919012835491930.jpg
http://www.subirimagenes.net/i/130919012846116190.jpg

Lo unico que te puedo corregir (aunque no esta mal lo que hiciste) es que los indices de la matriz los hagas de [-180;180] y [-90;90] asi te olvidas de hacer todas las cuentas de sumarle 180 y 90 en cada caso. Me imagino que al poner una parte positiva y otra negativa, querian que se den cuenta que podian poner igualmente los indices (aunque ponerlos todos positivos no es un error).

Eric!

0 en 0 posts · 20-09-2013 14:52

Yo rindo en esta fecha. Podriamos juntarnos este finde para tratar de resolver algunos finales. O conferencia via skype o algo asi.

291 en 67 posts · 20-09-2013 15:38

Off-topic:: Faa como cambio el final a cuando lo di yo!

0 en 0 posts · 23-09-2013 21:07

Estuve practicando en pascal y resolvi el punto 1 completo. Adjunto el archivo .pas (programa) y archivito de texto que use para simular algunas coordenadas.
Lo probe completo y me funciona bien. Lo subo para quien le sirva y de paso repasar la sintaxis de pascal. Esta bastante completito.

Saludos.

[/code]



 



PROGRAM ejercicio_final;



CONST

	FILAS = 0;

	COLUMNAS = 0;



TYPE 

	tBase = record

		cantidad_mediciones: integer;

		promedio_temperatura: real;

	end;

	

	tFilas = -1..FILAS;

	tColumnas = -1..COLUMNAS;

	tMatriz = array[tFilas,tColumnas] of tbase;

	

	tRMedidas = record 

		instante: integer;

		latitud: shortint;

		longitud: integer;

		temperatura: real;

	end;

	

	tAMedidas = FILE OF tRMedidas;

	

	tCoordenada = record

		latitud: shortint;

		longitud: integer;

	end;

	

VAR

	matriz: tMatriz;

	ArchText:TEXT;

	Amedidas: tAMedidas;

	Rmedidas: tRMedidas;

	ptoIni,ptoFin:tCoordenada;

	prom_zona:real;



PROCEDURE AbrirArchivos(var ArchText:TEXT; var Amedidas:tAMedidas);

BEGIN

    ASSIGN(ArchText, 'medidas.txt');

    RESET(ArchText);

    ASSIGN(Amedidas, 'medidas.dat');

    REWRITE(Amedidas);

END;



PROCEDURE convertirABinario(var ArchText:TEXT; var Amedidas:tAMedidas);

var 

	instante,longitud: integer;

	latitud: shortint;

	temperatura: real;



BEGIN

	WHILE NOT EOF(ArchText) DO 

	BEGIN

		READLN(ArchText, instante);

		Rmedidas.instante := instante;

		READLN(ArchText, latitud);

		Rmedidas.latitud := latitud;

		READLN(ArchText, longitud);

		Rmedidas.longitud := longitud;

		READLN(ArchText, temperatura);

		Rmedidas.temperatura := temperatura;

		WRITE(Amedidas,Rmedidas);

	END;

END;



PROCEDURE CierroArchivos (var ArchText:TEXT; var Amedidas:tAMedidas);

BEGIN

    CLOSE(Amedidas);

    CLOSE(ArchText);

END;



PROCEDURE generarMatriz(var matriz: tMatriz; var Amedidas:tAMedidas);

BEGIN

	RESET(Amedidas);

    WHILE NOT EOF(Amedidas) DO

	BEGIN

	    READ(Amedidas, Rmedidas);

	    

	    matriz[Rmedidas.latitud,Rmedidas.longitud].promedio_temperatura := ((matriz[Rmedidas.latitud,Rmedidas.longitud].promedio_temperatura * matriz[Rmedidas.latitud,Rmedidas.longitud].cantidad_mediciones) +  Rmedidas.temperatura) / (matriz[Rmedidas.latitud,Rmedidas.longitud].cantidad_mediciones + 1);

	    matriz[Rmedidas.latitud,Rmedidas.longitud].cantidad_mediciones := matriz[Rmedidas.latitud,Rmedidas.longitud].cantidad_mediciones + 1;

	END;

	CLOSE(Amedidas);

END;





PROCEDURE mostrarMatriz(matriz:tMatriz);

var i,j: integer;

BEGIN

	FOR i:= -1 TO FILAS DO BEGIN

		FOR j:= -1 TO COLUMNAS DO BEGIN

			write('Cant med: ',matriz[i,j].cantidad_mediciones,' ');	

			write('Prom tmp: ',matriz[i,j].promedio_temperatura:3:2,' ');

		END;

		writeln;

	END;

	

END;



FUNCTION promedioZona(a,b:tCoordenada; matriz:tMatriz):real;

var 

	i,j,tmp_cant: integer;

	tmp_promedioZona:real;

BEGIN

	tmp_promedioZona := 0;

	tmp_cant := 0;

	FOR i:= a.latitud TO b.latitud DO BEGIN

		FOR j:= a.longitud TO b.longitud DO BEGIN			

			tmp_promedioZona := ((tmp_promedioZona * tmp_cant) + matriz[i,j].promedio_temperatura) / (tmp_cant + 1) ;

			tmp_cant := tmp_cant + 1;

		END;

	END;

	promedioZona := tmp_promedioZona;

END;



BEGIN 

	AbrirArchivos(ArchText,Amedidas);

    convertirABinario(ArchText,Amedidas);	

	CierroArchivos(ArchText,Amedidas);

	generarMatriz(matriz,Amedidas);

	mostrarMatriz(matriz);

	

	ptoIni.latitud := -1;

	ptoIni.longitud := -1;

	

	ptoFin.latitud := 0;

	ptoFin.longitud := -1;

	

	prom_zona := promedioZona(ptoIni,ptoFin,matriz);

	writeln;

	write('Promedio Zona: ',prom_zona:3:2);

	

END.

Compilar y ejecutar código

0 en 0 posts · 23-09-2013 22:31

Eric, te acordas la respuesta del punto 3 ? o alguno la sabe?

55 en 17 posts · (24-09-2013)

Si, falso, porque la funcion que sirve para colas necesita como parametro cola-frente y cola-fin, y para la funcion de listas solo necesitas un unico puntero (eso lo podes resolver a simple vista en la hoja de funciones que te dan en el final, al reverso de la hoja).

Eric!

0 en 0 posts · 24-09-2013 13:44

- Subo mi propuesta de resolución del punto 2. Sinceramente me gustaría que me ayuden a pulir la función "diferenciaSimetrica" que creé, ya que a mi parecer es poco performante porque lo que estoy haciendo en esa funcion es tomar una de las listas (listaA) y comparar elemento por elemento con la otra lista (listaB). Y luego hago el procedimiento inverso, es decir, comparo elemento por elemento de la listaB con los de la listaA.

- Si bien NO es performante el programa funciona bien y me devuelve la diferencia simétrica correctamente.

- Me gustaria que le den una mirada asi me ayudan a entender mejor la parte de resolución algorítmica (que es en lo que ando flojo).



 



PROGRAM ejercicio2_listas_final;



TYPE 

	tipoinfo= string[30];

	tLista = ^tNodo;

	

	tNodo = record 

		info: tipoinfo;

		sgte: tLista;

	end;

	

VAR

	listaA,listaB,listaDif: tLista;





PROCEDURE crearLista(var lista:tlista);

BEGIN

    lista := NIL;    

END;



PROCEDURE insertaPrimero(var lista:tlista; valor:tipoinfo);

VAR ptr:tlista;

BEGIN

        NEW(ptr);

        ptr^.info := valor;        

        ptr^.sgte := NIL;                      

        lista := ptr;

END;



PROCEDURE insertaDelante(var lista:tlista; valor:tipoinfo);

VAR ptr:tlista;

BEGIN

        NEW(ptr);

        ptr^.info := valor;        

        ptr^.sgte := lista;                      

        lista := ptr;

END;



PROCEDURE insertaEnMedio(var lista:tlista; valor:tipoinfo);

VAR ptrNuevo, ptr:tlista;

BEGIN

        NEW(ptrNuevo);

        ptrNuevo^.info := valor;        

        ptrNuevo^.sgte := NIL;                      

        ptr := lista;

        

        WHILE(ptr^.sgte <> NIL) AND (valor > ptr^.sgte^.info) DO

	  ptr := ptr^.sgte;

	  

	ptrNuevo^.sgte := ptr^.sgte;

	ptr^.sgte := ptrNuevo;        

END;





//Inserta ordenado por 'valor'.

PROCEDURE insertaNodo(var lista:tlista; valor:tipoinfo);

BEGIN

  IF lista = NIL THEN

  BEGIN

    insertaPrimero(lista, valor);

  END

  ELSE

  BEGIN

    IF valor < lista^.info THEN

    BEGIN

      insertaDelante(lista,valor);

    END

    ELSE

    BEGIN

      insertaEnMedio(lista,valor);

    END;

  END;

END;





PROCEDURE imprimirLista(lista:tlista);

VAR ptr:tlista;

BEGIN

	ptr := lista;

        WHILE (ptr <> NIL) DO 

        BEGIN

	  WRITELN(ptr^.info);	  

	  ptr := ptr^.sgte;

	END;

END;



FUNCTION existeElemento(lista:tLista; valor:tipoinfo):boolean;

var rta:boolean;

BEGIN

	rta := false;

	WHILE (lista <> NIL) DO 

    BEGIN

		writeln(lista^.info , ' < - - > ', valor);

		IF(lista^.info = valor) THEN BEGIN

			rta := true;

		END;

		lista := lista^.sgte;

	END;

	existeElemento := rta;

END;



FUNCTION diferenciaSimetrica(listaA,listaB:tlista):tLista;

VAR ptrA,ptrB,ptrA_aux,ptrDif: tLista;

existeA,existeB:boolean;



BEGIN

	ptrA := listaA;

	ptrA_aux := listaA;

	ptrB := listaB;

	ptrDif := NIL;

	

{

	Busco los elementos de la lista A en la lista B. Si no existen entonces los cargo en la listaDif. 

}

	WHILE (ptrA <> NIL) DO BEGIN

		existeA := existeElemento(ptrB,ptrA^.info);

		writeln(existeA);

		writeln;

		

		IF (NOT existeA) THEN BEGIN

			insertaNodo(ptrDif,ptrA^.info);  		

		END;

		ptrA := ptrA^.sgte;			 

	END;



{

	Busco los elementos de la lista B en la lista A. Si no existen entonces los cargo en la listaDif. 

}

	WHILE (ptrB <> NIL) DO BEGIN

	

{

		Como en la estructura while anterior se actualizo el "ptrA" quedando en la ultima posicion de la lista (nil), ahora uso ptrA_aux.

}

		existeB := existeElemento(ptrA_aux,ptrB^.info);

		writeln(existeB);

		writeln;

		

		IF (NOT existeB) THEN BEGIN

			insertaNodo(ptrDif,ptrB^.info);  				 

		END;

		ptrB := ptrB^.sgte;

	END;

	

	diferenciaSimetrica := ptrDif;

END; 





BEGIN

   

	  WRITELN('Creo lista A ...');    

	  crearLista(listaA);

	  insertaNodo(listaA,'a');  

	  insertaNodo(listaA,'b');  

	  insertaNodo(listaA,'c');  

	  insertaNodo(listaA,'d');  

	  insertaNodo(listaA,'e');  

	  WRITELN('Imprimo la lista A...');

	  imprimirLista(listaA);

	  WRITELN;

	  

	  WRITELN('Creo lista B ...');  

	  crearLista(listaB);

	  insertaNodo(listaB,'d');  

	  insertaNodo(listaB,'e');  

	  insertaNodo(listaB,'f');  

	  insertaNodo(listaB,'g');  

	  insertaNodo(listaB,'h');  

	  WRITELN('Imprimo la lista B...');

	  imprimirLista(listaB);

	  WRITELN;

	  

	  listaDif := diferenciaSimetrica(listaA,listaB);

	  WRITELN('Diferencia simétrica A - B ...');

	  imprimirLista(listaDif);

	  WRITELN;



END.

Compilar y ejecutar código

0 en 0 posts · 26-09-2013 13:27

Subo unas mejoras para evitar que siga recorriendo la lista en caso de dar TRUE en la comparación de los elementos de las listas. De esta forma se optimiza un poco el algoritmo en caso de ser listas muy grandes.

También modifique el algoritmo de diferenciaSimetrica para que sea un procedimiento en vez de una función y probar el uso de variables globales o de referencia.



 

PROGRAM ejercicio2_listas_final;



TYPE 

	tipoinfo= string[30];

	tLista = ^tNodo;

	

	tNodo = record 

		info: tipoinfo;

		sgte: tLista;

	end;

	

VAR

	listaA,listaB,listaDif: tLista;

	





PROCEDURE crearLista(var lista:tlista);

BEGIN

    lista := NIL;    

END;



PROCEDURE insertaPrimero(var lista:tlista; valor:tipoinfo);

VAR ptr:tlista;

BEGIN

        NEW(ptr);

        ptr^.info := valor;        

        ptr^.sgte := NIL;                      

        lista := ptr;

END;



PROCEDURE insertaDelante(var lista:tlista; valor:tipoinfo);

VAR ptr:tlista;

BEGIN

        NEW(ptr);

        ptr^.info := valor;        

        ptr^.sgte := lista;                      

        lista := ptr;

END;



PROCEDURE insertaEnMedio(var lista:tlista; valor:tipoinfo);

VAR ptrNuevo, ptr:tlista;

BEGIN

        NEW(ptrNuevo);

        ptrNuevo^.info := valor;        

        ptrNuevo^.sgte := NIL;                      

        ptr := lista;

        

        WHILE(ptr^.sgte <> NIL) AND (valor > ptr^.sgte^.info) DO

	  ptr := ptr^.sgte;

	  

	ptrNuevo^.sgte := ptr^.sgte;

	ptr^.sgte := ptrNuevo;        

END;





//Inserta ordenado por 'valor'.

PROCEDURE insertaNodo(var lista:tlista; valor:tipoinfo);

BEGIN

  IF lista = NIL THEN

  BEGIN

    insertaPrimero(lista, valor);

  END

  ELSE

  BEGIN

    IF valor < lista^.info THEN

    BEGIN

      insertaDelante(lista,valor);

    END

    ELSE

    BEGIN

      insertaEnMedio(lista,valor);

    END;

  END;

END;





PROCEDURE imprimirLista(lista:tlista);

VAR ptr:tlista;

BEGIN

	ptr := lista;

        WHILE (ptr <> NIL) DO 

        BEGIN

	  WRITELN(ptr^.info);	  

	  ptr := ptr^.sgte;

	END;

END;



FUNCTION existeElemento(lista:tLista; valor:tipoinfo):boolean;

var rta:boolean;



BEGIN

	rta := false;

	WHILE (lista <> NIL) AND (rta = false) DO 

    BEGIN

		writeln(lista^.info , ' < - - > ', valor);

		IF(lista^.info = valor) THEN BEGIN

			rta := true;

		END;

		lista := lista^.sgte;

	END;

	existeElemento := rta;	

END;



PROCEDURE diferenciaSimetrica(listaA,listaB:tlista);

VAR ptrA_aux,ptrDif: tLista;

existeA,existeB:boolean;



BEGIN

	ptrA_aux := listaA;

	ptrDif := NIL;

	

{

	Busco los elementos de la lista A en la lista B. Si no existen entonces los cargo en la listaDif. 

}

	WHILE (listaA <> NIL) DO BEGIN

		existeA := existeElemento(listaB,listaA^.info);

		writeln(existeA);

		writeln;

		

		IF (NOT existeA) THEN BEGIN

			insertaNodo(ptrDif,listaA^.info);  		

		END;

		listaA := listaA^.sgte;			 

	END;



{

	Busco los elementos de la lista B en la lista A. Si no existen entonces los cargo en la listaDif. 

}

	WHILE (listaB <> NIL) DO BEGIN

	

{

		Como en la estructura while anterior se actualizo el "ptrA" quedando en la ultima posicion de la lista (nil), ahora uso ptrA_aux.

}

		existeB := existeElemento(ptrA_aux,listaB^.info);

		writeln(existeB);

		writeln;

		

		IF (NOT existeB) THEN BEGIN

			insertaNodo(ptrDif,listaB^.info);  				 

		END;

		listaB := listaB^.sgte;

	END;

		listaDif := ptrDif;

END; 





BEGIN

   

	  WRITELN('Creo lista A ...');    

	  crearLista(listaA);

	  insertaNodo(listaA,'z');  

	  insertaNodo(listaA,'f');  

	  insertaNodo(listaA,'a');  

	  insertaNodo(listaA,'n');  

	  insertaNodo(listaA,'b');  

	  WRITELN('Imprimo la lista A...');

	  imprimirLista(listaA);

	  WRITELN;

	  

	  WRITELN('Creo lista B ...');  

	  crearLista(listaB);

	  insertaNodo(listaB,'d');  

	  insertaNodo(listaB,'o');  

	  insertaNodo(listaB,'n');  

	  insertaNodo(listaB,'z');  

	  insertaNodo(listaB,'i');  

	  WRITELN('Imprimo la lista B...');

	  imprimirLista(listaB);

	  WRITELN;



{

		Modifique la llamada a diferenciaSimetrica para que en vez de ser una funcion sea un procedimiento y probar el uso de variables globales o de referencia.

}

	  diferenciaSimetrica(listaA,listaB);

	  WRITELN('Diferencia simétrica A - B ...');

	  imprimirLista(listaDif);

	  

	  WRITELN;



END.

Compilar y ejecutar código

Modo compacto \| Modo extendido [APORTE] Final Algoritmos 8/8/13
Autor	Mensaje