Ebarbeito

[ Nota: Si estás interesado en leer este post, antes léete la primera parte del mismo. He querido dividir este fragmento del post inicial porque aquí mostraré parte de un programa codificado en pseudocódigo ALC y… poco más. ]

Estos dos últimos días he estado aplicando, en un sencillo programa, los conceptos que se tratan en el tema de Estructuras de Datos de una de mis asignaturas de programación. Me ha dado por escribir un, por así decirlo, “manejador de vectores” en plan simplista: que sea capaz de crear un vector, visualizarlo, insertar elementos y demás operaciones básicas que se pueden hacer. Pues nada, con el código este y con el intérprete ALC instalado en nuestro sistema, veamos la salida del programa principal, del cual posteriormente pondré el código para que veáis que fácil es entenderlo :)

fp1$ alc arrayManager.alc
Departamento de Lenguajes y Sistemas Informaticos
Interprete del lenguaje ALC, ver. 2.22 (23/9/99) [alc -? para ver opciones]
http://www.dlsi.ua.es/~alc (errores, sugerencias, etc: paco@dlsi.ua.es)

=============================================
Bienvenido al menu de tratamiento de vectores
=============================================

  1. Crear un vector de enteros.
  2. Imprimir el vector por pantalla.
  3. Insertar un elemento en la posicion final.
  4. Insertar un elemento en la posicion indicada.
  5. Borrar un elemento del vector.
  6. Buscar un elemento en el vector (forma secuencial).
  7. Buscar un elemento en el vector (forma binaria).
  8. Ordenar vector por el método: Inserción Directa.
  9. Ordenar vector por el método: Selección Directa.
 10. Ordenar vector por el método: Intercambio (Burbuja).
  0. Salir del programa.

  Elige una opción: 0

  Hasta la próxima.

Tiempo empleado por el programa: 2 segundos, 256674 microsegundos

Como veréis, no tiene nada del otro mundo. Es un menú donde cada opción llama a una función que es la que se encarga de realizar las cosas marcadas en ese menú, procesar la información y devolver los resultados. Y bueno, el código en ALC sería el siguiente [Antes de nada, seguramente no quepan algunas de las líneas de código en una sola línea y ello quizás dificulte la legibilidad –si acaso tenéis intención de leerlo y comprenderlo– con lo que es aconsejable que sigáis leyendo el post individualmente, donde seguro que si que caben las líneas):

# programa principal de 'arrayManager.alc
# una simple muestra de código ALC

algoritmo: ejemplo

escribelin('=============================================');
escribelin('Bienvenido al menu de tratamiento de vectores');
escribelin('=============================================');

repetir
  escribelin(' ');
  escribelin('  1. Crear un vector de enteros.');
  escribelin('  2. Imprimir el vector por pantalla.');
  escribelin('  3. Insertar un elemento en la posicion final.');
  escribelin('  4. Insertar un elemento en la posicion indicada.');
  escribelin('  5. Borrar un elemento del vector.');
  escribelin('  6. Buscar un elemento en el vector (forma secuencial).');
  escribelin('  7. Buscar un elemento en el vector (forma binaria).');
  escribelin('  8. Ordenar vector por el método: Inserción Directa.');
  escribelin('  9. Ordenar vector por el método: Selección Directa.');
  escribelin(' 10. Ordenar vector por el método: Intercambio (Burbuja).');
  escribelin('  0. Salir del programa.');

  escribelin(' ');
  escribe('  Elige una opción: ');
  leelin(opcion);
  escribelin(' ');

caso (opcion) de
  1: CrearArray(arrayNum);
     fbloque

  2: VisualizarArray(arrayNum);
     fbloque

  3: escribe('  Indica el elemento a insertar: ');
     lee(elem);
     InsertarFinal(elem, arrayNum);
     fbloque

  4: escribe('  Indica el elemento a insertar: ');
     lee(elem);
     escribe('  Indica la posicion dondea insertar el elemento: ');
     lee(posicion);
     InsertarPos(elem, posicion, arrayNum);
     fbloque

  5: escribe('  Indica el elemento a borrar: ');
     lee(buscaElem);
     resultado := BorrarElem(buscaElem,arrayNum);
     si (resultado = cierto) entonces
       mientras ((mostrar<>’s’) y (mostrar<>‘n’)) hacer
         lee(limpiarBuffer);
         escribe(’  Elemento borrado. ¿Mostrar vector? (s/n): ‘);
         lee(mostrar);
       fmientras;
       si (mostrar=’s’) entonces
         escribelin(’ ‘);
         VisualizarArray(arrayNum);
       fsi;
     sino
       escribelin(’  El elemento indicado no existe.’);
     fsi;
     mostrar := ‘ ‘;
     fbloque

  6: escribe(’  Indica el elemento a buscar: ‘);
     lee(buscaElem);
     resultado := BuscarLineal(arrayNum, buscaElem, lugar);
     si (resultado = cierto) entonces
       escribelin(’  Encontrado en la posicion [’,lugar,’].’);
     sino
       escribelin(’  El elemento buscado no existe.’);
     fsi;
     fbloque

  7: escribe(’  Indica el elemento a buscar: ‘);
     lee(buscaElem);
     resultado := BuscarBinario(arrayNum, buscaElem, lugar);
     si (resultado = cierto) entonces
       escribelin(’  Encontrado en la posicion [’,lugar,’].’);
       escribelin(’  El vector ha sido previamente ORDENADO.’);
     sino
       escribelin(’  El elemento buscado no existe.’);
     fsi;
     fbloque

  8: CopiarArray(arrayNum, arrayAux);
     OrdenarID(arrayNum);
     escribelin(’  El vector ha sido ordenado.’);
     escribe(’  Antes: ‘);
     para n:=1 hasta kTAM hacer
       escribe(arrayAux[n],’ ‘);
     fpara;
     escribelin(’ ‘); escribe(’  Ahora: ‘);
     para n:=1 hasta kTAM hacer
       escribe(arrayNum[n],’ ‘);
     fpara;
     escribelin(’ ‘);
     fbloque

  9: CopiarArray(arrayNum, arrayAux);
     OrdenarSD(arrayNum);
     escribelin(’  El vector ha sido ordenado.’);
     escribe(’  Antes: ‘);
     para n:=1 hasta kTAM hacer
       escribe(arrayAux[n],’ ‘);
     fpara;
     escribelin(’ ‘); escribe(’  Ahora: ‘);
     para n:=1 hasta kTAM hacer
       escribe(arrayNum[n],’ ‘);
     fpara;
     escribelin(’ ‘);
     fbloque

  10: CopiarArray(arrayNum, arrayAux);
     OrdenarBurbuja(arrayNum);
     escribelin(’  El vector ha sido ordenado.’);
     escribe(’  Antes: ‘);
     para n:=1 hasta kTAM hacer
       escribe(arrayAux[n],’ ‘);
     fpara;
     escribelin(’ ‘); escribe(’  Ahora: ‘);
     para n:=1 hasta kTAM hacer
       escribe(arrayNum[n],’ ‘);
     fpara;
     escribelin(’ ‘);
     fbloque

  0: escribelin(’  Hasta la próxima.’);
     fbloque
fcaso

hasta (opcion=0) frepetir

falgoritmo.

Ya véis que todo se escribe entre

algoritmo:nombre

….

falgoritmo.

:) al igual que las estructuras empiezan con alguna palabra en castellano y terminan con la misma palabra precedida por una ‘f’ (

si ...

fsi; o

repetir

….

hasta

(…)

frepetir;

). Luego la entrada/salida de datos se efectua mediante las instrucciones

escribe();

,

escribelin();

(añade un salto de línea),

lee();

,

leelin();

que parecen instrucciones de Pascal traducidas al castellano ;) Si tenéis nociones de programación o conocéis algún lenguaje, yo creo que sí podréis entenderlo sin mucha complicación (vamos, eso creo repito; quizás me estoy equivocando).

¿Qué os parece? No he querido pegar todo el programita este aquí porque es algo largo (450 y pico líneas). Aunque si os lo he dejado en la sección de código por si alguno le da por probar ALC o alguno de mis compañeros que se estén preparando la asignatura para septiembre (como yo) y entren aquí, quieren ver algún ejemplo de los algoritmos de búsqueda y ordenación vistos en el temario implementados en código ALC.

Aquí lo tenéis: arrayManager.alc

Y ahora si que os dejo por fin en paz jeje.
Pásenselo bien :-)

Trackback URI |