TP_Busq.pas

   1 Program Estudio_Busquedas;\r
   2 \r
   3 {encabezado}\r
   4 \r
   5 uses Crt;\r
   6 \r
   7 {declaracion de constantes}\r
   8 \r
   9 const\r
  10 \r
  11 primera=1;\r
  12 ultima=100;\r
  13 ultimamas1=ultima+1;\r
  14 \r
  15 {declaracion de tipos}\r
  16 \r
  17 type\r
  18         tipollave=integer;\r
  19         subindices=primera..ultima;     {subindices para el vector}\r
  20         aumentado=primera..ultimamas1;\r
  21         T_Consultas= 1..8; {son ocho consultas}\r
  22         tipovector=array [subindices] of integer;\r
  23         Array_of_arrays= array [T_consultas] of tipovector;\r
  24         tipo_busq= array[T_consultas] of string;\r
  25 \r
  26 {declaracion de variables}\r
  27 \r
  28 var\r
  29         vector:tipovector;\r
  30         idx, clave: integer;    {variable de indice}\r
  31         caso: T_Consultas;      {subindice de los arrays}\r
  32         ref_vector: array_of_arrays;\r
  33         {vector para almacen de vectores utilizados}\r
  34 \r
  35         consultas: array[T_consultas] of integer;\r
  36         {vector para almacen de consultas efectuadas}\r
  37 \r
  38         busqueda: array[T_consultas] of integer;\r
  39         {vector para almacen del valor a buscar}\r
  40 \r
  41         Tipo_b: Tipo_busq;\r
  42         {vector para almacen de tipo de consultas}\r
  43         linea_t:string;\r
  44         ciclo,x,i,a,b:integer; {a y b son variables 'comodin' arbitrariamente empleadas}\r
  45         r,s,t:real;\r
  46 \r
  47         grDriver: Integer;\r
  48         grMode: Integer; {variables para el modo grafico}\r
  49 \r
  50 \r
  51 \r
  52 {---------------------------------------------------------------------}\r
  53 \r
  54 {seccion algorítmica}\r
  55 {procedimientos y funciones}\r
  56 \r
  57 \r
  58 {----------------------------------------------------------}\r
  59 {PROCEDIMIENTOS PARA VISUALIZACION EN PANTALLA}\r
  60 \r
  61 {-----------------------------------------------------------------}\r
  62 procedure Presentacion;\r
  63 \r
  64 var a,b:integer;\r
  65 \r
  66 begin\r
  67 \r
  68       textbackground(White);\r
  69       textcolor(Black);\r
  70       for a:=9 to 15 do for b:=25 to 55 do begin gotoxy(b,a);\r
  71                                                   write(' ');\r
  72                                             end;\r
  73       gotoxy(31,10);write('METODOS DE BUSQUEDA');\r
  74       gotoxy(31,12);write('-estudio  simulado-');\r
  75       gotoxy(34,14);write('72.40 C:7');\r
  76       textcolor(black+blink);\r
  77       gotoxy(25,17);write('Pulse una tecla para continuar');\r
  78       textbackground(Cyan);\r
  79       textcolor(black);\r
  80       readkey;\r
  81 end;{fin del procedimiento}\r
  82 \r
  83 \r
  84 {-----------------------------------------------------------------}\r
  85 procedure Salida;\r
  86 \r
  87 var a,b:integer;\r
  88 \r
  89 begin\r
  90 \r
  91       textbackground(cyan);\r
  92       textcolor(black);\r
  93       for a:=2 to 6 do for b:=25 to 55 do begin gotoxy(b,a);\r
  94                                                   write(' ');\r
  95                                             end;\r
  96       gotoxy(31,2);write('TRABAJO PRACTICO #3');\r
  97       gotoxy(31,3);write('Creado por el Gr#06');\r
  98       gotoxy(34,5);write('>NOV 1999');\r
  99       textcolor(black+blink);\r
 100 \r
 101       textcolor(black);\r
 102       readkey;\r
 103 end;{fin del procedimiento}\r
 104 \r
 105 \r
 106 {----------------------------------------------------------}\r
 107 Procedure    Imprime_en(a,b: integer;texto:string);\r
 108              begin\r
 109              gotoxy(a,b);\r
 110              Writeln (texto);\r
 111              end; {fin del procedimiento}\r
 112 \r
 113 \r
 114 {----------------------------------------------------------}\r
 115 Procedure Muestra_barra(color:byte;valor:real;fila:integer);\r
 116 \r
 117           var a:integer;\r
 118 \r
 119           begin\r
 120 \r
 121              textbackground(color);\r
 122              for a:=15 to round(valor*50+15) do imprime_en(a,fila,' ');\r
 123 \r
 124           end;\r
 125 \r
 126 {----------------------------------------------------------}\r
 127 \r
 128 \r
 129 {----------------------------------------------------------}\r
 130 {Exportacion hacia archivo de texto}\r
 131 \r
 132 procedure Graba_en_Archivo(     var Clave: integer;\r
 133                                         var V100: tipovector;\r
 134                                         n_cons: integer;\r
 135                                         TipoB: string;\r
 136                                         Proba: Integer);\r
 137 \r
 138 {encabezado}{proc}\r
 139 {declaracion de variables}\r
 140 \r
 141 var\r
 142 reporte : text; {archivo de salida con formato texto}\r
 143 a_salida,texto,linea, conv : string;\r
 144         cont: integer;\r
 145 \r
 146 {seccion algorítmica}{proc}\r
 147 \r
 148 begin\r
 149 \r
 150      str(Proba,conv); {conversion del numero de probadilidad}\r
 151      a_salida:='C:\reporte'+conv+'.txt';\r
 152      assign(reporte,a_salida);\r
 153      {$I-} {deshabilita el control sobre los archivos}\r
 154      append(reporte);\r
 155      if not (ioresult=0) then rewrite(reporte);    {abre el archivo}\r
 156 \r
 157      texto:='';\r
 158      for a:=1 to 10 do texto:='-'+texto;\r
 159      writeln(reporte,texto);    {linea divisoria}\r
 160      texto:= 'BUSQUEDA '  + TipoB;\r
 161      writeln(reporte, texto);   {exhibe tipo de busqueda}\r
 162      texto:='';\r
 163      for a:=1 to 10 do texto:='-'+texto;\r
 164      writeln(reporte,texto);    {linea divisoria}\r
 165      str(Clave,conv); {conversion del numero de ciclos}\r
 166      texto:= 'NUMERO de CICLOS: '+ conv;\r
 167      str(n_cons,conv);\r
 168      writeln(reporte, texto);   {informa cantidad de iteraciones}\r
 169      texto:= 'CONSULTAS efectuadas: '+ conv;\r
 170      writeln(reporte, texto);   {cantidad de consultas efectuadas}\r
 171      texto:= 'VECTOR obtenido';\r
 172      writeln(reporte, texto);   {informa cantidad de iteraciones}\r
 173      writeln(reporte);\r
 174 \r
 175      {informacion en pantalla}\r
 176      textcolor(black);\r
 177      Imprime_en(7,17,'Grabando Estadisticas en archivo');\r
 178      textcolor(red);\r
 179      for a:=5 to (Proba*2+5) do imprime_en(a,18,'.' );\r
 180      textcolor(black);\r
 181 \r
 182 \r
 183      for cont := 1 to high(V100) do\r
 184 \r
 185         begin\r
 186              imprime_en(5,17,'-');\r
 187              imprime_en(5,17,'\');\r
 188              imprime_en(5,17,'|');\r
 189              imprime_en(5,17,'/');\r
 190              imprime_en(5,17,'-');\r
 191              imprime_en(5,17,'\');\r
 192              imprime_en(5,17,'|');\r
 193              imprime_en(5,17,'/');\r
 194 \r
 195 \r
 196              str(V100[cont],conv); {conversion del contenido de los vectores}\r
 197              texto:=' ';\r
 198              for a:=1 to (7-length(conv)) do texto:=texto+' '; {separacion uniforme}\r
 199              linea := linea + conv + texto; {concatena el vector}\r
 200              if cont mod 10 = 0 then\r
 201                 begin\r
 202                 writeln(reporte, linea); {linea de exportacion hacia archivo}   {imprime el vector}\r
 203                 linea := '';\r
 204 \r
 205                 end;\r
 206         end;\r
 207 \r
 208         writeln(reporte);\r
 209         close(reporte);\r
 210 end; {fin del procedimiento}\r
 211 \r
 212 {----------------------------------------------------------}\r
 213 {PROCEDIMIENTOS PARA MANIPULACION Y CREACION DE VECTORES}\r
 214 {----------------------------------------------------------}\r
 215 {generacion aleatoria del vector}\r
 216 {este procedimiento se ejecuta cada vez que el programa es corrido, y carga el vector para muestrear las busquedas}\r
 217 \r
 218 procedure vectoraleatorio(dimension:integer;var aleatorio:tipovector);\r
 219 var i:integer;\r
 220         begin\r
 221                 Randomize;\r
 222                 for  i:=1 to dimension do aleatorio[i]:=trunc((random*65535)-32768);\r
 223         end;{fin del procedimiento}\r
 224 \r
 225 {----------------------------------------------------------}\r
 226 {generacion aleatoria de  los subindices}\r
 227 {los valores a,b,c continen las proporciones a emplearse para estimar la probabilidad de aparacion; "y" es un valor aleatorio\r
 228 (en el programa se usará la funcion random para cargar este vector); i,j,k son los "cortes en el vector", que determinarán\r
 229 los rangos deonde actuan las probabilidades}\r
 230 \r
 231 function subindice(y,a,b,c:real;i,j,k:integer):integer;\r
 232         begin\r
 233                 if y<=a then subindice:=trunc((y*(i-1)/a)+1)\r
 234                         else if y<=b then subindice:=trunc((y*(j-i)-(a*j)+(b*i))/(b-a))\r
 235                         else subindice:=trunc((y*(k-j)-(b*k)+(c*j))/(c-b));\r
 236         end;{fin de la funcion}\r
 237 \r
 238 {------------------------------------------------------------------}\r
 239 \r
 240 {----------------------------------------------------------}\r
 241 {obtencion del valor para el subindice}\r
 242 {esta funcion devuelve el valor para un indice de un vector}\r
 243 \r
 244 function valor(subindice:integer;vector:tipovector):integer;\r
 245 \r
 246         begin\r
 247                 valor:=vector[subindice];\r
 248         end;{fin de la funcion}\r
 249 \r
 250 {----------------------------------------------------------}\r
 251 {permutacion de probabilidades}\r
 252 {para una correcta evaluacion de los sistemas, es necesario contemplar todas las posibilidades}\r
 253 \r
 254 procedure perm(c:integer;var m,n,o:real);\r
 255 \r
 256 begin\r
 257         m:=0;\r
 258         n:=0;\r
 259         o:=0; {el ultimo valor de ser simpre 1!!}\r
 260 \r
 261 \r
 262         case c of\r
 263 1:\r
 264         begin\r
 265         m:=0.15;\r
 266         n:=0.5;\r
 267         o:=1; {el ultimo valor de ser simpre 1!!}\r
 268         end;\r
 269 2:\r
 270         begin\r
 271         m:=0.5;\r
 272         n:=0.15;\r
 273         o:=1; {el ultimo valor de ser simpre 1!!}\r
 274         end;\r
 275 3:\r
 276         begin\r
 277         m:=0.5;\r
 278         n:=1; {el ultimo valor de ser simpre 1!!}\r
 279         o:=0.15;\r
 280         end;\r
 281 4:\r
 282         begin\r
 283         m:=0.15;\r
 284         n:=1; {el ultimo valor de ser simpre 1!!}\r
 285         o:=0.5;\r
 286         end;\r
 287 5:\r
 288         begin\r
 289         m:=1;\r
 290         n:=0.5; {el ultimo valor de ser simpre 1!!}\r
 291         o:=0.15;\r
 292         end;\r
 293 6:\r
 294         begin\r
 295         m:=1; {el ultimo valor de ser simpre 1!!}\r
 296         n:=0.15;\r
 297         o:=0.5;\r
 298         end;\r
 299 end\r
 300 \r
 301 end;{fin del procedimiento}\r
 302 \r
 303 {---------------------------------------------------------------}\r
 304 {ordenado del vector}\r
 305 {utiliza para esto un procedimiento de iteracion, e incluye la posibilidad de ordenar un vector de culaquier dimension\r
 306 permitiendole gran flexibilidad }\r
 307 \r
 308 procedure ordenarvector(dimension:integer;vec1:tipovector;var vec2:tipovector);\r
 309 \r
 310 var\r
 311 j,k,ultimo:integer;\r
 312 \r
 313 begin\r
 314 ultimo:=1;\r
 315 k:=1;\r
 316 vec2[1]:=vec1[1];\r
 317 while ultimo<=dimension do\r
 318                         begin\r
 319                              if vec1[ultimo+1]>=vec2[ultimo]\r
 320                              then vec2[ultimo+1]:=vec1[ultimo+1]\r
 321                                   else begin\r
 322                                             j:= 1;\r
 323                                             while vec1[ultimo+1]>=vec2[j] do inc(j);\r
 324                                             for k:=ultimo+1 downto j do vec2[k]:=vec2[k-1];\r
 325                                             vec2[j]:=vec1[ultimo+1];\r
 326                                        end;\r
 327                              inc(ultimo);\r
 328                         end;\r
 329 end;{fin del procedimiento}\r
 330        { }\r
 331 {---------------------------------------------------------------}\r
 332 {con este procedimiento, se carga un vector que va a contener y administrar todos los vectores empleados para la busqueda}\r
 333 \r
 334 Procedure Asignar_Referencia (var r_vector:array_of_arrays;vect:tipovector);\r
 335         Var\r
 336         Vect_o:tipovector;\r
 337         begin\r
 338              r_vector[1] := vect;       {desordenado para busqueda basica}\r
 339              r_vector[2] := vect;       {desordenado para puesta al frente}\r
 340              r_vector[3] := vect;       {desordenado para trasposicion}\r
 341              ordenarvector(ultima,vect,vect_o);\r
 342              r_vector[4] := vect_o;     {ordenado para busqueda optimizada}\r
 343              r_vector[5] := vect_o;     {ordenado para busqueda binaria}\r
 344              r_vector[6] := vect_o;     {ordenado para busqueda por saltos}\r
 345              r_vector[7] := vect_o;     {ordenado para interpolacion}\r
 346              r_vector[8] := vect_o;     {ordenado para interpolacion/sec}\r
 347         end;{fin del procedimiento}\r
 348 \r
 349 \r
 350 {---------------------------------------------------------------}\r
 351 {con este procedimiento, se carga un vector que va a contener y administrar todos los vectores empleados para la busqueda}\r
 352 \r
 353 Procedure Tipo_Busqueda (var b_vector:tipo_busq );\r
 354         begin\r
 355              b_vector[1] := 'secuencial basica (exhibe el vector original)';\r
 356              b_vector[2] := 'con puesta al frente';\r
 357              b_vector[3] := 'con trasposicion';\r
 358              b_vector[4] := 'optimizada';\r
 359              b_vector[5] := 'binaria';\r
 360              b_vector[6] := 'por saltos';\r
 361              b_vector[7] := 'por interpolacion';\r
 362              b_vector[8] := 'por interpolacion + secuencial';\r
 363         end;{fin del procedimiento}\r
 364 \r
 365 \r
 366 {----------------------------------------------------------}\r
 367 {FUNCIONES DE BUSQUEDA}\r
 368 {-----------------------------------------------------------------}\r
 369 {busqueda secuencial basica}\r
 370 \r
 371 function SEQB (var a: tipovector; x:integer): integer;\r
 372         var\r
 373                 i: integer;\r
 374         begin\r
 375 for i:=1 to 100 do\r
 376                 if x=a[i] then\r
 377                         SEQB:= i;\r
 378                         exit;\r
 379                         end; {fin del procedimiento}\r
 380 \r
 381 {----------------------------------------------------------}\r
 382 {busqueda secuencial con traslado al frente del elemento}\r
 383 \r
 384 function MRU(var a:tipovector ; x:integer): integer;\r
 385         var\r
 386                 i: integer; cambio: integer;\r
 387         begin\r
 388                 for i:=1 to 100 do\r
 389                         if x=a[i] then\r
 390                                 begin\r
 391                                 cambio:=a[i];\r
 392                                 a[i]:= a[1];\r
 393                                 a[1]:=cambio;\r
 394                                 MRU:= i;\r
 395                                 exit;\r
 396                                 end;\r
 397                         end; {fin del procedimiento}\r
 398 \r
 399 {----------------------------------------------------------}\r
 400 {busqueda secuencial con trasposicion al elemento anterior}\r
 401 \r
 402 function MFU(var a:tipovector; x:integer): integer;\r
 403         var\r
 404                 i: integer; cambio: integer;\r
 405         begin;\r
 406                 if x=a[1] then exit;\r
 407                         for i:=1 to 100 do\r
 408                                 if x=a[i] then\r
 409                                         begin;\r
 410                                         cambio:=a[i];;\r
 411                                         a[i]:=a[i-1];\r
 412                                         a[i-1]:=cambio;\r
 413                                         MFU:=i;\r
 414                                         exit;\r
 415                                 end;\r
 416                         end; {fin del procedimiento}\r
 417 \r
 418 {----------------------------------------------------------}\r
 419 {busqueda binaria - recursiva}\r
 420 \r
 421 function BINR(var a:tipovector;clave:integer;Min,Max,Ct:integer):integer;\r
 422 var\r
 423      medio:integer;\r
 424 begin\r
 425      inc(Ct);\r
 426      medio:=(Min+Max) div 2;\r
 427      if (Min <= Max) and (a[medio] <> clave) then\r
 428           begin\r
 429                 if clave < a[medio]\r
 430                  then\r
 431                      begin\r
 432                       Max:=medio-1;\r
 433                      end\r
 434                  else\r
 435                     begin\r
 436                       Min:=medio+1;\r
 437                     end;\r
 438                   ct:=BINR(a,clave,Min,Max,ct);\r
 439             end;\r
 440 BINR:=ct;\r
 441 end; {fin del procedimiento}\r
 442 \r
 443 {----------------------------------------------------------}\r
 444 {busqueda por saltos}\r
 445 \r
 446 function SALT (var a: tipovector; x,Min,Max,salto:integer): integer;\r
 447         var\r
 448                 prop,i: integer;\r
 449         begin\r
 450 prop:=round(Max/salto);\r
 451 for i:=Min to (prop) do\r
 452                 if x=a[i*salto] then\r
 453                                 begin\r
 454                                 SALT:=i;\r
 455                                 exit;\r
 456 \r
 457                                 end\r
 458                                 else if x<a[i*salto] then\r
 459                                          begin\r
 460                                               Min:=i*salto-salto;\r
 461                                               Max:=i*salto;\r
 462                                               if salto>1 then\r
 463                                                  salto:=salto div 2\r
 464                                                  else salto :=1; {por si acaso llego a uno antes de hallar el valor}\r
 465                                               i:=SALT(a,x,Min,Max,salto);\r
 466                                           exit;\r
 467                                          end;\r
 468 \r
 469 \r
 470 \r
 471                         end; {fin del procedimiento}\r
 472 \r
 473 {----------------------------------------------------------}\r
 474 \r
 475 \r
 476 {----------------------------------------------------------}\r
 477 {busqueda por interpolacion - recursiva}\r
 478 {Este procedimiento realiza la busque de un numero n en un vector vec (el\r
 479 cual debe encontrarse ordenado de menor a mayor) y devuelve un valor cont\r
 480 que aclara cuantos ciclos de busqueda realizo}\r
 481 \r
 482 function INTR (var vec:tipovector;n:integer;PriInd,UltInd,Ct:integer):integer;\r
 483 var\r
 484    r,prinum,ultnum:integer;\r
 485    numerador,denominador:word;\r
 486    pend,y:real;\r
 487 \r
 488 Begin\r
 489 \r
 490      prinum:=vec[priind];\r
 491      ultnum:=vec[ultind];\r
 492      inc(Ct);\r
 493 \r
 494      begin\r
 495      if ultnum=prinum then INTR:=ct else\r
 496         begin\r
 497                 NUMERADOR:=ultind-priind;\r
 498                 DENOMINADOR:=ultnum-prinum;\r
 499                 pend:=NUMERADOR/DENOMINADOR;\r
 500                 y:=pend*n-pend*prinum+priind; {desarrollo de la ecuacion de una recta\r
 501                 que pasa por dos puntos}\r
 502                 r:=round(y);\r
 503                 if vec[r]=n then INTR:=ct\r
 504                             else begin\r
 505                                  if vec[r]>n then ultind:=r-1\r
 506                                              else priind:=r+1;\r
 507                                  ct:=INTR(vec,n,priind,ultind,ct);\r
 508                                  end;\r
 509 \r
 510 \r
 511         end;\r
 512      end;\r
 513 end; {fin del procedimiento}\r
 514 \r
 515 {----------------------------------------------------------}\r
 516 {busqueda por interpolacion + secuencial}\r
 517 {Este procedimiento realiza la busque de un numero n en un vector vec (el\r
 518 cual debe encontrarse ordenado de menor a mayor). Realiza una busqueda por\r
 519 interpolacio y si no lo encuentra lo buscaca por la busqueda secuencial\r
 520 y devuelve un valor priind que aclara cuantos ciclos de busqueda realizo}\r
 521 \r
 522 function sec_de_intysec (var v:tipovector;k:integer;x:integer):integer;\r
 523 \r
 524 {usada posteriormente}\r
 525 \r
 526 var p,n,busc:integer;\r
 527 \r
 528 Begin\r
 529 \r
 530      if v[x]<k then p:=x\r
 531                else p:=low(v);\r
 532      n:=high(v);\r
 533      while (p<=n) and (v[p]<>k) do\r
 534            begin\r
 535            inc(p);\r
 536            inc(busc);\r
 537            end;\r
 538 sec_de_intysec:=busc;\r
 539 end; {fin del procedimiento}\r
 540 \r
 541 function INTS(var vec:tipovector;n:integer):integer;\r
 542 {esta es la funcion que se usará en el programa principal}\r
 543 var\r
 544 \r
 545    r,priind,ultind,prinum,ultnum:integer;\r
 546    pend,y:real;\r
 547 \r
 548 Begin\r
 549 \r
 550      priind:=low(vec);\r
 551 \r
 552      ultind:=high(vec);\r
 553      prinum:=vec[priind];\r
 554      ultnum:=vec[ultind];\r
 555      pend:=(ultind-priind)/(ultnum-prinum);\r
 556      y:=pend*n;\r
 557      r:=round(y);\r
 558      if r<=0 then r:=priind;\r
 559      if r>ultind then r:=ultind;\r
 560      if vec[r]<>n then INTS:=sec_de_intysec (vec,n,r);\r
 561 end; {fin del procedimiento}\r
 562 \r
 563 {----------------------------------------------------------}\r
 564 {programa principal}\r
 565 {----------------------------------------------------------}\r
 566 \r
 567 begin\r
 568 \r
 569 \r
 570 \r
 571 clrscr;\r
 572 \r
 573 Presentacion;\r
 574 \r
 575 Tipo_busqueda (Tipo_b); {define el nombre de las busquedas que se van a usar}\r
 576 Randomize; {inicializa la funcion random}\r
 577 \r
 578 {por cada distribucion de probabilidades se deberá generar un ciclo}\r
 579 \r
 580 for i:=1 to 6 do\r
 581         begin\r
 582              {inicializacion del numero de consultas}\r
 583              for caso:=1 to 8 do Consultas[caso]:=0;\r
 584 \r
 585              {creacion del vector original}\r
 586              vectoraleatorio(100,vector);\r
 587              {carga de probalidades}\r
 588              perm(i,r,s,t);\r
 589 \r
 590              clrscr;\r
 591 \r
 592              textbackground(black);\r
 593              for a:=1 to 80 do for b:=1 to 5 do imprime_en(a,b,' ');\r
 594              textcolor(white);\r
 595              imprime_en(5,5,'DISTRIBUCION DE PROBABILIDADES');\r
 596 \r
 597 \r
 598              textbackground(white+blink);\r
 599              textcolor(black);\r
 600              for a:=1 to 80 do for b:=6 to 11 do imprime_en(a,b,' ');\r
 601              imprime_en(5,6,'ALTERNATIVA');\r
 602              str(i,linea_t);\r
 603              imprime_en(17,6,linea_t);\r
 604              imprime_en(5,8,'SECCION>>');\r
 605              imprime_en(5,9,'1ERA.:');\r
 606              imprime_en(5,10,'2DA:');\r
 607              imprime_en(5,11,'3RA.:');\r
 608 \r
 609              Str(round(r*100),linea_t);\r
 610              imprime_en(12,9,linea_t);\r
 611              Str(round(s*100),linea_t);\r
 612              imprime_en(12,10,linea_t);\r
 613              Str(round(t*100),linea_t);\r
 614              imprime_en(12,11,linea_t);\r
 615 \r
 616              textbackground(cyan);\r
 617              for a:=1 to 80 do imprime_en(a,7,' ');\r
 618 \r
 619              Muestra_barra(green,r,9);\r
 620              Muestra_barra(red,s,10);\r
 621              Muestra_barra(blue,t,11);\r
 622              textbackground(white);\r
 623              textbackground(cyan);\r
 624              textcolor(black);\r
 625 \r
 626              {carga de referencias}\r
 627              Asignar_Referencia (ref_vector,vector);\r
 628 \r
 629              for ciclo:=1 to 10000 do\r
 630                 begin\r
 631                         x:=subindice(random,r,s,t,30,60,100);\r
 632                         for caso:=1 to 8 do\r
 633                         busqueda[caso]:=valor(x,ref_vector[caso]);\r
 634                         {asigna para cada vector el valor correspondiente\r
 635                         al subindice hallado previamente}\r
 636                         consultas[1]:=SEQB(ref_vector[1],busqueda[1]);\r
 637                         consultas[2]:=MRU(ref_vector[2],busqueda[2]);\r
 638                         consultas[3]:=MFU(ref_vector[3],busqueda[3]);\r
 639                         consultas[4]:=SEQB(ref_vector[4],busqueda[4]);\r
 640                         consultas[5]:=BINR(ref_vector[5],busqueda[5],primera,ultima,0);\r
 641                         consultas[6]:=SALT(ref_vector[6],busqueda[6],1,100,2);\r
 642                         consultas[7]:=INTR(ref_vector[7],busqueda[7],primera,ultima,0);\r
 643                         consultas[8]:=INTS(ref_vector[8],busqueda[8]);\r
 644 \r
 645                         {en caso de estar en un valor "estadistico"}\r
 646                         if (ciclo=100) or (ciclo=500) or (ciclo=1000) or (ciclo=5000) or (ciclo=10000) then\r
 647                                 for caso := 1 to 8 do\r
 648                                         Graba_en_Archivo (ciclo,ref_vector[caso],consultas[caso],tipo_b[caso],i);\r
 649 {esto es una sola instruccion}\r
 650                 end;\r
 651         end;\r
 652         {Pantalla de salida}\r
 653         clrscr;\r
 654         textbackground(black);\r
 655         for a:=8 to 72 do for b:=10 to 15 do imprime_en(a,b,' ');\r
 656         textbackground(white);\r
 657         for a:=7 to 71 do for b:=11 to 17 do imprime_en(a,b,' ');\r
 658         textcolor(black);\r
 659 \r
 660         Imprime_en(10,12,'El programa programa finaliz¢ exitosamente.');\r
 661         Imprime_en(10,13,'Busque los resultados en la Raiz de su disco local (C:\)');\r
 662         Imprime_en(10,14,'<Presione una tecla para salir>');\r
 663         Salida; {cartel de salida}\r
 664 \r
 665 \r
 666 end.    {fin del programa}\r
 667 \r