A partir de la primera semana de aplicación de pruebas, a través del asesor de la asignatura en su centro local

UNIVERSIDAD NACIONAL ABIERTA
VICERRECTORADO ACADÉMICO
ÁREA INGENIERÍA

TRABAJO PRÁCTICO:

ASIGNATURA: COMPUTACIÓN II

CÓDIGO: 324

FECHA DE ENTREGA DE LAS ESPECIFICACIONES AL

ESTUDIANTE:

A partir de la primera semana de aplicación de pruebas, a través del asesor de la asignatura en su centro local

FECHA DE DEVOLUCIÓN DEL INFORME POR EL ESTUDIANTE:

Adjunto a la Segunda Prueba Integral
NOMBRE DEL ESTUDIANTE: Elizabeth Ojeda
CÉDULA DE IDENTIDAD: 18.748.295

CORREO ELECTRÓNICO: anais7152@gmail.com

CENTRO LOCAL: Carabobo

CARRERA: 236

NÚMERO DE ORIGINALES: 

FIRMA DEL ESTUDIANTE:

LAPSO: 2011/2

TAD de los Empleados

Imprimir Matriz
Imprimir Matriz
Generar Matriz
Generar Matriz

EMPELADOS 
EMPELADOS 

Generar Matriz
Generar Matriz
Búsqueda de Empleados
Búsqueda de Empleados








OBJETIVO N° 5 y 6 SOBRE LOS METODOS DE ORDENACION Y BUSQUEDA
program ordenacion;
USES crt;
CONST
N=100;
TYPE
Vector=array[1..N] of integer;
VAR
V,AP,P:Vector;
m, opcion:integer;
opc:char;

(* Procedure que recibe como parametro un vector y lo imprime *)
procedure imprimirVector (var A:Vector);
var i, j:integer;
begin
j:=1;
for i:=1 to N do
begin
if j>9 then
begin
writeln(' | ', A[i]:3);
j:=1;
end
else
begin
j:=j+1 ;
write(' | ', A[i]:3);
end;
end
end;

(*Procedure que permite generar un vector de manera aleatoria *)
procedure generarVector(var A:Vector);
var i,j,aleatorio: integer;
begin
Randomize;
(* writeln('************** Generar Vector ***************'); *)
for i:=1 to N do
begin
aleatorio:=random(101);
A[i]:=aleatorio;
end
end;
(* Procedimiento que consiste en emplear un vector de indices que apuntan a cada elemento del vector original*)
procedure ordenarApuntador(var A,AP:Vector);
var
i,j,k,aux, posicion,l:integer;
B:Vector;
buscar:boolean;
begin
buscar:=false;
(* Se crea una copia del vector original *)
for k:=1 to N do
B[k]:=A[k];
for i:=1 to N-1 do
for j:=i+1 to N do
if B[j]< B[i] then
begin
aux:=B[i];
B[i]:=B[j];
B[j]:=aux;
end;
(*** Asignar Vector Apuntador **)
for i:=1 to N dobegin
aux:=B[i];
j:=1;
buscar:=false;
while (j<=N) and not buscar do
begin
if (A[j] = aux) then
begin
buscar:=true;
posicion:=j;
end
else
j:=j+1;
end;
AP[i]:=posicion;
end; (* fin del for *)
end;



(* Procedimiento que crea un vector de indices o permutaciones que indican el orden en que se encuentra cada uno de los elementos del vector original *)
procedure permutacion(var A,P:Vector);
var
i,j,k,aux, posicion,l:integer;
B:Vector;
buscar:boolean;
begin
buscar:=false;
(* Se crea una copia del vector original *)
for k:=1 to N do
B[k]:=A[k];
(* Metodo para ordenar *)
for i:=1 to N-1 do
for j:=i+1 to N do
if B[j]< B[i] then
begin
aux:=B[i];
B[i]:=B[j];
B[j]:=aux;
end;
(** Permutacion **)
for i:=1 to N do
begin
aux:=V[i];
buscar:=false;
j:=1;
while (j<=N) and NOT buscar do
begin
if B[j]=aux then
begin
posicion := j;
buscar:=true;
end
else
j:=j+1;
end ;
P[i]:=posicion;
end;
end;


(* procedimiento que se encarga de cambiar el contenido de los elementos *)
procedure Intercambiar(var x,y:integer);
var
aux:integer;
begin
aux:=x;
x:=y;
y:=aux;
end;

(*Procedimiento que permite ordenar un vector tomando como condición que el mismo este ordenado previamente *)
procedure ordenarShell(var A:Vector) ;
var
i,j,k,intervalo,m,aux:integer;
begin
intervalo:= N div 2;
while intervalo > 0 do
begin
for i:= (intervalo+1) to N do
begin
j:=i-intervalo;
while j>0 do
begin 
k:=j+intervalo;
if A[j] <= A[k] then
j:=0
else
begin
Intercambiar(A[j],A[k]);
j:=j-intervalo;
end
end (* fin del while *)
end ;
intervalo:= intervalo div 2;
end ;
end ;(* funcion que se encarga de realizar una busqueda de un elemento en el vector generado, el cual debe de estar ordenado para aplicar esta busqueda *)

function busquedaBinaria(var A:Vector;valor:integer ):integer;
var
primero, ultimo, central:integer;
encontrado:boolean;
begin
primero:=1;
ultimo:=N;
encontrado:=false;
while (primero<=ultimo) and not encontrado do
begin
central:=(primero + ultimo )div 2;
if(valor=A[central]) then 
encontrado:=true
else
if valor > A[central] then
primero:=central+1
else
ultimo:=central-1
end; (* fin del while *)
if not encontrado then
busquedaBinaria:=0
else
busquedaBinaria:=central
end;














(* procedimiento que se encarga de leer el numero que se desea buscar llamando a la funcion de busqueda e indicando si consiguio o no consiguió el elemento *)
procedure LeerBuscar ;
var
numero, encontrar: integer;
begin
gotoxy(9,15) ; write('***************************************************');
gotoxy(9,16) ; write('** Buscar en arreglo **');
gotoxy(9,17) ; write('***************************************************');
gotoxy(12,18); writeln(' Ingrese el numero entre 1 y 100 :');
REPEAT
gotoxy(50,18); readln(numero);
IF (numero >100) or (numero < 0) THEN
Begin
gotoxy(25,12); writeln('Opcion Incorrecta');
end;
UNTIL (opcion>= 0) and (opcion<=100) ;
encontrar:= busquedaBinaria(V, numero);
if encontrar=0 then
writeln('El numero no figura en la lista')
else
writeln(' El numero ocupa la posicion ', encontrar:1 )
end;


(*procediento que se encarga de mostrar la interfaz del menu principal *)
PROCEDURE menu;
BEGIN
Clrscr;
(* textbackground(white);
textcolor(red); *)
gotoxy(20,5) ; writeln('**************************************');
gotoxy(20,6); writeln('****** MENU PRINCIPAL ****');gotoxy(20,7); writeln('**************************************');
gotoxy(20,8); writeln('** **');
gotoxy(20,9); writeln('** 1.- Generar Vector **');
gotoxy(20,10); writeln('** 2.- Metodo del Apuntador **');
gotoxy(20,11); writeln('** 3.- Permutacion **');
gotoxy(20,12); writeln('** 4.- Ordenar por Shell **');
gotoxy(20,13); writeln('** 5.- Busqueda **');
gotoxy(20,14); writeln('** 6.- Salida **');
gotoxy(20,15); writeln('** **');
gotoxy(20,16); writeln('** SELECCIONE UNA OPCION: **');
gotoxy(20,17); writeln('** **');
gotoxy(20,18); writeln('**************************************');
gotoxy(20,19); writeln('**************************************');
gotoxy(20,20); writeln('**************************************');
END; (*Fin del procedure Menu*)

(* procedimiento que llama al menu principal y lee la opcion del usuario que el mismo selecciono *)
procedure llamarMenu (var opcion:integer);
begin
REPEAT
menu;
gotoxy(50,16);
readln(opcion);
IF (opcion > 6) or (opcion < 1) THEN
begin
gotoxy(26,17);
writeln('Opcion Incorrecta');
end;

UNTIL (opcion>= 1) and (opcion<=6) ;
CASE opcion OF
1: begin
Clrscr;
gotoxy(13,2); writeln(' *** GENERAR VECTOR ALEATORIO *** ');
gotoxy(1,4);
generarVector(V);
imprimirVector(V);
gotoxy(1,17);
writeln('**** Presione R para volver al Menu Principal ***') ;
gotoxy(1,18);
Repeat
readln(opc);
if(opc <> 'R') or (opc <> 'r') then
begin
gotoxy(2,19);
writeln('Opcion Incorrecta');
end;
UNTIL (opc='r') or (opc='R') ;
llamarMenu(opcion);
end ;
2: beginClrscr;
gotoxy(13,2); writeln(' *** VECTOR ALEATORIO *** ');
gotoxy(1,4);
imprimirVector(V);
ordenarApuntador(V,AP);
gotoxy(13,15); writeln(' *** VECTOR GENERADO *** ');
gotoxy(1,17);
imprimirVector(AP);
gotoxy(1,33);
writeln('**** Presione R para volver al Menu Principal ***') ;
gotoxy(1,35);

Repeat
readln(opc);
if(opc <> 'R') or (opc <> 'r') then
begin
gotoxy(1,35);
writeln('Opcion Incorrecta');
end;
UNTIL (opc='r') or (opc='R') ;
llamarMenu(opcion);

end ;

3: begin
Clrscr;
gotoxy(13,2); writeln(' *** VECTOR ALEATORIO *** ');
gotoxy(1,4);
imprimirVector(V);
permutacion(V,P);
gotoxy(13,15); writeln(' *** VECTOR PERMUTACION *** ');
gotoxy(1,17);
imprimirVector(P);
gotoxy(1,33);
writeln('**** Presione R para volver al Menu Principal ***') ;
gotoxy(1,35);

Repeat
readln(opc);
if(opc <> 'R') or (opc <> 'r') then
begin
gotoxy(1,35);
writeln('Opcion Incorrecta');
end;
UNTIL (opc='r') or (opc='R') ;
llamarMenu(opcion);
end ;

4: begin
Clrscr;
gotoxy(13,2); writeln(' *** VECTOR ALEATORIO *** ');
gotoxy(1,4);
imprimirVector(V);
ordenarShell(V);
gotoxy(13,15); writeln(' *** VECTOR PERMUTACION *** ');
gotoxy(1,17);
imprimirVector(V);
gotoxy(1,33);writeln('**** Presione R para volver al Menu Principal ***') ;
gotoxy(1,35);

Repeat
readln(opc);
if(opc <> 'R') or (opc <> 'r') then
begin
gotoxy(1,35);
writeln('Opcion Incorrecta');
end;
UNTIL (opc='r') or (opc='R') ;
llamarMenu(opcion);
end ;

5: (* busquedaBinaria(v,m); *)
begin
Clrscr;
gotoxy(13,2); writeln(' *** VECTOR ALEATORIO *** ');
gotoxy(1,4);
ordenarShell(V);
imprimirVector(V);
LeerBuscar;

gotoxy(1,33);
writeln('**** Presione R para volver al Menu Principal ***') ;
gotoxy(1,35);

Repeat
readln(opc);
if(opc <> 'R') or (opc <> 'r') then
begin
gotoxy(1,35);
writeln('Opcion Incorrecta');
end;
UNTIL (opc='r') or (opc='R') ;
llamarMenu(opcion);
end;
6: exit;
END;

end;

(* Principal *)
BEGIN
Clrscr;
llamarMenu(opcion);
ReadKey;
END.




LISTADO DE LOS RESULTADOS OBTENIDOS AL REALIZAR AL MENOS DOS CORRIDAS

1ERA CORRIDA

1- Generar el vector Aleatorio






2- Vector auxiliar que utilizo el Método Apuntador









3.- Vector generado usando el método de Permutación











4- Vector Ordenado por el Método Shell 

** Vector Generado por Shell **
** Vector Generado por Shell **










5- Aplicando una Búsqueda al Vector Ordenado










LISTADO DEL OBJETIVO 5 Y 6 SEGUNDA CORRIDA 
1- Generar el vector Aleatorio



2- Vector auxiliar que utilizo el Método Apuntador



3.- Vector generado usando el método de Permutación

4.- Vector Ordenado por el Método Shell 




5- Aplicando una Búsqueda al Vector Ordenado

...