(04-03-2011 02:54)xtian89 escribió:  Sí, puede ser tmb la opción de usar la otra lista para guardar los dias trabajados, pero si hubiera puesto que la restriccion era filesize (EntradaSalida.dat) * nodos de 12 bytes ahi sí que no quedaba otra que hacerla por corte de control.

No me refería a hacer otra lista, sino modificarla, en vez de la fecha, poner el día solamente. Ya que el archivo tiene los datos de un mes especifico y va a ser todo para el mismo mes y año.

lista lst: |IdPuerta|dia|hora|Evento|Trabajados|sgte|
(1b + 1b + 2b + 1b + 4b + 1b = 10 bytes)

Pero estan sobrando 2 bytes de dinámica y no me convence

(04-03-2011 02:21)batty escribió:  Cantidad de Días Trabajados en el nodo de la Lista

Estarías gastando espacio demás porque no es necesario poner la cantidad de días en todos los nodos. Y además tendrías que hacer también una comparación para fijarte si el día es diferente al ultimo que pusiste en la lista (o un corte de control mientras lees el archivo).

No es necesario añadir ciclos para contar los días, en alguna parte al imprimir vas a tener "while(lista<>nil)", sólo tenés que agregar un if en ese ciclo que compare la fecha del nodo que estás procesando con la fecha anterior y sume uno al acumulador si son diferentes.

 

while(not EOF(empleados))do begin

    read(empleados, reg);	

    imprimirLoQueHayQueImprimir(reg);

    

    fechaAnterior:= 0;

    diasTrabajados:= 0;

    lista:= vector[reg.legajo];



    while(lista<>NIL) do begin

         info:= eliminarPrimerNodo(lista);

         imprimirLoQueHayQueImprimir2(info);

        

         if(fechaAnterior<>info.fecha) then begin

              diasTrabajados:= diasTrabajados + 1;

              fechaAnterior:= info.fecha;

         end;



     end;



     writeln(diasTrabajados);



end;

Si dejando la fecha tal como estaba queda bien el tamaño del nodo quizá fueron buenos (con los nervios quizá ni se te ocurra lo de agarrar sólo el día, a mi profesor le gusta hacer exámenes así, puntos extra para el que descubra cómo ocupar menos espacio) o simplemente no lo pensaron mientras hacían en el exámen.

Tenés razón, quedó más que claro

(04-03-2011 01:52)xtian89 escribió:  Yo me presenté al final de 26/02 que por suerte aprobé; lo habia pensado así:

array_Empleados: vector de 1000 registros de tipo lst
4b * 1000 = 4000 bytes

array_Acum: vector de 3 registros de tipo integer
3 * 2b = 6 bytes

lista lst: |IdPuerta|fecha|hora|Evento|sgte|
(1b + 4b + 2b + 1b + 4b = 12 bytes)


-Abro el archivo de EntradaSalida.dat y Agrego un nodo lst en el array_Empleado [Reg1.legajo] por cada registro Reg1 leído. En cada array_Empleado [ i ] me van a quedar una lista ya ordenada por nro de puerta y la fecha y hora. Cierro el archivo.
Che pero acá tecnicamente no podes tenerlo ordenado por fecha y hora ya que primero esta ordenado por puerta. Si te fijas en el listado que habia que emitir no habia que ordenarla por puerta... A lo que voy es que necesariamente habia que ordenarlo a parte, o no? Eso te lo consideraron como que estaba bien?

-Abro ahora el archivo Empleados.dat. Recorro también secuencialmente el archivo; por cada registro Reg2, leo el legajo y lo busco en array_Empleado [Reg2.Legajo]. Muestro la lista de nodos lst hasta q lst apunte a NIL, mientras acumulo la cantidad de veces que pasa por cada puerta en el array_Acum [lst.IdPuerta]. Muestro los totales Generales de cada puerta. La Cantidad de Días Trabajados serán la suma de los acumuladores dividido dos. Cierro el archivo y libero los nodos.

Hice exactamente lo mismo, sacando que para calcular los dias trabajados arme un IF:
IF (fecha <> p.^info.fecha)
then
fecha <- p.^info.fecha
inc (diasTrabajados)

O sea cuando inicializo la variable fecha en cero el primer dia lo cuenta (ya que van a ser distintos porq inicializo la variable en cero). Le asigna ESE dia trabajado. Siguen avanzando y mostrando los nodos. Si se encuentra con otro dia distinto incrementa nuevamente el contador de "diasTrabajados".

Ya que estoy planteo una duda sobre la liberacion de memoria dinamica:
Lo que Hago es mostrar todos los nodos conectados a una posicion del vector (que corresponden a todos los datos de un empleado) y luego los libero. Mi duda es si lo que hago a continuacion estaría bien.

Procedure LiberarLista
(var vec:tvec, N: word)

P <- vec[N].listado

WHILE ( P <> nil)
BEGIN
Q <- P
rinfo <- P^.rinfo
P <- P^.sgte
DISPOSE (Q)
END

vec[N].listado <- nil

Este procedimiento se podria hacer asi? Tengo mis dudas sobre estos procedimentos y tengo entendido que joden bastante con la liberacion de memoria dinamica.

xtian89 escribió:-Abro el archivo de EntradaSalida.dat y Agrego un nodo lst en el array_Empleado [Reg1.legajo] por cada registro Reg1 leído. En cada array_Empleado [ i ] me van a quedar una lista ya ordenada por nro de puerta y la fecha y hora. Cierro el archivo.

Fackus escribió:Che pero acá tecnicamente no podes tenerlo ordenado por fecha y hora ya que primero esta ordenado por puerta. Si te fijas en el listado que habia que emitir no habia que ordenarla por puerta... A lo que voy es que necesariamente habia que ordenarlo a parte, o no? Eso te lo consideraron como que estaba bien?

Sí, ahora que lo releo, tenes razon; o sea que en realidad hay que Insertar Ordenado en nodo en el array_Empleado [Reg1.Legajo]
No, no creo que me lo hayan considerado bien (igual no vi el examen).

Fackus escribió:Hice exactamente lo mismo, sacando que para calcular los dias trabajados arme un IF:
IF (fecha <> p.^info.fecha)
then
fecha <- p.^info.fecha
inc (diasTrabajados)

O sea cuando inicializo la variable fecha en cero el primer dia lo cuenta (ya que van a ser distintos porq inicializo la variable en cero). Le asigna ESE dia trabajado. Siguen avanzando y mostrando los nodos. Si se encuentra con otro dia distinto incrementa nuevamente el contador de "diasTrabajados".

Sí, esa resolución me parece válida

Fackus escribió:Procedure LiberarLista
(var vec:tvec, N: word)

P <- vec[N].listado

WHILE ( P <> nil)
BEGIN
Q <- P
rinfo <- P^.rinfo
P <- P^.sgte
DISPOSE (Q)
END

vec[N].listado <- nil

Nombrar al array vec.[N].listado me parece de más, xq el array es un vector de punteros, no de un registro de punteros. Simplemente con decir vec[N] es suficiente.
y no veo cómo incrementás la posicion del vector.

La forma correcta en que yo lo pensé es:

Procedur Liberar:
(var array_Empleado)
_____________________________________
|________For i=1 to 1000_______________|
|...........................................................|
|.... aux <- array_Empleado [ i ]................|
|.. _______________________________....|
|..|______While aux <> nil do________|....|
|..|...................................................|....|
|..|....auxSig <- aux^.sgte...................|....|
|..|...................................................|....|
|..|....dispose (aux)............................|....|
|..|...................................................|....|
|..|......aux <- auxSig..........................|...|
|..|_______________________________|...|
|___________________________________|

Claro... al tener un solo campo es al pedo ponerle ".listado" xD

Pasa que no necesitaba avanzar. El "N" seria la posicion del vector donde estan colgados todos los nodos de ESE legajo. O sea, no borro todos los nodos de todas las posiciones del vector, solo aquellas que acabo de emitir en el listado... No se si se entiende

Cuando liberas la memoria no hace falta asignar el registro?
En unos apuntes hechos por Adamoli te planchaba algo asi para liberar nodos:


Procedure SuprimirPrimerNodo
Var lista:tp , Var Rinfo:Tinfo

P <- lista
Rinfo <- lista^.Rinfo
lista <- lista^.sgte
DISPOSE (P)

Yo ahora lo estoy haciendo asi porque esta hecho por un profe... pero la realidad es que yo antes lo hacia como vos pusiste antes.
Mi duda es para que asigna a "Rinfo" el contenido de "lista^.Rinfo" ????

xtian89 escribió:

Fackus escribió:Procedure LiberarLista
(var vec:tvec, N: word)

P <- vec[N].listado

WHILE ( P <> nil)
BEGIN
Q <- P
rinfo <- P^.rinfo
P <- P^.sgte
DISPOSE (Q)
END

vec[N].listado <- nil

La forma correcta en que yo lo pensé es:

Procedur Liberar:
(var array_Empleado)
_____________________________________
|________For i=1 to 1000_______________|
|...........................................................|
|.... aux <- array_Empleado [ i ]................|
|.. _______________________________....|
|..|______While aux <> nil do________|....|
|..|...................................................|....|
|..|....auxSig <- aux^.sgte...................|....|
|..|...................................................|....|
|..|....dispose (aux)............................|....|
|..|...................................................|....|
|..|......aux <- auxSig..........................|...|
|..|_______________________________|...|
|___________________________________|

Tengo una duda, porque usan un puntero auxiliar (aux o P) en vez de directamente el puntero del vector?

Estaría mal si lo hago asi? :

Procedure LiberarLista
(var vec:tvec, N: word)

WHILE ( vec[N].listado <> nil)
BEGIN
Q <- vec[N].listado
rinfo <- vec[N].listado^.rinfo
vec[N].listado <- vec[N].listado^.sgte
DISPOSE (Q)
END

ó

Procedur Liberar:
(var array_Empleado)
_____________________________________
|________For i=1 to 1000_______________|
|...........................................................|
|.. _______________________________....|
|..|_While array_Empleado [ i ] <> nil do_|....|
|..|...................................................|....|
|..|.........aux <- array_Empleado [ i ]......|....|
|..|...................................................|....|
|..|.array_Empleado [ i ] <- array_Empleado [ i ]^.sgte.|....|
|..|...................................................|....|
|..|....dispose (aux)............................|....|
|..|...................................................|....|
|..|_______________________________|...|
|___________________________________|

Batty:
Tengo entendido que siempre que vayas a recorrer, borrar o lo que sea que hagas con la lista tenes que usar un puntero auxiliar y despues actualizas. El por qué teorico de eso no me acuerdo, pero es algo que me quedó fijo
Por las dudas siempre usa punteros auxiliares xD

(04-03-2011 14:26)Fackus escribió:  Batty:
Tengo entendido que siempre que vayas a recorrer, borrar o lo que sea que hagas con la lista tenes que usar un puntero auxiliar y despues actualizas. El por qué teorico de eso no me acuerdo, pero es algo que me quedó fijo
Por las dudas siempre usa punteros auxiliares xD

Claro, o sea, lo de usar punteros auxiliares siempre es para que el puntero original de la Lista quede en el primer lugar y no recorrés la lista con el puntero original para que no se "desconecten" los nodos y queden sueltos. Por eso usas punteros auxiliares para recorrer las listas cuando queres sacar información de la lista o actualizar los nodos.

Pero cuando querés liberar la lista, lo que haces es ir "desconectando" los nodos (Lst <- Lst^.sig) y borrandolos (dispose(pLib)). Por eso habría que usar el puntero original de la Lista, sinó no se desconectarían.

Tengo entendido que es así, a ver si alguien nos puede sacar la duda

(04-03-2011 14:38)batty escribió:  

(04-03-2011 14:26)Fackus escribió:  Batty:
Tengo entendido que siempre que vayas a recorrer, borrar o lo que sea que hagas con la lista tenes que usar un puntero auxiliar y despues actualizas. El por qué teorico de eso no me acuerdo, pero es algo que me quedó fijo
Por las dudas siempre usa punteros auxiliares xD

Claro, o sea, lo de usar punteros auxiliares siempre es para que el puntero original de la Lista quede en el primer lugar y no recorrés la lista con el puntero original para que no se "desconecten" los nodos y queden sueltos. Por eso usas punteros auxiliares para recorrer las listas cuando queres sacar información de la lista o actualizar los nodos.

Pero cuando querés liberar la lista, lo que haces es ir "desconectando" los nodos (Lst <- Lst^.sig) y borrandolos (dispose(pLib)). Por eso habría que usar el puntero original de la Lista, sinó no se desconectarían.

Tengo entendido que es así, a ver si alguien nos puede sacar la duda

Claro! Yo pensaba lo mismo hasta que lei los apuntes de Adamoli de una fotocopia y los apuntes mios (cursada de Bruno) donde lo hacen como escribi antes. Lo que tenes que tener en cuenta es que primero actualizas al puntero "original" con la posicion del siguiente (Lista <- Lista^.Sgte) y seguido a eso DISPOSE al auxiliar. Haciendo esto lo unico que quedaba apuntando al nodo que queres borrar es el puntero auxiliar que usaste antes. Lo que no me queda claro a mi es porque necesito asignar el registro...

No es necesario usar un liberarLista al final, los nodos hay que soltarlos cuando los usás por ultima vez, vuelvo al código que había puesto antes:

Cita:while(not EOF(empleados))do begin
read(empleados, reg);
imprimirLoQueHayQueImprimir(reg);

fechaAnterior:= 0;
diasTrabajados:= 0;
lista:= vector[reg.legajo];

while(lista<>NIL) do begin
info:=eliminarPrimerNodo(lista);
imprimirLoQueHayQueImprimir2(info);

if(fechaAnterior<>info.fecha) then begin
diasTrabajados:= diasTrabajados + 1;
fechaAnterior:= info.fecha;
end;

end;

writeln(diasTrabajados);

end;

Una vez que uno imprimió el listado ya no necesita más la lista, así que los nodos los vas eliminando mientras imprimís, sino tenés que recorrer otra vez más las listas al final del programa para borrarlas y no es necesario si se podía hacer antes.

Desarrollo eliminarPrimerNodo(var lista:t_lista):t_info

 

function eliminarPrimerNodo(var lista:t_lista):t_info

var aux:t_lista; info:t_info;

begin  

   aux:=lista;

   lista:=lista^.sig;

   info:=aux^.info;

   dispose(aux);

   eliminarPrimerNodo:=info;

end;

De esta forma, elimino el primer nodo, obtengo la info que tenía, imprimo las cosas y así con todos. Al terminar de imprimir el listado todas las listas del vector ya fueron liberadas. Es igual a la función sacar de la pila: http://holamundopascal.blogspot.com/2007...ml#oppilas
Yo al principio usaba siempre procedimientos, pero para estas cosas las funciones son muy útiles.

(04-03-2011 14:51)Fackus escribió:  Lo que no me queda claro a mi es porque necesito asignar el registro...

Es que hay 2 formas de liberar la lista.
1 - Mientras imprimis vas liberando por nodo
ó
2 - Una vez que imprimiste, volves a recorrer y liberas todo.

Si usas la 1 mientras imprimis, sacas primero el nodo y te traes rInfo del procedimiento SacarNodo, y ahi recien imprimis los datos de rInfo

Si usas la 2, ya imprimiste los datos Lst^.info mientras recorrias la lista, asi que no necesitas la info del nodo. Entonces lo unico que haces es recorrer la lista y liberar todo (no es necesario la linea de rInfo).

(04-03-2011 14:51)Anirus escribió:  Yo al principio usaba siempre procedimientos, pero para estas cosas las funciones son muy útiles.

Buen dato
Igual me queda la duda, en caso que tenga que liberar una lista al final
La lista se recorre con el puntero original de la lista, no con un auxiliar no?

Es lo mismo, supongamos una lista de un solo nodo:

Imaginemos que el puntero apunta a la dirección de memoria 123. Para liberar ese espacio hacemos dispose(lista), lo cual estaría liberando el lugar 123 de la memoria porque ahi apunta lista.

Si yo hago:

aux:=lista;
dispose(aux);

es lo mismo porque al hacer aux:=lista aux pasa a apuntar a 123 y estoy liberando el mismo lugar de la memoria.

Lo que determina si el nodo se libera no es el que use un auxiliar o no, sino el que haga dispose.

¿Cuándo importa si estoy usando el auxiliar o no? cuando recorres la lista y no querés perder la dirección del primer nodo, por esa razón recorres con un auxiliar, para que lista siga apuntando al primer nodo.

Acordate que en dinámica, lo afectado no son los punteros, sino la cosa a la que apuntan, si dos punteros apuntan a lo mismo, afectan a lo mismo.

Ahhh perfecto! Gracias!

Joya! Ya me quedo claro lo de la liberacion de memoria!! Gracias!!

Creo que nunca utilizo esa lectura "especial" para el corte de control... Generalmente uso procedimientos o cosas caseras
Supongo que no siempre hace falta usarlos, el temas es que a veces te facilita las cosas.

Edit: fijate en el blog de Pablo que ahi dejaron el link, está bastante claro!