Soluciones lección 009

Soluciones seleccionadas para los ejercicios propuestos en la lección 8:

Solución ejercicio 5:

Código:

Descripcion:

   Parte a.
   Programa que calcula la suma y el promedio de una secuencia de numeros
   enteros positivos.
   Se leen los valores de la entrada estandar y se van sumando en un
   acumulador. Ademas, el programa lleva un contador
  para registrar la cantidad
   de valores ingresados, dato que se utiliza al final para calcular el
   promedio (suma/cantidad de valores).
   El contador se incrementa en uno cada vez que se lee un nuevo valor.

   Parte b.
   Programa que determina el numero mayor y el numero menor de
  una secuencia de numeros enteros positivos.
   Se leen los valores de la entrada estandar y se van actualizando
  dos variables:
   una contiene el valor mayor y otra contiene el valor menor,
  segun los numeros leidos hasta el momento.
   -------

  *)


  (* Parte a *)

  (* Precondicion: Los valores ingresados son enteros positivos
     seguidos por el valor -1. *)

  PROGRAM suma_promedio(input, output);

  (* Defino una constante con el valor del centinela por eventuales cambios. *)
  CONST CENTINELA = -1;

  VAR valor, suma    : Integer;
   valores_leidos : Integer;
   promedio       : Real;

  BEGIN

   (* Inicializo variables. *)
   suma := 0;
   valores_leidos := 0;

   (* Leo el primer valor que puede ser el centinela. *)
   read(valor);

   (* Solo entro al ciclo si no lei el centinela. *)
   WHILE valor <> centinela DO
   BEGIN

   suma := suma + valor;
   valores_leidos := valores_leidos + 1;
   read(valor)

   END;

   (* Calculo promedio, evitando posible división entre 0. *)
   IF valores_leidos > 0 THEN
   promedio := suma / valores_leidos
   ELSE
   promedio := 0;

   (* Despliego resultados. *)
   writeln;
   writeln('Suma = ', suma);
   writeln('Promedio = ', promedio:4:2)

  END.

Código:

(* Parte b *)

  (* Precondicion: Los valores ingresados son enteros positivos
     seguidos por el valor -1. *)
  (* Asumo que se ingresa al menos un valor antes del -1. *)

  PROGRAM mayor_menor(input, output);

  (* Defino una constante con el valor del centinela por eventuales cambios. *)
  CONST CENTINELA = -1;

  VAR valor, mayor, menor : Integer;

  BEGIN

   (* Leo primer valor e inicializo variables. *)
   read(valor);
   mayor := valor;
   menor := valor;

   read(valor);

   (* Solo entro al ciclo si no lei el centinela. *)
   WHILE valor <> CENTINELA DO
   BEGIN

   IF valor > mayor THEN
   mayor := valor;
   IF valor < menor THEN
   menor := valor;
   read(valor)

   END;

   (* Despliego resultados. *)
   writeln('El mayor numero ingresado es: ',mayor);
   writeln('El menor numero ingresado es: ',menor)
  END.

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

Solución ejercicio 7:

Código:

Descripcion:
 Programa que busca letras duplicadas en forma contigua en un texto leido
 de la entrada estandar.
 Se lee el texto como secuencia de caracteres, se mantienen en todo momento
 el caracter que se se esta leyendo y el anterior para compararlos.
 Al comparar dos letras, se considera que una mayúscula y la minúscula
 correspondiente son la misma letra.
 -------

*)


  (* Precondicion: Se ingresa una secuencia de caracteres alfabeticos
   seguidos del signo $. *)

  PROGRAM proceso_texto(input, output);

  (* Defino una constante con el valor del centinela por eventuales cambios. *)
  CONST CENTINELA = '$';

  VAR caracter_actual, caracter_anterior: Char;

  BEGIN

   (* Leo el primer caracter que puede ser el centinela. *)
   read(caracter_actual);

   (* Convierto letras entre 'A' y 'Z' a minusculas. *)
   IF (ord(caracter_actual) >= ord('A')) AND (ord(caracter_actual) <= ord('Z')) THEN
   caracter_actual := chr(ord(caracter_actual)+ord('a')-ord('A'));

   (* Solo entro al ciclo si no lei el centinela. *)
   WHILE caracter_actual <> centinela DO
   BEGIN

   caracter_anterior := caracter_actual;
   read(caracter_actual);

   (* Convierto letras entre 'A' y 'Z' a minusculas. *)
   IF (ord(caracter_actual) >= ord('A')) AND (ord(caracter_actual) <= ord('Z')) THEN
   caracter_actual := chr(ord(caracter_actual)+ord('a')-ord('A'));

   IF caracter_anterior = caracter_actual THEN
   write(caracter_anterior, caracter_actual, ' ')

   END

END.

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

Solución ejercicio 8:

Código:

Descripcion:
 Programa que procesa una secuencia de digitos decimales intercalados con operadores
 de suma, resta, multiplicacion y division.
 Se considera la posibilidad de que haya cero o varios espacios en blanco entre digitos
 y operadores.
 La lectura se hace en variables de tipo Char, dado que, si no se ingresa un espacio
 entre un digito y un operador, FP no reconoce el digito como Integer.
 -------

*)


  (* Precondicion: Se ingresa una secuencia de tipo:
   "digito operador digito operador ... digito ="
   donde hay al menos un digito y el signo "=". *)

  PROGRAM calculadora(input, output);

  VAR   c, op : Char;
        v1, v2: Integer;

  BEGIN

      (* Leo el primer digito y lo convierto a entero. *)
      read(c);
      v1 := ord(c) - ord('0');

      (* Consumo posibles espacios y cargo el operador. *)
      repeat
          read(op)
      until op <> ' ';

      (* Entro en el ciclo si no lei el signo "=". *)
      WHILE op <> '=' DO
      BEGIN

          (* Consumo posibles espacios para leer el siguiente digito y
             convertirlo a entero. *)
          repeat
              read(c)
          until c <> ' ';
          v2 := ord(c) - ord('0');

          (* Aplico op a v1 y v2, acumulo el resultado en v1. *)
          CASE op OF
              '+' : v1 := v1 + v2;
              '-' : v1 := v1 - v2;
              '*' : v1 := v1 * v2;
              '/' : v1 := v1 DIV v2;
          END;

          (* Consumo posibles espacios y cargo el operador. *)
          repeat
              read(op)
          until op <> ' ';

      END;

      (* Despliego el resultado. *)
      writeln('Resultado: ',v1)

END.