Bienvenido a mis Tutorías © en la UNED
Exámenes
Programación I, Enero 2003:

  1. Si p, q y r son variables booleanas que toman los valores p= TRUE, q = FALSE y r = TRUE ¿cuál de las siguientes expresiones devuelve un valor FALSE?
    a) p OR q OR NOT (r=q) OR NOT (NOT r=q) 
    TRUE OR FALSE OR NOT (TRUE=FALSE) OR NOT (NOT TRUE=FALSE)
TRUE OR FALSE OR NOT FALSE OR NOT (FALSE=FALSE)
TRUE OR FALSE OR TRUE OR NOT TRUE
TRUE OR FALSE OR TRUE OR FALSE
TRUE
    b) NOT (p AND q AND NOT (r=q) AND NOT (NOT r=q)) 
    NOT (TRUE AND FALSE AND NOT (TRUE=FALSE) AND NOT (NOT TRUE=FALSE))
NOT (TRUE AND FALSE AND NOT FALSE AND NOT (FALSE=FALSE))
NOT (TRUE AND FALSE AND TRUE AND NOT TRUE)
NOT (TRUE AND FALSE AND TRUE AND FALSE)
NOT FALSE
TRUE
    c) (p OR q AND NOT (r>q)) AND NOT (NOT r<q) 
    (TRUE OR FALSE AND NOT (TRUE>FALSE)) AND NOT (NOT TRUE<FALSE)
(TRUE OR FALSE AND NOT (TRUE)) AND NOT (FALSE<FALSE)
(TRUE OR FALSE AND FALSE) AND NOT (FALSE)
(TRUE OR FALSE AND FALSE) AND TRUE
(TRUE OR FALSE) AND TRUE
TRUE AND TRUE
TRUE

       *** d) (p OR q AND NOT (r=q)) AND NOT (NOT r=q) 
    (TRUE OR FALSE AND NOT (TRUE=FALSE)) AND NOT (NOT TRUE=FALSE)
(TRUE OR FALSE AND NOT (FALSE)) AND NOT (FALSE=FALSE)
(TRUE OR FALSE AND TRUE) AND NOT (TRUE)
(TRUE OR FALSE AND TRUE) AND FALSE
(TRUE OR FALSE) AND FALSE
TRUE AND FALSE
FALSE
  2. El esquema básico de selección se corresponde con el esquema de datos:
    a) Formación
       *** b) Unión
    c) Registro
    d) Tupla
  3. En un registro con variantes el tipo del discriminante siempre tiene que ser:
    a) Real
       *** b) Ordinal 
    Las reglas BNF para la definición de tipos registros son las siguientes:

Tipo_Registro                ::= RECORD Secuencia_de_Listas_de_Campos END
Secuencia_de_Listas_de_Campo ::= Lista_de_Campos { ; Lista_de_Campos }
Lista_de_Campos              ::= Parte_Fija | Parte_Variante
Parte_Fija                   ::= Lista_de_Identificadores : Tipo
Parte_Variante               ::= CASE Identificador : Identificador_de_Tipo_Ordinal OF
                                   Variante { | Variante }
                                   [ ELSE Secuencia_de _Listas_de_Campos ]
                                 END

Variante                     ::= Lista_de_Valores :[ Secuencia_de_Listas_de_Campos ]
Lista_de_Valores             ::= Valores { , Valores }
Valores                      ::= Expresión_Constante [ .. Expresión_Constante ]
Identificador_de_Tipo_Ordinal::= Identificador
    c) Cardinal
    d) Entero
  4. Dado el tipo de dato: TYPE Cero = ARRAY Uno OF ARRAY Dos OF Tres;
    a) Sólo Tres puede ser CHAR o BOOLEAN
    b) Sólo Uno y Tres pueden ser CHAR o BOOLEAN
       *** c) Uno, Dos y Tres pueden ser CHAR o BOOLEAN
    d) Sólo Uno y Dos pueden ser CHAR o BOOLEAN 
    La sintaxis BNF para la declaración de un tipo array y el acceso a componentes es:

Tipo_Array                 ::= ARRAY Lista_Tipos_Ordinales OF Tipo
Lista_Tipos_Ordinales      ::= Tipo_Ordinal { , Tipo_Ordinal }
Tipo_Ordinal               ::= Identificador_Tipo_Ordinal | Tipo_Enumerado | Tipo_Subrango
Identificador_Tipo_Ordinal ::= Identificador
Variable_array             ::= Identificador_de_Variable { [ Lista_de_Expresiones ] }

Por lo tanto la respuesta válida es la c) porque cualquiera de ellos puede valer
CHAR o BOOLEAN. Al menos de acuerdo con la sintaxis anterior. Sin embargo, si utilizamos
Uno y Dos como CHAR en el compilador FST que facilita la UNED, el rango de los índices
supera el límite y el compilador lo rechaza.
  5. En la declaración: 
    TYPE TipoMatriz = ARRAY [1..3], [1..3] OF INTEGER;
VAR matrizUno : TipoMatriz;
    Nos podemos referir a un elemento de la matriz como : matrizUno[3]
    a) No, tendríamos que referenciarlo como matrizUno[1][2].
       *** b) Sí, porque hace referencia a todo un vector.
    c) Sí, porque los tipos índices son iguales.
    d) No, tendríamos que referenciarlo como matrizUno[1,2].
  6. La declaración: VAR miVector: ARRAY [0..N] OF INTEGER;
    a) Es incorrecta
    b) Es un vector abierto
       *** c) Es un tipo anónimo 
    
Las variables anónimas son aquellas que son de un tipo no simple, ARRAY,
RECORD,... pero que se declaran indicando el tipo en el mismo momento de
la declaración, y no declarando un tipo y después declarando la variable
de ese tipo.
    d) Es una ristra
  7. En el procedimiento: 
    PROCEDURE Ejl(VAR R, S : INTEGER; T: CHAR);
    los argumentos
    a) S es por referencia y R y T por valor
       *** b) R y S son por referencia y T por valor
    c) R y S son por valor y T por referencia
    d) R es por referencia y S y T por valor
  8. En Modula-2 y respecto a RETURN se puede decir que:
    a) Es el identificador predefinido de un procedimiento
    b) Es el identificador predefinido de una función
       *** c) Es la palabra clave de una sentencia
    d) Es la palabra clave de una expresión
  9. ¿Cuál de las siguientes afirmaciones es correcta en Modula-2?
    a) No tiene sentencias para manejo de excepciones ni se pueden programar
    b) Tiene sentencias para manejo de excepciones que emplean el RETURN
       *** c) No tiene sentencias para manejo de excepciones pero se pueden programar
    d) Tiene sentencias especiales para manejo de excepciones
  10. ¿Cuál de las siguientes afirmaciones es correcta?
    a) El tipo INTEGER es exacto y sin límites
       *** b) El tipo INTEGER es exacto pero con límites
    c) El tipo REAL es exacto y sin límites
    d) El tipo REAL es exacto pero con límites
Programación I, Enero 2003:
Ejercicio Práctico

Realizar un tipo abstracto de datos para el juego de las TRES EN RAYA. El tablero es de 3 x 3 y cualquier cuadrícula podrá estar vacía u ocupada sólo por una ficha blanca o negra. Las operaciones son:

  1. Poner ficha en 1 cuadrícula comprobando que no está ocupada (sólo para plan viejo)
  2. Quitar una ficha de una cuadrícula
  3. Comprobar si se produce 3 en raya e indicar si es de blancas o negras. 
================================================================================

DEFINITION MODULE Juego;
CONST Lado = 3;

TYPE  RangoLado = [1..Lado];
      TipoFicha = (Vacia, Blanca, Negra);
      TipoTablero = ARRAY RangoLado,RangoLado OF TipoFicha;

PROCEDURE Poner(VAR Tablero:TipoTablero; Color:TipoFicha; Columna, Fila:RangoLado);
PROCEDURE Quitar(VAR Tablero:TipoTablero; Columna, Fila:RangoLado);
PROCEDURE Comprobar(Tablero:TipoTablero; VAR Quien:TipoFicha):BOOLEAN;
PROCEDURE Iniciar(VAR Tablero:TipoTablero);
END Juego.

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

IMPLEMENTATION MODULE Juego;

FROM InOut IMPORT WriteString,WriteLn;

PROCEDURE Quitar(VAR Tablero:TipoTablero; Columna,Fila:RangoLado);
BEGIN
   IF (Fila < 1) OR (Fila > Lado) OR (Columna < 1) OR (Columna > Lado) THEN
      WriteString("ERROR: Casilla fuera de rango"); WriteLn;
   ELSE
      IF (Tablero[Fila,Columna] <> Vacia) THEN
         Tablero[Fila,Columna] := Vacia;
      ELSE
         WriteString("ERROR: Casilla NO ocupada");WriteLn;
      END;
   END;
END Quitar;

PROCEDURE Comprobar(Tablero:TipoTablero; VAR Quien:TipoFicha):BOOLEAN;

   PROCEDURE Raya(c1,f1,c2,f2,c3,f3: RangoLado): BOOLEAN;
   BEGIN
      IF ((Tablero[c1,f1] <> Vacia) AND (Tablero[c1,f1]=Tablero[c2,f2]) AND
         (Tablero[c1,f1]=Tablero[c3,f3])) THEN
         RETURN TRUE;
      ELSE
         RETURN FALSE;
      END;
   END Raya;
   
BEGIN
   IF (Raya(1,1, 1,2, 1,3) OR Raya(1,1, 2,1, 3,1)) THEN
      Quien := Tablero[1,1];
   END;

   IF (Raya(2,1, 2,2, 2,3) OR Raya(1,2, 2,2, 3,2) OR
       Raya(1,1, 2,2, 3,3) OR Raya(3,1, 2,2, 1,3)) THEN
      Quien := Tablero[2,2];
   END;

   IF (Raya(3,1, 3,2, 3,3) OR Raya(1,3, 2,3, 3,3)) THEN
      Quien := Tablero[3,3];
   END;

   IF (Quien <> Vacia) THEN
      IF (Quien = Blanca) THEN
         WriteString("Ganan BLANCAS");WriteLn;
      ELSE
         WriteString("Ganan NEGRAS");WriteLn;
      END;
      RETURN TRUE;
   ELSE
      RETURN FALSE;
   END;
END Comprobar;

PROCEDURE Poner(VAR Tablero:TipoTablero; Color:TipoFicha; Columna, Fila:RangoLado);
BEGIN
   IF (Fila < 1) OR (Fila > Lado) OR (Columna < 1) OR (Columna > Lado) THEN
      WriteString("ERROR: Casilla fuera de rango"); WriteLn;
   ELSE
      IF (Tablero[Fila,Columna] = Vacia) THEN
         Tablero[Fila,Columna] := Color;
      ELSE
         WriteString("ERROR: Casilla ocupada");WriteLn;
      END;
   END;
END Poner;

PROCEDURE Iniciar(VAR Tablero:TipoTablero);
VAR
  i,j :RangoLado;
BEGIN
   FOR i:=1 TO Lado DO
      FOR j:=1 TO Lado DO
         Tablero[i,j]:=Vacia;
      END;
   END;
END Iniciar;

END Juego.
Este ejercio está basado en la solución propuesta por José Antonio Vaqué, al que desde aquí quiero agraceder su constante colaboración en los foros de las tutorías virtuales y en los grupos de discusión de la UNED
No dudes en escribir si tienes alguna duda sobre estos ejercicios
abellogijon.uned.es