universidad tecnica federico santa maria …lsb/pascal/clases/cap06.pdf · universidad tecnica...

UNIVERSIDAD TECNICA FEDERICO SANTA MARIA DEPARTAMENTO DE ELECTRONICA

Programación en Pascal Capítulo 6. Ejemplos Resueltos.

Prof. Leopoldo Silva Bijit. 07-07-2003 46

6. Ejemplos resueltos 6.1. Empleo de alternativa. a) Uso de condicional. Se tienen 3 números enteros, si el primero de ellos es negativo (menor que 0), entonces debe obtenerse el producto de los 3 números y escribirlo; en caso contrario debe escribirse 0. Solución: Sean NUM1, NUM2 Y NUM3 los 3 enteros:

PRODUCTO:=0; IF (NUM1<0) THEN PRODUCTO:=NUM1*NUM2*NUM3; WRITE('PRODUCTO ES',PRODUCTO);

De acuerdo al esquema dado en el punto 3.6, se tiene que NUM1<0 corresponde a la condición C. Si C se cumple , se efectúa el producto de los 3 enteros (acción A). b) Si el primer entero (NUM1) es negativo se debe realizar el producto de los 3 enteros (igual al ejemplo anterior), pero ahora si NUM1 es positivo debe obtenerse la suma de los 3 enteros: Solución:

IF NUM1<0 THEN PRODUCTO:=NUM1*NUM2*NUM3 ELSE SUMA:=NUM1+NUM2+NUM3;

Del algoritmo se desprende que es indispensable el uso de a lo menos 5 variables: (NUM1, NUM2, NUM3, PRODUCTO Y SUMA). PROGRAM PDTOSUMA(INPUT,OUTPUT);

(* Se leen 3 enteros e imprime su producto si el primero de ellos es negativo; en caso contrario imprime la suma *) VAR NUM1, NUM2, NUM3, PRODUCTO, SUMA: INTEGER; BEGIN (*PROGRAMA*) READ(NUM1,NUM2,NUM3);(*lee variables*) IF NUM1<0




THEN BEGIN

PRODUCTO:=NUM1*NUM2*NUM3; WRITELN('PRODUCTO = ',PRODUCTO) END ELSE

BEGIN SUMA:=NUM1+NUM2+NUM3; (*calcula suma *)

(* ^ comentario superfluo*) WRITELN('SUMA = ',SUMA) END

END. (*PROGRAMA*) Debe notarse el uso de comentarios y la forma de indentación. 6.2. Lectura de booleanos. La sentencia read en lenguaje Pascal no acepta leer variables booleanas. Se desea leer datos booleanos como caracteres y asignarlos a una variable booleana. Solución: Espacio de trabajo:

CONST verdadero = 'V', falso = 'F'; VAR estado : BOOLEAN; Algoritmo: -Leer caracter -If caracter='V' then estado = true else If caracter='F' then estado := False else write('Error')

A continuación se codifican en Pascal, las ideas anteriores.

PROGRAM leeboolean(INPUT,OUTPUT); CONST VERDADERO='V'; FALSO='F'; MENSAJE='ERROR EN FORMATO'; VAR ESTADO: BOOLEAN;




CARACTER: CHAR; BEGIN (*PROGRAMA*) READ(CARACTER); IF CARACTER=VERDADERO

THEN ESTADO:=TRUE ELSE IF CARACTER=FALSO THEN ESTADO:=FALSE ELSE WRITELN(MENSAJE); IF ESTADO

THEN WRITELN('ES VERDADERO') ELSE WRITELN('ES FALSO') END. (*PROGRAMA*)

Observaciones: ¿Qué pasa si el carácter leído no es ni 'V' ni 'F'?

6.3. Decisión entre múltiples alternativas. - Se reciben 3 datos de entrada A, B y C. Estos corresponden a las dimensiones de los lados de un triángulo. - El programa debe detectar con sentencias IF-THEN-ELSE el tipo de triángulo. Solución: - Si se cumple Pitágoras entonces es triángulo rectángulo - Si sólo dos lados del triángulo son iguales entonces es isósceles. - Si los 3 lados son iguales entonces es equilátero. - Si no se cumple ninguna de las condiciones anteriores, es escaleno. if A*A = B*B + C*C then triángulo=”Rectángulo” else if B*B=A*A + C*C then triángulo=”Rectángulo” else if C*C=A*A + B*B then triángulo=”Rectángulo” else if A = B then if A = C then triángulo=”Equilátero” else triángulo=”Isósceles” else if A = C then triángulo=”Isósceles” else if B=C then triángulo=”Isósceles” else triángulo=”Escaleno”




Nota: Cuando los números son reales, no conviene probar la igualdad de dos números. Es preferible determinar que difieran a lo más en una cantidad pequeña; por ejemplo, que difieran en la cuarta cifra significativa. Modificar el algoritmo de acuerdo a lo recién planteado. 6.4 Algoritmo de Euclides. Si x e y son enteros, no ambos ceros, su máximo común divisor, que anotaremos mcd(x,y), es el mayor entero que los divide a ambos exactamente; es decir, sin resto. Ejemplo: mcd( 7,11) = 1 mcd(16,28) = 4 Puede comprobarse que: mcd( x,0) = |x| mcd( x,y) = mcd(y,x) mcd(-x,y) = mcd(x,y) Por lo tanto interesa obtener un algoritmo para el mcd de enteros no negativos. El conocimiento matemático que se necesita, para resolver este problema es el siguiente: a) Si x es igual a y; x (ó y) es el resultado. b)Si se reemplaza el número mayor por la diferencia del mayor menos el menor, no cambia el máximo común divisor. En términos matemáticos: a) mcd(x,x) = x b) Si x > y se tiene mcd(x,y) = mcd(x-y,y) Entonces para enteros mayores que cero: Mientras los números sean diferentes: Deje el menor, y forme otro restando el menor al mayor. Si los números son x e y, el algoritmo queda: While x<>y do if x>y then x:=x-y else y:=y-x Un programa que desarrolla la idea anterior es:




Program mcd;

var x,y:integer; begin write('máximo común divisor de enteros mayores que cero'); writeln; write('x=');read(x);readln;writeln; write('y=');read(y);readln;writeln; write('mcd(',x,',',y,')='); while x<>y do if x>y then x:=x-y else y:=y-x; write(x); writeln end.

Una variante del algoritmo de Euclides es la siguiente: Puede comprobarse que: mcd(x,y) = mcd(y,x mod y) El que muestra cómo reducir uno de los números, manteniendo en el primer lugar al mayor. La transformación debe repetirse hasta que el menor de los números sea igual a cero. El cambio de posición de los números requiere una variable temporal que denominaremos resto. Entonces: ...

read(x); read(y); while y<>0 do begin resto:=x mod y; x:=y; y:=resto end; write(x); ...

Otra forma del Algoritmo de Euclides es la siguiente: ... read(x);read(y); {x>0 e y>0} repeat




while x>y do x:=x-y; while y>x do y:=y-x until x=y; write(x); ...

Los ejemplos anteriores muestran que nunca existe una sola solución para un problema determinado. Unas pueden ser más simples que otras; o más rápidas; o más fáciles de leer. Existen técnicas especiales que permiten evaluar la complejidad de un algoritmo tanto en uso del espacio como en tiempo de ejecución. Por las razones anteriores siempre es conveniente, una vez desarrollado un algoritmo, analizar si pueden efectuarse modificaciones que lo simplifiquen o lo hagan más eficiente. 6.5 Repeticiones Anidadas. Triángulo de números. Se desea imprimir un triángulo de números consecutivos. Tal que en la primera línea se tenga un número, dos en al segunda y así sucesivamente, hasta imprimir la línea n-ava, con n números. Puede plantearse: repetir

ponerse al principio de la línea escribir una línea hasta llegar a la línea final

Escribir una línea puede concebirse:

repetir escribir un número incrementar número avanzar a la siguiente columna hasta que la columna tenga el mismo valor que la línea actual

Definiendo la variables número, línea y columna, es posible seguir descendiendo en el nivel de detalle:

... línea:=1;numero:=1; repeat




writeln;columna:=1; repeat write(numero); numero:=numero+1; columna:=columna+1 until columna> línea; línea:=línea+1 until línea>n+1; ...

Se denomina anidamiento al hecho de que un bloque esté dentro (en el nido ) de otro. Gráficamente:

Se dice que B está anidado (nested) en A.

Debido a la estructura de Pascal, todas las construcciones repetitivas que están dentro de otras, quedan naturalmente anidadas. En lenguajes que usan saltos como instrucciones para controlar la secuencia, pueden escribirse bloques repetitivos no anidados, lo que generalmente es causa de errores, y complica su análisis. 6.6. Efectuar traza. En sentencia while. Determinar qué escribe el segmento:

.... n:=15; while n>0 do begin n:=(n-1) div 2; write(n+1) end; .... Solución:

Iteracíon n (n-1) div 2 n+1 1 15 7 8

A

B




2 7 3 4 Iteracíon n (n-1) div 2 n+1

3 3 1 2 4 1 0 1

Cuando n=0 sale del lazo. Y escribe: 8 4 2 1 6.7. Uso de while. Potencia de dos. Dado un límite, determinar cuál es la potencia de 2 más cercana al límite (use sentencia While-Do). Solución:

PROGRAM POTENCIADOS(INPUT,OUTPUT); VAR LIMITE, POTENCIA, EXPONENTE, RESTA1, RESTA2: INTEGER; BEGIN (*PROGRAMA*) READ(LIMITE); POTENCIA:=1; EXPONENTE:=0; WHILE POTENCIA<LIMITE DO BEGIN (*WHILE*) EXPONENTE:=EXPONENTE+1; POTENCIA:=POTENCIA*2 END; (*WHILE*) (*al salir del lazo potencia será mayor que límite*) RESTA1:=POTENCIA-LIMITE; RESTA2:=LIMITE-(POTENCIA DIV 2); IF RESTA1>RESTA2 THEN WRITE('2 ELEVADO A',EXPONENTE-1,'ES LA POTENCIA DE 2 MAS CERCANA A',LIMITE) ELSE WRITE('2 ELEVADO A',EXPONENTE,'ES LA POTENCIA DE 2 MAS CERCANA A',LIMITE) END. (*PROGRAMA*)

6.8. Efectuar traza. En sentencia repeat.




Determinar qué escribe el segmento. .... n:=0; repeat j:=n+1; n:=3*n+j; j:=n+1; writeln(j,n) until j>17; .... Solución: Iteración n j=n+1 n=3*n+j j=n+1 j n 1 0 1 1 2 2 1 2 1 2 5 6 6 5 3 5 6 21 22 22 21 Sale del lazo con j=22. Escribe: 2 1 6 5 22 21

6.9. Efectuar traza. En repeat forever. Determinar qué escribe el segmento.

...... n:=1; repeat n:=2*n+2;write(2*n+2) until n=48; ...... Solución: Iteración n n=2*n+2 2*n+2 1 1 4 10 2 4 10 22 3 10 22 46 4 22 46 94 Se repite hasta el overflow. Escribe: 10 22 46 94 .....




6.10. Generar Secuencia. Escribir programa en Pascal, que genere la secuencia definida por la siguiente relación de recurrencia:

f(i+2) = f(i)+2*f(i-1)+f(i+1) para i>0 f(0)=1; f(1)=2; f(2)=1 Solución: PROGRAM PRUEBA; VAR FIMEM,FI,FIMAS,FIDOS,I,J:INTEGER; BEGIN (*PROGRAMA*) WRITE('GENERA HASTA F(I). I='); READLN(I);WRITELN; FIMEN:=1; WRITELN(' F(0)=1'); FI :=2; WRITELN(' F(1)=2'); FIMAS:=1; WRITELN(' F(2)=1'); J:=2; REPEAT { ITERA HASTA J=I} FIDOS:=FI+2*FIMEN+FIMAS; {FUNCION} FIMEN:=FI; FI:=FIMAS; {SALVA VALORES PARA PROX. ITERACION} FIMAS:=FIDOS; J:=J+1;

WRITELN('F(',J,')=',FIDOS) UNTIL J=I

END. {PROGRAMA} 6.11. Cálculo de serie. Sumar los primeros diez términos de la serie. Escribir la relación de recurrencia. -4/3 + 8/15 - 12/35 + - ...... Solución: n

f(n)=(-1) 4n/((2n-1)(2n+1)) ; para n = 1,2,....




PROGRAM SERIE; VAR SUMA:REAL; {para acumular las fracciones} SGN,N:INTEGER; BEGIN { OTRO } SUMA:=0; SGN:=-1; FOR N:=1 TO 10 DO {SUMA DESDE F(1) HASTA F(10)} BEGIN { FOR } SUMA:=SUMA+(SGN*(4*N))/((2*N-1)*(2*N+1)); SGN:= -SGN; {ALTERNA SIGNO} END; { FOR } WRITELN('SUMA = ',SUMA) END. { OTRO }

6.12. Desarrollo Operación Mod. Determinar un algoritmo que evalúe el resto de la división entera de n y d. Es decir, se desea implementar el operador mod empleando operaciones más básicas. r:= n mod d Solución: Basada en la definición de mod. ..... if n = d then r:=0 else begin r:=n; while r>d do r:=r-d end ..... El algoritmo es lento, pues si n>>d debe realizar n div d veces el lazo de repetición. Puede decirse que el algoritmo es lineal, en el sentido que las veces que se repite la resta es proporcional al número de veces que d cabe en n.




Un algoritmo más eficiente, y que dará que el número de veces que se repite el bloque sea proporcional al logaritmo en base dos de n div d es el siguiente: .... r:=n ;dd:= d;

while dd<=r do dd:=2*dd; while dd<>d do begin dd:=dd div 2; if dd<=r then r:=r-dd end;

.... En este algoritmo se emplean multiplicaciones y divisiones por 2, además de sumas y restas. Todas operaciones existentes en el repertorio de máquina de cualquier computador. Una variante del algoritmo anterior permite obtener el cuociente y el resto de la división entera entre n y d: r:= n mod d q:= n div d Esto considerando que: n:= q*d + r .... r:=n ;dd:= d; q:= 0;

while dd<=r do dd:=2*dd; while dd<>d do begin dd:=dd div 2; q:= q*2; if dd<=r then begin r:=r-dd; q:= q+1 end end;

.... 6.13. Diagrama de flujo Estructurado. Mediante la introducción de una variable booleana, modificar el siguiente diagrama de flujo a un diagrama de flujo estructurado. Escribir el segmento empleando Pascal, sin usar goto.




C1 y C2 son predicados en general y pueden o no ser modificados por la acción A.

Sea C3 la variable booleana a introducir. Una solución posible es: C3:=TRUE El diagrama de flujo estructurado:

El segmento asociado es: ... C3:=TRUE; WHILE C3 DO {la acción a repetir no necesita} IF C1 {Begin .. End ; ya que es una alternativa}

THEN

C1

A

F V

V F C2

A

C2 F V

C3:=FALSE

C1 V F

C3:=FALSE

C3

C3:=TRUE




BEGIN A; IF NOT C2 THEN C3:=FALSE END ELSE C3:=FALSE ; ..... Otra solución, más simple, puede ser: El segmento asociado es: ... REPEAT IF C1 THEN A UNTIL NOT (C1 AND C2) ...

6.14. Serie con números reales. Se tiene la siguiente serie:

3 5

1 ....3! 5!ix xS = − + +

a) Determinar la relación de recurrencia. b) Escribir un programa para obtener la suma de los términos. La suma debe detenerse cuando el término general sea menor que el valor epsilon; que debe leerse desde el terminal.

Solución:

3 5 2* 111 .... ( 1)

3! 5! (2* 1)!

ii

i

x x xS

i

−+= − + − + + −

−

A

C1 F V

not (C1 and C2)




Dividiendo el último por el antepenúltimo se logra:

2

1 , 0, 0(2* 2)(2* 1)j j

xT T j T x

j j−= − ∗ > =− −

Pero no puede emplearse pues para j=1 se tendrá denominador cero.

Puede plantearse: 2

j i

i jj

S x T=

== + ∑

Ahora la relación queda:

2

1 , 1, 1(2* 2)(2* 1)j j

xT T j T x

j j−= − ∗ > =− −




Program seno; var x, s, t, epsilon: real; j: integer; begin read(x); read(epsilon); t:=x;s:=t;j:= 2; while abs(t)>epsilon do begin t:=-t*x*x/((2*j-1)*(2*j-2)); s:=s+t; j:=j+1 end; writeln(s) end.

6.15. Bloques de repetición. Procedimientos. Leer un número entero menor que un millón; y escribir la cantidad de billetes y monedas que representan el valor. El ejemplo ilustra como pueden definirse procedimientos cuando se detectan bloques repetitivos de código en un programa. Solución:

Program cajero; var m:integer; begin read(m); if m<1000000 then begin writeln(m div 5000,' de a 5000'); m:=m mod 5000; writeln(m div 1000,' de a 1000'); m:=m mod 1000;

writeln(m div 500,' de a 500'); m:=m mod 500; writeln(m div 100,' de a 100'); m:=m mod 100;




writeln(m div 50,' de a 50'); m:=m mod 50; writeln(m div 10,' de a 10'); m:=m mod 10;

writeln(m div 5,' de a 5'); m:=m mod 5; writeln(m, 'de a 1') end else writeln('solo acepto valores menores que un millon') end.

Se detecta grupo de repetición, que se agrupa bajo el nombre tantosdea. El Programa queda: program cajero2;

var m,p:integer; procedure tantosdea; begin writeln(m div p,' de a',p); m:=m mod p end; {tantosdea} begin {programa} read(m); if m<1000000 then begin p:=5000; tantosdea; p:=1000; tantosdea; p:= 500; tantosdea; p:= 100; tantosdea; p:= 50; tantosdea; p:= 10; tantosdea;

p:= 5; tantosdea; p:= 1; tantosdea end else writeln('solo acepto valores menores que un millon') end.

Aún se aprecia una repetición, que permite definir un procedimiento llamado grupo. La versión se muestra a continuación.




program cajero3; var m,p:integer; procedure tantosdea; begin writeln(m div p,'de a',p); m:=m mod p end; {tantosdea} procedure grupo; begin repeat tantosdea; p:=p div 5; tantosdea; p:=p div 2 until p=0 end; {grupo} begin {programa} read(m); if m<1000000 then begin p:=5000; grupo end else writeln('solo acepto menores que un millon') end.

6.16. Multiplicación como suma repetitiva. Se tiene el siguiente programa:

Program multiplica; var x,y,t,s:integer; begin read(x); read(y); s:=0; while x<>0 do begin t:=0; while t<>y do begin s:=s+1; t:=t+1 end;




x:=x-1 end; write(s) end.

a) Explicar qué hace el programa. b) Describir el algoritmo en forma top-down. c) Restricciones de la entrada para no tener lazos infinitos. d) Para que se emplean las variables s y t. e) Efectuar traza para x=3 e y=4. Solución: a) Se efectúa la multiplicación de dos enteros positivos. Se repite y veces la acción de incrementar en uno un contador s; y lo anterior se repite x veces. Es decir se repite x por y veces el incremento en uno de la variable s. b) 1. Multiplicar dos enteros x e y

1.1 Leer enteros x e y 1.2 Multiplicarlos dejando el producto en s 1.3 Escribir el resultado s.

No es necesario expandir los pasos 1.1 y 1.3 pues pueden implementarse directamente por instrucciones del repertorio. La siguiente secuencia es una refinación de 1.2

1.2.1 Hacer cero el producto 1.2.2 repetir x veces 1.2.3 repetir y veces: sumar uno al producto.

Se estima suficiente el grado de descripción de la multiplicación. El descenso al código es casi inmediato, falta sólo definir la necesidad de la variable t. c) x e y no pueden ser negativos. En caso de serlo (cualquiera de ellos) el respectivo lazo se repetiría infinitas veces.




c1) Si se inicia x con valor negativo, en cada repetición se hará más negativo el valor de x. Y nunca será x=0, que es la condición para terminar el lazo externo. Cuestión similar ocurre para un valor inicial negativo de y. c2) Sin embargo una o ambas variables pueden ser cero; y el algoritmo da el resultado correcto para el producto. d) La variable s se emplea para acumular el producto. La variable t se emplea para contar y veces; esto es necesario pues no debe destruirse el valor de y. Ambas variables se emplean como contadores ascendentes módulo 1. e) Numeración de pasos.

1) read(x); read(y); s:=0; 2) while x<>0 do begin 3) t:=0; 4) while t<>y do begin s:=s+1; t:=t+1 end 5) x:=x+1 end; 6) write(s)

Traza.

x y s t 1 3 4 0 - 2.1 3.1 0 4.1 1 1 4.2 2 2 4.3 3 3 4.4 4 4 5.1 2 2.2 3.2 0 4.1 5 1 4.2 6 2 4.3 7 3 4.4 8 4 5.2 1




2.3 3.3 0 4.1 9 1 4.2 10 2 4.3 11 3 4.4 12 4 5.3 0 6. Se escribe 12.

6.17. Lectura de caracter con confirmación. Leer un caracter diferente de espacio, sujeto a confirmación : repeat write('Entre caracter : '); while ch=' ' do readln(ch); write('Esta seguro? Seguro=s Repita=<otro caracter> '); readln(verificacion) until verificacion='s' 6.18. Reducción de fracciones. program fraccion(input,output); const pleca = '/'; var num,den,nn,nd : integer; begin writeln('Entre una fraccion, sin espacios : '); read(num);write(pleca);readln(den); nn:=num;nd:=den; {obtiene mcd(nn,nd) } while nn<>nd do if nn>nd then nn:=nn-nd else nd:=nd-nn; {al salir mcd=nn=nd} write (num:3,pleca,den:3,'='); writeln(num div nn:3,pleca,den div nd:3) end.




6.19. Ejercicios. 6.19.1. Equivalencia sintáctica. Se tienen : a) if c >= 0 then a1 else a2; b) if c < 0 then a2 else a1; Determinar si son sintácticamente equivalentes, en qué condiciones; y cuál es la ventaja de usar una u otra. 6.19.2. Uso de paréntesis. Comprobar que las expresiones a la izquierda son equivalentes con las de las de la derecha. -2 mod k (-2) mod k i - k div j i-(k div j) x/j/z (x/j)/z x*y*z (x*y)*z 6.19.3. Orden de evaluación. Comprobar que el siguiente diagrama ilustra el orden en que se evalúa una expresión; el número al lado del operador refleja el orden.

z - ( a + b div c ) + d * y

div

+

*

-

+

1

2

3

4

5




6.19.4. Nombres sugerentes. Siempre es conveniente identificar las variables con nombres que sean sugerentes. Se tienen : a) for contadordellazo:=inicial to final do a[contadordellazo]:=0; b) for i:=inicial to final do a[i]:=0; Analizar, en general, cuando conviene usar nombres largos para las variables. En el ejemplo ilustrado se emplean arreglos y la instrucción for, que se verán más adelante. Para el caso mostrado es mejor la forma b). 6.19.5. Sumatoria. Comprobar que el siguiente segmento, calcula :

1

i n

ii

suma X=

== ∑

.. suma:=0; for i:=1 to n do begin readln(x); suma:=suma + x end; writeln(suma); .. 6.19.6 Lazos infinitos. Condición de término. Verificar que el siguiente segmento produce un lazo infinito: .. x:=0; repeat x:=x+0.01; write(x:5:1) until x=1.0; .. Explicar a qué se debe.

universidad tecnica federico santa maria …lsb/pascal/clases/cap06.pdf · universidad tecnica...

Documents