Ejercicios de aplicación:


Vayamos entonces a los primeros ejercicios en Modula, de modo que puedan practicar y chocar definitivamente con el lenguaje, con el entorno de desarrollo y con todos los problemas que pueden comenzar a tener a la hora de programar.


Esto es importante porque ustedes pueden venir leyendo este curso a la perfección y entender todo lo que comento, pero cuando llega el momento de sentarse a escribir código la cosa se complica. Espero entonces que hagan lo que se pide aquí:


Ejercicio 1: Realicen el programa del Adivinador planteado en el curso de Pascal, pero ahora en Modula 2. Esta versión será distinta, ya que en vez de intentar adivinar un número generado al azar por la CPU, el juego será de dos personas: Una persona primero deberá ingresar un número y luego la otra deberá intentar adivinar dicho número. Lo único que cambia entonces es que en vez de generar un número al azar deberán leerlo de la entrada estándar.


¿Por qué este cambio? Porque no tenemos en Modula 2 una librería por defecto que nos permita generar números aleatorios, sino que debemos implementar una o usar una de un tercero. Esto lo veremos más adelante.
----------------------------------------------------------------------------------


Ejercicio 2: Supongan que a los estudiantes de un curso se les dice que su calificación final será el promedio de las cuatro calificaciones más altas de entre las cinco que hayan obtenido en el curso.
Escribir en MODULA-2 un procedimiento llamado PROMCLASE con cinco parámetros de entrada (las calificaciones obtenidas) y un parámetro de salida (la calificación promedio) que realice el cálculo.


-------------------------------------------------------------------------------------


Ejercicio 3: Escribir en MODULA-2 un programa que determine las raíces de una ecuación de segundo grado, donde a, b y c son números reales. Presentar la salida discriminando los casos en que se tiene una raíz doble, dos raíces reales o ninguna raíz real. Los que se lleven bien con matemáticas podrían hacer que en el caso en que no existan raíces reales el programa muestre las raíces complejas.
-------------------------------------------------------------------------------------


Ejercicio 4: Escribir en MODULA-2 una función ALFA que tenga como parámetros:



  • un arreglo de caracteres llamado FRASE (con un máximo de 100 caracteres)
  • un natural llamado LARGO (número de caracteres en la frase)
  • una variable de tipo carácter llamada LETRA


La función ALFA devuelve el número de apariciones del carácter LETRA en el arreglo FRASE.


------------------------------------------------------------------------------------


Ejercicio 5: Escribir en MODULA-2 un procedimiento de clasificación por selección que ordene un arreglo de enteros en orden ascendente, mediante la localización del menor en cada iteración y la realización de intercambios.
------------------------------------------------------------------------------------


Ejercicio 6: Considerar una MATRIZ representada como un arreglo bidimensional de diez filas y diez columnas. Escribir en MODULA-2 un procedimiento llamado CAMBIO que recibe como parámetros una MATRIZ y dos variables naturales M y N e intercambia las filas M y N de la MATRIZ.


------------------------------------------------------------------------------------


Ejercicio 7: Este ejercicio está pensado para quienes manejan algo del álgebra de matrices, cómo por ejemplo, cómo se suman, cómo se multiplican, cómo se trasponen y qué es una matriz simétrica. Si conocen al menos alguno de estos conceptos hagan lo que saben, no importa si no completan todo el ejercicio.


Escribir en MODULA-2 los siguientes algoritmos sobre matrices de enteros:



  • SUMA: recibe dos matrices y devuelve la suma.
  • PRODUCTO: recibe dos matrices y devuelve el producto.
  • TRASPUESTA : recibe una matriz y devuelve su traspuesta.
  • ESSIMETRICA : recibe una matriz y devuelve un booleano que indica si es o no simétrica.




--------------------------------------------------------------------------------


Ejercicio 8: ¿Qué hace el siguiente código Pascal?


Código:
TYPE 
    apuntador = ^registro; 
    registro = RECORD 
        dato: integer; 
        sig : apuntador; 
    END; 
VAR 
    apuntaInic : apuntador; 
    apuntActual : apuntador; 
    indice : integer; 
BEGIN 
    new(apuntaInic); 
    apuntActual := apuntaInic; 
    FOR indice := 1 TO 3 DO 
    BEGIN 
        new(apuntActual^.sig); 
        apuntActual := apuntActual^.sig; 
        apuntActual^.dato := indice 
    END; 
apuntActual^.sig := NIL; 
END.

Escribir código MODULA-2 equivalente al presentado.
------------------------------------------------------------------------------------


Ejercicio 9: Dada la siguiente definición de lista de naturales:


Código:
FROM Storage IMPORT ALLOCATE; 
TYPE 
         LNat = POINTER TO NodoLista; 
         
         NodoLista = RECORD 
             elem : CARDINAL; 
             sig : LNat; 
         END;


  • Escribir en MODULA-2 un procedimiento que recibe como parámetro una lista de naturales de tipo LNat y muestra todos los números de dicha lista, desde el primero al último.
  • Escribir en MODULA-2 un procedimiento que recibe como parámetro una lista de naturales de tipo LNat y muestra todos los números de dicha lista, desde el último al primero, es decir, al revés.
  • Escribir en MODULA-2 una función que retorne el mínimo elemento de una lista, no vacía, de naturales de tipo Lnat.




===============================================
===============================================


Soluciones:


No se publicarán en el curso todas las soluciones, sino que tendremos las más significativas. Espero que intenten hacer los ejercicios antes de ver una solución. Tengan en cuenta que el hecho de que la solución que ustedes hayan implementado sea distinta a la que vean aquí no significa que esté mal, simplemente es diferente y punto. Pueden comparar sus soluciones con las mostradas aquí para ver en qué mejorar, si es que hace falta mejorar.


Solución Ejercicio 4: Escribir una función ALFA que tenga como parámetros un arreglo de caracteres llamado FRASE (con un máximo de 100 caracteres), un natural llamado LARGO (número de caracteres en la frase) y una variable de carácter llamada LETRA. La función ALFA produce el número de apariciones del carácter LETRA en el arreglo FRASE.
La idea es recorrer el arreglo FRASE carácter a carácter y comparar cada uno de los caracteres con el carácter buscado. En caso de coincidencia se incrementa una variable, la cual es la salida del procedimiento. A continuación se presenta una solución al problema. Además de la función ALFA se incluye un programa principal que pide al usuario la frase y el carácter a buscar y devuelve la cantidad de veces que el carácter aparece en la frase.


Código:
MODULE Pr1_4; 
FROM STextIO IMPORT WriteString, WriteLn, WriteChar, ReadRestLine, ReadChar, SkipLine; 
FROM SWholeIO IMPORT WriteCard; 
FROM Strings IMPORT Length; 
PROCEDURE ALFA (FRASE:ARRAY OF CHAR;LARGO:CARDINAL; LETRA:CHAR ): CARDINAL; 
VAR n, cantVeces: CARDINAL; 
BEGIN 
  cantVeces := 0; 
  FOR n:= 0 TO LARGO DO 
    IF FRASE[n] = LETRA THEN 
      cantVeces := cantVeces +1; 
    END; (*END IF*) 
  END; (*END FOR*) 
  RETURN cantVeces; 
END ALFA; 
(*---------------PROGRAMA PRINCIPAL----------------------*) 
VAR 
  f: ARRAY[0..100]OF CHAR; 
  c: CHAR; 
  cant: CARDINAL; 
BEGIN 
  WriteString('INGRESE LA FRASE'); 
  WriteLn(); 
  ReadRestLine(f); 
  SkipLine(); 
  WriteLn(); 
  WriteString('INGRESE CARACTER'); 
  WriteLn(); 
  ReadChar(c); 
  SkipLine(); 
  WriteLn(); 
  cant := ALFA(f, Length(f), c); 
  WriteString('El caracter '); 
  WriteChar(c); 
  WriteString(' aparece '); 
  WriteCard(cant,2); 
  WriteString(' veces.'); 
END Pr1_4.
------------------------------------------------------------------------------------


Solución Ejercicio 9: Dada la siguiente definición de lista de naturales:


Código:
FROM Storage IMPORT ALLOCATE; 
TYPE 
   LNat = POINTER TO NodoLista; 
   NodoLista = RECORD
     elem : CARDINAL; 
     sig : LNat; 
   END;
-----------------------------------------------------------------------------------


Escribir en MODULA-2 un procedimiento que recibe como parámetro una lista de naturales de tipo LNat y muestra todos los números de dicha lista, desde el primero al último.


Solución


Código:
MODULE Pr1_9show; 
FROM STextIO IMPORT WriteString, WriteLn; 
FROM SWholeIO IMPORT WriteCard; 
FROM Storage IMPORT ALLOCATE; 
TYPE
  LNat = POINTER TO NodoLista; 
  NodoLista = RECORD 
    elem : CARDINAL; 
    sig : LNat; 
  END; 
PROCEDURE printLst(L: LNat); 
VAR lpos: LNat; 
BEGIN 
  lpos:= L; 
  IF (lpos = NIL) THEN 
    WriteString("Lista vacía."); 
  ELSE 
    WHILE (lpos <> NIL) DO 
      WriteCard(lpos^.elem,0); 
      WriteString(" "); 
      lpos:= lpos^.sig; 
    END;
  END; 
END printLst; 
(*---------------PROGRAMA PRINCIPAL----------------------*) 
VAR 
  L, aux, actual: LNat; 
  x:CARDINAL; 
BEGIN 
 (* Se genera la lista L*) 
 L := NIL; 
 FOR x := 1 TO 10 DO
    NEW(aux); 
    aux^.elem := x; 
    aux^.sig := NIL; 
    IF L = NIL THEN 
      (* L es puntero al primer elemento de la lista *)
      L := aux; 
   ELSE 
      actual^.sig := aux; 
   END; 
  (* puntero al último elemento agregado en la lista *) 
  actual := aux; 
 END;   
 (* Este es un ejemplo para ver como se muestran los   *) 
 (* elementos de una lista, también podría solicitarse *)
 (* al usuario que ingrese dichos elementos            *) 
 printLst(L);    
END Pr1_9show.

Escribir en MODULA-2 un procedimiento que recibe como parámetro una lista de naturales de tipo LNat y muestra todos los números de dicha lista, desde el último al primero, es decir, al revés.


Solución


Para resolver este ejercicio existen dos posibilidades:
recorrer iterativamente la lista toda las veces que sea necesario para encontrar los elementos en el orden pedido.
recorrer la lista mediante un procedimiento recursivo.


Solución Iterativa


Código:
MODULE pr1_9i; 
FROM STextIO IMPORT WriteString;
     FROM SWholeIO IMPORT WriteCard;  
TYPE 
        LNat = POINTER TO NodoLista; 
   NodoLista = RECORD
           elem : CARDINAL;
           sig : Lnat;
       END;
PROCEDURE printLstReverseIt(L: LNat); 
VAR lpos, lult: LNat; 
BEGIN
       lult:= NIL;
  WHILE (lult<>L) DO 
         lpos:= L; 


         WHILE (lpos^.sig <>lult) DO 
            lpos:= lpos^.sig; 
         END; 
    WriteCard(lpos^.elem,0); 
         WriteString(" "); 
         lult:= lpos; 
      END; 
END printLstReverseIt; 
(*---------------PROGRAMA PRINCIPAL----------------------*) 
VAR
        L: LNat; 
BEGIN 
  ... (*Se genera la lista L*)
  printLstReverseIt(L); 
END pr1_9i.

Solución Recursiva: Para comprender esta solución debe ver el tema Recursión, que viene a continuación de estos ejercicios. Igualmente, aunque aún no lo dimos, les dejo aquí el primer ejemplo de un programa recursivo:


Código:
    MODULE pr1_9r; 
    FROM STextIO IMPORT WriteString;
    FROM SWholeIO IMPORT WriteCard;  
    TYPE 
      LNat = POINTER TO NodoLista; 
    NodoLista = RECORD 
           elem : CARDINAL; 
        sig : LNat; 
    END;
    PROCEDURE printLstReverseRec(L: LNat); 
    BEGIN 
        IF (L <> NIL) THEN 
            printLstReverseRec(L^.sig);
            WriteCard(L^.elem,0);
            WriteString(" ");
        END;
    END printLstReverseRec; 
    (*---------------PROGRAMA PRINCIPAL----------------------*) 
    VAR
        L: LNat; 
    BEGIN
        ... (*Se genera la lista L*)
        printLstReverseRec(L);
    END pr1_9r.

-----------------------------------------------------------------------------------


Espero realmente que practiquen. Al igual que desde hace tiempo, tengo la sensación de que simplemente leen las lecciones y la cosa queda ahí. Si no practican y preguntan, no avanzarán, créanme, solo leer no sirve.


Saludos.