4.

Indicar si son correctas o no las expresiones indicadas, especificando el motivo o

motivos, dadas las definiciones de tipos, constantes y variables siguientes:
a) verdadero o final y p ≠ a
a. p ≠ a – correcto, resultado booleano
b. final y p ≠ a – correcto, resultado booleano
c. verdadero o final y p ≠ a – correcto, resultado booleano
d. La expresión es correcta.
b) q > numProvincias o 3.0 < d
a. q > numProvincias – correcto, resultado será un entero
b. 3.0 < d – incorrecto, se están comparando tipos diferentes (real y entero)
c. q > numProvincias o 3.0 < d – entero o incorrecto, no se evalúa
d. La expresión es incorrecta.
c) ‘Z’ = codigoACaracter (realAEntero (maxDistancia + 5.0) + numCiudades)
a. maxDistancia + 5.0 – correcta, resultado real
b. realAEntero (maxDistancia + 5.0) + numCiudades – correcto, resultado
entero
c. ‘Z’ = codigoACaracter (realAEntero (maxDistancia + 5.0) + numCiudades)
- correcta, el resultado será un booleano
d. La expresión es correcta.
d) f = LLEIDA o m = maxDistancia + enteroAReal(caracterACodigo( v ) +
numCiudades + numProvincias div 3 ) y a = MOLLERUSA
a. numProvincias div 3 – correcto, resultado entero
b. caracterACodigo( v ) + numCiudades + numProvincias div 3 – correcto,
resultado entero
c. maxDistancia + enteroAReal(caracterACodigo( v ) + numCiudades +
numProvincias div 3 ) – correcto, resultado entero
d. f = LLEIDA – incorrecto, tipos distintos
e. m = maxDistancia + enteroAReal(caracterACodigo( v ) + numCiudades +
numProvincias div 3 ) – correcto, resultado booleano
f. a = MOLLERUSA – incorrecto, tipos distintos
g. m = maxDistancia + enteroAReal(caracterACodigo( v ) + numCiudades +
numProvincias div 3 ) y a = MOLLERUSA – real e incorrecto por lo que no
se puede evaluar
h. f = LLEIDA o m = maxDistancia + enteroAReal(caracterACodigo( v ) +
numCiudades + numProvincias div 3 ) y a = MOLLERUSA – incorrecto,
real e incorrecto por lo que no se puede evaluar
i. La expresión es incorrecta
5. Calcular el resultado de las expresiones indicadas:
a) enteroAReal( d ) > m < final o TARRAGONA = p
a. enteroAReal (d) -> enteroAReal (50) -> 50 > 1.5 -> cierto
b. cierto < final -> cierto < falso -> falso
c. TARRAGONA = p -> TARRAGONA = GIRONA -> falso
d. falso o falso -> falso
e. Resultado = falso
b) ‘D’ = codigoACaracter( realAEntero( m ) + caracterACodigo( v ) ) o c ≠ f
a. realAEntero (1.5) + caracterACodigo (‘C’) -> realAEntero (1.5) +
caracterACodigo (67) -> 1 + 67 = 68
b. ‘D’ = codigoACaracter (68) -> ‘D’ = codigoACaracter (‘D’) -> ‘D’ = ‘D’ ->
cierto
c. c ≠ f -> falso
d. cierto o falso -> cierto
e. Resultado = cierto
c) –(d * q) div (caracterACodigo(v) -57)+ realAEntero(w * m) mod
caracterACodigo(‘A’)
a. d * q -> 50 * 1 -> 50
b. caracterACodigo(‘C’) -57 -> 68 – 57 -> 11
c. realAEntero(10.0 * 1.5) -> realAEntero(15) -> 15
d. caracterACodigo(65) -> 65
e. -50 div 11 -> -4
f. 15 mod 65 -> 15
g. -4 + 15 -> 11
h. Resultado = 11
6. En el siguiente algoritmo falta definir las secciones de constantes y variables. Definir
correctamente el siguiente algoritmo, en el que falta definir las secciones de
constantes y variables, según lo que se pueda deducir del mismo. El objeto Y tiene un
valor fijo (supondremos que corresponde al número 3.1415).
const
Y: real = 3.1415
fconst

var
euro, yen: real;
t, m, x: real;
mínimo, máximo: real;
c: entero;
fvar

euro:= 0.0;
minimo:= 0.0;
maximo:= minimo;
euro:= enteroAReal( c );
mientras euro > 10.0 hacer

t := t + yen;
yen := euro * Y;
si yen > maximo entonces
maximo:= yen * 2.0;

fsi
si yen < minimo entonces
minimo:= yen;

fsi
yen:= enteroAReal( c ); c:= c + 2;
fmientras
m := (minimo + maximo) / 10.0;
x := m = yen;
{ Una vez realizados los cálculos, se muestran los resultados por pantalla. }
falgoritmo
7. Construir un algoritmo que cuente los enteros positivos inferiores a 1000 que
cumplan que sean múltiplos de 3.
algoritmo digitos
var
n, contador: entero ;
centenas, decenas, unidades: entero ;
digitos: booleano ;
fvar
{Pre: cierto }
contador := c
n := 1 ;
mientras n < 1000 hacer
si n < 10 entonces
digitos := (n mod 3 = 0);
sino
si n < 100 entonces
digitos := ((n div 10) + (n mod 10)) mod 3 = 0;
sino
si n < 1000 entonces
digitos := (n div 100 + (n div 10) mod 10 + n mod 10) mod 3 = 0;
fsi
fsi
si digitos := cierto entonces
c := c+1;
fsi
n := n + 1;
fmientras
{Una vez hechos los cálculos, se imprimirán los resultados por pantalla.}
{Post: contador contiene el número de enteros positivos inferiores a 1000, que cumplen
que son múltiplos de tres.}
falgoritmo
7.1. Vuelve a escribir el mismo algoritmo pero esta vez utilizando la estructura para ...
fpara en lugar de mientras ... fmientras.
algoritmo digitos
var
n, contador: entero ;
centenas, decenas, unidades: entero ;
digitos: booleano ;
fvar
{Pre: cierto }
contador := c
n := 1 ;
para n := 1 hasta 1000 hacer
si n < 10 entonces
digitos := (n mod 3 = 0);
sino
si n < 100 entonces
digitos := ((n div 10) + (n mod 10)) mod 3 = 0;
sino
si n < 1000 entonces
digitos := (n div 100 + (n div 10) mod 10 + n mod 10) mod 3 = 0;
fsi
fsi
si digitos := cierto entonces
c := c+1;
fsi
fpara
{Una vez hechos los cálculos, se imprimirán los resultados por pantalla.}
{Post: contador contiene el número de enteros positivos inferiores a 1000, que cumplen
que son múltiplos de tres.}
falgoritmo