From: Leandro Lucarella Date: Sun, 23 Mar 2003 07:10:16 +0000 (+0000) Subject: Import inicial después del "/var incident". :( X-Git-Tag: svn_import~1 X-Git-Url: https://git.llucax.com/z.facultad/75.41/parcial.git/commitdiff_plain/39702780c4d4e84bb6b531bfe48a63414278c829 Import inicial después del "/var incident". :( --- 39702780c4d4e84bb6b531bfe48a63414278c829 diff --git a/a2000-c1-p1-1.pas b/a2000-c1-p1-1.pas new file mode 100644 index 0000000..06c6d77 --- /dev/null +++ b/a2000-c1-p1-1.pas @@ -0,0 +1,254 @@ +{ algoritmos y programacion II - Catedra Carolo - PRACTICA } +{ PARCIAL 1 1ra Op CUAT 1 2000 } + +program A2000_C1_P1_1; + +uses SYSUTILS, CRT, + T_COLORD_B1, T_LSC, TDA_GRAL; + +type + + TClaseComando =( INS, INO, ORD, BUC, BUR, LIA, LID, LIC, BOR, MOV, LIM, MOC ); + + { registro de entrada } + TComando = record + comando:TClaseComando; + dni:longint; + strDni:string[8]; + nombre:string[40]; + movimiento: LSC_movimiento; + strMovim: string[2]; + dni_hasta:longint; + end; + + +{ este procedimiento lee una linea de texto y la convierte en un comando } +{ devuelve TRUE si mapeo correctamente, sino FALSE } +function MapearComando( linea: String; VAR c: TComando ): boolean; +VAR + strComando: string; + strMovim: string; + strDNI: string; + ok: boolean; +BEGIN + ok := true; + + { defino que comando es } + strComando := copy( linea, 1,2 ); + + if strComando='IN' then c.comando := INS + else if strComando='OR' then c.comando := ORD + else if strComando='LS' then c.comando := LIA + else if strComando='LC' then c.comando := LIC + else if strComando='BO' then c.comando := BOR + else if strComando='MV' then c.comando := MOV + else if strComando='MO' then c.comando := MOC + else if strComando='LI' then c.comando := LIM + else ok := false; + + { defino el DNI, nombre y hasta } + strDNI := copy( linea, 3,8 ); + IF LeftStr( strDNI, 1 ) <> '*' + THEN c.dni := strToIntDef( strDNI, -1 ) + ELSE c.dni := -2; + c.strDni := strDni; + + strDNI := copy( linea, 52,8 ); + IF LeftStr( strDNI, 1 ) <> '*' + THEN c.dni_hasta := strToIntDef( strDNI, -1 ) + ELSE c.dni_hasta := -2; + + IF (c.dni = -1 ) or (c.dni_hasta = -1 ) THEN ok := false; + + IF copy( linea, 11, 1 ) = '*' + THEN c.nombre := '*' + ELSE c.nombre := copy( linea, 11, 40 ); + + { el tipo de movimiento } + strMovim := copy( linea, 51, 1 ); + c.strMovim := strMovim; + if strMovim='P' then c.movimiento := LSC_primero + else if strMovim='S' then c.movimiento := LSC_siguiente + else if strMovim<>'*' then ok := false; + + { writeln( 'dat:', c.nombre, ':', c.dni, ':', c.dni_hasta, ':', strMovim, ':', strComando,':' ); } + MapearComando := ok; +END; + +PROCEDURE inicializar( VAR archEnt: text; VAR archSal: text); +VAR + nomArchEnt: string; + nomArchSal: string; +BEGIN + { busco los nombres de los archivos } + nomArchEnt := ParamStr( 1 ); + nomArchSal := ParamStr( 2 ); + + writeln( 'IN :', nomArchEnt ); + writeln( 'OUT:', nomArchSal ); + + { preparo los archivos } + assign ( archEnt, nomArchEnt ); + reset ( archEnt ); + assign ( archSal, nomArchSal ); + rewrite( archSal ); +END; + +PROCEDURE Ordenar_Lista( VAR l: LSC_Lista; VAR archSal: text ); +VAR + c: COLAORD_Cola; + e: Tipo_Elem; + error : boolean; +BEGIN + { inicializo la cola } + COLAORD_inicializar( c ); + + { pongo todos los registros en la cola } + LSC_Mover_cte( l, LSC_primero, error ); + writeln('ahora empiezo a sacar de la lista'); + WHILE not error + DO BEGIN + LSC_elem_cte( l, e ); + COLAORD_poner( c, e, error ); + IF error THEN writeln( archSal, 'ERROR ELEMENTO DUPLICADO [', devolver_clave_elem( e ), '] SERA DESCARTADO'); + LSC_Mover_cte( l, LSC_siguiente, error ); + END; + + writeln('ahora empiezo a poner de vuelta en la lista'); + { ahora limpio la lista y los pongo de vuelta ordenados } + LSC_vaciar( l ); + WHILE not COLAORD_Vacia( c ) + DO BEGIN + COLAORD_sacar( c, e ); + writeln('saque ', e.dni, ':',e.nombre); + LSC_Insertar( l, LSC_siguiente, e ); + END; + +END; + + +var + { la tabla ppd } + t: LSC_Lista; + + { los archivos } + archEnt: text; + archSal: text; + + { temporales } + linea: string; + c: Tcomando; + elem: tipo_elem; + error, + found: boolean; + +BEGIN + inicializar( archEnt, archSal); + + { creo la tabla donde voy a trabajar } + LSC_Inicializar( t ); + + { itero por la entrada } + WHILE not eof( archEnt ) DO + BEGIN + { leo la entrada } + readln( archEnt, linea ); + + IF not MapearComando( linea, c ) + THEN BEGIN + writeln( archSal, 'ERROR MAP [', linea, ']'); + continue; + END; + + + { ahora empiezo con el case de las operaciones } + case c.comando of + MOV:begin { mover corriente } + writeln( archSal, 'MOV [', c.strMovim, ']' ); + if not LSC_vacia( t ) + then BEGIN + LSC_mover_cte( t, c.movimiento, error ); + IF error THEN writeln( 'MOV ERROR' ); + END + ELSE + writeln( 'ERROR: tabla vacia' ); + end; + + INS: BEGIN { tengo que insertar } + str( c.dni:8 , c.strDni ); + writeln( archSal, 'INS [', c.strDni, ':', c.nombre, ':', c.strMovim, ']' ); + IF LSC_llena( t ) + THEN writeln( archSal, 'ERROR tabla llena') + ELSE BEGIN + elem.dni := c.dni; + elem.nombre := c.nombre; + LSC_insertar( t, c.movimiento, elem ); + END; + END; + + LIC: begin { listar corriente } + if not LSC_VACIA( t ) + then begin + LSC_ELEM_CTE( t, elem ); + str( elem.dni:8 , c.strDni ); + writeln( archSal, 'LIC [', c.strDni, ':', elem.nombre,']' ); + end + else writeln( archSal, 'LIC ERROR vacia'); + end; + + LIA: begin { listar la tabla } + writeln( archSal, 'LIS ASC'); + if not LSC_VACIA( t ) + then begin + LSC_MOVER_CTE( t, LSC_primero, error ); + LSC_ELEM_CTE( t, elem ); + + while not error do + begin + str( elem.dni:8 , c.strDni ); + writeln( archSal, ' [', c.strDni, ':', elem.nombre,']' ); + LSC_MOVER_CTE( t, LSC_siguiente, error); + LSC_ELEM_CTE( t, elem); + end; + end; + end; + + ORD: begin { ordenar la tabla } + writeln( archSal, 'ORD' ); + if not LSC_vacia( t ) + then + { este es la llamada al ejercicio } + Ordenar_Lista( t, archSal ); + end; + + BOR: begin { borrar el corriente } + writeln( archSal, 'BOR' ); + if not LSC_VACIA( t ) + then + LSC_BORRAR_CTE( t ) + else writeln( archSal, ' ERROR TABLA VACIA'); + end; + + MOC:begin { modificar el corriente } + str( c.dni:8 , c.strDni ); + writeln( archSal, 'MOC [', c.strDni, ':', c.nombre, ']' ); + if not LSC_VACIA(t) + then begin + elem.dni := c.dni; + elem.nombre := c.nombre; + LSC_MODIF_CTE( t, elem ); + end + else writeln( archSal, ' ERROR TABLA VACIA'); + end; + + LIM:begin { limpiar tabla } + writeln( archSal, 'LIM' ); + LSC_Vaciar( t ); + end; + end; + END; {WHILE} + + { cierro los archivos } + close( archEnt ); + close( archSal ); +END. \ No newline at end of file diff --git a/t_colord_a1.pas b/t_colord_a1.pas new file mode 100644 index 0000000..cd2fee2 --- /dev/null +++ b/t_colord_a1.pas @@ -0,0 +1,263 @@ +{ algoritmos y programacion II - Catedra Carolo - PRACTICA } +{ PARCIAL 1 1ra Op CUAT 1 2000 } + +unit T_COLORD_A1; + +{ + IMPLEMENTACION : cola ordenada (cola de prioridades) + ALMACENAMIENTO : CURSORES + CARACTERISTICAS: poner ordenado + +} + +{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular } +interface + +{ usa las funciones generales de TDAs } +uses tda_gral; + +{ maximo tamano del cursor } +const COLAORD_MAX_CURSOR = 100; + +{ tipos propios de la lista para definir el cursor } +TYPE + COLAORD_puntero = integer; + +const + COLAORD_nulo : COLAORD_puntero = 0; + +type + + COLAORD_nodo = RECORD + Elem : Tipo_Elem; + Sig : COLAORD_puntero; + END; + + + { ahora le toca definir el cursor } + COLAORD_Almac = record + almacenamiento : array [ 1 .. COLAORD_MAX_CURSOR ] of COLAORD_Nodo; + disponibles : array [ 1 .. COLAORD_MAX_CURSOR ] of COLAORD_Puntero; + primero_dispo : COLAORD_Puntero; + end; + + + COLAORD_Cola = RECORD + almac : COLAORD_Almac; + primero: COLAORD_puntero; + END; + + +{ ========= } +{ INTERFASE } + + +PROCEDURE COLAORD_Inicializar ( VAR l: COLAORD_Cola ); +FUNCTION COLAORD_vacia( l: COLAORD_Cola): BOOLEAN; +FUNCTION COLAORD_llena( l: COLAORD_Cola): BOOLEAN; + +PROCEDURE COLAORD_poner ( VAR l: COLAORD_Cola; e: Tipo_Elem; VAR error: boolean); +PROCEDURE COLAORD_sacar ( VAR l: COLAORD_Cola; VAR e: Tipo_Elem); +PROCEDURE COLAORD_vaciar ( VAR l: COLAORD_Cola ); +PROCEDURE COLAORD_copiar ( a: COLAORD_Cola; VAR b: COLAORD_Cola ); + +implementation + +{ CURSORES DE ESTA IMPLEMENTACION } +{ ========================================================================== } +{ inicializar el almacenamiento } +{ PRE : 'almac' no esta inicializado } +{ POST: 'almac' esta inicializado y vacio } +procedure COLAORD_Almac_Inicializar( VAR almac : COLAORD_Almac ); +var i : COLAORD_Puntero; +begin + almac.primero_dispo := 1; + for i := 1 to COLAORD_MAX_CURSOR - 1 do + begin + almac.disponibles[i] := i + 1; + end; + almac.disponibles[COLAORD_MAX_CURSOR] := COLAORD_Nulo; +end; + +{ ========================================================================== } +{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento } +{ PRE : 'almac' esta inicializado } +{ POST: si hay lugar en 'almac' para un nuevo elemento, + entonces retorna TRUE y sino FALSE } +function COLAORD_Almac_HayLugar( almac : COLAORD_Almac ): boolean; +begin + COLAORD_Almac_HayLugar := almac.primero_dispo <> COLAORD_Nulo; +end; + +{ ========================================================================== } +{ el pedido de un nuevo elemento al almacenamiento } +{ PRE : 'almac' esta inicializado } +{ POST: si hay lugar en 'almac' para un nuevo elemento, + entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento + sino 'puntero' tiene el valor TTDA_Nulo } +procedure COLAORD_Almac_Reservar( VAR almac : COLAORD_Almac; VAR puntero : COLAORD_Puntero ); +begin + if not COLAORD_Almac_HayLugar( almac ) + then + puntero := COLAORD_Nulo + else begin + puntero := almac.primero_dispo; + almac.primero_dispo := almac.disponibles[ puntero ]; + end; +end; + +{ ========================================================================== } +{ liberar un elemento del almacenamiento } +{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento } +{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo } +procedure COLAORD_Almac_Liberar( VAR almac : COLAORD_Almac; VAR puntero : COLAORD_Puntero ); +begin + almac.disponibles[ puntero ] := almac.primero_dispo; + almac.primero_dispo := puntero; + puntero := COLAORD_Nulo; +end; + +{ ========================================================================== } +{ acceder al elemento del almacenamiento apuntado por un puntero } +{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento } +{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' } +procedure COLAORD_Almac_Acceder( almac : COLAORD_Almac; puntero : COLAORD_Puntero; VAR elemento : COLAORD_Nodo ); +begin + elemento := almac.almacenamiento[ puntero ]; +end; + +{ ========================================================================== } +{ modificar el elemento del almacenamiento apuntado por un puntero } +{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento } +{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' } +procedure COLAORD_Almac_Modificar( VAR almac : COLAORD_Almac; puntero : COLAORD_Puntero; elemento : COLAORD_Nodo ); +begin + almac.almacenamiento[ puntero ] := elemento; +end; + + + +{ Estas son los dos procedimientos principales de la aplicación } + +PROCEDURE COLAORD_Inicializar ( VAR l: COLAORD_Cola ); +BEGIN + COLAORD_Almac_Inicializar( l.almac ); + l.primero := COLAORD_Nulo; +END; + +FUNCTION COLAORD_vacia( l: COLAORD_Cola): BOOLEAN; +BEGIN + COLAORD_vacia := ( l.Primero = COLAORD_Nulo); +END; + +FUNCTION COLAORD_llena( l: COLAORD_Cola): BOOLEAN; +BEGIN + COLAORD_llena := not COLAORD_Almac_HayLugar( l.almac ); +END; + +PROCEDURE COLAORD_poner ( VAR l: COLAORD_Cola; e: Tipo_Elem; VAR error: boolean); +VAR + n : COLAORD_Nodo; + np: COLAORD_Puntero; + npa: COLAORD_Puntero; + na : COLAORD_Nodo; + m : COLAORD_Nodo; + mp : COLAORD_Puntero; +BEGIN + error := false; + np := l.primero; + npa := COLAORD_nulo; + WHILE ( np <> COLAORD_Nulo ) AND ( not error ) + DO BEGIN + COLAORD_Almac_Acceder( l.almac, np, n ); + error := devolver_clave_elem( n.elem ) = devolver_clave_elem( e ); + + { como el almacenamiento esta ordenado, corto cuando me pase de clave } + IF devolver_clave_elem( n.elem ) > devolver_clave_elem( e ) THEN break; + { cambio los punteros } + npa := np; + np := n.sig; + na := n; + END; + + IF not error + THEN BEGIN + { inserto directamente el elemento } + m.Elem := e; + m.sig := np; + COLAORD_Almac_Reservar( l.almac, mp ); + COLAORD_Almac_Modificar( l.almac, mp, m ); + + { toco el anterior o el puntero al primero } + IF npa = COLAORD_Nulo + THEN + { estoy en el primero } + l.primero := mp + ELSE BEGIN + { el siguiente ahora es el nuevo } + na.sig := mp; + COLAORD_Almac_Modificar( l.almac, npa, na ); + END; + END; +END; + +{ pre: no esta vacia } +PROCEDURE COLAORD_sacar ( VAR l: COLAORD_Cola; VAR e: Tipo_Elem); +VAR n : COLAORD_Nodo; + tmp : COLAORD_Nodo; + tmpp: COLAORD_Puntero; +BEGIN + COLAORD_Almac_Acceder( l.almac, l.primero, n ); + COLAORD_Almac_Liberar( l.almac, l.primero ); + l.primero := n.Sig; + + { y se lo asigno al parametro } + e := n.Elem; +END; + +PROCEDURE COLAORD_vaciar ( VAR l: COLAORD_Cola ); +VAR np : COLAORD_Puntero; + n : COLAORD_Nodo; +BEGIN + np := l.primero; + while( np <> COLAORD_Nulo ) do begin + COLAORD_Almac_Acceder( l.almac, np, n ); + COLAORD_Almac_Liberar( l.almac, np ); + np := n.sig; + end; + l.primero := COLAORD_Nulo; +END; + +{ pre: 'a' y 'b' estan creadas y 'b' esta vacia } +{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero } +PROCEDURE COLAORD_copiar ( a : COLAORD_Cola; VAR b : COLAORD_Cola ); +VAR np, mp, tmpp : COLAORD_Puntero; + n, m : COLAORD_Nodo; +BEGIN + if a.primero = COLAORD_Nulo then exit; + np := a.primero; + COLAORD_Almac_Acceder( a.almac, np, n ); + + COLAORD_Almac_Reservar( b.almac, mp ); + b.primero := mp; + m.elem := n.elem; + + while( n.sig <> COLAORD_Nulo ) do begin + + COLAORD_Almac_Reservar( b.almac, tmpp ); + m.sig := tmpp; + COLAORD_Almac_Modificar( b.almac, mp, m ); + + np := n.sig; + COLAORD_Almac_Acceder( a.almac, np, n ); + + mp := tmpp; + m.elem := n.elem; + + end; + m.sig := COLAORD_Nulo; + COLAORD_Almac_Modificar( b.almac, mp, m ); +END; + +end. + diff --git a/t_colord_a2.pas b/t_colord_a2.pas new file mode 100644 index 0000000..1432bfd --- /dev/null +++ b/t_colord_a2.pas @@ -0,0 +1,278 @@ +{ algoritmos y programacion II - Catedra Carolo - PRACTICA } +{ PARCIAL 1 1ra Op CUAT 1 2000 } + +unit T_COLORD_A2; + +{ + IMPLEMENTACION : cola ordenada (cola de prioridades) + ALMACENAMIENTO : CURSORES + CARACTERISTICAS: sacar ordenado + +} + +{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular } +interface + +{ usa las funciones generales de TDAs } +uses tda_gral; + +{ maximo tamano del cursor } +const COLAORD_MAX_CURSOR = 100; + +{ tipos propios de la lista para definir el cursor } +TYPE + COLAORD_puntero = integer; + +const + COLAORD_nulo : COLAORD_puntero = 0; + +type + + COLAORD_nodo = RECORD + Elem : Tipo_Elem; + Sig : COLAORD_puntero; + END; + + + { ahora le toca definir el cursor } + COLAORD_Almac = record + almacenamiento : array [ 1 .. COLAORD_MAX_CURSOR ] of COLAORD_Nodo; + disponibles : array [ 1 .. COLAORD_MAX_CURSOR ] of COLAORD_Puntero; + primero_dispo : COLAORD_Puntero; + end; + + + COLAORD_Cola = RECORD + almac : COLAORD_Almac; + primero: COLAORD_puntero; + END; + + +{ ========= } +{ INTERFASE } + + +PROCEDURE COLAORD_Inicializar ( VAR l: COLAORD_Cola ); +FUNCTION COLAORD_vacia( l: COLAORD_Cola): BOOLEAN; +FUNCTION COLAORD_llena( l: COLAORD_Cola): BOOLEAN; + +PROCEDURE COLAORD_poner ( VAR l: COLAORD_Cola; e: Tipo_Elem; VAR error: boolean); +PROCEDURE COLAORD_sacar ( VAR l: COLAORD_Cola; VAR e: Tipo_Elem); +PROCEDURE COLAORD_vaciar ( VAR l: COLAORD_Cola ); +PROCEDURE COLAORD_copiar ( a: COLAORD_Cola; VAR b: COLAORD_Cola ); + +implementation + +{ CURSORES DE ESTA IMPLEMENTACION } +{ ========================================================================== } +{ inicializar el almacenamiento } +{ PRE : 'almac' no esta inicializado } +{ POST: 'almac' esta inicializado y vacio } +procedure COLAORD_Almac_Inicializar( VAR almac : COLAORD_Almac ); +var i : COLAORD_Puntero; +begin + almac.primero_dispo := 1; + for i := 1 to COLAORD_MAX_CURSOR - 1 do + begin + almac.disponibles[i] := i + 1; + end; + almac.disponibles[COLAORD_MAX_CURSOR] := COLAORD_Nulo; +end; + +{ ========================================================================== } +{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento } +{ PRE : 'almac' esta inicializado } +{ POST: si hay lugar en 'almac' para un nuevo elemento, + entonces retorna TRUE y sino FALSE } +function COLAORD_Almac_HayLugar( almac : COLAORD_Almac ): boolean; +begin + COLAORD_Almac_HayLugar := almac.primero_dispo <> COLAORD_Nulo; +end; + +{ ========================================================================== } +{ el pedido de un nuevo elemento al almacenamiento } +{ PRE : 'almac' esta inicializado } +{ POST: si hay lugar en 'almac' para un nuevo elemento, + entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento + sino 'puntero' tiene el valor TTDA_Nulo } +procedure COLAORD_Almac_Reservar( VAR almac : COLAORD_Almac; VAR puntero : COLAORD_Puntero ); +begin + if not COLAORD_Almac_HayLugar( almac ) + then + puntero := COLAORD_Nulo + else begin + puntero := almac.primero_dispo; + almac.primero_dispo := almac.disponibles[ puntero ]; + end; +end; + +{ ========================================================================== } +{ liberar un elemento del almacenamiento } +{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento } +{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo } +procedure COLAORD_Almac_Liberar( VAR almac : COLAORD_Almac; VAR puntero : COLAORD_Puntero ); +begin + almac.disponibles[ puntero ] := almac.primero_dispo; + almac.primero_dispo := puntero; + puntero := COLAORD_Nulo; +end; + +{ ========================================================================== } +{ acceder al elemento del almacenamiento apuntado por un puntero } +{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento } +{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' } +procedure COLAORD_Almac_Acceder( almac : COLAORD_Almac; puntero : COLAORD_Puntero; VAR elemento : COLAORD_Nodo ); +begin + elemento := almac.almacenamiento[ puntero ]; +end; + +{ ========================================================================== } +{ modificar el elemento del almacenamiento apuntado por un puntero } +{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento } +{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' } +procedure COLAORD_Almac_Modificar( VAR almac : COLAORD_Almac; puntero : COLAORD_Puntero; elemento : COLAORD_Nodo ); +begin + almac.almacenamiento[ puntero ] := elemento; +end; + + + +{ Estas son los dos procedimientos principales de la aplicación } + +PROCEDURE COLAORD_Inicializar ( VAR l: COLAORD_Cola ); +BEGIN + COLAORD_Almac_Inicializar( l.almac ); + l.primero := COLAORD_Nulo; +END; + +FUNCTION COLAORD_vacia( l: COLAORD_Cola): BOOLEAN; +BEGIN + COLAORD_vacia := ( l.Primero = COLAORD_Nulo); +END; + +FUNCTION COLAORD_llena( l: COLAORD_Cola): BOOLEAN; +BEGIN + COLAORD_llena := not COLAORD_Almac_HayLugar( l.almac ); +END; + +PROCEDURE COLAORD_poner ( VAR l: COLAORD_Cola; e: Tipo_Elem; VAR error: boolean); +VAR + n : COLAORD_Nodo; + np: COLAORD_Puntero; + m : COLAORD_Nodo; + mp : COLAORD_Puntero; +BEGIN + error := false; + np := l.primero; + WHILE ( np <> COLAORD_Nulo ) AND ( not error ) + DO BEGIN + COLAORD_Almac_Acceder( l.almac, np, n ); + error := devolver_clave_elem( n.elem ) = devolver_clave_elem( e ); + + { cambio los punteros } + np := n.sig; + END; + + IF not error + THEN BEGIN + { inserto como en una pila, adelante } + m.Elem := e; + m.sig := l.primero; + COLAORD_Almac_Reservar( l.almac, mp ); + COLAORD_Almac_Modificar( l.almac, mp, m ); + + l.primero := mp; + END; +END; + +{ pre: no esta vacia } +PROCEDURE COLAORD_sacar ( VAR l: COLAORD_Cola; VAR e: Tipo_Elem); +VAR + n,m : COLAORD_Nodo; + np, mp, ap, amp: COLAORD_Puntero; +BEGIN + mp := l.primero; + COLAORD_Almac_Acceder( l.almac, mp, m ); { este es el primer menor } + amp := COLAORD_Nulo; + np := m.sig; { y salto al siguiente para no hacer la comparacion dos veces } + ap := mp; + + { busco el menor } + WHILE np <> COLAORD_Nulo + DO BEGIN + COLAORD_Almac_Acceder( l.almac, np, n ); + IF devolver_clave_elem( n.elem ) < devolver_clave_elem( m.elem ) + THEN BEGIN + m := n; + mp := np; + amp := ap; + END; + + { cambio los punteros } + ap := np; + np := n.sig; + END; + + IF l.primero = mp THEN BEGIN + { como estoy tocando el primero el primero es su siguiente } + l.primero := m.sig; + END + ELSE BEGIN + COLAORD_Almac_Acceder( l.almac, amp, n ); + n.sig := m.sig; + COLAORD_Almac_Modificar( l.almac, amp, n ); + END; + + { libero el nodo del menor } + COLAORD_Almac_Liberar( l.almac, mp ); + + { y se lo asigno al parametro } + e := m.Elem; +END; + +PROCEDURE COLAORD_vaciar ( VAR l: COLAORD_Cola ); +VAR np : COLAORD_Puntero; + n : COLAORD_Nodo; +BEGIN + np := l.primero; + while( np <> COLAORD_Nulo ) do begin + COLAORD_Almac_Acceder( l.almac, np, n ); + COLAORD_Almac_Liberar( l.almac, np ); + np := n.sig; + end; + l.primero := COLAORD_Nulo; +END; + +{ pre: 'a' y 'b' estan creadas y 'b' esta vacia } +{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero } +PROCEDURE COLAORD_copiar ( a : COLAORD_Cola; VAR b : COLAORD_Cola ); +VAR np, mp, tmpp : COLAORD_Puntero; + n, m : COLAORD_Nodo; +BEGIN + if a.primero = COLAORD_Nulo then exit; + np := a.primero; + COLAORD_Almac_Acceder( a.almac, np, n ); + + COLAORD_Almac_Reservar( b.almac, mp ); + b.primero := mp; + m.elem := n.elem; + + while( n.sig <> COLAORD_Nulo ) do begin + + COLAORD_Almac_Reservar( b.almac, tmpp ); + m.sig := tmpp; + COLAORD_Almac_Modificar( b.almac, mp, m ); + + np := n.sig; + COLAORD_Almac_Acceder( a.almac, np, n ); + + mp := tmpp; + m.elem := n.elem; + + end; + m.sig := COLAORD_Nulo; + COLAORD_Almac_Modificar( b.almac, mp, m ); +END; + +end. + diff --git a/t_colord_b1.pas b/t_colord_b1.pas new file mode 100644 index 0000000..e8dbdb8 --- /dev/null +++ b/t_colord_b1.pas @@ -0,0 +1,135 @@ +{ algoritmos y programacion II - Catedra Carolo - PRACTICA } +{ PARCIAL 1 1ra Op CUAT 1 2000 } + +unit T_COLORD_B1; + +{ + IMPLEMENTACION : cola ordenada (cola de prioridades) + ALMACENAMIENTO : LISTAS + CARACTERISTICAS: poner ordenado + +} + +{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular } +interface + +{ usa las funciones generales de TDAs } +uses tda_gral, T_LDC; + +TYPE + + COLAORD_Cola = RECORD + almac : LDC_Lista; + END; + + +{ ========= } +{ INTERFASE } + + +PROCEDURE COLAORD_Inicializar ( VAR l: COLAORD_Cola ); +FUNCTION COLAORD_vacia( l: COLAORD_Cola): BOOLEAN; +FUNCTION COLAORD_llena( l: COLAORD_Cola): BOOLEAN; + +PROCEDURE COLAORD_poner ( VAR l: COLAORD_Cola; e: Tipo_Elem; VAR error: boolean); +PROCEDURE COLAORD_sacar ( VAR l: COLAORD_Cola; VAR e: Tipo_Elem); +PROCEDURE COLAORD_vaciar ( VAR l: COLAORD_Cola ); +PROCEDURE COLAORD_copiar ( a: COLAORD_Cola; VAR b: COLAORD_Cola ); + +implementation + +{ Estas son los dos procedimientos principales de la aplicación } + +PROCEDURE COLAORD_Inicializar ( VAR l: COLAORD_Cola ); +BEGIN + LDC_Inicializar( l.almac ); +END; + +FUNCTION COLAORD_vacia( l: COLAORD_Cola): BOOLEAN; +BEGIN + COLAORD_vacia := ( LDC_Vacia( l.almac )); +END; + +FUNCTION COLAORD_llena( l: COLAORD_Cola): BOOLEAN; +BEGIN + COLAORD_llena := LDC_llena( l.almac ); +END; + +PROCEDURE COLAORD_poner ( VAR l: COLAORD_Cola; e: Tipo_Elem; VAR error: boolean); +VAR + error_mov : boolean; + found : boolean; + rep: Tipo_elem; + cte: Tipo_elem; + ant: Tipo_elem; +BEGIN + error := false; + IF LDC_Vacia( l.almac ) THEN + LDC_insertar( l.almac, LDC_primero, e ) + ELSE BEGIN + { recorro para ver si esta duplicado y buscar donde insertarlo } + LDC_mover_cte( l.almac, LDC_primero, error_mov ); + LDC_elem_cte( l.almac, cte ); + IF devolver_clave_elem( cte ) > devolver_clave_elem( e ) + THEN LDC_insertar( l.almac, LDC_primero, e ) + ELSE IF devolver_clave_elem( cte ) = devolver_clave_elem( e ) + THEN error := true + ELSE BEGIN + ant := cte; + LDC_mover_cte( l.almac, LDC_siguiente, error_mov ); + WHILE ( not error ) AND ( not error_mov ) DO BEGIN + LDC_elem_cte( l.almac, cte ); + IF devolver_clave_elem( cte ) > devolver_clave_elem( e ) + THEN error_mov := true + ELSE IF devolver_clave_elem( cte ) = devolver_clave_elem( e ) + THEN error := true + ELSE BEGIN + LDC_mover_cte( l.almac, LDC_siguiente, error_mov ); + ant := cte; + END; + END; + + IF not error + THEN BEGIN + LDC_mover_cte( l.almac, LDC_primero, error_mov ); + WHILE not error_mov DO BEGIN + LDC_elem_cte( l.almac, cte ); + IF devolver_clave_elem( cte ) = devolver_clave_elem( ant ) + THEN BEGIN + LDC_insertar( l.almac, LDC_siguiente, e ); + error_mov := true; + END + ELSE + LDC_mover_cte( l.almac, LDC_siguiente, error_mov ); + END; + END; + END; + END + + +END; + +{ pre: no esta vacia } +PROCEDURE COLAORD_sacar ( VAR l: COLAORD_Cola; VAR e: Tipo_Elem); +VAR + error : boolean; +BEGIN + LDC_mover_cte( l.almac, LDC_primero, error ); + LDC_elem_cte( l.almac, e ); + LDC_borrar_cte( l.almac ); +END; + +PROCEDURE COLAORD_vaciar ( VAR l: COLAORD_Cola ); +BEGIN + LDC_Vaciar( l.almac ); +END; + +{ pre: 'a' y 'b' estan creadas y 'b' esta vacia } +{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero } +PROCEDURE COLAORD_copiar ( a : COLAORD_Cola; VAR b : COLAORD_Cola ); +BEGIN + LDC_Copiar( a.almac, b.almac ); +END; + +end. + diff --git a/t_colord_b2.pas b/t_colord_b2.pas new file mode 100644 index 0000000..1ffd7d8 --- /dev/null +++ b/t_colord_b2.pas @@ -0,0 +1,130 @@ +{ algoritmos y programacion II - Catedra Carolo - PRACTICA } +{ PARCIAL 1 1ra Op CUAT 1 2000 } + +unit T_COLORD_B2; + +{ + IMPLEMENTACION : cola ordenada (cola de prioridades) + ALMACENAMIENTO : LISTAS + CARACTERISTICAS: sacar ordenado + +} + +{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular } +interface + +{ usa las funciones generales de TDAs } +uses tda_gral, T_LDC; + +TYPE + + COLAORD_Cola = RECORD + almac : LDC_Lista; + END; + + +{ ========= } +{ INTERFASE } + + +PROCEDURE COLAORD_Inicializar ( VAR l: COLAORD_Cola ); +FUNCTION COLAORD_vacia( l: COLAORD_Cola): BOOLEAN; +FUNCTION COLAORD_llena( l: COLAORD_Cola): BOOLEAN; + +PROCEDURE COLAORD_poner ( VAR l: COLAORD_Cola; e: Tipo_Elem; VAR error: boolean); +PROCEDURE COLAORD_sacar ( VAR l: COLAORD_Cola; VAR e: Tipo_Elem); +PROCEDURE COLAORD_vaciar ( VAR l: COLAORD_Cola ); +PROCEDURE COLAORD_copiar ( a: COLAORD_Cola; VAR b: COLAORD_Cola ); + +implementation + +{ Estas son los dos procedimientos principales de la aplicación } + +PROCEDURE COLAORD_Inicializar ( VAR l: COLAORD_Cola ); +BEGIN + LDC_Inicializar( l.almac ); +END; + +FUNCTION COLAORD_vacia( l: COLAORD_Cola): BOOLEAN; +BEGIN + COLAORD_vacia := ( LDC_Vacia( l.almac )); +END; + +FUNCTION COLAORD_llena( l: COLAORD_Cola): BOOLEAN; +BEGIN + COLAORD_llena := LDC_llena( l.almac ); +END; + +PROCEDURE COLAORD_poner ( VAR l: COLAORD_Cola; e: Tipo_Elem; VAR error: boolean); +VAR + error_mov : boolean; + rep: Tipo_elem; +BEGIN + error := false; + IF not LDC_Vacia( l.almac ) THEN BEGIN + { recorro para ver si esta duplicado } + LDC_mover_cte( l.almac, LDC_primero, error_mov ); + WHILE ( not error ) AND ( not error_mov ) DO BEGIN + LDC_elem_cte( l.almac, rep ); + error := devolver_clave_elem( rep ) = devolver_clave_elem( e ); + + IF not error THEN + LDC_mover_cte( l.almac, LDC_siguiente, error_mov ); + END; + END; + + IF not error THEN + { si no esta repetido lo inserto } + LDC_insertar( l.almac, LDC_primero, e ); +END; + +{ pre: no esta vacia } +PROCEDURE COLAORD_sacar ( VAR l: COLAORD_Cola; VAR e: Tipo_Elem); +VAR + error : boolean; + menor : Tipo_Elem; + cte : Tipo_Elem; +BEGIN + LDC_mover_cte( l.almac, LDC_primero, error ); + LDC_elem_cte( l.almac, menor ); + LDC_mover_cte( l.almac, LDC_siguiente, error ); + + { recorro buscando } + WHILE not error DO BEGIN + LDC_elem_cte( l.almac, cte ); + IF devolver_clave_elem( cte ) < devolver_clave_elem( menor ) THEN menor := cte; + + LDC_mover_cte( l.almac, LDC_siguiente, error ); + + END; + writeln( 'el menor es ', menor.dni ); + + { aqui ya tenemos el ultimo } + LDC_mover_cte( l.almac, LDC_primero, error ); + WHILE not error DO BEGIN + LDC_elem_cte( l.almac, cte ); + IF devolver_clave_elem( cte ) <> devolver_clave_elem( menor ) + THEN LDC_mover_cte( l.almac, LDC_siguiente, error ) + ELSE error := true; + writeln( 'siguiendo es ', cte.dni ); + END; + + LDC_elem_cte( l.almac, e ); + writeln( 'borrado es ', e.dni ); + LDC_borrar_cte( l.almac ); +END; + +PROCEDURE COLAORD_vaciar ( VAR l: COLAORD_Cola ); +BEGIN + LDC_Vaciar( l.almac ); +END; + +{ pre: 'a' y 'b' estan creadas y 'b' esta vacia } +{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero } +PROCEDURE COLAORD_copiar ( a : COLAORD_Cola; VAR b : COLAORD_Cola ); +BEGIN + LDC_Copiar( a.almac, b.almac ); +END; + +end. +