ejercicios resueltos - elaboración de algoritmos

Capítulo 3

3.5 Ejercicios resueltos (Continuación…)

Ejercicio 3.5.4

Dados los lados A y B de un triángulo rectángulo, según el teorema de Pitágoras, el cua-drado de la hipotenusa (C), es igual a la suma del cuadrado de los catetos (lados).

c² = a² + b²

Elaborar un algoritmo que lea el tamaño de los lados A y B, y calcule e imprima C (hipotenusa).

(Primero hágalo usted....después compare la solución)

Algoritmo CALCULA HIPOTENUSA Clase Hipotenusa1 1. Método principal a. Declaraciones Variables a, b, c: Real b. Solicitar Cateto A y Cateto B c. Leer a, b d. Calcular c = RaízCuad(Potencia(a,2) + Potencia(b,2)) e. Imprimir c f. Fin Método principal Fin Clase Hipotenusa1Fin

Explicación:

El algoritmo tiene una clase; la Clase Hipotenusa1 misma que termina con Fin Clase Hipotenusa1.

3-2 Metodología de la Programación Orientada a Objetos

La Clase Hipotenusa1 tiene un solo método; el Método principal el cual tiene las siguientes acciones:

a. Se declaran las variables a para leer el cateto A b para leer el cateto B c para calcular la hipotenusa b. Se solicitan el cateto A y el cateto B c. Se leen los datos en a y b d. Se calcula la hipotenusa c e. Se imprime la hipotenusa c

f. Fin del método principal

Luego se tiene el fi n de la clase y el fi n del algoritmo.

Ejercicio 3.5.5

Elaborar un algoritmo que lea una temperatura en grados Fahrenheit e imprima su equivalente en grados Celsius, Kelvin y Rankine. Para convertir a Celsius a la temperatura Fahrenheit se le resta 32 y se multiplica por 5/9. Para convertir a Kelvin, se le suma 273 a los grados Celsius. Para convertir a Rankine a los grados Fahrenheit se le suma 460.


Algoritmo CONVERTIR TEMPERATURAS Clase Temperaturas 1. Método principal a. Declaraciones Variables fahrenheit, celsius, rankine, kelvin: Real b. Solicitar Fahrenheit c. Leer fahrenheit d. Calcular celsius = (fahrenheit-32)*(5/9) kelvin = celsius + 273 rankine = fahrenheit + 460 e. Imprimir celsius, kelvin, rankine f. Fin Método principal Fin Clase TemperaturasFin

Explicación:

El algoritmo tiene una clase; la Clase Temperaturas misma que termina con Fin Clase Temperaturas. La Clase Temperaturas tiene un solo método; el Método principal el cual tiene las siguientes acciones:

Ejercicios resueltos (Continuación...) 3-3

a. Se declaran las variables fahrenheit para leer los grados correspondientes celsius para calcular los grados Celsius kelvin para calcular los grados Kelvin rankine para calcular los grados Rankine b. Se solicitan los grados Fahrenheit c. Se lee el dato d. Se calculan los grados Celsius, Kelvin, Rankine e. Se imprimen los datos celsius, kelvin, rankine

f. Fin del método principal


Ejercicio 3.5.6

El volumen de un cilindro se calcula multiplicando la constante Pi (π=3.1415926536) por el cuadrado del radio de la base(r) por la altura(h).

v = πr²h

Elaborar un algoritmo que lea el radio de la base y la altura de un cilindro, que calcule e imprima el volumen.


Algoritmo VOLUMEN CILINDRO Clase Cilindro 1. Método principal a. Declaraciones Constantes PI = 3.145926536 Variables radio, altura, volumen: Real b. Solicitar Radio y Altura c. Leer radio, altura d. Calcular volumen = PI*(Potencia(radio,2))*altura e. Imprimir volumen f. Fin Método principal Fin Clase CilindroFin

Explicación:

El algoritmo tiene una clase; la Clase Cilindro misma que termina con Fin Clase Cilin-dro. La Clase Cilindro tiene un solo método; el Método principal el cual tiene las siguientes acciones:


a. Se declaran La constante PI = 3.145926536 Las variables radio para leer el radio altura para leer la altura volumen para calcula el volumen b. Se solicitan los datos Radio y Altura c. Se leen los datos en las variables radio y altura d. Se calcula el volumen e. Se imprime el volumen f. Fin del método principal


Ejercicio 3.5.7

Dados dos ángulos de un triángulo se puede calcular el tercer ángulo. Se sabe que la suma de los ángulos de un triángulo es 180° , por ejemplo, sean A y B los ángulos conocidos, entonces C = 180 - (A+B). Elaborar un algoritmo que lea los ángulos A y B e imprima el ángulo C.


Algoritmo TAMAÑO ANGULO Clase TamAngulo 1. Método principal a. Declaraciones Variables a, b, c: Real b. Solicitar A y B c. Leer a, b d. Calcular c = 180-(a + b) e. Imprimir c f. Fin Método principal Fin Clase TamAnguloFin

Explicación:

El algoritmo tiene una clase; la Clase TamAngulo misma que termina con Fin Clase TamAngulo. La Clase TamAngulo tiene un solo método; el Método principal el cual tiene las si-guientes acciones:

a. Se declaran las variables a para leer ángulo A


b para leer el ángulo B c para calcular el ángulo C b. Se solicitan loa ángulos A y B c. Se leen los datos en las variables a y b d. Se calcula el ángulo c e. Se imprime el dato c f. Fin del método principal


Ejercicio 3.5.8

Dados el cateto A y la hipotenusa C, el cateto B se calcula

b² = c² - a²

Elaborar un algoritmo que lea el tamaño del cateto A y la hipotenusa C; y calcule e imprima el tamaño del cateto B.


Algoritmo CALCULA CATETO B Clase CatetoB 1. Método principal a. Declaraciones Variables a, b, c: Real b. Solicitar A y C c. Leer a, c d. Calcular b = RaízCuad(Potencia(c,2) – Potencia(a,2)) e. Imprimir b f. Fin Método principal Fin Clase CatetoBFin

Explicación:

El algoritmo tiene una clase; la Clase CatetoB misma que termina con Fin Clase Cate-toB. La Clase CatetoB tiene un solo método; el Método principal el cual tiene las siguientes acciones:

a. Se declaran las variables a para leer el cateto A c para leer la hipotenusa b para calcular el cateto B b. Se solicitan el cateto A y la hipotenusa C


c. Se leen los datos en las variables a y c d. Se calcula el cateto b e. Se imprime el dato b f. Fin del método principal


Ejercicio 3.5.9

Elaborar un algoritmo que permita leer un valor e imprima el seno hiperbólico, coseno hiperbólico y tangente hiperbólica.

Seno Hiperbólico = 12

((Exp(Angulo)-Exp(-Angulo))

Coseno Hiperbólico = 12

((Exp(Angulo)+Exp(-Angulo))

Tangente Hiperbólica =

Seno HiperbólicoCoseno Hiperbólico


Algoritmo CALCULOS LOGARITMICOS Clase Angulo2 1. Método principal a. Declaraciones Variables valor, senHip, cosHip, tanHip: Real b. Solicitar Valor c. Leer valor d. Calcular senHip = (1/2)*((Exp(valor)- Exp(-valor)) cosHip = (1/2)*((Exp(valor)+ Exp(-valor)) tanHip = senHip/cosHip e. Imprimir senHip, cosHip, tanHip f. Fin Método principal Fin Clase Angulo2Fin

Explicación:

El algoritmo tiene una clase; la Clase Angulo2 misma que termina con Fin Clase An-gulo2.


La Clase Angulo2 tiene un solo método; el Método principal el cual tiene las siguientes acciones:

a. Se declaran las variables valor para leer el valor senHip para calcular el seno hiperbólico cosHip para calcular el coseno hiperbólico tanHip para calcular la tangente hiperbólica b. Se solicita el valor c. Se lee el valor d. Se calcula el Seno hiperbólico, Coseno hiperbólico y Tangente hiperbólica. e. Se imprimen los datos de salida f. Fin del método principal


Ejercicio 3.5.10

Elaborar un algoritmo que permita leer el tamaño de un ángulo en grados e imprima el seno y coseno. Debe convertirse los grados leídos a radianes antes de calcular el seno y coseno.


Algoritmo CALCULOS LOGARITMICOS DE ANGULO Clase Angulo3 1. Método principal a. Declaraciones Constantes PI = 3.145926536 Variables tamAngulo, angRadianes, senAng, cosAng: Real b. Solicitar Tamaño del ángulo en grados c. Leer tamAngulo d. Calcular angRadianes = tamAngulo *(PI/180) senAng = Seno(angRadianes) cosAng = Coseno(angRadianes) e. Imprimir angRadianes, senAng, cosAng f. Fin Método principal Fin Clase Angulo3Fin

Explicación:

El algoritmo tiene una clase; la Clase Angulo3 misma que termina con Fin Clase An-gulo3.


La Clase Angulo3 tiene un solo método; el Método principal el cual tiene las siguientes acciones:

a. Se declaran La constante PI = 3.145926536 Las variables tamAngulo para leer el tamaño del ángulo angRadianes para calcular el tañano del ángulo en radianes senAng para calcular el seno cosAng para calcular el coseno b. Se solicita el Tamaño del ángulo en radianes c. Se lee el dato tamAngulo d. Se calcula el tamaño del ángulo en radianes, el seno y coseno e. Se imprimen los datos requeridos f. Fin del método principal

Luego se tiene el fin de la clase y el fin del algoritmo.

Capítulo 4


Ejercicio 4.7.6

Elaborar un algoritmo que lea el tamaño de un ángulo en grados e imprimir si es:

Agudo si es menor a 90° Recto si es igual a 90° Obtuso si es mayor que 90° pero menor que 180° Llano si es igual a 180° Concavo si es mayor que 180° pero menor que 360°

Utilizar IF-THEN.

(Primero hágalo usted...después compare la solución)

Algoritmo TIPO ANGULO Clase TipoAngulo1 1. Método principal a. Declaraciones Variables angulo: Real b. Solicitar Angulo c. Leer angulo d. IF angulo < 90 THEN 1. Imprimir “Agudo” e. ENDIF f. IF angulo = 90 THEN 1. Imprimir “Recto” g. ENDIF h. IF (angulo>90)AND(angulo<180) THEN 1. Imprimir “Obtuso”


i. ENDIF j. IF angulo = 180 THEN 1. Imprimir “Llano” k. ENDIF l. IF (angulo>180)AND(angulo<360) THEN 1. Imprimir “Concavo” m. ENDIF n. Fin Método principal Fin Clase TipoAngulo1Fin

Explicación:

En el Método principal de la Clase TipoAngulo1, se tienen las acciones:

a. Se Declara la variable angulo b. Se solicita el tamaño del Angulo c. Se lee el dato en angulo d. Se compara si angulo < 90 si se cumple, entonces a. Se imprime que el ángulo es “Agudo” e. Fin del IF f. Se compara si angulo = 90 si se cumple, entonces a. Se imprime que el ángulo es “Recto” g. Fin del IF h. Se compara si (angulo>90)y(angulo<180) si se cumple, entonces a. Se imprime que el ángulo es “Obtuso” i. Fin del IF j. Se compara si angulo = 180 si se cumple, entonces a. Se imprime que el ángulo es “Llano” k. Fin del IF l. Se compara si (angulo>180)AND(angulo<360) si se cumple, entonces a. Se imprime que el ángulo es “Concavo” m. Fin del IF n. Fin del método principal


Ejercicio 4.7.7

Elaborar un algoritmo que permita leer el tamaño de dos ángulos A y B; e imprima:

- si son iguales y que tipo de ángulo son- si son diferentes y que tipo de ángulo es cada uno

Utilizar IF-THEN-ELSE e IF-THEN.



Algoritmo ANGULOS IGUALES O DIFERENTES Clase AngulosIgualesDife 1. Método principal a. Declaraciones Variables anguloA, anguloB: Real b. Solicitar AnguloA y AnguloB c. Leer anguloA, anguloB d. IF anguloA = anguloB THEN 1. Imprimir “LOS ANGULOS SON IGUALES” 2. IF anguloA < 90 THEN a. Imprimir “SON AGUDOS” 3. ENDIF 4. IF anguloA = 90 THEN a. Imprimir “SON RECTOS” 5. ENDIF 6. IF (anguloA>90)AND(anguloA<180) THEN a. Imprimir “SON OBTUSOS” 7. ENDIF 8. IF anguloA = 180 THEN a. Imprimir “SON LLANOS” 9. ENDIF 10. IF (anguloA>180)AND(anguloA<360) THEN a. Imprimir “SON CONCAVOS” 11. ENDIF e. ELSE 1. Imprimir “LOS ANGULOS SON DIFERENTES” 2. IF anguloA < 90 THEN a. Imprimir “EL ANGULO A ES AGUDO” 3. ENDIF 4. IF anguloA = 90 THEN a. Imprimir “EL ANGULO A ES RECTO” 5. ENDIF 6. IF (anguloA>90)AND(anguloA<180) THEN a. Imprimir “EL ANGULO A ES OBTUSO” 7. ENDIF 8. IF anguloA = 180 THEN a. Imprimir “EL ANGULO A ES LLANO” 9. ENDIF 10. IF (anguloA>180)AND(anguloA<360) THEN a. Imprimir “EL ANGULO A ES CONCAVO” 11. ENDIF 12. IF anguloB < 90 THEN a. Imprimir “EL ANGULO B ES AGUDO” 13. ENDIF 14. IF anguloB = 90 THEN a. Imprimir “EL ANGULO B ES RECTO”


15. ENDIF 16. IF (anguloB>90)AND(anguloB<180) THEN a. Imprimir “EL ANGULO B ES OBTUSO” 17. ENDIF 18. IF anguloB = 180 THEN a. Imprimir “EL ANGULO B ES LLANO” 19. ENDIF 20. IF (anguloB>180)AND(anguloB<360) THEN a. Imprimir “EL ANGULO B ES CONCAVO” 21. ENDIF f. ENDIF g. Fin Método principal Fin Clase AngulosIgualesDifeFin

Explicación:

En el Método principal de la Clase AngulosIgualesDife, se tienen las acciones:

a. Se declaran las variables anguloA y anguloB b. Se solicitan los datos anguloA y anguloB c. Se leen los datos en anguloA y anguloB d. Se compara si anguloA = anguloB si se cumple, entonces 1. Se imprime que los ángulos “SON IGUALES” 2. Se compara si anguloA < 90 si se cumple, entonces a. Se imprime que “SON AGUDOS” 3. Fin del IF 4. Se compara si anguloA = 90 si se cumple, entonces a. Se imprime que “SON RECTOS” 5. Fin del IF 6. Se compara si (anguloA>90)AND(anguloA<180) si se cumple, entonces a. Se imprime que “SON OBTUSOS” 7. Fin del IF 8. Se compara si anguloA = 180 si se cumple, entonces a. Se imprime que “SON LLANOS” 9. Fin del IF 10. Se compara si (anguloA>180)AND(anguloA<360) si se cumple, entonces a. Se imprime que “SON CONCAVOS” 11. Fin del IF e. Si no se cumple (ELSE) 1. Se imprime que los ángulos “SON DIFERENTES” 2. Se compara si anguloA < 90 si se cumple, entonces a. Se imprime que “EL ANGULO A ES AGUDO” 3. Fin del IF 4. Se compara si anguloA = 90 si se cumple, entonces a. Se imprime que “EL ANGULO A ES RECTO” 5. Fin del IF


6. Se compara si (anguloA>90)AND(anguloA<180) si se cumple, entonces a. Se imprime que “EL ANGULO A ES OBTUSO” 7. Fin del IF 8. Se compara si anguloA = 180 si se cumple, entonces a. Se imprime que “EL ANGULO A ES LLANO” 9. Fin del IF 10. Se compara si (anguloA>180)AND(anguloA<360) si se cumple, entonces a. Se imprime que “EL ANGULO A ES CONCAVO” 11. Fin del IF 12. Se compara si anguloB < 90 si se cumple, entonces a. Se imprime que “EL ANGULO B ES AGUDO” 13. Fin del IF 14. Se compara si anguloB = 90 si se cumple, entonces a. Se imprime que “EL ANGULO B ES RECTO” 15. Fin del IF 16. Se compara si (anguloB>90)AND(anguloB<180) si se cumple, entonces a. Se imprime que “EL ANGULO B ES OBTUSO” 17. Fin del IF 18. Se compara si anguloB = 180 si se cumple, entonces a. Se imprime que “EL ANGULO B ES LLANO” 19. Fin del IF 20. Se compara si (anguloB>180)AND(anguloB<360) si se cumple, entonces a. Se imprime que “EL ANGULO B ES CONCAVO” 21. Fin del IF f. Fin del IF g. Fin del método principal


Ejercicio 4.7.8

Elaborar un algoritmo que permita leer el tamaño de un ángulo en radianes o en grados (debe preguntar en que lo va a leer); e imprima su equivalencia (en grados o radianes según corresponda), el seno y el coseno. Utilizar IF-THEN-ELSE.

(Primero hágalo usted...después compare la solución) Algoritmo SENO COSENO ARCO TANGENTE DE ANGULO Clase Angulo4 1. Método principal a. Declaraciones Constantes PI = 3.145926536 Variables angulo, senAng, cosAng, angRadianes, angGrados: Real


resp: Carácter b. Imprimir “¿EN QUE TIENE EL TAMAÑO DEL ANGULO? “ “¿GRADOS(G), RADIANES(R)?: “ c. Leer resp d. Solicitar ANGULO e. Leer angulo f. IF resp = “G” THEN 1. angRadianes = angulo * (PI/180) 2. Imprimir “EQUIVALEN A”, angRadianes, “ RADIANES” 3. senAng = Seno(angRadianes) 4. cosAng = Coseno(angRadianes) g. ELSE 1. angGrados = angulo * (180 / PI) 2. Imprimir “EQUIVALEN A”, angGrados, “ GRADOS” 3. senAng = Seno(angulo) 4. cosAng = Coseno(angulo) h. ENDIF i. Imprimir “SENO = “, senAng j. Imprimir “COSENO = “, cosAng k. Fin Método principal Fin Clase Angulo4Fin

Explicación:

En el Método principal de la Clase Angulo4, se tienen las acciones:

a. Se declaran constante y variables b. Se pregunta “¿EN QUE TIENE EL TAMAÑO DEL ANGULO? “ “¿GRADOS(G), RADIANES(R)?: “ Sugiere que teclee G si lo tiene en grados o R si lo tiene en radianes. c. Se lee en resp d. Se solicita el tamaño del ángulo e. Se lee en angulo f. Se compara si resp = “G” si se cumple, entonces 1. Calcula la equivalencia del angulo en radianes 2. Se imprime a cuántos radianes equivale el ángulo 3. Se calcula el seno 4. Se calcula el coseno g. Si no se cumple (ELSE) 1. Se calcula la equivalencia angulo en grados 2. Se imprime el tamaño del ángulo en grados 3. Se calcula el seno 4. Se calcula el coseno h. Fin del IF i. Se imprime el seno j. Se imprime el coseno


k. Fin del método principal


Ejercicio 4.7.9

Elabore un algoritmo que permita hacer conversiones de equivalencias de metros, yardas, pies y pulgadas. Primero debe preguntar que desea convertir y debe indicar una de las medidas mencionadas. Por ejemplo; si escogió metros, debe solicitar y leer el número de metros a convertir, enseguida imprimir la equivalencia en pies, yardas y pulgadas, y asi, hará lo propio para cada una de las medidas indicadas. Equivalencias: 1 pie = 12 pulgadas, 1 yarda = 3 pies, 1 pulgada = 2.54 cm, 1 metro = 100 cm. Utilizar IF-THEN.


Algoritmo EQUIVALENCIAS YARDAS PIES PULGADAS METROS Clase EquivalenciasPies 1. Método principal a. Declaraciones Variables metros, yardas, pies, pulgadas: Real resp: Carácter b. Imprimir “¿QUÉ DESEA CONVERTIR? “ “¿METROS(M), YARDAS(Y), PIES(P), PULGADAS(U)?: “ c. Leer resp d. IF resp = “M” THEN 1. Solicitar NUMERO DE METROS 2. Leer metros 3. pulgadas = (metros * 100) / 2.54 4. pies = pulgadas / 12 5. yardas = pies / 3 6. Imprimir metros, “METROS EQUIVALEN A: “ 7. Imprimir pulgadas, “PULGADAS” 8. Imprimir pies, “PIES” 9. Imprimir yardas, “YARDAS” e. ENDIF f. IF resp = “Y” THEN 1. Solicitar NUMERO DE YARDAS 2. Leer yardas 3. pies = yardas * 3 4. pulgadas = pies * 12 5. metros = (pulgadas * 2.54 ) / 100 6. Imprimir yardas, “YARDAS EQUIVALEN A: “ 7. Imprimir pulgadas, “PULGADAS” 8. Imprimir pies, “PIES” 9. Imprimir metros, “METROS”


g. ENDIF h. IF resp = “P” THEN 1. Solicitar NUMERO DE PIES 2. Leer pies 3. pulgadas = pies * 12 4. yardas = pies / 3 5. metros = (pulgadas * 2.54 ) / 100 6. Imprimir pies, “PIES EQUIVALEN A: “ 7. Imprimir pulgadas, “PULGADAS” 8. Imprimir yardas, “YARDAS” 9. Imprimir metros, “METROS” i. ENDIF j. IF resp = “U” THEN 1. Solicitar NUMERO DE PULGADAS 2. Leer pulgadas 3. pies = pulgadas / 12 4. yardas = pies / 3 5. metros = (pulgadas * 2.54 ) / 100 6. Imprimir pulgadas, “PULGADAS EQUIVALEN A: “ 7. Imprimir pies, “PIES” 8. Imprimir yardas, “YARDAS” 9. Imprimir metros, “METROS” k. ENDIF l. Fin Método principal Fin Clase EquivalenciasPiesFin

Explicación:

En el Método principal de la Clase EquivalenciasPies, se tienen las acciones:

a. Se declaran las variables b. Se pregunta “¿QUÉ DESEA CONVERTIR? “ “¿METROS(M), YARDAS(Y), PIES(P), PULGADAS(U) ?: “ c. Se lee en resp d. Si acaso resp = “M” si se cumple, entonces 1. Se solicita NUMERO DE METROS 2. Se lee en metros 3. Se calcula pulgadas 4. Se calcula pies 5. Se calcula yardas 6. Se imprime metros, “METROS EQUIVALEN A: “ 7. Se imprime pulgadas, “PULGADAS” 8. Se imprime pies, “PIES” 9. Se imprime yardas, “YARDAS” e. Fin del IF f. Si acaso resp = “Y” si se cumple, entonces


1. Se solicita NUMERO DE YARDAS 2. Se lee en yardas 3. Se calcula pies 4. Se calcula pulgadas 5. Se calcula metros 6. Se imprime yardas, “YARDAS EQUIVALEN A: “ 7. Se imprime pulgadas, “PULGADAS” 8. Se imprime pies, “PIES” 9. Se imprime metros, “METROS” g. Fin del IF h. Si acaso resp = “P” si se cumple, entonces 1. Se solicita NUMERO DE PIES 2. Se lee en pies 3. Se calcula pulgadas 4. Se calcula yardas 5. Se calcula metros 6. Se imprime pies, “PIES EQUIVALEN A: “ 7. Se imprime pulgadas, “PULGADAS” 8. Se imprime yardas, “YARDAS” 9. Se imprime metros, “METROS” i. Fin del IF j. Si acaso resp = “U” si se cumple, entonces 1. Se solicita NUMERO DE PULGADAS 2. Se lee en pulgadas 3. Se calcula pies 4. Se calcula yardas 5. Se calcula metros 6. Se imprime pulgadas, “PULGADAS EQUIVALEN A: “ 7. Se imprime pies, “PIES” 8. Se imprime yardas, “YARDAS” 9. Se imprime metros, “METROS” k. Fin del IF l. Fin del método principal


Ejercicio 4.7.10

La ecuación de la segunda ley de Newton:

F = ma

Donde:

F es la fuerza que actúa sobre el objeto (cuerpo), en gramos por centímetro cuadrado.m es la masa del cuerpo (en gramos).a es la aceleración en centímetros por segundo cuadrado.


y dice; que la fuerza (F) que actúa sobre un cuerpo se obtiene multiplicando la masa por la aceleración.

Se puede calcular la aceleración (a) si se tienen los datos F y m; con la fórmula:

a = F

m

Se puede calcular la masa (m) si se tienen los datos fuerza (F) y aceleración (a), con la fórmula:

m = F

a

Elaborar un algoritmo que pregunte lo que desea calcular; fuerza (F), masa (m) o aceleración (a). Si es F, se leen los datos m y a. Si es a, se leen los datos F y m. Si es m, se leen los datos F y a. Utilizar IF-THEN.


Algoritmo SEGUNDA LEY NEWTON Clase LeyNewton1 1. Método principal a. Declaraciones Variables f, a, m: Real resp: Carácter b. Imprimir “¿QUÉ DESEA CALCULAR? “ “¿FUERZA(F), ACELERACION(A), MASA(M) ?: “ c. Leer resp d. IF resp = “F” THEN 1. Solicitar MASA 2. Leer m 3. Solicitar ACELERACION 4. Leer a 5. f = m * a 6. Imprimir “F = “, f e. ENDIF f. IF resp = “A” THEN 1. Solicitar MASA 2. Leer m 3. Solicitar FUERZA 4. Leer f 5. a = f / m 6. Imprimir “A = “, a g. ENDIF h. IF resp = “M” THEN


1. Solicitar FUERZA 2. Leer f 3. Solicitar ACELERACION 4. Leer a 5. m = f / a 6. Imprimir “M = “, m i. ENDIF j. Fin Método principal Fin Clase LeyNewton1Fin

Explicación:

En el Método principal de la Clase LeyNewton1, se tienen las acciones:

a. Se declaran las variables b. Se pregunta “¿QUÉ DESEA CALCULAR? “ “¿FUERZA(F), ACELERACION(A), MASA(M) ?: “ c. Se lee en resp d. Si acaso resp = “F” entonces 1. Se solicita MASA 2. Se lee en m 3. Se solicita ACELERACION 4. Se lee en a 5. Se calcula la fuerza 6. Se imprime la fuerza e. Fin del IF f. Si acaso resp = “A” entonces 1. Se solicita MASA 2. Se lee en m 3. Se solicita FUERZA 4. Se lee en f 5. Se calcula la aceleración 6. Se imprime la aceleración g. Fin del IF h. Si acaso resp = “M” entonces 1. Se solicita FUERZA 2. Se lee en f 3. Se solicita ACELERACION 4. Se lee en a 5. Se calcula la masa 6. Se imprime la masa i. Fin del IF j. Fin del método principal



Ejercicio 4.7.11

Teniendo como datos de entrada valores para los coeficientes a, b, c; y aplicando la ecuación cuadrática: F(x) = ax²+bx+c Las raíces se calculan con la fórmula

X =

-b ± b2 − 4ac

2a

Si b²-4ac = 0 tiene raíz única, que se calcula

−b2a

Si b²-4ac es menor que 0 (cero) tiene raíces complejas que se calculan:

Parte Real ± Parte Imaginaria

Donde:

Parte Real =

−b2a

Parte Imaginaria =

b2 − 4ac

2a

Por lo que:

Raíz compleja 1 = Parte real + Parte imaginariaRaíz compleja 2 = Parte real - Parte imaginaria

Si b²-4ac es mayor que 0 (cero) tiene raíces reales, aplicando la ecuación completa se calculan:

Raíz real 1 =

−2+ b2 − 4ac

2a

Raíz real 2 =

−2− b2 − 4ac

2a

Elaborar un algoritmo que permita leer los valores de los coeficientes a, b, c; y, que imprima la raíz única, las raíces complejas o las raíces reales, según corresponda. Utilizar IF-THEN-ELSE.

(Primero hágalo usted...después compare la solución) Algoritmo ECUACION CUADRATICA Clase Cuadratica1 1. Método principal a. Declaraciones Variables


a, b, c, raizUnica, parteReal, parteImaginaria, raizReal1, raizReal2: Real b. Solicitar COEFICIENTES A, B, C c. Leer a, b, c d. IF (Potencia(b,2)-4*a*c) = 0 THEN 1. raizUnica = -b/(2*a) 2. Imprimir “TIENE RAIZ UNICA = ” 3. Imprimir “RAIZ UNICA = ”, raizUnica e. ELSE 1. IF (Potencia(b,2)-4*a*c) < 0 THEN a. ParteReal = -b/(2*a) b. ParteImaginaria = raizCuad(Absoluto(Potencia(b,2)-4*a*c))/(2*a) c. Imprimir “TIENE RAICES COMPLEJAS” d. Imprimir parteReal, “+”, parteImaginaria, “i” e. Imprimir parteReal, “-”, parteImaginaria, “i” 2. ELSE a. raizReal1 = (-b+raizCuad(b^2-4*a*c))/(2*a) b. raizReal2 = (-b-raizCuad(b^2-4*a*c))/(2*a) c. Imprimir “TIENE RAICES REALES” d. Imprimir “Raiz Real 1 = “, raizReal1 e. Imprimir “Raiz Real 2 = “, raizReal2 3. ENDIF f. ENDIF g. Fin Método principal Fin Clase Cuadratica1Fin

Explicación:

En el Método principal de la Clase Cuadratica1, se tienen las acciones:

a. Se declaran las variables b. Se solicitan los coefi cientes A, B, C c. Se leen en a, b, c d. Si (Potencia(b,2)-4*a*c) = 0 entonces 1. Calcula la raizUnica 2. Imprime “TIENE RAIZ UNICA” 3. Imprime la raizUnica e. Si no 1. Si (Potencia(b,2)-4*a*c) < 0 entonces a. Calcula parteReal b. Calcula parteImaginaria c. Imprime “TIENE RAICES COMPLEJAS” d. Imprime raizCompleja1 e. Imprime raizCompleja2 2. Si no


a. Calcula raizReal1 b. Calcula raizReal2 c. Imprime “TIENE RAICES REALES” d. Imprime “Raiz Real 1 = “, raizReal1 e. Imprime “Raiz Real 2 = “, raizReal2 3. Fin del IF f. Fin del IF g. Fin del método principal


Ejercicio 4.7.12

De acuerdo con la igualdad o desigualdad de sus lados los triángulos se clasifi can en:

Escaleno todos sus lados son diferentes Isósceles al menos dos de sus lados son iguales equilátero los tres lados son iguales. Note que un equilátero también es isósceles

Elaborar un algoritmo que lea el tamaño de los tres lados A, B y C de un triángulo e imprima que tipo de triángulo es. Utilizar IF-THEN-ELSE.


Algoritmo TIPO TRIANGULO Clase TipoTriangulo 1. Método principal a. Declaraciones Variables ladoA, ladoB, ladoC: Real b. Solicitar LADOA, LADOB, LADOC c. Leer ladoA, ladoB, ladoC d. IF (ladoA<>ladoB)AND(ladoA<>ladoC)AND(ladoB<>ladoC) THEN 1. Imprimir “ES ESCALENO” e. ELSE 1. IF (ladoA=ladoB)AND(ladoA=ladoC)AND(ladoB=ladoC) THEN a. Imprimir “ES EQUILÁTERO” 2. ELSE a. Imprimir “ES ISÓSCELES” 3. ENDIF f. ENDIF g. Fin Método principal Fin Clase TipoTrianguloFin

Explicación:

En el Método principal de la Clase TipoTriangulo, se tienen las acciones:


a. Se declaran las variables b. Se solicitan los tres lados c. Se leen en ladoA, ladoB, ladoC d. Si (ladoA<>ladoB) y (ladoA<>ladoC) y (ladoB<>ladoC) entonces 1. Imprime “ES ESCALENO” e. Si no 1. Si (ladoA=ladoB) y (ladoA=ladoC) y (ladoB=ladoC) entonces a. Imprime “ES EQUILÁTERO” 2. Si no a. Imprime “ES ISÓSCELES” 3. Fin del IF f. Fin del IF g. Fin del método principal


Ejercicio 4.7.13

Una empresa vende hojas de hielo seco, con las condiciones siguientes:

Si el cliente es tipo 1 se le descuenta el 5 % Si el cliente es tipo 2 se le descuenta el 8 % Si el cliente es tipo 3 se le descuenta el 12 % Si el cliente es tipo 4 se le descuenta el 15 %

Cuando el cliente realiza una compra se generan los datos siguientes:

Nombre del cliente Tipo de cliente (1,2,3,4) Cantidad de hojas compradas Precio por hoja

Elabore un algoritmo que lea estos datos, haga cálculos e imprima:

Nombre del cliente Sub total a pagar (Cantidad de hojas × Precio por hoja) Descuento (El porcentaje correspondiente del Sub total a pagar) Total a pagar (Sub total – Descuento)

Utilizar SWITCH.


Algoritmo CLIENTE HOJAS HIELO SECO Clase Cliente1 1. Método principal a. Declaraciones


Nota:

Variables nombreClie: Cadena tipoClie, cantidad: Entero precioUni, subTotal, descuento, totalPagar: Real b. Solicitar Nombre, Tipo cliente, Cantidad, Precio unitario c. Leer nombreClie, tipoClie, cantidad, precioUni d. subTotal = cantidad * precioUni e. SWITCH tipoClie 1: descuento = subTotal * 0.05 2: descuento = subTotal * 0.08 3: descuento = subTotal * 0.12 4: descuento = subTotal * 0.15 f. ENDSWITCH g. totalPagar = subTotal - descuento h. Imprimir nombreClie, subTotal, descuento, totalPagar i. Fin Método principal Fin Clase Cliente1Fin

Explicación:

En el Método principal de la Clase Cliente1, se tienen las acciones:

a. Se declaran las variables b. Se solicitan los datos c. Se leen en nombreClie, tipoClie, cantidad, precioUni d. Se calcula el subTotal e. Se plantea el SWITCH con el selector tipoClie Si tipoClie es 1 calcula descuento con el 5% Si tipoClie es 2 calcula descuento con el 8% Si tipoClie es 3 calcula descuento con el 12% Si tipoClie es 4 calcula descuento con el 15% f. Fin del SWITCH g. Se calcula el totalPagar h. Imprime nombreClie, subTotal, descuento, totalPagar i. Fin del método principal


En caso que se permita que el cliente pueda ser de tipo diferente de 1 a 4, y sólo tienen descuento éstos tipos; se agregaría el DEFAULT colocándole cero a descuento, ésa parte quedaría:


e. SWITCH tipoClie 1: descuento = subTotal * 0.05 2: descuento = subTotal * 0.08 3: descuento = subTotal * 0.12 4: descuento = subTotal * 0.15 f. DEFAULT a. descuento = 0 g. ENDSWITCH

Capítulo 5


Ejercicio 5.2.3

Elaborar un algoritmo que proporcione el siguiente reporte:

Califi caciones fi nales

Calif. Obser- Nombre Cal.1 Cal.2 Cal.3 fi nal vacion XXXXXXXXXXXXXXXX 99.99 99.99 99.99 99.99 Aprobado XXXXXXXXXXXXXXXX 99.99 99.99 99.99 99.99 Reprobado . . . . . . . . . . XXXXXXXXXXXXXXXX 99.99 99.99 99.99 99.99 Reprobado

Total Aprobados: 999 Total Reprobados: 999

A partir de que se tienen varios alumnos. Por cada alumno se tiene el NOMBRE, califi cación 1,2, y 3, y que la califi cación 1 vale el 20%, la 2 el 30% y la 3 el 50%. Deberá imprimir la observación APROBADO si la califi cación fi nal es mayor o igual a 60, en caso contrario imprimirá REPROBADO. Al fi nal se imprime el total de alumnos aprobados y el total de reprobados, es decir, debe contar la cantidad de alumnos que obtuvieron 60 o más de califi cación; y la cantidad de alumnos que su califi cación fue menor a 60.


Algoritmo ALUMNOS APROBADOS REPROBADOS Clase Alumnos2 1. Método principal


a. Declaraciones Variables nombreAlum: Cadena totAprobados, totReprobados: Entero calif1, calif2, calif3, caliFinal: Real observacion: Cadena desea: Carácter b. Imprimir encabezado c. totAprobados = 0 totReprobados = 0 d. DO 1. Solicitar Nombre, califi cación 1, 2 y 3 2. Leer nombreAlum, calif1, calif2, calif3 3. caliFinal = (calif1*0.2)+(calif2*0.3)+(calif3*0.5) 4. IF caliFinal >= 60 THEN a. totAprobados = totAprobados + 1 b. observacion = “APROBADO” 5. ELSE a. totReprobados = totReprobados + 1 b. observacion = “REPROBADO” 6. ENDIF 7. Imprimir nombreAlum, calif1, calif2, calif3, caliFinal, observacion 8. Preguntar “¿Desea procesar otro alumno (S/N)?” 9. Leer desea e. WHILE desea = “S” f. Imprimir totAprobados, totReprobados g. Fin Método principal Fin Clase Alumnos2Fin

Explicación:

En el Método principal de la Clase Alumnos2, se tienen las acciones:

a. Se declaran las variables b. Imprime encabezado c. Inicia totAprobados en 0 Inicia totReprobados en 0 d. Inicia el ciclo DO 1. Solicita los datos Nombre, califi cación 1, 2 y 3 2. Lee en nombreAlum, calif1, calif2, calif3 3. Calcula caliFinal 4. Si caliFinal >= 60 entonces a. Incrementa totAprobados en 1 b. Coloca en observacion “APROBADO” 5. Si no (ELSE)


a. Incrementa totReprobados en 1 b. Coloca en observacion “REPROBADO” 6. Fin del IF 7. Imprime nombreAlum, calif1, calif2, calif3, caliFinal, observacion 8. Pregunta “¿Desea procesar otro alumno (S/N)?” 9. Lee en desea la respuesta e. Fin ciclo WHILE desea = “S” ; Si se cumple, vuelve al DO; si no, sale del ciclo. f. Imprime totAprobados, totReprobados g. Fin del método principal


Ejercicio 5.2.4

Elaborar un algoritmo que mida la inflación que han tenido ciertos artículos y que imprima el siguiente reporte:

Analisis de inflacion

Articulo Precio anterior Precio actual Ptje. inflacion XXXXXXXXXXXX 99,999.99 99,999.99 99.99 XXXXXXXXXXXX 99,999.99 99,999.99 99.99 . . . . . . . . XXXXXXXXXXXX 99,999.99 99,999.99 99.99

Promedio de inflación: 99.99 Artículo con mayor inflación : XXXXXXXXXXXXXXXXXXXXXXXXXXX Porcentaje mayor de inflación : 99.99

Datos disponibles por cada artículo:

Descripción Precio anterior Precio actual

Forma de calcular el porcentaje de inflación:

Ptje. inflación = Precio actual - Precio anterior

Precio anterior × 100

Se supone que los porcentajes de inflación de los artículos son diferentes.


Algoritmo INFLACION DE ARTICULOS Clase ArticulosInfla 1. Método principal


a. Declaraciones Variables articulo, articuloMayor: Cadena totArticulos: Entero precioAct, precioAnt, ptjeInfl a, totInfl a, mayorInfl a, promInfl a: Real otro: Carácter b. Imprimir encabezado c. totArticulos = 0 totInfl a = 0 mayorInfl a = 0 d. DO 1. Solicitar Artículo, precio actual y precio anterior 2. Leer articulo, precioAct, precioAnt 3. ptjeInfl a = ((precioAct-precioAnt)/precioAnt)*100 4. Imprimir articulo, precioAnt, precioAct, ptjeInfl a 5. IF ptjeInfl a > mayorInfl a THEN a. mayorInfl a = ptjeInfl a b. articuloMayor = artículo 6. ENDIF 7. totArticulos = totArticulos + 1 8. totInfl a = totInfl a + ptjeInfl a 9. Preguntar “¿Desea procesar otro articulo (S/N)?” 10. Leer otro e. WHILE otro = “S” f. promInfl a = totInfl a / totArticulos g. Imprimir promInfl a, articuloMayor, mayorInfl a h. Fin Método principal Fin Clase ArticulosInfl aFin

Explicación:

En el Método principal de la Clase ArticulosInfl a, se tienen las acciones:

a. Se declaran las variables b. Imprime encabezado c. Se inicia totArticulos en 0 totInfl a en 0 mayorInfl a en 0 d. Inicia el ciclo DO 1. Solicita los datos Artículo, precio actual y precio anterior 2. Lee en articulo, precioAct, precioAnt 3. Calcula el porcentaje de infl ación ptjeInfl a 4. Imprime articulo, precioAnt, precioAct, ptjeInfl a 5. Si acaso ptjeInfl a > mayorInfl a entonces a. Coloca en mayorInfl a el ptjeInfl a


b. Coloca en articuloMayor la descripción del artículo 6. Fin del IF 7. Se incrementa totArticulos en 1 8. Se incrementa totInfl a con ptjeInfl a 9. Pregunta “¿Desea procesar otro articulo (S/N)?” 10. Lee en otro la respuesta e. Fin del ciclo WHILE otro = “S” ; Si se cumple, vuelve al DO; si no, sale del ciclo. f. Calcula el promedio de infl ación total promInfl a g. Imprime promInfl a, articuloMayor, mayorInfl a h. Fin del método principal


Nota:mayorInfl a se inicia en 0 antes del ciclo, para que cuando entre la primera vez al ciclo y procese la infl ación del primer artículo ptjeInfl a y se compare en el IF

5. IF ptjeInfl a > mayorInfl a THEN a. mayorInfl a = ptjeInfl a b. articuloMayor = artículo 6. ENDIF

se cumpla la condición y entre al IF a colocar los datos del primer artículo como el mayor porcentaje de infl ación y el artículo del mayor porcentaje de infl ación; y así, cuando de la vuelta al ciclo y procese el segundo artículo, comparará el porcentaje de infl ación de este segundo artículo, con el del primero, que es el que está como el mayor porcentaje, si se cumple la condición entrará al IF a colocar los datos del segundo artículo como el mayor, y si no se cumple la condición dejará el artículo que esta como el mayor, luego hará lo propio con el siguiente artículo y así hasta que se terminen los artículos.

Ejercicio 5.2.5

En una empresa manufacturera de mesas. Se tienen varios obreros, y por cada obrero los datos:

Nombre del obrero: X------------------------------------------X Cada obrero puede haber trabajado varios días, por cada día que trabajó, se tiene un

dato: Cantidad de unidades fabricadas (construidas).

Cantidad de unidades fabricadas: --- Cantidad de unidades fabricadas: --- . Cantidad de unidades fabricadas: ---

Nota: cada cantidad fabricada es de un día de trabajo.

Nombre del obrero: X------------------------------------------X


Cantidad de unidades fabricadas: --- . Cantidad de unidades fabricadas: ---------------

Elaborar un algoritmo que lea los datos de cada uno de los obreros e imprima el siguiente reporte:

Reporte de produccion

Nombre del obrero Total produccion XXXXXXXXXXXXXXXXXXXXXXXX 999 XXXXXXXXXXXXXXXXXXXXXXXX 999 . . . XXXXXXXXXXXXXXXXXXXXXXXX 999

Total 999 obreros 9999

Nombre obrero mas productivo: xxxxxxxxxxxxxxxxxxxxxx Produccion que fabrico: 999

Nombre obrero menos productivo: xxxxxxxxxxxxxxxxxxxx Produccion que fabrico: 999

Cálculos:

Se lee el nombre de un obrero, luego cada una de las cantidades producidas por dia, se suman estas cantidades para calcular el TOTAL PRODUCCION; en otras palabras, es la sumatoria de las cantidades producidas de todos los días que laboró.Al final se pide el TOTAL de obreros y el TOTAL del TOTAL PRODUCCION de todos los obreros. Además el nombre del obrero más productivo y la producción que fabricó, y el nombre del obrero menos productivo y la producción que fabricó. El obrero más productivo es el que tenga el TOTAL PRODUCCION mayor. El obrero menos productivo es el que tenga el TOTAL PRODUCCION menor. Se supone que el TOTAL PRODUCCION de los obreros son diferentes.


Algoritmo OBREROS Clase Obreros1 1. Método principal a. Declaraciones Variables nombreObr, obrMayor, obrMenor: Cadena


proDia, totProd, toTotProd, totObreros, mayorProd, menorProd: Entero otro, desea: Carácter b. Imprimir encabezado c. totObreros = 0 toTotProd = 0 mayorProd = 0 menorProd = 10000 d. DO 1. Solicitar Nombre 2. Leer nombreObr 3. totProd = 0 4. DO a. Solicitar Producción del dia b. Leer proDia c. totProd = totProd + proDia d. Preguntar “¿Desea procesar otro dia (S/N)?” e. Leer otro 5. WHILE otro = “S” 6. Imprimir nombreObr, totProd 7. IF totProd > mayorProd THEN a. mayorProd = totProd b. obrMayor = nombreObr 8. ENDIF 9. IF totProd < menorProd THEN a. menorProd = totProd b. obrMenor = nombreObr 10. ENDIF 11. totObreros = totObreros + 1 toTotProd = toTotProd + totProd 12. Preguntar “¿Desea procesar otro obrero (S/N)?” 13. Leer desea e. WHILE desea = “S” f. Imprimir totObreros, toTotProd, obrMayor, mayorProd, obrMenor, menorProd g. Fin Método principal Fin Clase Obreros1Fin

Explicación:

En el Método principal de la Clase Obreros1, se tienen las acciones:

a. Se declaran las variables b. Imprime encabezado c. Se inician totObreros, toTotProd, mayorProd en ceros; y, menorProd en 10000


d. Inicia el ciclo DO 1. Solicita el nombre 2. Lee en nombreObr 3. Inicia totProd en 0 4. Inicia el ciclo DO a. Solicita la Producción del dia b. Lee en proDia c. Incrementa totProd con proDia d. Pregunta “¿Desea procesar otro dia (S/N)?” e. Lee en otro la respuesta 5. Fin del ciclo WHILE otro = “S” ; Si se cumple, vuelve al DO; si no, sale del ciclo. 6. Imprime nombreObr, totProd 7. Compara si totProd > mayorProd entonces a. Coloca en mayorProd el totProd b. Coloca en obrMayor el nombreObr 8. Fin del IF 9. Compara si totProd < menorProd entonces a. Coloca en menorProd el totProd b. Coloca en obrMenor el nombreObr 10. Fin del IF 11. Se incrementa totObr en 1 Se incrementa toTotProd en totProd 12. Pregunta “¿Desea procesar otro obreo (S/N)?” 13. Lee en desea la respuesta e. Fin del ciclo WHILE desea = “S” ; Si se cumple, vuelve al DO; si no, sale del ciclo. f. Imprime totObreros, toTotProd, obrMayor, mayorProd, obrMenor, menorProd g. Fin del método principal


Nota 1:Observe que este problema se resuelve utilizando dos ciclos DO…WHILE; un primer ciclo que permite procesar varios obreros. Al procesar cada obrero, después de leer su nombre, se debe procesar varios días de trabajo, para lo cual, se utiliza un segundo ciclo DO…WHILE. Además observe que no todos los contadores y acumuladores se inician en cero en el mismo lugar; antes del primer ciclo se inician los contadores y acumuladores que se imprimirán hasta el fi nal del reporte, como son totObreros y toTotProd; los contadores y acumuladores que se usarán o imrimirán en el detalle del reporte como es el totProd, se inicia en cero antes del segundo ciclo (pero adentro del primer ciclo), que se incrementa adentro del segundo ciclo con proDia y que se imprime afuera del segundo ciclo, pero adentro del primer ciclo.


Nota 2:mayorProd se inicia en 0 antes del ciclo, para que cuando entre la primera vez al ciclo y procese la producción del primer obrero totProd y se compare en el IF

7. IF totProd > mayorProd THEN a. mayorProd = totProd b. obrMayor = nombreObr 8. ENDIF

se cumpla la condición y entre al IF a colocar los datos del primer obrero como el más productivo; y así, cuando de la vuelta al ciclo y procese el segundo obrero, comparará el total de producción de este segundo obrero, con el del primero, que es el que está como el más productivo, si se cumple la condición entrará al IF a colocar los datos del segundo obrero como el mayor, y si no se cumple la condición dejará el obrero que esta como el mayor, luego hará lo propio con el siguiente obrero y así hasta que se terminen los obreros.

Nota 3:menorProd se inicia en 10000 antes del ciclo, para que cuando entre la primera vez al ciclo y procese la producción del primer obrero totProd y se compare en el IF

9. IF totProd < menorProd THEN a. menorProd = totProd b. obrMenor = nombreObr 10. ENDIF

se cumpla la condición y entre al IF a colocar los datos del primer obrero como el menos productivo; y así, cuando de la vuelta al ciclo y procese el segundo obrero, comparará el total de producción de este segundo obrero, con el del primero, que es el que está como el menos productivo, si se cumple la condición entrará al IF a colocar los datos del segundo obrero como el menor, y si no se cumple la condición dejará el obrero que esta como el menor, luego hará lo propio con el siguiente obrero y así hasta que se terminen los obreros. Es decir, 10000 es una cantidad mucho muy alta, que estamos seguros que ningún obrero lograría hacerla; de esta manera se forza a que la primera vez que llega al IF, se cumpla la condición.

Ejercicio 5.2.6

En una empresa comercial, se tienen las compras de varios clientes, y por cada cliente los datos:

Nombre del cliente: X------------------------------------------X Cada cliente puede haber comprado varios artículos, por cada artículo que com-

pró, se tienen los datos:

Artículo: X--------------------------------X Cantidad de artículos comprados: --- Precio unitario: ---


------ ------Nombre del cliente: X------------------------------------------X Artículo: X--------------------------------X Cantidad de artículos comprados: --- Precio unitario: --- ------ ------------------------

Elaborar un algoritmo que lea los datos de cada uno de los clientes e imprima el siguiente reporte:

Reporte de ventas

Nombre Articulo Total a pagar

XXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXX 99,999.99 XXXXXXXXXXXXXXXXXX 99,999.99 . . XXXXXXXXXXXXXXXXXX 99,999.99

Total cliente 999,999.99 XXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXX 99,999.99 XXXXXXXXXXXXXXXXXX 99,999.99 . . XXXXXXXXXXXXXXXXXX 99,999.99 Total cliente 999,999.99 . . . Total cliente 999,999.99

Total general 999 clientes 999,999.99

Cálculos:

TOTAL A PAGAR por cada artículo se calcula multiplicando la cantidad de artículos por el precio unitario.TOTAL A PAGAR POR CLIENTE es la sumatoria del TOTAL A PAGAR de todos los artículos que compró dicho cliente.En TOTAL GENERAL se imprime el total de clientes y el TOTAL A PAGAR el cual es la sumatoria del TOTAL A PAGAR de todos los clientes.



Algoritmo CLIENTES CON ARTICULOS Clase Clientes2 1. Método principal a. Declaraciones Variables nombreClie: Cadena articulo: Cadena otro, hay: Carácter totClientes, cantidad: Entero precio, totPagar, totPagarClie, totPagarGral: Real b. Imprimir encabezado c. totClientes = 0 totPagarGral = 0 d. DO 1. Solicitar NOMBRE DEL CLIENTE 2. Leer nombreClie 3. Imprimir nombreClie 4. totPagarClie = 0 5. DO a. Solicitar Articulo, Cantidad, Precio b. Leer articulo, cantidad, precio c. totPagar = cantidad * precio d. Imprimir articulo, totPagar e. totPagarClie = totPagarClie + totPagar f. Preguntar “¿HAY OTRO ARTICULO(S/N)?” g. Leer hay 6. WHILE hay = “S” 7. Imprimir totPagarClie 8. totClientes = totClientes + 1 totPagarGral = totPagarGral + totPagarClie 9. Preguntar “¿HAY OTRO CLIENTE(S/N)?” 10. Leer otro e. WHILE otro = “S” f. Imprimir totClientes, totPagarGral g. Fin Método principal Fin Clase Clientes2Fin

Explicación:

En el Método principal de la Clase Clientes2, se tienen las acciones:

a. Se declaran las variables b. Imprime encabezado c. Inicia totClientes y totPagarGral en ceros d. Inicia ciclo DO 1. Se solicita NOMBRE DEL CLIENTE


2. Lee en nombreClie 3. Imprime nombreClie 4. Inicia totPagarClie en 0 5. Inicia el ciclo DO a. Solicita los datos Articulo, Cantidad, Precio b. Lee en articulo, cantidad, precio c. Calcula totPagar d. Imprime articulo, totPagar e. Incrementa totPagarClie en totPagar f. Pregunta “¿HAY OTRO ARTICULO(S/N)?” g. Lee en hay 6. Fin ciclo (WHILE hay = “S”); Si se cumple, vuelve al DO; si no, sale del ciclo. 7. Imprime totPagarClie 8. Incrementa totClientes en 1 Incrementa totPagarGral en totPagarClie 9. Pregunta “¿HAY OTRO CLIENTE(S/N)?” 10. Lee en otro la respuesta e. Fin ciclo (WHILE otro = “S”); Si se cumple, vuelve al DO; si no, sale del ciclo. f. Imprime totClientes, totPagarGral g. Fin del método principal


Ejercicio 5.2.7

En una compañía comercial, se tienen varios vendedores, y por cada vendedor los datos:

Nombre del vendedor: XXXXXXXXXXXXXXXXXXXXXXXXXX

Cada vendedor puede haber vendido varios artículos, por cada artículo que vendió, se tienen los datos:

Artículo: XXXXXXXXXXXXXXXXXXXXXXXXXX Cantidad de artículos vendidos: 999 Precio unitario: 9,999.99 Clave de pago (1-4): 9 ------ ------ ------Nombre del vendedor: XXXXXXXXXXXXXXXXXXXXXXXXXX

Artículo: XXXXXXXXXXXXXXXXXXXXXXXXXX Cantidad de artículos vendidos: 999 Precio unitario: 9,999.99 Clave de pago (1- 4): 9 ------ ------ ------


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

Elaborar un algoritmo que lea los datos de cada uno de los vendedores e imprima el siguiente reporte:

Reporte de incentivos

Nombre Total vendido Incentivo

XXXXXXXXXXXXXXXXXXXX 99,999.99 99,999.99 XXXXXXXXXXXXXXXXXXXX 99,999.99 99,999.99 . . . XXXXXXXXXXXXXXXXXXXX 99,999.99 99,999.99

Total 999 vendedores 99,999.99 99,999.99

Cálculos:

TOTAL VENDIDO por cada vendedor es la sumatoria de lo vendido por el vendedor. Por cada artículo se calcula el importe vendido multiplicando la cantidad por precio unitario, y se suman los importes de todos los artículos vendidos.INCENTIVO cada vez que se calcula el importe vendido de un artículo, es necesario calcular el incentivo que se le pagará por la venta de dicho artículo: si la clave de pago es 1, el incentivo es 15%, si la clave es 2, el incentivo es 10%, si es 3, el incentivo es 5% y si es 4, el incentivo es 3%.TOTAL al final se imprime el total de vendedores, el total vendido por todos los vendedores y el total de incentivos de todos los vendedores.


Algoritmo VENDEDORES CON ARTICULOS Clase Vendedores1 1. Método principal a. Declaraciones Variables nombreVend: Cadena articulo: Cadena otro, hay: Carácter totVend, cantidad, clave: Entero precio, totVendido, incentivo, totIncentivo, venta, totGralIncentivo, totGralVenta: Real b. Imprimir encabezado c. totVend = 0; totGralVenta = 0; totGralIncentivo = 0


d. DO 1. Solicitar NOMBRE DEL VENDEDOR 2. Leer nombreVend 3. totVendido = 0; totIncentivo = 0 4. DO a. Solicitar ARTICULO, CLAVE, CANTIDAD, PRECIO b. Leer articulo, clave, cantidad, precio c. venta = cantidad * precio d. SWITCH clave 1: incentivo = venta * 0.15 2: incentivo = venta * 0.1 3: incentivo = venta * 0.05 4: incentivo = venta * 0.03 e. ENDSWITCH f. totVendido = totVendido + venta totIncentivo = totIncentivo + incentivo g. Preguntar “¿HAY OTRO ARTICULO(S/N)?” h. Leer hay 5. WHILE hay = “S” 6. Imprimir nombreVend, totVendido, totIncentivo 7. totVend = totVend + 1 totGralVenta = totGralVenta + totVendido totGralIncentivo = totGralIncentivo + totIncentivo 8. Preguntar “¿HAY OTRO VENDEDOR(S/N)?” 9. Leer otro e. WHILE otro = “S” f. Imprimir totVend, totGralVenta, totGralIncentivo g. Fin Método principal Fin Clase Vendedores1Fin

Explicación:

En el Método principal de la Clase Vendedores1, se tienen las acciones:

a. Se declaran las variables b. Imprime el encabezado c. Se inician en cero totVend, totGralVenta, totGralIncentivo d. Inicia ciclo DO 1. Solicita el NOMBRE DEL VENDEDOR 2. Se lee en nombreVend 3. Se inician totVendido = 0; totIncentivo = 0 4. Inicia ciclo DO a. Se solicita ARTICULO, CLAVE, CANTIDAD, PRECIO b. Se leen en articulo, clave, cantidad, precio c. Calcula venta = cantidad * precio d. Inicia SWITCH clave


1: Calcula incentivo = venta * 0.15 2: Calcula incentivo = venta * 0.1 3: Calcula incentivo = venta * 0.05 4: Calcula incentivo = venta * 0.03 e. Fin del SWITCH f. Se incrementa totVendido con venta Se incrementa totIncentivo con incentivo g. Pregunta “¿HAY OTRO ARTICULO(S/N)?” h. Lee en hay la respuesta 5. Fin del ciclo (WHILE hay = “S”); Si se cumple, vuelve al DO; si no, sale del ciclo. 6. Imprime nombreVend, totVendido, totIncentivo 7. Incrementa totVend en 1 Incrementa totGralVenta con totVendido Incrementa totGralIncentivo con totIncentivo 8. Pregunta “¿HAY OTRO VENDEDOR(S/N)?” 9. Se lee en otro la respuesta e. Fin del ciclo (WHILE otro = “S”) ; Si se cumple, vuelve al DO; si no, sale del ciclo. f. Imprime totVend, totGralVenta, totGralIncentivo g. Fin del método principal


Nota:Los problemas que hemos planteado para la aplicación de la repetición DO…WHILE, son situaciones en que algo se repite varias veces, no se sabe cuántas. Es por ello que se plantea la pregunta “¿HAY OTRO VENDEDOR(S/N)?” y luego se lee la respuesta en otro, desea o hay.

Hay otro tipo de situaciones en que algo se repite un número conocido de veces; por ejemplo, tomando el ejercicio anterior ahora hagamos el mismo algoritmo pero considerando que se tienen 15 vendedores. ¿Cómo podríamos controlar la repetición del ciclo mediante una forma distinta?

............... Piénselo ...............

Si observamos el algoritmo, podemos ver que se tiene el contador totVend en el cual se cuenta la cantidad de vendedores que se están procesando; utilizando ése contador en el WHILE quedaría de la forma siguiente:

Algoritmo VENDEDORES CON ARTICULOS Clase Vendedores2 1. Método principal a. Declaraciones Variables nombreVend: Cadena articulo: Cadena hay: Carácter


totVend, cantidad, clave: Entero precio, totVendido, incentivo, totIncentivo, venta, totGralIncentivo, totGralVenta: Real b. Imprimir encabezado c. totVend = 0; totGralVenta = 0; totGralIncentivo = 0 d. DO 1. Solicitar NOMBRE DEL VENDEDOR 2. Leer nombreVend 3. totVendido = 0; totIncentivo = 0 4. DO a. Solicitar ARTICULO, CLAVE, CANTIDAD, PRECIO b. Leer articulo, clave, cantidad, precio c. venta = cantidad * precio d. SWITCH clave 1: incentivo = venta * 0.15 2: incentivo = venta * 0.1 3: incentivo = venta * 0.05 4: incentivo = venta * 0.03 e. ENDSWITCH f. totVendido = totVendido + venta totIncentivo = totIncentivo + incentivo g. Preguntar “¿HAY OTRO ARTICULO(S/N)?” h. Leer hay 5. WHILE hay = “S” 6. Imprimir nombreVend, totVendido, totIncentivo 7. totVend = totVend + 1 totGralVenta = totGralVenta + totVendido totGralIncentivo = totGralIncentivo + totIncentivo e. WHILE totVend < 15 f. Imprimir totVend, totGralVenta, totGralIncentivo g. Fin Método principal Fin Clase Vendedores2Fin

Observe que las acciones (del anterior algoritmo)

8. Preguntar “¿HAY OTRO VENDEDOR(S/N)?” 9. Leer otro e. WHILE otro = “S”

han sido cambiadas por (en este algoritmo):

e. WHILE totVend < 15

Simplemente se pregunta si totVend es menor a 15; si se cumple, significa que no se han procesado 15 vendedores, y regresa al DO a procesar el siguiente. Si no se cumple; se sale del ciclo, lo que quiere decir que ya se han procesado los 15 vendedores,

Capítulo 6


Ejercicio 6.2.9

Elaborar un algoritmo que pregunte a cuántos números se desea calcular el factorial; lea la cantidad en N. A continuación, debe leer un número e imprimir su factorial, luego leer otro, y así hasta leer los N números.


Algoritmo FACTORIALES DE N NUMEROS Clase Factoriales1 1. Método principal a. Declaraciones Variables n, i, j, fact, num: Entero b. Solicitar Cantidad de números a calcular factorial c. Leer n d. FOR j=1; j<=n; j++ 1. Solicitar Número 2. Leer num 3. IF num = 0 THEN a. fact = 1 4. ELSE a. fact = 1 b. FOR i=num; i>=1; i-- 1. fact = fact * i c. ENDFOR 5. ENDIF 6. Imprimir fact e. ENDFOR f. Fin Método principal


Fin Clase Factoriales1Fin

Explicación:

En el Método principal de la Clase Factoriales1, se tienen las acciones:

a. Se declaran las variables b. Se pregunta (solicita) la cantidad de números a calcular factorial c. Se lee en n d. Ciclo FOR desde j = 1 hasta n con incrementos de 1 1. Se solicita el número 2. Se lee en num 3. Se compara si num = 0 si se cumple, entonces a. Se hace fact = 1 4. Si no (ELSE) a. Se inicia fact = 1 b. Ciclo FOR desde i = num hasta 1 con decrementos de -1 1. Se calcula fact = fact * i c. Fin del FOR 5. Fin del IF 6. Se imprime fact e. Fin del FOR f. Fin del método principal


Ejercicio 6.2.10

Los números de Fibonacci constituyen una secuencia que empieza con 0 y 1; el número que sigue a éstos se calcula sumando los dos anteriores y así sucesivamente. Elaborar un algoritmo que imprima los 20 siguientes números de la secuencia.


Algoritmo SECUENCIA FIBONACCI Clase Fibonacci 1. Método principal a. Declaraciones Variables i, numero, penultimo, ultimo: Entero b. penultimo = 0 ultimo = 1 c. FOR i=1; i<=20; i++ 1. numero = penultimo + ultimo 2. Imprimir numero 3. penultimo = ultimo 4. ultimo = numero


d. ENDFOR e. Fin Método principal Fin Clase FibonacciFin

Explicación:

En el Método principal de la Clase Fibonacci, se tienen las acciones:

a. Se declaran las variables b. Se inicia el penultimo en 0 Se inicia el ultimo en 1 c. Ciclo FOR desde i = 1 hasta 20 con incrementos de 1 1. Se calcula el nuevo numero = penultimo + ultimo 2. Se imprime el nuevo numero 3. En penultimo se coloca el ultimo 4. En ultimo se coloca el numero d. Fin del FOR e. Fin del método principal


Ejercicio 6.2.11

Elaborar un algoritmo que imprima una tabla con las potencias de los números desde 1 hasta 8. La potencia de 1, es 1 elevado a la potencia 1. La potencia de 2, es 2 elevado a la potencia 2. Y así sucesivamente, hasta la potencia de 8, es 8 elevado a la potencia 8.

Número Potencia

1 9999 2 9999 - - 8 9999


Algoritmo POTENCIAS 1-8 Clase Potencias2 1. Método principal a. Declaraciones Variables numero, potencia: Real i: Entero b. Imprimir encabezado c. FOR numero=1; numero<=8; numero++ 1. potencia = numero 2. FOR i=1; i<numero; i++ a. potencia = potencia * numero


3. ENDFOR 4. Imprimir numero, potencia d. ENDFOR e. Fin Método principal Fin Clase Potencias2Fin

Explicación:

En el Método principal de la Clase Potencias2, se tienen las acciones:

a. Se declaran las variables b. Se imprime el encabezado c. Inicia ciclo FOR desde numero = 1 hasta 8 con incrementos de 1 1. Se inicia potencia con numero 2. Inicia ciclo FOR desde i = 1 hasta numero -1 con incrementos de 1 a. Calcula potencia = potencia * numero 3. Fin del FOR 4. Imprime numero, potencia d. Fin del FOR e. Fin del método principal


Ejercicio 6.2.12

Teniendo como datos de entrada valores para los coefi cientes a, b, c; y aplicando la ecuación cuadrática: F(x) = ax²+bx+c Las raíces se calculan con la fórmula:

X =

-b ± b2 − 4ac

2a

Si b²-4ac = 0 tiene raíz única, que se calcula

−b2a

Si b²-4ac es menor que 0 (cero) tiene raíces complejas, que se calculan:Parte Real ± Parte Imaginaria

Donde:

Parte Real =

−b2a

Parte Imaginaria =

b2 − 4ac

2a

Por lo que:

Raíz compleja 1 = Parte real + Parte imaginariaRaíz compleja 2 = Parte real - Parte imaginaria


Si b²-4ac es mayor que 0 (cero) tiene raíces reales, aplicando la ecuación completa se calculan:

Raíz real 1 =

−2+ b2 − 4ac

2a

Raíz real 2 =

−2− b2 − 4ac

2a

Elaborar un algoritmo que permita que los valores de los coeficientes a, b, c; se comporten así: A debe ir de 1 hasta 5. C debe ir de 5 a 0. B debe tomar cada vez la diferencia de A-C. Y, que imprima para cada juego de valores de a, b, c; si tiene raíz única, raíces complejas o raíces reales, en una tabla como se muestra:

A B C TIENE RAIZ 1 RAIZ 2

1 -4 5 Raiz unica 999.99 2 -2 4 Raices complejas 999.99 ± 999.99 - - - - - - - - 5 4 1 Raices reales 999.99 999.99

(Primero hágalo usted...después compare la solución) Algoritmo ECUACION CUADRATICA PARA A DE 1-5 Clase Cuadratica2 1. Método principal a. Declaraciones Variables a, b, c, raizUnica, parteReal, parteImaginaria, raizReal1, raizReal2: Real b. Imprimir encabezado c. c = 6 d. FOR a=1; a<=5; a++ 1. c = c - a 2. b = a - c 3. Imprimir a, b, c 4. IF (Potencia(b,2)-4*a*c) = 0 THEN a. raizUnica = -b/(2*a) b. Imprimir “RAIZ UNICA ”, raizUnica 5. ELSE a. IF (Potencia(b,2)-4*a*c) < 0 THEN 1. parteReal = -b/(2*a) 2. parteImaginaria = RaizCuad(Absoluto(Potencia(b,2)- 4*a*c))/(2*a) 3. Imprimir “RAICES COMPLEJAS” 4. Imprimir parteReal,“+”,parteImaginaria,“i”


5. Imprimir parteReal,“-”,parteImaginaria,“i” b. ELSE 1. raizReal1 = (-b+RaizCuad(Potencia(b,2)-4*a*c))/(2*a) 2. raizReal2 = (-b-RaizCuad(Potencia(b,2)-4*a*c))/(2*a) 3. Imprimir “RAICES REALES” 4. Imprimir raizReal1, raizReal2 c. ENDIF 6. ENDIF e. ENDFOR f. Fin Método principal Fin Clase Cuadratica2Fin

Explicación:

En el Método principal de la Clase Cuadratica2, se tienen las acciones:

a. Se declaran las variables b. Se imprime el encabezado c. Se inicia c en 6 d. Inicia ciclo FOR desde a = 1 hasta 5 con incrementos de 1 1. Se calcula el coefi ciente c = c - a 2. Se calcula el coefi ciente b = a - c 3. Se imprimen los coefi cientes a, b, c 4. Si (Potencia(b,2)-4*a*c) = 0 entonces a. Calcula la raizUnica b. Imprime “RAIZ UNICA” , raizUnica 5. Si no a. Si (Potencia(b,2)-4*a*c) < 0 entonces 1. Calcula parteReal 2. Calcula parteImaginaria 3. Calcula raizCompleja1 4. Calcula raizCompleja2 5. Imprime “RAICES COMPLEJAS” 6. Imprime raizCompleja1, raizCompleja2 b. Si no 1. Calcula raizReal1 2. Calcula raizReal2 3. Imprime “RAICES REALES” 4. Imprime raizReal1, raizReal2 c. Fin del IF 6. Fin del IF e. Fin del FOR f. Fin del método principal



Ejercicio 6.2.13

Se deposita la cantidad de 10,000.00 a un plazo de 24 meses, con una tasa de interés de 36% anual, capitalizable cada mes, es decir, se suman los intereses ganados al capital. Elaborar un algoritmo que imprima el siguiente reporte:

Inversion Mes Capital Interes Saldo

1 99,999.99 99,999.99 99,999.99 2 99,999.99 99,999.99 99,999.99 . . .

24 99,999.99 99,999.99 99,999.99

Total interes ganado: 99,999.99

Cálculos:

MES es el número de mes.CAPITAL es el capital que se tiene en cada mes, por ejemplo, en el mes 1, el capital es 10,000.00, para el mes 2, deberá tener incrementado el interés que ganó en el mes 1, y así sucesivamente.INTERES es el interés que gana en el mes correspondiente, aplicandole al capital del mes, la tasa de interés mensual que le corresponda (36/12).SALDO es el saldo de la inversión del mes correspondiente; se suman el capital y el interés.


Algoritmo INVERSION 24 MESES Clase Interes1 1. Método principal a. Declaraciones Variables mes : Entero saldo , capital, interes, totInteres: Real b. Imprimir encabezado c. capital = 10000.00 d. totInteres = 0 e. FOR mes=1; mes<=24; mes++ 1. interes = capital * (0.36/12) 2. saldo = capital + interes 3. Imprimir mes, capital, interes, saldo 4. totInteres = totInteres + interes 5. capital = saldo


f. ENDFOR g. Imprimir totInteres h. Fin Método principal Fin Clase Interes1Fin

Explicación:

En el Método principal de la Clase Interes1, se tienen las acciones:

a. Se declaran las variables b. Se imprime el encabezado c. Se inicia capital en 10000.00 d. Se inicia totInteres en 0 e. Ciclo FOR desde mes = 1 hasta 24 con incrementos de 1 1. Se calcula el interes del mes 2. Se calcula el saldo del mes (capital + interes) 3. Se imprime mes, capital, interes, saldo 4. Se calcula el totInteres con interes 5. El capital se actualiza con saldo f. Fin del FOR g. Se Imprime totInteres h. Fin del método principal


Ejercicio 6.2.14

Similar al anterior, pero ahora el capital, la tasa de interés anual y el plazo son datos que deben leerse. Elaborar un algoritmo que lea dichos datos e imprima el siguiente reporte.

Inversion

Capital: 99,999.99 Interes anual: 999.99% Plazo en meses: 999 Mes Capital Interes Saldo

1 99,999.99 99,999.99 99,999.99 2 99,999.99 99,999.99 99,999.99 . . . N 99,999.99 99,999.99 99,999.99

Total interes ganado: 99,999.99



Algoritmo INVERSION LEYENDO DATOS Clase Interes2 1. Método principal a. Declaraciones Variables mes, plazo: Entero saldo, capital, interes, totInteres, tasaAnual: Real b. Solicitar CAPITAL, TASA INTERES ANUAL, PLAZO c. Leer capital, tasaAnual, plazo d. Imprimir capital, tasaAnual, plazo e. Imprimir encabezado f. totInteres = 0 g. FOR mes=1; mes<=plazo; mes++ 1. interes = capital * (tasaAnual/100/12) 2. saldo = capital + interes 3. Imprimir mes, capital, interes, saldo 4. totInteres = totInteres + interes 5. capital = saldo h. ENDFOR i. Imprimir totInteres j. Fin Método principal Fin Clase Interes2Fin

Explicación:

En el Método principal de la Clase Interes2, se tienen las acciones:

a. Se declaran las variables b. Se Solicita CAPITAL, TASA INTERES ANUAL, PLAZO c. Se leen en capital, tasaAnual, plazo d. Se imprimen capital, tasaAnual, plazo e. Imprime el encabezado f. Se inicia totInteres en 0 g. Ciclo FOR desde mes = 1 hasta plazo, con incrementos de 1 1. Se calcula el interes del mes 2. Se calcula el saldo (capital + interes) 3. Se imprimen mes, capital, interes, saldo 4. Se incrementa totInteres en interes 5. El capital se actualiza con saldo h. Fin del FOR i. Se imprime totInteres j. Fin del método principal



Ejercicio 6.2.15

En una empresa manufacturera de sillas. Se tienen 15 trabajadores, y por cada trabajador los datos:

Nombre del trabajador 1: X------------------------------------------X

Se tiene el dato: cantidad de unidades fabricadas (construidas) en cada uno de los 6 días de la semana.

Día 1 (Cantidad de unidades fabricadas): --- Día 2 (Cantidad de unidades fabricadas): --- Día 3 (Cantidad de unidades fabricadas): --- Día 4 (Cantidad de unidades fabricadas): --- Día 5 (Cantidad de unidades fabricadas): --- Día 6 (Cantidad de unidades fabricadas): ---

Nombre del trabajador 2: X------------------------------------------X Día 1 (Cantidad de unidades fabricadas): --- Día 2 (Cantidad de unidades fabricadas): --- Día 3 (Cantidad de unidades fabricadas): --- Día 4 (Cantidad de unidades fabricadas): --- Día 5 (Cantidad de unidades fabricadas): --- Día 6 (Cantidad de unidades fabricadas): ---------------Nombre del trabajador 15: X------------------------------------------X Día 1 (Cantidad de unidades fabricadas): --- Día 2 (Cantidad de unidades fabricadas): --- Día 3 (Cantidad de unidades fabricadas): --- Día 4 (Cantidad de unidades fabricadas): --- Día 5 (Cantidad de unidades fabricadas): --- Día 6 (Cantidad de unidades fabricadas): ---

Elaborar un algoritmo que lea los datos de cada uno de los trabajadores, y por cada trabajador, la cantidad de unidades fabricadas de cada uno de los 6 días que trabajó e imprima el siguiente reporte:

Reporte Semanal De Produccion

Nombre del trabajador Total Produccion

XXXXXXXXXXXXXXXXXXXXXXXX 9999 XXXXXXXXXXXXXXXXXXXXXXXX 9999 . . XXXXXXXXXXXXXXXXXXXXXXXX 9999

Total 999 Trabajadores 9999


Cálculos:

Se lee el nombre de un trabajador, luego cada una de las cantidades producidas, se suman estas cantidades para calcular TOTAL PRODUCCION; en otras palabras, es la sumatoria de las cantidades producidas de los 6 días que laboró. Al fi nal se pide el TOTAL de trabajadores y el TOTAL del TOTAL PRODUCCION de todos los trabajadores.


Algoritmo TRABAJADORES Clase Trabajadores 1. Método principal a. Declaraciones Variables nombreTra: Cadena t, d, totTrab, proDia, totProd, totProdGral: Entero b. Imprimir encabezado c. totTrab = 0; toTotProd = 0 d. FOR t=1; t<=15; t++ 1. Solicitar NOMBRE 2. Leer nombreTra 3. totProd = 0 4. FOR d=1; d<=6; d++ a. Solicitar PRODUCCION DEL DIA b. Leer proDia c. totProd = totProd + proDia 5. ENDFOR 6. Imprimir nombreTra, totProd 7. toTotProd = toTotProd + totProd totTrab = totTrab + 1 e. ENDFOR f. Imprimir totTrab, toTotProd g. Fin Método principal Fin Clase TrabajadoresFin

Explicación:

En el Método principal de la Clase Trabajadores, se tienen las acciones:

a. Se declaran las variables b. Se imprime el encabezado c. Se inicia totTrab = 0; toTotProd = 0 d. Inicia ciclo FOR desde t = 1 hasta 15 con incrementos de 1 1. Se solicita el NOMBRE 2. Se lee en nombreTra


3. Se inicia totProd = 0 4. Inicia ciclo FOR desde d = 1 hasta 6 con incrementos de 1 a. Se solicita PRODUCCION DEL DIA b. Se lee en proDia c. Se incrementa totProd con proDia 5. Fin del FOR 6. Imprime nombreTra, totProd 7. Se incrementa toTotProd con totProd Se incrementa totTrab en 1 e. Fin del FOR f. Imprime totTrab, toTotProd g. Fin del método principal


Nota:Observe que este problema se resuelve utilizando dos ciclos FOR; un primer ciclo que permite procesar varios obreros. Al procesar cada obrero, después de leer su nombre, se deben procesar seis días de trabajo, para lo cual, se utiliza un segundo ciclo FOR. Además observe que no todos los contadores y acumuladores se inician en cero en el mismo lugar; antes del primer ciclo se inician los contadores y acumuladores que se imprimirán hasta el fi nal del reporte, como son totTrab y toTotProd; los contadores y acumuladores que se usarán o imrimirán en el detalle del reporte como es el totProd, se inicia en cero antes del segundo ciclo (pero adentro del primer ciclo), que se incrementa adentro del segundo ciclo con proDia y que se imprime afuera del segundo ciclo, pero adentro del primer ciclo.

Ejercicio 6.2.16

Se tienen varios vendedores, por cada vendedor los datos: nombre y la cantidad vendida (en dinero) de cada uno de los 6 días de la semana. Elaborar un algoritmo que lea dichos datos e imprima el reporte:

Reporte Semanal Ventas

Nombre del vendedor Venta semanal Dia de mayor venta

XXXXXXXXXXXXXXXXXXXXX 999,999.99 99 XXXXXXXXXXXXXXXXXXXXX 999,999.99 99 . . . XXXXXXXXXXXXXXXXXXXXX 999,999.99 99

Total 999 vendedores 999,999.99

Se lee el nombre del vendedor, luego la venta que hizo en cada uno de los 6 días de la semana, se suman para calcular la VENTA SEMANAL, el DIA DE MAYOR VENTA se


determina comparando la venta de los 6 días entre sí, obteniendo el día que tuvo la mayor venta. Al fi nal se pide el total de vendedores y el total general de venta semanal.


Algoritmo VENDEDORES MAYOR VENTA DIA Clase Vendedores3 1. Método principal a. Declaraciones Variables nombreVend: Cadena otro: Carácter totVend, dia, mejorDia: Entero ventaDia, totVenta, totVentaGral, mayorVenta: Real b. Imprimir encabezado c. totVend = 0; totVentaGral = 0 d. DO 1. Solicitar NOMBRE 2. Leer nombreVend 3. totVenta = 0; mayorVenta = 0 4. FOR dia=1; dia<=6; dia++ a. Solicitar VENTA DEL DIA b. Leer ventaDia c. totVenta = totVenta + ventaDia d. IF ventaDia > mayorVenta THEN 1. mayorVenta = ventaDia 2. mejorDia = dia e. ENDIF 5. ENDFOR 6. Imprimir nombreVend, totVenta, mejorDia 7. totVentaGral = totVentaGral + totVenta totVend = totVend + 1 8. Preguntar “¿HAY OTRO VENDEDOR (S/N)?” 9. Leer otro e. WHILE otro = “S” f. Imprimir totVend, totVentaGral g. Fin Método principal Fin Clase Vendedores3Fin

Explicación:

En el Método principal de la Clase Vendedores3, se tienen las acciones:

a. Se declaran las variables b. Se imprime el encabezado c. Se inician totVend = 0; totVentaGral = 0


d. Inicia ciclo DO 1. Solicita el NOMBRE 2. Se lee en nombreVend 3. Se inicia totVenta = 0; mayorVenta = 0 4. Inicia FOR desde dia = 1 hasta 6 con incrementos de 1 a. Se solicita VENTA DEL DIA b. Se lee ventaDia c. Se incrementa totVenta con ventaDia d. Si acaso ventaDia > mayorVenta entonces 1. Coloca en mayorVenta la ventaDia 2. Coloca en mejorDia el dia e. Fin del IF 5. Fin del FOR 6. Imprime nombreVend, totVenta, mejorDia 7. Incrementa totVentaGral con totVenta Incrementa totVend en 1 8. Pregunta “¿HAY OTRO VENDEDOR (S/N)?” 9. Se lee en otro la respuesta e. Fin ciclo (WHILE otro = “S”) f. Imprime totVend, totVentaGral g. Fin del método principal


Nota:Observe que este problema se resuelve con dos ciclos; un primer ciclo DO…WHILE, porque se procesarán varios vendedores; y un segundo ciclo FOR, porque dentro del proceso de un vendedor, se procesarán 6 días de venta.

Ejercicio 6.2.17

Elaborar un algoritmo similar al Ejercicio 5.2.5, con la diferencia de que ahora se tienen 15 obreros y cada obrero trabajó varios días.


Algoritmo OBREROS Clase Obreros2 1. Método principal a. Declaraciones Variables nombreObr, obrMayor, obrMenor: Cadena proDia, totProd, toTotProd, totObreros, i, mayorProd, menorProd: Entero otro: Carácter b. Imprimir encabezado


c. totObreros = 0 toTotProd = 0 mayorProd = 0 menorProd = 10000 d. FOR i=1; i<=15; i++ 1. Solicitar Nombre 2. Leer nombreObr 3. totProd = 0 4. DO a. Solicitar Producción del dia b. Leer proDia c. totProd = totProd + proDia d. Preguntar “¿Desea procesar otro dia (S/N)?” e. Leer otro 5. WHILE otro = “S” 6. Imprimir nombreObr, totProd 7. IF totProd > mayorProd THEN a. mayorProd = totProd b. obrMayor = nombreObr 8. ENDIF 9. IF totProd < menorProd THEN a. menorProd = totProd b. obrMenor = nombreObr 10. ENDIF 11. totObreros = totObreros + 1 toTotProd = toTotProd + totProd e. ENDFOR f. Imprimir totObreros, toTotProd, obrMayor, mayorProd, obrMenor, menorProd g. Fin Método principal Fin Clase Obreros2Fin

Explicación:

Lo que cambia es el primer ciclo, que en el ejercicio 5.2.5 se había hecho con DO…WHILE usando la pregunta y leer desea, ahora se resuelve con FOR usando la variable i para controlar el proceso de los 15 obreros.

Ejercicio 6.2.18

Elaborar un algoritmo similar al Ejercicio 5.2.5, con la diferencia de que ahora se tienen varios obreros y cada obrero trabajó 6 días.



Algoritmo OBREROS Clase Obreros3 1. Método principal a. Declaraciones Variables nombreObr, obrMayor, obrMenor: Cadena proDia, totProd, toTotProd, totObreros, i, mayorProd, menorProd: Entero desea: Carácter b. Imprimir encabezado c. totObreros = 0 toTotProd = 0 mayorProd = 0 menorProd = 10000 d. DO 1. Solicitar Nombre 2. Leer nombreObr 3. totProd = 0 4. FOR i=1; i<=6; i++ a. Solicitar Producción del dia b. Leer proDia c. totProd = totProd + proDia 5. ENDFOR 6. Imprimir nombreObr, totProdObr 7. IF totProd > mayorProd THEN a. mayorProd = totProd b. obrMayor = nombreObr 8. ENDIF 9. IF totProd < menorProd THEN a. menorProd = totProd b. obrMenor = nombreObr 10. ENDIF 11. totObreros = totObreros + 1 toTotProd = toTotProd + totProd 12. Preguntar “¿Desea procesar otro obrero (S/N)?” 13. Leer desea e. WHILE desea = “S” f. Imprimir totObreros, toTotProd, obrMayor, mayorProd, obrMenor, menorProd g. Fin Método principal Fin Clase Obreros3Fin


Explicación:

Lo que cambia es el segundo ciclo, que en el ejercicio 5.2.5 se había hecho con DO…WHILE usando la pregunta y leer otro, ahora se resuelve con FOR usando la variable i para controlar el proceso de los 6 días.


Ejercicio 6.3.2

Elaborar un algoritmo similar al Ejercicio 6.2.6, utilizando DO…WHILE en lugar de FOR.

Algoritmo EQUIVALENCIAS FAHRENHEIT CELSIUS Clase EquivalenciasFahr2 1. Método principal a. Declaraciones Variables fahrenheit, celsius: Real b. Imprimir encabezado c. fahrenheit = 0 d. DO 1. fahrenheit = fahrenheit + 1 2. celsius = (fahrenheit-32)*(5/9) 3. Imprimir fahrenheit, celsius e. WHILE fahrenheit < 65 f. Fin Método principal Fin Clase EquivalenciasFahr2Fin

Ejercicio 6.3.3


Algoritmo FACTORIALES DE N NUMEROS Clase Factoriales2 1. Método principal a. Declaraciones Variables n, i, j, fact, num: Entero b. Solicitar Cantidad de números a calcular factorial c. Leer n d. j = 0 e. DO 1. j = j + 1 2. Solicitar Número


3. Leer num 4. IF num = 0 THEN a. fact = 1 5. ELSE a. fact = 1 b. FOR i=num; i>=1; i-- 1. fact = fact * i c. ENDFOR 6. ENDIF 7. Imprimir fact f. WHILE j < n g. Fin Método principal Fin Clase Factoriales2Fin

Ejercicio 6.3.4


Algoritmo ECUACION CUADRATICA PARA A DE 1-5 Clase Cuadratica3 1. Método principal a. Declaraciones Variables a, b, c, raizUnica, parteReal, parteImaginaria, raizReal1, raizReal2: Real b. Imprimir encabezado c. c = 6 d. a = 0 e. DO 1. a = a + 1 2. c = c - a 3. b = a - c 4. Imprimir a, b, c 5. IF (Potencia(b,2)-4*a*c) = 0 THEN a. raizUnica = -b/(2*a) b. Imprimir “RAIZ UNICA ”, raizUnica 6. ELSE a. IF (Potencia(b,2)-4*a*c) < 0 THEN 1. parteReal = -b/(2*a) 2. parteImaginaria = RaizCuad(Absoluto(Potencia(b,2)- 4*a*c))/(2*a) 3. Imprimir “RAICES COMPLEJAS” 4. Imprimir parteReal,“+”,parteImaginaria,“i” 5. Imprimir parteReal,“-”,parteImaginaria,“i”


b. ELSE 1. raizReal1 = (-b+RaizCuad(Potencia(b,2)-4*a*c))/(2*a) 2. raizReal2 = (-b-RaizCuad(Potencia(b,2)-4*a*c))/(2*a) 3. Imprimir “RAICES REALES” 4. Imprimir raizReal1, raizReal2 c. ENDIF 7. ENDIF f. WHILE a < 5 g. Fin Método principal Fin Clase Cuadratica3Fin

Capítulo 7


Ejercicio 7.3.3

Una compañía manufacturera fabrica el producto A. Para fabricar una unidad de dicho producto se requieren los siguientes materiales:

Material 1: 3 unidades Material 2: 4 unidades Material 3: 1 unidades Material 4: 2 unidades Material 5: 3 unidades Material 6: 2 unidades

Elaborar un algoritmo que lea pedidos del producto A, en cada pedido se tiene el dato cantidad de unidades del producto A; cuando termine de leer los pedidos, imprimir:

Listado de materiales requeridos

Material Total de unidades

1 999 2 999 3 999 4 999 5 999 6 999


Algoritmo MATERIAL REQUERIDO Clase Materiales 1. Método principal


a. Declaraciones Variables resp: Carácter material1, material2, material3, material4, material5, material6, cantidad, totProd: Entero b. totProd = 0 c. Preguntar “¿HAY PEDIDO (S/N)?” d. Leer resp e. WHILE resp = “S” 1. Solicitar Cantidad pedida 2. Leer cantidad 3. totProd = totProd + cantidad 4. Preguntar “¿HAY OTRO PEDIDO (S/N)?” 5. Leer resp f. ENDWHILE g. material1 = totProd * 3 material2 = totProd * 4 material3 = totProd * 1 material4 = totProd * 2 material5 = totProd * 3 material6 = totProd * 2 h. Imprimir encabezado i. Imprimir 1, material1, 2, material2, 3, material3, 4, material4, 5, material5, 6, material6 j. Fin Método principal Fin Clase MaterialesFin

Explicación:

En el Método principal de la Clase Materiales, se tienen las acciones:

a. Se declaran las variables b. Inicia totProd en 0 c. Pregunta “¿HAY PEDIDO (S/N)?” d. Lee en resp la respuesta e. Inicia ciclo WHILE mientras resp es igual a “S”; entra al ciclo 1. Solicita cantidad pedida 2. Lee en cantidad 3. Incrementa totProd en cantidad 4. Pregunta “¿HAY OTRO PEDIDO (S/N)?” 5. Lee en resp la respuesta f. Fin del ciclo WHILE


g. Calcula material1 = totProd * 3 material2 = totProd * 4 material3 = totProd * 1 material4 = totProd * 2 material5 = totProd * 3 material6 = totProd * 2 h. Imprime encabezado i. Imprime 1, material1, 2, material2, 3, material3, 4, material4, 5, material5, 6, material6 j. Fin del método principal


Nota:El ciclo que procesa los pedidos, sólo puede resolverse con WHILE porque la repetición que se presenta puede ir desde 0 (cero) hasta cualquier cantidad de pedidos.

Ejercicio 7.3.4

En una compañía manufacturera se tienen 10 máquinas, y hay 7 tipos de mantenimiento correctivo que se les aplican. Se tienen los datos:

Máquina 1 Mantenimiento tipo: -- Mantenimiento tipo: -- . Mantenimiento tipo: --

Máquina 2 Mantenimiento tipo: -- Mantenimiento tipo: -- . Mantenimiento tipo: -- ----- ----- ----- Máquina 10 Mantenimiento tipo: -- Mantenimiento tipo: -- . Mantenimiento tipo: --


Para cada máquina se pueden tener cualquier cantidad (incluso cero) de mantenimientos, teniendose como dato la identificación del tipo de mantenimiento (1,2,3,4,5,6,7). Elaborar un algoritmo que lea dichos datos e imprima el reporte:

Reporte de mantenimiento

Maquina Total de mantenimientos

1 9999 2 9999 . . 10 9999

Total mantenimientos 9999

Total tipo 1: --- Total tipo 2: --- Total tipo 3: --- Total tipo 4: --- Total tipo 5: --- Total tipo 6: --- Total tipo 7: ---


Algoritmo MANTENIMIENTO MAQUINAS Clase Maquinas 1. Método principal a. Declaraciones Variables hay: Carácter totManten, cantManten, tipo, maquina, toTipo1, toTipo2, toTipo3, toTipo4, toTipo5, toTipo6, toTipo7: Entero b. Imprimir encabezado c. totManten = 0; toTipo1 = 0; toTipo2 = 0; toTipo3=0; toTipo4 = 0; toTipo5 = 0; toTipo6 = 0; toTipo7 = 0; d. FOR maquina=1; maquina<=10; maquina++ 1. cantManten = 0 2. Preguntar “¿HAY MANTENIMIENTO (S/N)?” 3. Leer hay 4. WHILE hay = “S” a. Solicitar Tipo de mantenimiento b. Leer tipo c. cantManten = cantManten + 1 d. SWITCH tipo 1: toTipo1 = toTipo1 + 1


2: toTipo2 = toTipo2 + 1 3: toTipo3 = toTipo3 + 1 4: toTipo4 = toTipo4 + 1 5: toTipo5 = toTipo5 + 1 6: toTipo6 = toTipo6 + 1 7: toTipo7 = toTipo7 + 1 e. ENDSWITCH f. Preguntar “¿HAY OTRO MANTENIMIENTO(S/N)?” g. Leer hay 5. ENDWHILE 6. Imprimir maquina, cantManten 7. totManten = totManten + cantManten e. ENDFOR f. Imprimir totManten, toTipo1, toTipo2, toTipo3, toTipo4, toTipo5, toTipo6, toTipo7 g. Fin Método principal Fin Clase MaquinasFin

Explicación:

En el Método principal de la Clase Maquinas, se tienen las acciones:

a. Se declaran las variables b. Imprime encabezado c. Inicia totManten en 0; toTipo1 en 0; toTipo2 en 0; toTipo3 en 0; toTipo4 en 0; toTipo5 en 0; toTipo6 en 0; toTipo7 en 0; d. Inicia ciclo FOR desde maquina = 1 hasta 10 con incrementos de 1 1. Inicia cantManten en 0 2. Pregunta “¿HAY MANTENIMIENTO (S/N)?” 3. Lee en hay la respuesta 4. Inicia ciclo WHILE mientras hay = “S”; entra al ciclo a. Solicita tipo de mantenimiento b. Lee en tipo c. Incrementa cantManten en 1 d. Casos (SWITCH) Si tipo es 1: Incrementa toTipo1 en 1 Si tipo es 2: Incrementa toTipo2 en 1 Si tipo es 3: Incrementa toTipo3 en 1 Si tipo es 4: Incrementa toTipo4 en 1 Si tipo es 5: Incrementa toTipo5 en 1 Si tipo es 6: Incrementa toTipo6 en 1 Si tipo es 7: Incrementa toTipo7 en 1 e. Fin del SWITCH f. Pregunta “¿HAY OTRO MANTENIMIENTO (S/N)?” g. Lee en hay la respuesta


5. Fin del ciclo WHILE 6. Imprime maquina, mantManten 7. Incrementa totManten con cantManten e. Fin ciclo FOR f. Imprime totManten, toTipo1, toTipo2, toTipo3, toTipo4, toTipo5, toTipo6, toTipo7 g. Fin del método principal


Nota:El ciclo que procesa los mantenimientos, sólo puede resolverse con WHILE porque la repetición que se presenta puede ir desde 0 (cero) hasta cualquier cantidad de mantenimientos.

Ejercicio 7.3.5

En una fábrica se tienen 10 estaciones de trabajo, y la producción hecha en número de unidades fabricadas en cada uno de los días de la semana; cada estación pudo haber trabajado cualquier cantidad de días en la semana.

Estación 1: Producción dia: --- Producción dia: --- . . Producción dia: ---



También se tiene un dato que es el nivel de productividad.

Elaborar un algoritmo que lea el nivel de productividad, y los datos de la produc-ción de cada una de las estaciones, e imprima el siguiente reporte:



Estacion Total produccion Nivel productividad 1 999 Deficiente 2 999 Bueno 3 ----- . ----- . ----- 10 999 Excelente

Total 999

TOTAL PRODUCCION es la sumatoria de la producción de los días laborados.NIVEL PRODUCTIVIDAD es un comentario que indica DEFICIENTE, BUENO o EXCELENTE si el TOTAL PRODUCCION es menor, es igual o es mayor al nivel de productividad respectivamente.TOTAL es el total del TOTAL PRODUCCION de todas las estaciones de trabajo.


Algoritmo ESTACIONES DE TRABAJO Clase Estaciones1 1. Método principal a. Declaraciones Variables observacion: Cadena hay: Carácter estacion, proDia, totProd, nivProductividad, toTotProd: Entero b. Imprimir encabezado c. toTotProd = 0 d. Solicitar Nivel de productividad e. Leer nivProductividad f. FOR estacion=1; estacion<=10; estacion++ 1. totProd = 0 2. Preguntar “¿HAY DIA DE PRODUCCION (S/N)?” 3. Leer hay 4. WHILE hay = “S” a. Solicitar Producción del día b. Leer proDia c. totProd = totProd + proDia d. Preguntar “¿HAY DIA DE PRODUCCION (S/N)?” e. Leer hay 5. ENDWHILE 6. IF totProd < nivProductividad THEN a. observacion = “DEFICIENTE”


7. ELSE a. IF totProd = nivProductividad THEN 1. observacion = “BUENO” b. ELSE 1. observacion = “EXCELENTE” c. ENDIF 8. ENDIF 9. Imprimir estacion, totProd, observacion 10. toTotProd = toTotProd + totProd g. ENDFOR h. Imprimir toTotProd i. Fin Método principal Fin Clase Estaciones1Fin

Explicación:

En el Método principal de la Clase Estaciones1, se tienen las acciones:

a. Se declaran las variables b. Imprime encabezado c. Inicia toTotProd en 0 d. Solicita Nivel de productividad e. Se lee en nivProductividad f. Inicia ciclo FOR desde estacion = 1 hasta 10 con incrementos de 1 a. Inicia totProd en 0 b. Pregunta “¿HAY DIA DE PRODUCCION (S/N)?” c. Lee en hay la respuesta d. Inicia ciclo WHILE mientras hay = “S”; entra al ciclo 1. Solicita Producción del día 2. Lee en proDia 3. Incrementa totProd con proDia 4. Pregunta “¿HAY DIA DE PRODUCCION (S/N)?” 5. Lee en hay la respuesta e. Fin del ciclo WHILE f. Si totProd < nivProductividad entonces 1. Coloca “DEFICIENTE” en observacion g. Si no 1. Si totProd = nivProductividad entonces a. Coloca “BUENO” en observacion 2. Si no a. Coloca “EXCELENTE” en observacion 3. Fin del IF h. Fin del IF i. Imprime estacion, totProd, observacion j. Incrementa toTotProd con totProd g. Fin del FOR


h. Imprime toTotProd i. Fin del método principal


Ejercicio 7.3.6

Similar al ejercicio anterior, con la diferencia de que ahora se tienen varias estaciones de trabajo. Por cada estación se tiene el número de identificación y la producción de cada uno de los días de la semana que trabajó. Elaborar un algoritmo que lea los datos e imprima el reporte ya conocido, pero al final que imprima la estación más productiva (suponiendo que no habrá dos estaciones con el total producción igual) y cuánto fue su producción.


Algoritmo ESTACIONES DE TRABAJO Clase Estaciones2 1. Método principal a. Declaraciones Variables observacion: Cadena otra, hay: Carácter estacion, proDia, totProd, nivProductividad, toTotProd, estacionMayor, prodMayor: Entero b. Imprimir encabezado c. toTotProd = 0; prodMayor = 0 d. Solicitar Nivel de productividad e. Leer nivProductividad f. DO 1. totProd = 0 2. Solicitar Número de estación de trabajo 3. Leer estacion 4. Preguntar “¿HAY DIA DE PRODUCCION (S/N)?” 5. Leer hay 6. WHILE hay = “S” a. Solicitar Producción del día b. Leer proDia c. totProd = totProd + proDia d. Preguntar “¿HAY DIA DE PRODUCCION (S/N)?” e. Leer hay 7. ENDWHILE 8. IF totProd < nivProductividad THEN a. observacion = “DEFICIENTE” 9. ELSE a. IF totProd = nivProductividad THEN 1. observacion = “BUENO” b. ELSE


1. observacion = “EXCELENTE” c. ENDIF 10. ENDIF 11. Imprimir estacion, totProd, observacion 12. IF totProd > prodMayor THEN a. prodMayor = totProd b. estacionMayor = estacion 13. ENDIF 14. toTotProd = toTotProd + totProd 15. Preguntar “¿HAY OTRA ESTACION (S/N)?” 16. Leer otra g. WHILE otra = “S” h. Imprimir toTotProd, estacionMayor, prodMayor i. Fin Método principal Fin Clase Estaciones2Fin

Explicación:

En el Método principal de la Clase Estaciones2, se tienen las acciones:

a. Se declaran las variables b. Imprime encabezado c. Inicia toTotProd en 0; prodMayor en 0 d. Solicita nivel de productividad e. Lee en nivProductividad f. Inicia ciclo DO 1. Inicia totProd en 0 2. Solicita número de estación de trabajo 3. Lee en estacion 4. Pregunta “¿HAY DIA DE PRODUCCION (S/N)?” 5. Lee en hay la respuesta 6. Inicia ciclo WHILE mientras hay = “S”; entra al ciclo a. Solicita producción del día b. Lee en proDia c. Incrementa totProd con proDia d. Pregunta “¿HAY DIA DE PRODUCCION (S/N)?” e. Lee en hay la respuesta 7. Fin del ciclo WHILE 8. Si totProd < nivProductividad entonces a. Coloca en observacion “DEFICIENTE” 9. Si no a. Si totProd = nivProductividad entonces 1. Coloca en observacion “BUENO” b. Si no 1. Coloca en observacion “EXCELENTE” c. Fin del IF


10. Fin del IF 11. Imprime estacion, totProd, oservacion 12. Si totProd > prodMayor entonces a. Coloca totProd en prodMayor b. Coloca estacion en estacionMayor 13. Fin del IF 14. Incrementa toTotProd con totProd 15. Pregunta “¿HAY OTRA ESTACION (S/N)?” 16. Lee otra la respuesta g. Fin del DO…WHILE mientras otra = “S” vuelve al DO, si no se sale del ciclo h. Imprime toTotProd, estacionMayor, prodMayor i. Fin del método principal


Ejercicio 7.3.7

Elaborar un algoritmo que imprima los valores de X, Y, y Z. Y y Z son valores dependientes de X; X deberá tomar valores desde 0.5 hasta 10 con incrementos de 0.5. Para cada valor de X, los valores de Y y Z se calculan con las siguientes ecuaciones:

Y = 3X² + 7X -15 Z = Y - 2X²

Debe imprimir el reporte:

Valores de X Y Z

X Y Z

99.99 99.99 99.99 99.99 99.99 99.99 -- -- 99.99 99.99 99.99

Nota:Este es un problema tipo FOR porque se conoce cuántas veces se debe repetir el ciclo, sin embargo, debido a que hay lenguajes en los que la variable de control del FOR sólo funciona con valores tipo entero; no es posible resolverlo con FOR, la solución debe hacerse con WHILE o con DO…WHILE.

Solución con WHILE:


Algoritmo VALORES X Y Z Clase ValoresXYZ1 1. Método principal


a. Declaraciones Variables x, y, z: Real b. Imprimir encabezado c. x = 0 d. WHILE x < 10 1. x = x + 0.5 2. y = 3*(x^2) + 7*x - 15 3. z = y - 2*(x^2) 4. Imprimir x, y, z e. ENDWHILE f. Fin Método principal Fin Clase ValoresXYZ1Fin

Explicación:

En el Método principal de la Clase ValoresXYZ1, se tienen las acciones:

a. Se declaran las variables b. Imprime encabezado del reporte c. Se inicia x en 0 d. Inicia ciclo WHILE pregunta si x es menor que 10 si es así, entra al ciclo 1. Incrementa x en 0.5 2. Calcula y 3. Calcula z 4. Imprime x, y, z e. Fin del ciclo WHILE f. Fin del método principal


Solución con DO…WHILE:


Algoritmo VALORES X Y Z Clase ValoresXYZ2 1. Método principal a. Declaraciones Variables x, y, z: Real b. Imprimir encabezado c. x = 0 d. DO 1. x = x + 0.5 2. y = 3*(x^2) + 7*x - 15 3. z = y - 2*(x^2)


4. Imprimir X, Y, Z e. WHILE x < 10 f. Fin Método principal Fin Clase ValoresXYZ2Fin

Explicación:


a. Se declaran las variables b. Imprime encabezado c. Se inicia x en 0 d. Inicia ciclo DO 1. Se incrementa x en 0.5 2. Se calcula y 3. Se calcula z 4. Imprime x, y, z e. Fin ciclo WHILE si x es menor que 10 regresa al DO; si no se sale del ciclo f. Fin del método principal


Solución con FOR:

Para lenguajes que aceptan variables tipo real en la variable de control del ciclo FOR:


Algoritmo VALORES X Y Z Clase ValoresXYZ3 1. Método principal a. Declaraciones Variables x, y, z: Real b. Imprimir encabezado c. FOR x=0; x<=10; x=x+0.5 1. y = 3*(x^2) + 7*x - 15 2. z = y - 2*(x^2) 3. Imprimir x, y, z d. ENDFOR e. Fin Método principal Fin Clase ValoresXYZ3Fin

Explicación:



a. Se declaran las variables b. Imprime encabezado c. Inicia ciclo FOR desde x = 0 hasta 10 con incrementos de 0.05 1. Calcula y 2. Calcula z 3. Imprime x, y, z d. Fin del ciclo FOR e. Fin del método principal


Ejercicio 7.3.8

Elaborar un algoritmo para enlistar los números pares entre 0 y 20.


Algoritmo IMPRIME PARES 0-20 Clase Pares 1. Método principal a. Declaraciones Variables i: Entero b. i = 0 c. WHILE i <= 20 1. Imprimir i 2. i = i + 2 d. ENDWHILE e. Fin Método principal Fin Clase ParesFin

Explicación:

En el Método principal de la Clase Pares, se tienen las acciones:

a. Se declaran las variables b. Inicia i en 0 c. Inicia ciclo WHILE se pregunta si i <= 20, si es así, entra al ciclo 1. Imprime i 2. Incrementa i en 2 d. Fin del ciclo WHILE e. Fin del método principal


Ejercicio 7.3.9

Elaborar un algoritmo capaz de leer un valor entero positivo y que determine e imprima si este valor es par o impar.



Algoritmo PAR IMPAR Clase ParImpar 1. Método principal a. Declaraciones Variables numero, residuo: Entero b. Solicitar el número c. Leer numero d. residuo = numero e. WHILE residuo > 1 1. residuo = residuo - 2 f. ENDWHILE g. IF residuo = 0 THEN 1. Imprimir numero, “ES PAR” h. ELSE 1. Imprimir numero, “ES IMPAR” i. ENDIF j. Fin Método principal Fin Clase ParImparFin

Explicación:

En el Método principal de la Clase ParImpar, se tienen las acciones:

a. Se declaran las variables b. Se solicita el número c. Se lee en numero d. Se inicia residuo con numero e. Inicia ciclo WHILE compara si residuo > 1; si se cumple, entra al ciclo 1. Le resta (quita) 2 a residuo f. Fin del ciclo WHILE g. Si residuo = 0 entonces 1. Imprime numero, “ES PAR” h. Si no (ELSE) 1. Imprime numero, “ES IMPAR” i. Fin del IF j. Fin del método principal


Nota:Este problema sólo puede resolverse con WHILE porque la repetición que se presenta puede ir desde 0 (cero) hasta N veces.

Capítulo 8

8.1.1 Ejercicios resueltos para unidimensionales (Continuación…)

Ejercicio 8.1.1.4

Elaborar un algoritmo que permita leer 15 números en un arreglo de 15 elementos; calcular la media, imprimir cada elemento del arreglo y la desviación que tiene respecto a la media de la siguiente forma:

Elemento Desviacion

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

Media = ---

Cálculos:

r MEDIA se obtiene la sumatoria de los 15 elementos del arreglo y se divide entre 15.r DESVIACION de cada elemento se obtiene restándole al elemento la MEDIA.


Algoritmo DESVIACION DE MEDIA Clase DesviacionMedia 1. Método principal a. Declaraciones Variables numeros: Arreglo[15] Entero r, sumatoria: Entero media, desviacion: Real


b. sumatoria = 0 c. FOR r=0; r<=14; r++ 1. Solicitar numero r+1 2. Leer numeros[r] 3. sumatoria = sumatoria + numeros[r] d. ENDFOR e. media = sumatoria / r f. Imprimir encabezado g. FOR r=0; r<=14; r++ 1. desviacion = numeros[r] - media 2. Imprimir numeros[R], desviacion h. ENDFOR i. Imprimir media j. Fin Método principal Fin Clase DesviacionMediaFin

Explicación:

En el Método principal de la Clase DesviacionMedia, se tienen las acciones:

a. Se declaran las variables b. Inicia sumatoria en 0 c. Inicia ciclo FOR desde r=0 hasta 14 1. Solicita numero r 2. Se lee en numeros[r] 3. Incrementa sumatoria con numeros[r] d. Fin del FOR e. Calcula media = sumatoria / r f. Imprime encabezado g. Inicia ciclo FOR desde r=0 hasta 14 1. Calcula desviacion = numeros[r] - media 2. Imprime numeros[r], desviacion h. Fin del FOR i. Imprime media j. Fin del Método principal


Ejercicio 8.1.1.5

Elaborar un algoritmo que lea el nombre de un obrero y las unidades producidas por éste los 30 días del mes y que, además, imprima el siguiente reporte:

Nombre del obrero : XXXXXXXXXXXXXXXXXXXXXXXXXXXXX Producción del día 1 : 999 Producción del día 2 : 999 .

Ejercicios resueltos para unidimensionales (Continuación...) 8-3

. . Producción del día 30: 999

Promedio de producción : 999.99 Total de días arriba del promedio : 99 Cantidad producida más alta : 999 Día más productivo : 99

Cálculos:

r Promedio de producción. Se calcula mediante la suma de todos los días de producción dividido entre 30.

r Total de días arriba del promedio. Es el total de días en que la producción fue mayor que el promedio. Se compara la producción de cada día con el promedio y se cuentan sólo los días cuya producción es mayor que éste.

r Cantidad producida más alta. Comparar la producción de todos los días para determinar la que es mayor; se supone que son diferentes.

r Día más productivo. El número de día al que corresponda la cantidad producida más alta.


Algoritmo PRODUCCION PROMEDIO Clase ProduccionObrero 1. Método principal a. Declaraciones Variables nombreObr: Cadena produccion: Arreglo[30] Entero i, totArriba, sumaProd, diaMayor, prodMayor: Entero promedio: Real b. sumaProd = 0 c. Solicitar nombre del obrero d. Leer nombreObr e. FOR i=0; i<=29; i++ 1. Solicitar producción del día i+1 2. Leer produccion[i] 3. sumaProd = sumaProd + produccion[i] f. ENDFOR g. promedio = sumaProd / 30 h. totArriba = 0 i. prodMayor = 0 j. Imprimir nombreObr k. FOR i=0; i<=29; i++ 1. Imprimir produccion[i] 2. IF produccion[i] > promedio THEN


a. totArriba = totArriba + 1 3. ENDIF 4. IF produccion[i] > prodMayor THEN a. prodMayor = produccion[i] b. diaMayor = i 5. ENDIF l. ENDFOR m. Imprimir promedio, totArriba, prodMayor, diaMayor n. Fin Método principal Fin Clase ProduccionObreroFin

Explicación:

En el Método principal de la Clase ProduccionObrero, se tienen las acciones:

a. Se declaran las variables b. Se inicia sumaProd en 0 c. Solicita nombre del obrero d. Se lee en nombreObr e. Inicia ciclo FOR desde i=0 hasta 29 con incrementos de 1 1. Solicita producción del día i+1 2. Se lee en produccion[i] 3. Incrementa sumaProd con produccion[i] f. Fin del FOR g. Calcula promedio = sumaProd / 30 h. Inicia totArriba en 0 i. Inicia prodMayor en 0 j. Imprime nombreObr k. Inicia ciclo FOR desde i=0 hasta 29 con incrementos de 1 1. Imprime produccion[i] 2. Si produccion[i] > promedio entonces a. Incrementa totArriba en 1 3. Fin del IF 4. Si produccion[i] > prodMayor entonces a. Coloca produccion[i] en prodMayor b. Coloca i en diaMayor 5. Fin del IF l. Fin del FOR m. Imprime promedio, totArriba, prodMayor, diaMayor n. Fin del Método principal


Ejercicio 8.1.1.6

Elaborar un algoritmo que permita leer 10 números en un arreglo. A continuación preguntar si desea introducir un nuevo valor, si es así, debe leer el nuevo valor y meterlo en


la posición 0 del arreglo y todos los demás recorrerlos a la siguiente posición. El elemento de la posición 9 se perderá, es decir, saldrá del arreglo, porque el valor que se introduce “empuja” a los demás. Enseguida debe imprimirse todo el arreglo. Esto deberá repetirse mientras desee introducir un nuevo valor.


Algoritmo FILA DE DATOS Clase Fila 1. Método principal a. Declaraciones Variables fi la: Arreglo [10] Entero i, valor: Entero desea: Carácter b. FOR i=0; i<=9; i++ 1. Solicitar elemento i de la fi la 2. Leer fi la[i] c. ENDFOR d. Preguntar “¿Desea introducir valor (S/N)?” e. Leer desea f. WHILE desea = “S” 1. Se solicita el valor a introducir 2. Leer valor 3. FOR i=9; i>=1; i-- a. fi la[i+1] = fi la[i] 4. ENDFOR 5. fi la[0] = valor 6. FOR i=0; i<=9; i++ a. Imprimir fi la[i] 7. ENDFOR 8. Preguntar “¿Desea introducir el valor (S/N)?” 9. Leer desea g. ENDWHILE h. Fin Método principal Fin Clase FilaFin

Explicación:

En el Método principal de la Clase Fila, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde i=0 hasta 9 con incrementos de 1 1. Solicita elemento i de la fi la 2. Se lee en fi la[i] c. Fin del FOR


d. Pregunta “¿Desea introducir valor (S/N)?” e. Lee en desea la respuesta f. Inicia ciclo WHILE Si desea=“S” entonces 1. Se solicita el valor a introducir 2. Se lee en valor 3. Inicia ciclo FOR desde i=9 hasta 1 con decrementos de -1 a. Coloca fila[i] en fila[i+1] 4. Fin del FOR 5. Coloca valor en fila[0] 6. Inicia ciclo FOR desde i=0 hasta 9 con incrementos de 1 a. Imprime fila[i] 7. Fin del FOR 8. Pregunta “¿Desea introducir el valor (S/N)?” 9. Se leeen desea la respuesta g. Fin del WHILE h. Fin del Método principal


Ejercicio 8.1.1.7

Elaborar un algoritmo que lea 20 números enteros en un arreglo, que imprima el arreglo, el número mayor y cuántos elementos hay de éste número.


Algoritmo MAYOR 20 NUMEROS Clase Mayor20Numeros 1. Método principal a. Declaraciones Variables numeros: Arreglo[20] Entero r, mayor, totIguales: Entero b. FOR r=0; r<=19; r++ 1. Solicitar numero r 2. Leer numeros[r] c. ENDFOR d. FOR r=0; r<=19; r++ 1. Imprimir numeros[r] e. ENDFOR f. mayor = numeros[0] g. totIguales = 1 h. FOR r=1; r<=19; r++ 1. IF numeros[r] > mayor THEN a. mayor = numeros[r] b. totIguales = 1


2. ELSE a. IF numeros[r] = mayor THEN 1. totIguales = totIguales + 1 b. ENDIF 3. ENDIF i. ENDFOR j. Imprimir mayor, totIguales k. Fin Método principal Fin Clase Mayor20NumerosFin

Explicación:

En el Método principal de la Clase Mayor20Numeros, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde r=0 hasta 19 1. Solicita numero r 2. Se lee en numeros[r] c. Fin del FOR d. Inicia ciclo FOR desde r=0 hasta 19 1. Imprime numeros[r] e. Fin del FOR f. Coloca numeros[0] en mayor g. Inicia totIguales en 1 h. Inicia ciclo FOR desde r=1 hasta 19 1. Si numeros[r] > mayor entonces a. Coloca numeros[r] en mayor b. Inicia totIguales en 1 2. Si no a. Si numeros[r] = mayor entonces 1. Incrementa totIguales en 1 b. Fin del IF 3. Fin del IF i. Fin del FOR j. Imprime mayor, totIguales k. Fin del Método principal


Ejercicio 8.1.1.8

Elaborar un algoritmo que permita leer los nombres de 10 personas en un arreglo de una dimensión, los pesos de esas 10 personas en otro arreglo y las estaturas de las mismas en otro arreglo de una dimensión, es decir, se tendrán un arreglo de nombres, otro de pesos y otro de estaturas; imprimir el siguiente reporte:


Reporte de personas

Nombre Peso Estatura

XXXXXXXXXXXXXXXXXXXXX 99.9 99.9 XXXXXXXXXXXXXXXXXXXXX 99.9 99.9 . . XXXXXXXXXXXXXXXXXXXXX 99.9 99.9

Promedio peso: 99.9 Promedio estatura: 99.9


Algoritmo PESOS Y ESTATURAS Clase PesosEstaturas 1. Método principal a. Declaraciones Variables nombres: Arreglo[10] Cadena pesos: Arreglo[10] Real estaturas : Arreglo[10] Real i: Entero totPeso,totEstatura,promPeso,promEstatura: Real b. FOR i=0; i<=9; i++ 1. Solicitar nombres[i], pesos[i], estaturas[i] 2. Leer nombres[i], pesos[i], estaturas[i] c. ENDFOR d. Imprimir encabezado e. totPeso = 0 ; totEstatura = 0 f. FOR i=0; i<=9; i++ 1. Imprimir nombres[i], pesos[i], estaturas[i] 2. totPeso = totPeso + pesos[i] totEstatura = totEstatura + estaturas[i] g. ENDFOR h. promPeso = totPeso / 10 promEstatura = totEstatura / 10 i. Imprimir promPeso, promEstatura j. Fin Método principal Fin Clase PesosEstaturasFin

Explicación:

En el Método principal de la Clase PesosEstaturas, se tienen las acciones:

a. Se declaran las variables


b. Inicia ciclo FOR desde i=0 hasta 9 1. Solicita nombres[i], pesos[i], estaturas[i] 2. Se leen en nombres[i], pesos[i], estaturas[i] c. Fin del FOR d. Imprime encabezado e. Inicia totPeso en 0; totEstatura en 0 f. Inicia ciclo FOR desde i=0 hasta 9 1. Imprime nombres[i], pesos[i], Estaturas[i] 2. Incrementa totPeso con pesos[i] Incrementa totEstatura con estaturas[i] g. Fin del FOR h. Calcula promPeso = totPeso / 10 Calcula promEstatura = totEstatura / 10 i. Imprime promPeso, promEstatura j. Fin del Método principal


Ejercicio 8.1.1.9

Elaborar un algoritmo que permita leer los nombres de 15 personas en un arreglo de una dimensión, las edades de esas 15 personas en otro arreglo y los sueldos de las mismas en otro arreglo de una dimensión, es decir, se tendrán un arreglo de nombres, otro de edades y otro de sueldos; imprimir el siguiente reporte:

Reporte de empleados

Nombre Edad Sueldo

XXXXXXXXXXXXXXXXXXXXX 999 99999.99 XXXXXXXXXXXXXXXXXXXXX 999 99999.99 . . XXXXXXXXXXXXXXXXXXXXX 999 99999.99

Total 999999.99

Empleado con mayor sueldo: XXXXXXXXXXXXXXXXXXXXXXXXX Sueldo del empleado que gana mas: 99999.99 Edad del empleado que gana mas: 999


Algoritmo EDADES Y SUELDOS Clase EdadesSueldos 1. Método principal a. Declaraciones Variables


nombres: Arreglo[15] Cadena edades: Arreglo[15] Entero sueldos: Arreglo[15] Real i, edadMayor: Entero sueldoMayor, totSueldos : Real empleadoMayor: Cadena b. FOR i=0; i<=14; i++ 1. Solicitar nombres[i], edades[i], sueldos[i] 2. Leer nombres[i], edades[i], sueldos[i] c. ENDFOR d. Imprimir encabezado e. sueldoMayor = 0 ; totSueldos = 0 f. FOR i=0; i<=14; i++ 1. Imprimir nombres[i], edades[i], sueldos[i] 2. totSueldos = totSueldos + sueldos[i] 3. IF sueldos[i] > sueldoMayor THEN a. sueldoMayor = sueldos[i] b. empleadoMayor = nombres[i] c. edadMayor = edades[i] 4. ENDIF g. ENDFOR h. Imprimir totSueldos, empleadoMayor, sueldoMayor, edadMayor i. Fin Método principal Fin Clase EdadesSueldosFin

Explicación:

En el Método principal de la Clase EdadesSueldos, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde i=0 hasta 14 1. Solicita nombres[i], edades[i], sueldos[i] 2. Se leen en nombres[i], edades[i], sueldos[i] c. Fin del FOR d. Imprime encabezado e. Inicia sueldoMayor en 0; totSueldos en 0 f. Inicia ciclo FOR desde i=0 hasta 14 1. Imprime nombres[i], edades[i], sueldos[i] 2. Incrementa totSueldos con sueldos[i] 3. Si sueldos[i] > sueldoMayor entonces a. Coloca sueldos[i] en sueldoMayor b. Coloca nombres[i] en empleadoMayor c. Coloca edades[i] en edadMayor 4. Fin del IF g. Fin del FOR

Ejercicios resueltos para bidimensionales (Continuación...) 8-11

h. Imprime totSueldos, empleadoMayor, sueldoMayor, edadMayor i . Fin del Método principal


8.2.1 Ejercicios resueltos para bidimensionales(Continuación…)

Ejercicio 8.2.1.4

Elaborar un algoritmo que lea números en una matriz de 4 × 5 e imprima ésta y la trans-puesta. La transpuesta de una matriz de orden mxn, es una matriz de orden nxm que se obtiene intercambiando filas por columnas, es decir, el elemento Aij, se coloca en el Bji.


Algoritmo TRANSPUESTA Clase Transpuesta 1. Método principal a. Declaraciones Variables a: Arreglo[4][5] Entero b: Arreglo[5][4] Entero r, c: Entero b. FOR r=0; r<=3; r++ 1. FOR c=0; c<=4; c++ a. Solicitar Elemento r,c de la matriz a b. Leer a[r][c] 2. ENDFOR c. ENDFOR d. FOR r=0; r<=3; r++ 1. FOR c=0; c<=4; c++ a. b[c][r]= a[r][c] 2. ENDFOR e. ENDFOR f. FOR r=0; r<=3; r++ 1. FOR c=0; c<=4; c++ a. Imprimir a[r][c] 2. ENDFOR g. ENDFOR h. FOR r=0; r<=4; r++ 1. FOR c=0; c<=3; c++ a. Imprimir b[r][c] 2. ENDFOR i. ENDFOR j. Fin Método principal Fin Clase TranspuestaFin


Explicación:

En el Método principal de la Clase Transpuesta, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde r=0 hasta 3 1. Inicia ciclo FOR desde c=0 hasta 4 a. Solicita Elemento r,c de la matriz a b. Se lee en a[r][c] 2. Fin del FOR c. Fin del FOR d. Inicia ciclo FOR desde r=0 hasta 3 1. Inicia ciclo FOR desde c=0 hasta 4 a. Coloca a[r][c] en b[c][r] 2. Fin del FOR e. Fin del FOR f. Inicia ciclo FOR desde r=0 hasta 3 1. Inicia ciclo FOR desde c=0 hasta 4 a. Imprime a[r][c] 2. Fin del FOR g. Fin del FOR h. Inicia ciclo FOR desde r=0 hasta 4 1. Inicia ciclo FOR desde c=0 hasta 3 a. Imprime b[r][c] 2. Fin del FOR i. Fin del FOR j. Fin del Método principal


Ejercicio 8.2.1.5

Elaborar un algoritmo que permita leer números en una matriz A de 3 × 5, lo propio para una matriz B, que las imprima e indique si las matrices son iguales o no. Dos matrices son iguales si todos sus elementos correspondientes son iguales.


Algoritmo IGUALDAD DE MATRICES Clase IgualdadMatrices 1. Método principal a. Declaraciones Variables a, b: Arreglo[3][5] Entero r, c, bandera: Entero b. FOR r=0; r<=2; r++ 1. FOR c=0; c<=4; c++


a. Solicitar Elemento r,c de la matriz a b. Leer a[r][c] 2. ENDFOR c. ENDFOR d. FOR r=0; r<=2; r++ 1. FOR c=0; c<=4; c++ a. Solicitar Elemento r,c de la matriz b b. Leer b[r][c] 2. ENDFOR e. ENDFOR f. FOR r=0; r<=2; r++ 1. FOR c=0; c<=4; c++ a. Imprimir a[r][c] 2. ENDFOR g. ENDFOR h. bandera = 0 i. FOR r=0; r<=2; r++ 1. FOR c=0; c<=4; c++ a. Imprimir b[r][c] b. IF a[r][c] <> b[r][c] THEN 1. bandera = 1 c. ENDIF 2. ENDFOR j. ENDFOR k. IF bandera = 0 THEN 1. Imprimir “SON IGUALES” l. ELSE 1. Imprimir “NO SON IGUALES” m. ENDIF n. Fin Método principal Fin Clase IgualdadMatricesFin

Explicación:

En el Método principal de la Clase IgualdadMatrices, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde r=0 hasta 2 1. Inicia ciclo FOR desde c=0 hasta 4 a. Solicita Elemento r,c de la matriz a b. Se lee en a[r][c] 2. Fin del FOR c. Fin del FOR d. Inicia ciclo FOR desde r=0 hasta 2 1. Inicia ciclo FOR desde c=0 hasta 4 a. Solicita Elemento r,c de la matriz b b. Se lee en b[r][c]


2. Fin del FOR e. Fin del FOR f. Inicia ciclo FOR desde r=0 hasta 2 1. Inicia ciclo FOR desde c=0 hasta 4 a. Imprime a[r][c] 2. Fin del FOR g. Fin del FOR h. Inicia bandera en 0 i. Inicia ciclo FOR desde r=0 hasta 2 1. Inicia ciclo FOR desde c=0 hasta 4 a. Imprime b[r][c] b. Si a[r][c] <> b[r][c] entonces 1. Coloca 1 en bandera, para indicar que no hay igualdad c. Fin del IF 2. Fin del FOR j. Fin del FOR k. Si bandera=0 entonces 1. Imprime “SON IGUALES” l. Si no 1. Imprime “NO SON IGUALES” m. Fin del IF n. Fin del Método principal


Ejercicio 8.2.1.6

Elaborar un algoritmo que permita leer números en una matriz A de 5 × 6, lo propio para un vector X de 5 elementos. Calcular el producto de matriz por vector columna: el producto de la matriz A por el vector X, es un vector Z donde el elemento 1 esta dado por la sumatoria de los productos del elemento 1 del vector X por cada uno de los elementos del renglón 1 de la matriz A, lo propio para el 2, 3, etc. Imprimir la matriz A, el vector X y el vector Z.


Algoritmo MATRIZ POR VECTOR COLUMNA Clase MatrizVector 1. Método principal a. Declaraciones Variables a: Arreglo[5][6] Entero x, z: Arreglo[5] Entero r, c: Entero b. FOR r=0; r<=4; r++ 1. FOR c=0; c<=5; c++


a. Solicitar Elemento r,c de la matriz a b. Leer a[r][c] 2. ENDFOR c. ENDFOR d. FOR r=0; r<=4; r++ 1. Solicitar Elemento r del vector x 2. Leer x[r] e. ENDFOR f. FOR r=0; r<=4; r++ 1. z[r] = 0 2. FOR c=0; c<=5; c++ a. z[r] = z[r] + (a[r][c] * x[r]) 3. ENDFOR g. ENDFOR h. FOR r=0; r<=4; r++ 1. FOR c=0; c<=5; c++ a. Imprimir a[r][c] 2. ENDFOR 3. Imprimir x[r], z[r] i. ENDFOR j. Fin Método principal Fin Clase MatrizVectorFin

Explicación:

En el Método principal de la Clase MatrizVector, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde r=0 hasta 4 1. Inicia ciclo FOR desde c=0 hasta 5 a. Solicita Elemento r,c de la matriz a b. Se lee en a[r][c] 2. Fin del FOR c. Fin del FOR d. Inicia ciclo FOR desde r=0 hasta 4 1. Solicita Elemento r del vector x 2. Se lee en x[r] e. Fin del FOR f. Inicia ciclo FOR desde r=0 hasta 4 1. Inicia z[r] en 0 2. Inicia ciclo FOR desde c=0 hasta 5 a. Calcula z[r] = z[r] + (a[r][c] * x[r]) 3. Fin del FOR g. Fin del FOR h. Inicia ciclo FOR desde r=0 hasta 4 1. Inicia ciclo FOR desde c=0 hasta 5


a. Imprime a[r][c] 2. Fin del FOR 3. Imprime x[r], z[r] i. Fin del FOR j. Fin del Método principal


Ejercicio 8.2.1.7

Elaborar un algoritmo que permita leer números en una matriz de 4 × 5, que la imprima, que calcule e imprima la sumatoria por renglones y por columnas, además que imprima el número de renglón y el número de columna que tuvieron la mayor sumatoria.


Algoritmo SUMAS POR RENGLONES Y COLUMNAS Clase SumasRenCol 1. Método principal a. Declaraciones Variables matriz: Arreglo[4][5] Entero r, c, renMay, colMay, sumaRen, SumaCol, mayorRen, mayorCol: Entero b. FOR r=0; r<=3; r++ 1. FOR c=0; c<=4; c++ a. Solicitar matriz[r][c] b. Leer matriz[r][c] 2. ENDFOR c. ENDFOR d. mayorRen = -9999 e. FOR r=0; r<=3; r++ 1. sumaRen = 0 2. FOR c=0; c<=4; c++ a. Imprimir matriz[r][c] b. sumaRen = sumaRen + matriz[r][c] 3. ENDFOR 4. Imprimir sumaRen 5. IF sumaRen > mayorRen THEN a. mayorRen = sumaRen b. renMay = r 6. ENDIF f. ENDFOR g. mayorCol = -9999 h. FOR c=0; c<=4; c++ 1. sumaCol =0 2. FOR r=0; r<=3; r++ a. sumaCol = sumaCol + matriz[r][c]


3. ENDFOR 4. Imprimir sumaCol 5. IF sumaCol > mayorCol THEN a. mayorCol = sumaCol b. colMay = c 6. ENDIF i. ENDFOR j. Imprimir renMay, colMay k. Fin Método principal Fin Clase SumasRenColFin

Explicación:

En el Método principal de la Clase SumasRenCol, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde r=0 hasta 3 1. Inicia ciclo FOR desde c=0 hasta 4 a. Solicita matriz[r][c] b. Se lee en matriz[r][c] 2. Fin del FOR c. Fin del FOR d. Inicia mayorRen en -9999 e. Inicia ciclo FOR desde r=0 hasta 3 1. Inicia sumaRen en 0 2. Inicia ciclo FOR desde c=0 hasta 4 a. Imprime matriz[r][c] b. Incrementa sumaRen con matriz[r][c] 3. Fin del FOR 4. Imprime sumaRen 5. Si sumaRen > mayorRen entonces a. Coloca sumaRen en mayorRen b. Coloca r en renMay 6. Fin del IF f. Fin del FOR g. Inicia mayorCol en -9999 h. Inicia ciclo FOR desde c=0 hasta 4 1. Inicia sumaCol en 0 2. Inicia ciclo FOR desde r=0 hasta 3 a. Incrementa sumaCol con matriz[r][c] 3. Fin del FOR 4. Imprime sumaCol 5. Si sumaCol > mayorCol entonces a. Coloca sumaCol en mayorCol b. Coloca c en colMay 6. Fin del IF


i. Fin del FOR j. Imprime renMay, colMay k. Fin del Método principal


Ejercicio 8.2.1.8

Una compañía manufacturera fabrica 10 artículos diferentes y se trabajan tres turnos. Elaborar un algoritmo que permita leer el nombre de cada artículo y la producción que se hizo en cada uno de los tres turnos del día; utilizar un arreglo de una dimensión para leer los nombres de los artículos y un arreglo de dos dimensiones (10 × 3) para leer la producción de los diez artículos (uno en cada renglón) en los tres turnos una columna para cada turno. La idea es leer el nombre del primer artículo y luego la producción hecha en cada uno de los tres turnos, luego procesar el artículo 2, posteriormente el 3 y así sucesivamente. Imprimir el siguiente reporte:

Reporte diario de producccion

Articulo Turno 1 Turno 2 Turno 3 Tot. Prod.

XXXXXXXXXXXXXXX 999 999 999 999 XXXXXXXXXXXXXXX 999 999 999 999 . . . XXXXXXXXXXXXXXX 999 999 999 999 Total 999 999 999 999

Articulo con mayor produccion: XXXXXXXXXXXXXXXXXXXXXX Produccion del articulo mayor: 999


Algoritmo PRODUCCION TURNOS Clase ProduccionTurnos 1. Método principal a. Declaraciones Variables articulos: Arreglo[10] Cadena prod: Arreglo[10][3] Entero r,c,mayorProd,totTurno,totProd,toTotProd: Entero articuloMay: Cadena b. FOR r=0; r<=9; r++ 1. Solicitar articulos[r] 2. Leer articulos[r] 3. FOR c=0; c<=2; c++


a. Solicitar prod[r][c] b. Leer prod[r][c] 4. ENDFOR c. ENDFOR d. Imprimir encabezado e. toTotProd = 0 mayorProd =0 f. FOR r=0; r<=9; r++ 1. Imprimir articulos[r] 2. totProd =0 3. FOR c=0; c<=2; c++ a. Imprimir prod[r][c] b. totProd = totProd + prod[r][c] 4. ENDFOR 5. Imprimir totProd 6. IF totProd > mayorProd THEN a. mayorProd = totProd b. articuloMay = articulos[r] 7. ENDIF 8. toTotProd = toTotProd + totProd g. ENDFOR h. FOR c=0; c<=2; c++ 1. totTurno = 0 2. FOR r=0; r<=9; r++ a. totTurno = totTurno + prod[r][c] 3. ENDFOR 4. Imprimir totTurno i. ENDFOR j. Imprimir toTotProd, articuloMay, mayorProd k. Fin Método principal Fin Clase ProduccionTurnosFin

Explicación:

En el Método principal de la Clase ProduccionTurnos, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde r=0 hasta 9 1. Solicita articulos[r] 2. Se lee en articulos[r] 3. Inicia ciclo FOR desde c=0 hasta 2 a. Solicita prod[r][c] b. Se lee en prod[r][c] 4. Fin del FOR c. Fin del FOR d. Imprimir encabezado


e. Inicia totProd y mayorProd en 0 f. Inicia ciclo FOR desde r=0 hasta 9 1. Imprime articulos[r] 2. Inicia totProd en 0 3. Inicia ciclo FOR desde c=0 hasta 2 a. Imprim prod[r][c] b. Incrementa totProd con prod[r][c] 4. Fin del FOR 5. Imprime totProd 6. Si totProd>mayorProd entonces a. Coloca totProd en mayorProd b. Coloca articulos[r] en articuloMay 7. Fin del IF 8. Incrementa toTotProd con totProd g. Fin del FOR h. Inicia ciclo FOR desde c=0 hasta 2 1. Inicia totTurno en 0 2. Inicia ciclo FOR desde r=0 hasta 9 a. Incrementa totTurno con prod[r][c] 3. Fin del FOR 4. Imprime totTurno i. Fin del FOR j. Imprime toTotProd, articuloMay, mayorProd k. Fin del Método principal


Ejercicio 8.2.1.9

Elaborar un algoritmo que permita leer el nombre de los 32 estados del país y sus respec-tivas capitales en un arreglo de 32 × 2, donde cada renglón se utilice para un estado; en la columna 1 se coloca el nombre del estado y en la columna 2 el nombre de la capital. A continuación, debe permitir realizar consultas (mientras se desee), se introduce el nom-bre del estado y se deberá imprimir la capital del mismo, es decir, se busca el estado en la columna 1 y donde se encuentre se imprime la columna 2.


Algoritmo CAPITALES ESTADOS Clase Capitales 1. Método principal a. Declaraciones Variables estados: Arreglo[32][2] Cadena estado: Cadena r: Entero desea: Carácter


b. FOR r=0; r<=31; r++ 1. Solicitar estado, r 2. Leer estados[r][0] 3. Solicitar capital, r 4. Leer estados[r][1] c. ENDFOR d. Preguntar “¿DESEA CONSULTAR CAPITAL (S/N)?” e. Leer desea f. WHILE desea =”S” 1. Solicitar estado 2. Leer estado 3. r = -1 4. DO a. r = r + 1 b. IF estado = estados[r][0] THEN 1. Imprimir estados[r][1] c. ENDIF 5. WHILE estado <> estados[r][0] 6. Preguntar “¿DESEA CONSULTAR CAPITAL (S/N)?” 7. Leer desea g. ENDWHILE h. Fin Método principal Fin Clase CapitalesFin

Explicación:

En el Método principal de la Clase Capitales, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde r=0 hasta 31 1. Solicita estado, r 2. Se lee en estados[r][0] 3. Solicita capital, r 4. Se lee en estados[r][1] c. Fin del FOR d. Pregunta “¿DESEA CONSULTAR CAPITAL (S/N)?” e. Lee en desea la respuesta f. Inicia ciclo WHILE Si desea =”S” 1. Solicitar estado a consultar 2. Se lee en estado 3. Inicia r en -1 4. Inicia ciclo DO a. Incrementa r en 1 b. Si estado = estados[r][0] entonces 1. Imprime estados[r][1] c. Fin del IF


5. Fin ciclo DO mientras que estado<>estados[r][0] 6. Pregunta “¿DESEA CONSULTAR CAPITAL (S/N)?” 7. Lee en desea g. Fin del WHILE h. Fin del Método principal


Ejercicio 8.2.1.10

Elaborar un algoritmo que permita leer 15 rangos en un arreglo de 15 × 3, cada renglón se utilizará para un rango de la siguiente forma: la columna 1 se utilizará para leer el límite inferior del rango, la columna 2 para el límite superior y la columna 3 se utilizará como un contador, el cual se iniciará en cero en el momento de hacer la lectura de cada rango. A continuación se deben leer 50 números, cada número debe ser mayor o igual al límite inferior del primer rango y menor o igual al límite superior del último rango. Cada número leído debe buscarse en cuál rango está, se trata de contar cuántos números cayeron en cada rango, en otras palabras, hacer una distribución de frecuencias. Se debe imprimir el siguiente reporte:

Distribucion de frecuencias

Rango Limite inferior Limite superior No. ocurrencias

1 999 999 999 2 999 999 999 . .

15 999 999 999


Algoritmo DISTRIBUCION DE FRECUENCIAS Clase Distribucion 1. Método principal a. Declaraciones Variables rangos: Arreglo[15][3] Entero i, c, r, numero: Entero b. FOR r=0; r<=14; r++ 1. Solicitar LIMITE INFERIOR rango, r 2. Leer rangos[r][0] 3. Solicitar LIMITE SUPERIOR rango, r 4. Leer rangos[r][1] 5. rangos[r][2] = 0 c. ENDFOR d. FOR c=1; c<=50; c++


1. Solicitar numero 2. Leer numero 3. r = -1 4. DO a. r=r+1 b. IF (numero>=rangos[r][0])AND (numero<=rangos[r][1]) THEN 1. rangos[r][2] = rangos[r][2]+1 c. ENDIF 5. WHILE NOT((numero>=rangos[r][0])AND (numero<=rangos[r][1])) e. ENDFOR f. Imprimir encabezado g. FOR r=0; r<=14; r++ 1. Imprimir r 2. FOR c=0; c<=2; c=c+1 a. Imprimir rangos[r][c] 3. ENDFOR h. ENDFOR i. Fin Método principal Fin Clase DistribucionFin

Explicación:

En el Método principal de la Clase Distribucion, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde r=0 hasta 14 1. Solicita LIMITE INFERIOR rango, r 2. Se lee en rangos[r][0] 3. Solicita LIMITE SUPERIOR rango, r 4. Se lee en rangos[r][1] 5. Inicia rangos[r][2] en 0 c. Fin del FOR d. Inicia ciclo FOR desde c=1 hasta 50 1. Solicita numero 2. Se lee en numero 3. Inicia r en -1 4. Inicia ciclo DO a. Incrementa r en 1 b. Si (numero>=rangos[r][0])AND(numero<=rangos[r][1]) entonces 1. Incrementa rangos[r][2] en 1 c. Fin del IF 5. Fin ciclo DO mientras NOT((numero>=rangos[r][0])AND (numero<=rangos[r][1])) e. Fin del FOR


f. Imprime encabezado g. Inicia ciclo FOR desde r=0 hasta 14 1. Imprime r 2. Inicia ciclo FOR desde c=0 hasta 2 a. Imprime rangos[r][c] 3. Fin del FOR h. Fin del FOR i. Fin del Método principal


Ejercicio 8.2.1.11

Elaborar un algoritmo que permita leer números en un arreglo de 3 × 3 e indique si es un cuadrado mágico. Es un cuadrado mágico si la sumatoria de los elementos es 15 por renglones, columnas y diagonales.


Algoritmo CUADRADO MAGICO Clase CuadradoMagico 1. Método principal a. Declaraciones Variables cuadrado: Arreglo[3][3] Entero r, c,sumDiag1,sumDiag2,sumRen,sumCol,bandera: Entero b. FOR r=0; r<=2; r++ 1. FOR c=0; c<=2; c++ a. Solicitar Elemento r,c b. Leer cuadrado[r][c] 2. ENDFOR c. ENDFOR d. bandera = 0; sumDiag1 = 0 e. FOR r=0; r<=2; r++ 1. sumRen = 0 2. FOR c=0; c<=2; c++ a. Imprimir cuadrado[r][c] b. sumRen = sumRen + cuadrado[r][c] c. IF r=c THEN 1. sumDiag1 = sumDiag1 + cuadrado[r][c] d. ENDIF 3. ENDFOR 4. Imprimir sumRen 5. IF sumRen<>15 THEN a. bandera = 1 6. ENDIF f. ENDFOR


g. FOR r=0; r<=2; r++ 1. sumCol = 0 2. FOR c=0; c<=2; c++ a. sumCol = sumCol + cuadrado[r][c] 3. ENDFOR 4. Imprimir sumCol 5. IF sumCol<>15 THEN a. bandera = 1 6. ENDIF h. ENDFOR i. sumDiag2 = 0 j. FOR r=0; r<=2; r++ 1. sumDiag2 = sumDiag2 + cuadrado[r][2-(r-1)] k. ENDFOR l. Imprimir sumDiag1, sumDiag2 m. IF (sumDiag1<>15)OR(sumDiag2<>15) THEN 1. bandera = 1 n. ENDIF o. IF bandera=0 THEN 1. Imprimir “ES UN CUADRADO MAGICO” p. ELSE 1. Imprimir “NO ES UN CUADRADO MAGICO” q. ENDIF r. Fin Método principal Fin Clase CuadradoMagicoFin

Explicación:

En el Método principal de la Clase CuadradoMagico, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde r=0 hasta 2 1. Inicia ciclo FOR desde c=0 hasta 2 a. Solicita Elemento r,c b. Se lee en cuadrado[r][c] 2. Fin del FOR c. Fin del FOR d. Inicia bandera en 0; sumDiag1 en 0 e. Inicia ciclo FOR desde r=0 hasta 2 1. Inicia sumRen en 0 2. Inicia ciclo FOR desde c=0 hasta 2 a. Imprime cuadrado[r][c] b. Incrementa sumR en cuadrado[r][c] c. Si r=c entonces a. Incrementa sumDiag1 con cuadrado[r][c] d. Fin del IF


3. Fin del FOR 4. Imprime sumRen 5. Si sumRen<>15 entonces a. Coloca 1 en bandera 6. Fin del IF f. Fin del FOR g. Inicia ciclo FOR desde r=0 hasta 2 1. Inicia sumCol en 0 2. Inicia ciclo FOR desde c=0 hasta 2 a. Incrementa sumCol con cuadrado[r][c] 3. Fin del FOR 4. Imprime sumCol 5. Si sumCol<>15 entonces a. Coloca 1 en bandera 6. Fin del IF h. Fin del FOR i. Inicia sumDiag2 en 0 j. Inicia ciclo FOR desde r=0 hasta 2 1. Incrementa sumDiag2 con cuadrado[r][2-(r-1)] k. Fin del FOR l. Imprime sumDiag1, sumDiag2 m. Si (sumDiag1<>15)OR(sumDiag2<>15) entonces 1. Coloca 1 en bandera n. Fin del IF o. Si bandera =0 entonces 1. Imprime “ES UN CUADRADO MAGICO” p. Si no 1. Imprime “NO ES UN CUADRADO MAGICO” q. Fin del IF r. Fin del Método principal


Ejercicio 8.2.1.12

Dos matrices A y B se pueden multiplicar si el número de columnas de A es igual al número de renglones de B. En otras palabras, que los vectores renglón de A, contengan el mismo número de elementos que los vectores columna de B. La multiplicación de matrices se hace multiplicando cada vector renglón de A por cada uno de los vectores columna de B. Consideremos el siguiente ejemplo:

Se tiene la matriz A de 2 × 3, con los siguientes valores:

A =

2 4 5

1 3 4

y la matriz B de 3 × 4, con los valores:


B=

5 1 3 4

2 4 6 3

3 2 1 5

Al multiplicar A por B, se obtiene una matriz P de 2 × 4, es decir, con el número de renglones de A y el número de columnas de B. Cada elemento de P se obtiene mediante el producto de vector renglón de A por vector columna de B. El proceso en detalle para calcular cada uno de los elementos de P, es el siguiente:

P11 = [ 2,4,5 ] × 523

= 2(5) + 4(2) + 5(3) = 10 + 8 + 15 = 33

P12 = [ 2,4,5 ] × 142

= 2(1) + 4(4) + 5(2) = 2 + 16 + 10 = 28

P13 = [ 2,4,5 ] × 361

= 2(3) + 4(6) + 5(1) = 6 + 24 + 5 = 35

P14 = [ 2,4,5 ] × 435

= 2(4) + 4(3) + 5(5) = 8 + 12 + 25 = 45

P21 = [ 1,3,4 ] × 523

= 1(5) + 3(2) + 4(3) = 5 + 6 + 12 = 23

P22 = [ 1,3,4 ] × 142

= 1(1) + 3(4) + 4(2) = 1 + 12 + 8 = 21

P23 = [ 1,3,4 ] × 361

= 1(3) + 3(6) + 4(1) = 3 + 18 + 4 = 25

P24 = [ 1,3,4 ] × 523

= 1(4) + 3(3) + 4(5) = 4 + 9 + 20 = 33


La matriz P resultante es:

P =

33 28 35 4523 21 25 33

Elaborar un algoritmo que permita leer números enteros para cada uno de los elementos de una matriz A de 2 × 3, lo mismo para una matriz B de 3 × 4 y calcular una matriz P de 2 × 4, multiplicando la matriz A por la matriz B.


Algoritmo MULTIPLICACION DE MATRICES Clase MultiplicaMatrices 1. Método principal a. Declaraciones Variables a: Arreglo[2][3] Entero b: Arreglo[3][4] Entero p: Arreglo[2][4] Entero r, c, i: Entero b. FOR r=0; r<=1; r++ 1. FOR c=0; c<=2; c++ a. Solicitar Elemento a[r][c] b. Leer a[r][c] 2. ENDFOR c. ENDFOR d. FOR r=0; r<=2; r++ 1. FOR c=0; c<=3; c++ a. Solicitar Elemento b[r][c] b. Leer b[r][c] 2. ENDFOR e. ENDFOR f. FOR i=0; i<=1; i++ 1. FOR c=0; c<=3; c++ a. p[i][c] = 0 b. FOR r=0; r<=2; r++ a. p[i][c] = p[i][c]+(a[i][r]*b[r][c]) c. ENDFOR 2. ENDFOR g. ENDFOR h. FOR r=0; r<=1; r++ 1. FOR c=0; c<=2; c++ a. Imprimir a[r][c] 2. ENDFOR i. ENDFOR j. FOR r=0; r<=2; r++ 1. FOR c=0; c<=3; c++ a. Imprimir b[r][c]


2. ENDFOR k. ENDFOR l. FOR r=0; r<=1; r++ 1. FOR c=0; c<=3; c++ a. Imprimir p[r][c] 2. ENDFOR m. ENDFOR n. Fin Método principal Fin Clase MultiplicaMatricesFin

Explicación:

En el Método principal de la Clase MultiplicaMatrices, se tienen las acciones:

a. Se declaran las variables b. Inicia ciclo FOR desde r=0 hasta 1 1. Inicia ciclo FOR desde c=0 hasta 2 a. Solicita Elemento a[r][c] b. Se lee en a[r][c] 2. Fin del FOR c. Fin del FOR d. Inicia ciclo FOR desde r=0 hasta 2 1. Inicia ciclo FOR desde c=0 hasta 3 a. Solicita Elemento b[r][c] b. Se lee en b[r][c] 2. Fin del FOR e. Fin del FOR f. Inicia ciclo FOR desde i=0 hasta 1 1. Inicia ciclo FOR desde c=0 hasta 3 a. Inicia p[i][c] en 0 b. Inicia ciclo FOR desde r=0 hasta 2 1. Incrementa p[i][c] con (a[i][r] *b[r][c]) c. Fin del FOR 2. Fin del FOR g. Fin del FOR h. Inicia ciclo FOR desde r=0 hasta 1 1. Inicia ciclo FOR desde c=0 hasta 2 a. Imprime a[r][c] 2. Fin del FOR i. Fin del FOR j. Inicia ciclo FOR desde r=0 hasta 2 1. Inicia ciclo FOR desde c=0 hasta 3 a. Imprime b[r][c] 2. Fin del FOR k. Fin del FOR l. Inicia ciclo FOR desde r=0 hasta 1


1. Inicia ciclo FOR desde c=0 hasta 3 a. Imprime p[r][c] 2. Fin del FOR m. Fin del FOR n. Fin del Método principal


8.3.1 Ejercicios resueltos para tridimensionales (Continuación…)

Ejercicio 8.3.1.1

Una compañía manufacturera tiene 6 plantas, en cada planta tiene 4 estaciones de trabajo y, por cada estación de trabajo se tiene la producción (número de unidades fabricadas) de cada uno de los 5 días laborables de la semana. Elaborar un algoritmo que lea los datos de la producción en un arreglo de tres dimensiones; la primera dimensión la conforman las plantas, la segunda dimensión las estaciones de trabajo, y la tercera, los días de producción, esquemáticamente:

Día .......... Día

0 1 2 3 4

Planta 0

Estación 0

Estación 1

Estación 2

Estación 3

Planta 1

.

.

.

Planta 5

Ejercicios resueltos para tridimensionales (Continuación...) 8-31

Una vez leídos los datos, que imprima el siguiente reporte:

Reporte semanal de producción

PLANTA 0 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Estación-0 -- -- -- -- -- Estación-1 -- -- -- -- -- Estación-2 -- -- -- -- -- Estación-3 -- -- -- -- --


. . .


A continuación se presenta el algoritmo:


Algoritmo ARREGLO TRES DIMENSIONES Clase ArregloTresDim2 1. Método principal a. Declaraciones Variables prod: Arreglo[6][4][5] Entero pla, est, dia: Entero b. FOR pla=0; pla<=5; pla++ 1. FOR est=0; est<=3; est++ a. FOR dia=0; dia<=4; dia++ 1. Solicitar Producción pla,est,dia


2. Leer prod[pla][est][dia] b. ENDFOR 2. ENDFOR c. ENDFOR d. FOR pla=0; pla<=5; pla++ 1. Imprimir encabezado 2. FOR est=0; est<=3; est++ a. FOR dia=0; dia<=4; dia++ 1. Imprimir prod[pla][est][dia] b. ENDFOR 3. ENDFOR e. ENDFOR f. Fin Método principal Fin Clase ArregloTresDim2Fin

Explicación:

En el Método principal de la Clase ArregloTresDim2, se tienen las acciones:

a. Se declaran las variables prod es un arreglo de 6 elementos de 4 por 5 pla, est, dia variables para los ciclos b. Inicia ciclo FOR desde pla=0 hasta 5 1. Inicia ciclo FOR desde est=0 hasta 3 a. Inicia ciclo FOR desde dia=0 hasta 4 1. Solicita Producción pla,est,dia 2. Se lee en prod[pla][est][dia] b. Fin del FOR 2. Fin del FOR c. Fin del FOR d. Inicia ciclo FOR desde pla=0 hasta 5 1. Imprime encabezado 2. Inicia ciclo FOR desde est=0 hasta 3 a. Inicia ciclo FOR desde dia=0 hasta 4 1. Imprime prod[pla][est][dia] b. Fin del FOR 3. Fin del FOR e. Fin del FOR f. Fin del Método principal


Ejercicio 8.3.1.2

Elaborar un algoritmo similar al anterior, pero ahora imprimir el total de producción por estación y por cada día para cada planta:



PLANTA 0 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Total Estación-0 -- -- -- -- -- -- Estación-1 -- -- -- -- -- -- Estación-2 -- -- -- -- -- -- Estación-3 -- -- -- -- -- -- Totales -- -- -- -- -- -- . . .

PLANTA 5 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Total Estación-0 -- -- -- -- -- -- Estación-1 -- -- -- -- -- -- Estación-2 -- -- -- -- -- -- Estación-3 -- -- -- -- -- -- Totales -- -- -- -- -- --

Total general de produccion --


Algoritmo ARREGLO TRES DIMENSIONES Clase ArregloTresDim3 1. Método principal a. Declaraciones Variables prod: Arreglo[6][4][5] Entero pla, est, dia, totEst, totDia, totPlanta, totProd: Entero b. FOR pla=0; pla<=5; pla++ 1. FOR est=0; est<=3; est++ a. FOR dia=0; dia<=4; dia++ 1. Solicitar Producción pla,est,dia 2. Leer prod[pla][est][dia] b. ENDFOR 2. ENDFOR c. ENDFOR d. Imprimir primer renglón del encabezado e. totProd = 0 f. FOR pla=0; pla<=5; pla++


1. Imprimir encabezado 2. FOR est=0; est<=3; est++ a. totEst = 0 b. FOR dia=0; dia<=4; dia++ 1. Imprimir prod[pla][est][dia] 2. totEst = totEst + prod[pla][est][dia] c. ENDFOR d. Imprimir totEst 3. ENDFOR 4. totPlanta = 0 5. FOR dia=0; dia<=4; dia++ a. totDia = 0 b. FOR est=0; est<=3; est++ 1. totDia = totDia + prod[pla][est][dia] c. ENDFOR d. Imprimir totDia e. totPlanta = totPlanta + totDia 6. ENDFOR 7. Imprimir totPlanta 8. totProd = totProd + totPlanta g. ENDFOR h. Imprimir totProd i. Fin Método principal Fin Clase ArregloTresDim3Fin

Explicación:


a. Se declaran las variables b. Inicia ciclo FOR desde pla=0 hasta 5 1. Inicia ciclo FOR desde est=0 hasta 3 a. Inicia ciclo FOR desde dia=0 hasta 4 1. Solicita Producción pla,est,dia 2. Se lee en prod[pla][est][dia] b. Fin del FOR 2. Fin del FOR c. Fin del FOR d. Imprime primer renglón del encabezado e. Inicia totProd en 0 f. Inicia ciclo FOR desde pla=0 hasta 5 1. Imprime encabezado 2. Inicia ciclo FOR desde est=0 hasta 3 a. Inicia totEst en 0 b. Inicia ciclo FOR desde dia=0 hasta 4 1. Imprime prod[pla][est][dia]


2. Incrementa totEst con prod[pla][est][dia] c. Fin del FOR d. Imprime totEst 3. Fin del FOR 4. Inicia totPlanta en 0 5. Inicia ciclo FOR desde dia=0 hasta 4 a. Inicia totDia en 0 b. Inicia ciclo FOR desde est=0 hasta 3 1. Incrementa totDia con prod[pla][est][dia] c. Fin del FOR d. Imprime totDia e. Incrementa totPlanta con totDia 6. Fin del FOR 7. Imprime totPlanta 8. Incrementa totProd con totPlanta g. Fin del FOR h. Imprime totProd i. Fin del Método principal


Ejercicio 8.3.1.3

Elaborar un algoritmo similar al anterior, pero ahora imprimir el total de producción por planta, la estación más productiva de la planta y cuánto fue su producción; y el total de producción general, la planta más productiva de la compañía y cuánto fue su producción.


Algoritmo ARREGLO TRES DIMENSIONES Clase ArregloTresDim4 1. Método principal a. Declaraciones Variables prod: Arreglo[6][4][5] Entero pla, est, dia, totEst, totDia, totPlanta, totProd, mayPla, mayProdPla, mayEst, mayProdEst: Entero b. FOR pla=0; pla<=5; pla++ 1. FOR est=0; est<=3; est++ a. FOR dia=0; dia<=4; dia++ 1. Solicitar Producción pla,est,dia 2. Leer prod[pla][est][dia] b. ENDFOR 2. ENDFOR c. ENDFOR d. Imprimir primer renglón del encabezado


e. totProd = 0; mayProdPla = 0 f. FOR pla=0; pla<=5; pla++ 1. Imprimir encabezado 2. mayProdEst = 0 3. FOR est=0; est<=3; est++ a. totEst = 0 b. FOR dia=0; dia<=4; dia++ 1. Imprimir prod[pla][est][dia] 2. totEst = totEst + prod[pla][est][dia] c. ENDFOR d. Imprimir totEst e. IF totEst > mayProdEst THEN 1. mayProdEst = totEst 2. mayEst = est f. ENDIF 4. ENDFOR 5. totPlanta = 0 6. FOR dia=0; dia<=4; dia++ a. totDia = 0 b. FOR est=0; est<=3; est++ 1. totDia = totDia + prod[pla][est][dia] c. ENDFOR d. Imprimir totDia e. totPlanta = totPlanta + totDia 7. ENDFOR 8. Imprimir totPlanta, mayEst, mayProdEst 9. totProd = totProd + totPlanta 10. IF totPlanta > mayProdPla THEN a. mayProdPla = totPlanta b. mayPla = pla 11. ENDIF g. ENDFOR h. Imprimir totProd, mayPla, mayProdPla i. Fin Método principal Fin Clase ArregloTresDim4Fin

Explicación:


a. Se declaran las variables b. Inicia ciclo FOR desde pla=0 hasta 5 1. Inicia ciclo FOR desde est=0 hasta 3 a. Inicia ciclo FOR desde dia=0 hasta 4 1. Solicita Producción pla,est,dia 2. Se lee prod[pla][est][dia]

Ejercicios resueltos para tetradimensionales (Continuación...) 8-37

b. Fin del FOR 2. Fin del FOR c. Fin del FOR d. Imprime primer renglón del encabezado e. Inicia totProd en 0; mayProdPla en 0 f. Inicia ciclo FOR desde pla=0 hasta 5 1. Imprime encabezado 2. Inicia mayProdEst en 0 3. Inicia ciclo FOR desde est=0 hasta 3 a. Inicia totEst en 0 b. Inicia ciclo FOR desde dia=0 hasta 4 1. Imprime prod[pla][est][dia] 2. Incrementa totEst con prod[pla][est][dia] c. Fin del FOR d. Imprime totEst e. Compara Si totEst > mayProdEst Si es asi, entonces 1. Coloca totEst en mayProdEst 2. Coloca est en mayEst f. Fin del IF 4. Fin del FOR 5. Inicia totPlanta en 0 6. Inicia ciclo FOR desde dia=0 hasta 4 a. Inicia totDia en 0 b. Inicia ciclo FOR desde est=0 hasta 3 1. Incrementa totDia con prod[pla][est][dia] c. Fin del FOR d. Imprime totDia e. Incrementa totPlanta con totDia 7. Fin del FOR 8. Imprime totPlanta, mayEst, mayProdEst 9. Incrementa totProd con totPlanta 10. Compara Si totPlanta > mayProdPla si es asi, entonces a. Coloca totPlanta en mayProdPla b. Coloca pla en mayPla 11. Fin del IF g. Fin del FOR h. Imprime totProd, mayPla, mayProdPla i. Fin del Método principal


8.4.1 Ejercicios resueltos para tetradimensionales (Continuación…)Ejercicio 8.4.1.1Una compañía manufacturera tiene 6 plantas, en cada planta tiene 3 estaciones de trabajo, en cada estación de trabajo se tienen 4 obreros, y por cada obrero se tiene la


producción (número de unidades fabricadas) de cada uno de los 5 días laborables de la semana. Elaborar un algoritmo que lea los datos de la producción en un arreglo de cuatro dimensiones; la primera dimensión la conforman las plantas, la segunda dimensión las estaciones de trabajo, la tercera dimensión los obreros y la cuarta los días de producción, esquemáticamente:

Estación 0 Estación 1 Estación 2

Día ....... Día0 1 2 3 4

Planta 0

Obrero 0Obrero 1Obrero 2Obrero 3

Planta 1

.

.

.

.

.

.

Planta 5

Una vez leídos los datos en el arreglo, imprimir el siguiente reporte:


PLANTA 0 ESTACION 0 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Obrero-0 -- -- -- -- -- Obrero-1 -- -- -- -- -- Obrero-2 -- -- -- -- -- Obrero-3 -- -- -- -- --


ESTACION 1 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Obrero-0 -- -- -- -- -- Obrero-1 -- -- -- -- -- Obrero-2 -- -- -- -- -- Obrero-3 -- -- -- -- --

ESTACION 2 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Obrero-0 -- -- -- -- -- Obrero-1 -- -- -- -- -- Obrero-2 -- -- -- -- -- Obrero-3 -- -- -- -- --

. . .

PLANTA 5 ESTACION 0 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Obrero-0 -- -- -- -- -- Obrero-1 -- -- -- -- -- Obrero-2 -- -- -- -- -- Obrero-3 -- -- -- -- -- ESTACION 1 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Obrero-0 -- -- -- -- -- Obrero-1 -- -- -- -- -- Obrero-2 -- -- -- -- -- Obrero-3 -- -- -- -- --

ESTACION 2 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Obrero-0 -- -- -- -- -- Obrero-1 -- -- -- -- --


Obrero-2 -- -- -- -- -- Obrero-3 -- -- -- -- --

A continuación se presenta el algoritmo:


Algoritmo ARREGLO TETRADIMENSIONAL Clase ArregloCuatroDim2 1. Método principal a. Declaraciones Variables prod: Arreglo[6][3][4][5] Entero pla, est, obr, dia: Entero b. FOR pla=0; pla<=5; pla++ 1. FOR est=0; est<=2; est++ a. FOR obr=0; obr<=3; obr++ 1. FOR dia=0; dia<=4; dia++ a. Solicitar producción[pla][est][obr][dia] b. Leer prod[pla][est][obr][dia] 2. ENDFOR b. ENDFOR 2. ENDFOR c. ENDFOR d. Imprimir primer renglón del encabezado e. FOR pla=0; pla<=5; pla++ 1. Imprimir encabezado de planta 2. FOR est=0; est<=2; est++ a. Imprimir encabezado de estación b. FOR obr=0; obr<=3; obr++ 1. Imprimir “OBRERO-“,Obr 2. FOR dia=0; dia<=4; dia++ a. Imprimir prod[pla][est][obr][dia] 3. ENDFOR c. ENDFOR 3. ENDFOR f. ENDFOR g. Fin Método principal Fin Clase ArregloCuatroDim2Fin

Explicación:

En el Método principal de la Clase ArregloCuatroDim2, se tienen las acciones:


a. Se declaran las variables prod es un arreglo de cuatro dimensiones 6 elementos en la primera dimensión, 3

elementos en la segunda, 4 en la tercera dimensión y 5 elementos en la cuarta. pla,est,obr,dia son variables para controlar los cuatro ciclos. b. Inicia ciclo FOR desde pla=0 hasta 5 1. Inicia ciclo FOR desde est=0 hasta 2 a. Inicia ciclo FOR desde obr=0 hasta 3 1. Inicia ciclo FOR desde dia=0 hasta 4 a. Solicita prod[pla][est][obr][dia] b. Se lee en prod[pla][est][obr][dia] 2. Fin del FOR b. Fin del FOR 2. Fin del FOR c. Fin del FOR d. Imprim primer renglón del encabezado e. Inicia ciclo FOR desde pla=0 hasta 5 1. Imprime encabezado de planta 2. Inicia ciclo FOR desde est=0 hasta 2 a. Imprime encabezado de estación b. Inicia ciclo FOR desde obr=0 hasta 3 1. Imprime “OBRERO-“, obr 2. Inicia ciclo FOR desde dia=0 hasta 4 a. Imprime prod[pla][est][obr][dia] 3. Fin del FOR c. Fin del FOR 3. Fin del FOR f. Fin del FOR g. Fin del Método principal


Ejercicio 8.4.1.2

Elaborar un algoritmo similar al anterior, pero ahora imprimir el siguiente reporte:


PLANTA 0 ESTACION 0 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Total Obrero-0 -- -- -- -- -- -- Obrero-1 -- -- -- -- -- -- Obrero-2 -- -- -- -- -- -- Obrero-3 -- -- -- -- -- -- Totales -- -- -- -- -- --


ESTACION 1 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Total Obrero-0 -- -- -- -- -- -- Obrero-1 -- -- -- -- -- -- Obrero-2 -- -- -- -- -- -- Obrero-3 -- -- -- -- -- -- Totales -- -- -- -- -- --


. .

PLANTA 5 ESTACION 0 Dia 0 Dia 1 Dia 2 Dia 3 Dia 4 Total Obrero-0 -- -- -- -- -- -- Obrero-1 -- -- -- -- -- -- Obrero-2 -- -- -- -- -- -- Obrero-3 -- -- -- -- -- -- Totales -- -- -- -- -- --




Total general de produccion --


Algoritmo ARREGLO CUATRO DIMENSIONES Clase ArregloCuatroDim3 1. Método principal a. Declaraciones Variables prod: Arreglo[6][3][4][5] Entero pla, est, obr, dia, totEst, totDia, totObr, totPlanta, totProd: Entero b. FOR pla=0; pla<=5; pla++ 1. FOR est=0; est<=2; est++ a. FOR obr=0; obr<=3; obr++ 1. FOR dia=0; dia<=4; dia++ a. Solicitar producción pla,est,obr,dia b. Leer prod[pla][est][obr][dia] 2. ENDFOR b. ENDFOR 2. ENDFOR c. ENDFOR d. Imprimir primer renglón del encabezado e. totProd = 0 f. FOR pla=0; pla<=5; pla++ 1. Imprimir encabezado de planta 2. totPlanta = 0 3. FOR est=0; est<=2; est++ a. Imprimir encabezado de estación b. FOR obr=0; obr<=3; obr++ 1. Imprimir ‘OBRERO-’,Obr 2. totObr = 0 3. FOR dia=0; dia<=4; dia++ a. Imprimir prod[pla][est][obr][dia]


b. totObr = totObr + prod[pla][est][obr][dia] 4. ENDFOR 5. Imprimir totObr c. ENDFOR d. totEst = 0 e. FOR dia=0; dia<=4; dia++ 1. totDia = 0 2. FOR obr=0; obr<=3; obr++ a. totDia = totDia + prod[pla][est][obr][dia] 3. ENDFOR 4. Imprimir totDia 5. totEst = totEst + totDia f. ENDFOR g. Imprimir totEst h. totPlanta = totPlanta + totEst 4. ENDFOR 5. Imprimir totPlanta 6. totProd = totProd + totPlanta g. ENDFOR h. Imprimir totProd i. Fin Método principal Fin Clase ArregloCuatroDim3Fin

Explicación:


a. Se declaran las variables b. Inicia ciclo FOR desde pla=0 hasta 5 1. Inicia ciclo FOR desde est=0 hasta 2 a. Inicia ciclo FOR desde obr=0 hasta 3 1. Inicia ciclo FOR desde dia=0 hasta 4 a. Solicita prod[pla][est][obr][dia] b. Se lee en prod[pla][est][obr][dia] 2. Fin del FOR b. Fin del FOR 2. Fin del FOR c. Fin del FOR d. Imprime primer renglón del encabezado

e. Inicia totProd en 0 f. Inicia ciclo FOR desde pla=0 hasta 5 1. Imprime encabezado de planta 2. Inicia totPlanta en 0 3. Inicia FOR desde est=0 hasta 2


a. Imprime encabezado de estación b. Inicia ciclo FOR desde obr=0 hasta 3 1. Imprime “OBRERO-“,obr 2. Inicia totObr en 0 3. Inicia ciclo FOR desde dia=0 hasta 4 a. Imprime prod[pla][est][obr][dia] b. Incrementa totObr con prod[pla][est][obr][dia] 4. Fin del FOR 5. Imprime totObr c. Fin del FOR d. Inicia totEst en 0 e. Inicia ciclo FOR desde dia=0 hasta 4 1. Inicia totDia en 0 2. Inicia ciclo FOR desde obr=0 hasta 3 a. Incrementa totDia con prod[pla][est][obr][dia] 3. Fin del FOR 4. Imprime totDia 5. Incrementa totEst con totDia f. Fin del FOR g. Imprime totEst h. Incrementa totPlanta con totEst 4. Fin del FOR 5. Imprime totPlanta 6. Incrementa totProd con totPlanta g. Fin del FOR h. Imprime totProd i. Fin del Método principal


Ejercicio 8.4.1.3

Elaborar un algoritmo similar al anterior, añadiéndo al final de cada planta imprimir la estación más productiva de la planta y cuánto fué su producción. Y al final del reporte imprimir la planta más productiva de toda la compañía y cuánto fué su producción.


Algoritmo ARREGLO CUATRO DIMENSIONES Clase ArregloCuatroDim4 1. Método principal a. Declaraciones Variables prod: Arreglo[6][3][4][5] Entero pla, est, obr, dia, totEst, totDia, totObr, totPlanta, totProd, mayEst, mayProdEst, mayPla, mayProdPla: Entero


b. FOR pla=0; pla<=5; pla++ 1. FOR est=0; est<=2; est++ a. FOR obr=0; obr<=3; obr++ 1. FOR dia=0; dia<=4; dia++ a. Solicitar prod[pla][est][obr][dia] b. Leer prod[pla][est][obr][dia] 2. ENDFOR b. ENDFOR 2. ENDFOR c. ENDFOR d. Imprimir primer renglón del encabezado e. totProd = 0 ; mayProdPla = 0 f. FOR pla=0; pla<=5; pla++ 1. Imprimir encabezado de planta 2. totPlanta = 0 ; mayProdEst = 0 3. FOR est=0; est<=2; est++ a. Imprimir encabezado de estación b. FOR obr=0; obr<=3; obr++ 1. Imprimir ‘OBRERO-’,obr 2. totObr = 0 3. FOR dia=0; dia<=4; dia++ a. Imprimir prod[pla][est][obr][dia] b. totObr = totObr + prod[pla][est][obr][dia] 4. ENDFOR 5. Imprimir totObr c. ENDFOR d. totEst = 0 e. FOR dia=0; dia<=4; dia++ 1. totDia = 0 2. FOR obr=0; obr<=3; obr++ a. totDia = totDia + prod[pla][est][obr][dia] 3. ENDFOR 4. Imprimir totDia 5. totEst = totEst + totDia f. ENDFOR g. Imprimir totEst h. totPlanta = totPlanta + totEst i. IF totEst > mayProdEst THEN 1. mayProdEst = totEst 2. mayEst = est j. ENDIF 4. ENDFOR 5. Imprimir totPlanta, mayEst, mayProdEst 6. totProd = totProd + totPlanta 7. IF totPlanta > mayProdPla THEN


a. mayProdPla = totPlanta b. mayPla = Pla 8. ENDIF g. ENDFOR h. Imprimir totProd, mayPla, mayProdPla i. Fin Método principal Fin Clase ArregloCuatroDim4Fin

Explicación:


a. Se declaran las variables b. Inicia ciclo FOR desde pla=0 hasta 5 1. Inicia ciclo FOR desde est=0 hasta 2 a. Inicia ciclo FOR desde obr=0 hasta 3 1. Inicia ciclo FOR desde dia=0 hasta 4 a. Solicita prod[pla][est][obr][dia] b. Se lee en prod[pla][est][obr][dia] 2. Fin del FOR b. Fin del FOR 2. Fin del FOR c. Fin del FOR d. Imprime primer renglón del encabezado e. Inicia totProd en 0; mayProdPla en 0 f. Inicia ciclo FOR desde pla=0 hasta 5 1. Imprime encabezado de planta 2. Inicia totPlanta en 0; mayProdEst en 0 3. Inicia ciclo FOR desde est=0 hasta 2 a. Imprime encabezado de estación b. Inicia ciclo FOR desde obr=0 hasta 3 1. Imprime “OBRERO-“,obr 2. Inicia totObr en 0 3. Inicia ciclo FOR desde dia=0 hasta 4 a. Imprime prod[pla][est][obr][dia] b. Incrementa totObr con prod[pla][est][obr][dia] 4. Fin del FOR 5. Imprime totObr c. Fin del FOR d. Inicia totEst en 0 e. Inicia ciclo FOR desde dia=0 hasta 4 1. Inicia totDia en 0 2. Inicia ciclo FOR desde obr=0 hasta 3 a. Incrementa totDia con prod[pla][est][obr][dia] 3. Fin del FOR 4. Imprime totDia


5. Incrementa totEst con totDia f. Fin del FOR g. Imprime totEst h. Incrementa totPlanta con totEst i. Compara Si totEst > mayProdEst Si es asi, entonces 1. Coloca totEst en mayProdEst 2. Coloca est en mayEst j. Fin del IF 4. Fin del FOR 5. Imprime totPlanta, mayEst, mayProdEst 6. Incrementa totProd con totPlanta 7. Compara Si totPlanta > mayProdPla Si es asi, entonces a. Coloca totPlanta en mayProdPla b. Coloca pla en mayPla 8. Fin del IF g. Fin del FOR h. Imprime totProd, mayPla, mayProdPla i. Fin del Método principal


Capítulo 9


Ejercicio 9.6.4

Elaborar un algoritmo que lea 20 números en un arreglo de 20 elementos, que los imprima y que permita calcular e imprimir la media, la varianza, o la desviación estándar, o las tres al mismo tiempo, ofreciendo el siguiente menú:

MEDIDAS ESTADISTICAS

1. MEDIA2. VARIANZA3. DESVIACION ESTANDAR4. TODAS5. FIN

OPCION:

MEDIA se obtiene mediante la sumatoria de todos los números dividida entre la cantidad de números (20).VARIANZA se obtiene la sumatoria del cuadrado de cada una de las desviaciones de cada número respecto a la media, ésta sumatoria se divide entre la cantidad de números (20) menos 1 (N-1; si la cantidad de números es N).DESVIACION ESTANDAR se obtiene mediante la raíz cuadrada de la varianza.

Usar variables globales.

A continuación se tiene el algoritmo de la solución:


Algoritmo MEDIDAS ESTADISTICAS Clase MedidasEstadisticas 1. Declaraciones de clase


Variables numeros: Arreglo[20] Real n, opcion: Entero sumatoria, media, varianza, desviacion, desviacionEstandar: Real

2. Método principal a. Imprimir MENU

MEDIDAS ESTADISTICAS

1. MEDIA2. VARIANZA3. DESVIACION ESTANDAR4. TODAS5. FIN

OPCION:

b. Leer opcion c. FOR n=0; n<=19; n++ 1. Solicitar Numeros[n] 2. Leer numeros[n] d. ENDFOR e. FOR n=0; n<=19; n++ 1. Imprimir numeros[n] f. ENDFOR g. IF (opcion=1)OR(opcion=4) THEN 1. Llamar calcularMedia 2. Imprimir media h. ENDIF i. IF (opcion=2)OR(opcion=4) THEN 1. Llamar calcularVarianza 2. Imprimir varianza j. ENDIF k. IF (opcion=3)OR(opcion=4) THEN 1. Llamar calcularDesviacion 2. Imprimir desviacionEstandar l. ENDIF m. Fin Método principal

3. Método calcularMedia a. sumatoria = 0 b. FOR n=0; n<=19; n++ 1. sumatoria = sumatoria + numeros[n] c. ENDFOR d. media = sumatoria / n e. Fin Método calcularMedia


4. Método calcularVarianza a. Llamar calcularMedia b. sumatoria = 0 c. FOR n=0; n<=19; n++ 1. desviacion = numeros[n] - media 2. desviacion = desviacion^2 3. sumatoria = sumatoria + desviacion d. ENDFOR e. varianza = sumatoria / (n-1) f. Fin Método calcularVarianza

5. Método calcularDesviacion a. Llamar calcularVarianza b. desviacionEstandar = RaízCuad(varianza) c. Fin Método calcularDesviacion Fin Clase MedidasEstadisticasFin

Explicación:

Dentro de la clase, primeramente se hacen declaraciones de variables de clase; luego se defi nen cuatro métodos: Uno es el método principal; y los otros métodos, calculan la media, la varianza y la desviación estándar, respectivamente:

Se tiene el método principal:

1. Método principal a. Imprime MENU y solicita la opción b. Lee opcion c. Inicia ciclo FOR desde n = 0 hasta 19 1. Solicita numeros[n] 2. Lee numeros[n] d. Fin del FOR e. Inicia ciclo desde n = 0 hasta 19 1. Imprime numeros[n] f. Fin del FOR g. Si (opcion=1)OR(opcion=4) Entonces 1. Llama calcularMedia 2. Imprime media h. Fin del IF i. Si (opcion=2)OR(opcion=4) Entonces 1. Llama calcularVarianza 2. Imprime varianza j. Fin del IF k. Si (opcion=3)OR(opcion=4) Entonces 1. Llama calcularDesviacion 2. Imprime desviacionEstandar


l. Fin del IF m. Fin Método principal

2. Método calcularMedia a. Inicia sumatoria en 0 b. Inicia ciclo FOR desde n = 0 hasta 19 1. Incrementa Sumatoria con numeros[n] c. Fin del FOR d. Calcula media = sumatoria / n e. Fin Método calcularMedia

3. Método calcularVarianza a. Llama calcularMedia b. Inicia sumatoria en 0 c. Inicia ciclo FOR desde n = 0 hasta 19 1. calcula desviacion = numeros[n] - media 2. Eleva desviacion al cuadrado 3. Incrementa sumatoria con desviacion d. Fin del FOR e. Calcula varianza = sumatoria / (n-1) f. Fin Método calcularVarianza

4. Método calcularDesviacion a. Llama calcularVarianza b. Calcula desviacionEstandar = RaízCuad(varianza) c. Fin Método calcularDesviacion

Ejercicio 9.6.5

Elaborar un algoritmo que permita leer la base y el exponente, que llame a una método que eleve la base al exponente, al regresar al método principal que imprima el resultado. Usar parámetros por valor. A continuación se presenta el algoritmo de la solución:


Algoritmo EXPONENCIACION Clase Exponenciacion 1. Método principal a. Declaraciones Variables base, exponente, resultado: Real b. Solicitar Base, Exponente c. Leer base, exponente d. resultado = elevarPotencia(base, exponente) e. Imprimir resultado f. Fin Módulo principal


2. Método elevarPotencia(Val b, e: Real) a. Declaraciones Variables potencia: Real b. potencia = Exp(e * Ln(b)) c. return potencia d. Fin Método elevarPotencia Fin Clase ExponenciacionFin

Explicación:

Se defi ne un método que recibe en los parámetros por valor b y e los valores de la base y el exponente, calcula y devuelve el resultado de elevar la base a la potencia utilizando las funciones Exp y Ln. También podría hacerse así: Potencia(b,e). En el método principal se lee la base y el exponente; luego se utiliza el método elevarPo-ten cia, enviándose dichos datos como parámetros por valor, por último se imprime el resultado.

Ejercicio 9.6.6

Elaborar un algoritmo que imprima la sumatoria de las raíces cuadradas de los números pares desde 2 hasta 1500. Utilizar un método para el cálculo de la sumatoria. Usar pará-metro por refrencia. A continuación se tiene el algoritmo de la solución:


Algoritmo RAICES CUADRADAS Clase RaicesCuadradas 1. Método principal a. Declaraciones Variables sumatoria: Real b. Llamar calcularSuma(sumatoria) c. Imprimir sumatoria d. Fin Método principal

2. Método calcularSuma(Ref suma: Real) a. Declaraciones Variables r: Entero b. suma = 0 r = 0 c. DO 1. r = r + 2 2. suma = suma + RaízCuad(r)


d. WHILE r <> 1500 e. Fin Método calcularSuma Fin Clase RaicesCuadradasFin

Explicación:

1. Método principal a. Se declara la variable sumatoria b. Llama calcularSuma(sumatoria) enviando el parámetro sumatoria c. Imprime sumatoria

d. Fin Método principal

2. Método calcularSuma(Ref suma: Real) suma se defi ne como parámetro por referencia. a. Declara la variable r b. Inicia suma en 0 Inicia r en 0 c. Inicia ciclo DO 1. Incrementa r con 2 2. Incrementa suma con RaízCuad(r) d. Fin del ciclo WHILE r <>1500 regresa al DO e. Fin Método calcularSuma

Ejercicio 9.6.7

Elaborar un algoritmo que lea un número N, que imprima la sumatoria de los cuadrados de los enteros entre 1 y N. Utilizar un método para el cálculo de la sumatoria vía parámetro por referencia. También usar parámetro por valor. A continuación se tiene el algoritmo de la solución:

(Primero hágalo usted...después compara la solución)

Algoritmo SUMA CUADRADOS Clase SumaCuadrados 1. Método principal a. Declaraciones Variables n: Entero sumatoria: Real b. Solicitar N c. Leer n d. Llamar calcularSuma(sumatoria,n) e. Imprimir sumatoria f. Fin Método principal


2. Método calcularSuma(Ref suma: Real; Val x: Entero) a. Declaraciones Variables r: Entero b. suma = 0 r = 0 c. DO 1. r = r + 1 2. suma = suma + Potencia(r,2) d. WHILE r <> x e. Fin Método calcularSuma Fin Clase SumaCuadradosFin

Explicación:

1. Método Principal a. Se declaran las variables b. Solicita N c. Lee n d. Llama calcularSuma(sumatoria,n) enviando los parámetros sumatoria y n. e. Imprime sumatoria f. Fin Método principal

2. Método calcularSuma(Ref suma: Real; Val x: Entero) Declara suma como parámetro por referencia; y, x por valor. a. Se declaran las variables b. Inicia suma en 0 Inicia r en 0 c. Inicia ciclo DO 1. Incrementa r con 1 2. Incrementa suma con el cuadrado de r d. Fin ciclo WHILE r <> x regresa al DO e. Fin Método calcularSuma

Ejercicio 9.6.8

Elaborar un algoritmo que permita leer diez números de tipo real en un arreglo de 10 elementos en un método, utilizar un método que reciba como parámetro el arreglo y calcule la media (promedio) e imprima el resultado (en un método). Usar un arreglo de una dimensión como parámetro. A continuación se tiene el algoritmo de la solución:



Algoritmo MEDIA CON METODOS Clase MediaConMetodos 1. Método principal a. Declaraciones Variables vector: Arreglo[10] Real promedio: Real b. Llamar leerVector(vector) c. promedio = calcularMedia(vector) d. Llamar imprimirVector(vector) e. Imprimir promedio f. Fin Método principal

2. Método leerVector(Ref vec: Arreglo[10] Real) a. Declaraciones Variables n: Entero b. FOR n=0; n<=9; n++ 1. Solicitar elemento vec[n] 2. Leer vec[n] c. ENDFOR d. Fin Método leerVector

3. Método calcularMedia(Ref v: Arreglo[10] Real): Real a. Declaraciones Variables sumatoria, prom: Real i: Entero b. sumatoria = 0 c. FOR i=0; i<=9; i++ 1. sumatoria = sumatoria + v[i] d. ENDFOR e. prom = sumatoria / i f. return prom g. Fin Método calcularMedia

4. Método imprimirVector(Ref vect: Arreglo[10] Real) a. Declaraciones Variables x: Entero b. FOR x=0; x<=9; x++ 1. Imprimir vect[x] c. ENDFOR d. Fin Método imprimirVector Fin Clase MediaConMetodosFin


Explicación:

1. Método principal a. Se declaran variables vector: Arreglo de 10 elementos promedio: Real b. Llama leerVector(vector) enviando vector como parámetro c. Llama la función calcularMedia(vector) enviando vector como parámetro; y coloca

en promedio el valor que devuelva. d. Llama imprimirVector(vector) enviando vector como parámetro e. Imprime promedio f. Fin Método principal

2. Método leerVector(Ref vec: Arreglo de 10 elementos) Declara vec como parámetro por referencia, para conectarlo con vector. a. Se declara la variable n b. Inicia ciclo FOR desde n = 0 hasta 9 1. Solicita elemento vec[n] 2. Lee vec[n] c. Fin del FOR d. Fin Método leerVector

3. Método calcularMedia(Ref v: Arreglo de 10 elementos): Real Declara v como parámetro por referencia (podría ser por valor), para conectarlo con

vector. a. Se declaran variables b. sumatoria = 0 c. Inicia ciclo FOR desde i = 0 hasta 9 1. Incrementa sumatoria con v[i] d. Fin del FOR e. Calcula prom = sumatoria / i f. Regresa el valor de prom g. Fin Método calcularMedia

4. Método imprimirVector(Ref vect: Arreglo de 10 elementos) Declara v como parámetro por referencia (podría ser por valor), para conectarlo con

vector. a. Se declara la variable x b. Inicia ciclo FOR desde x = 0 hasta 9 1. Imprime vect[x] c. Fin del FOR d. Fin Método imprimirVector

Ejercicio 9.6.9

Elaborar un algoritmo que lea diez valores para Y y X que calcule el valor de Z e imprima los valores de X, Y y Z en cada ocasión; utilizando la función:


Z = Yx

Además del método principal, utilizar un método para leer los valores de X y Y, otro método para elevar Y a la X, y otro método para imprimir los valores de X, Y y Z. A continuación se tiene el algoritmo de la solución:


Algoritmo VALOR Z Clase ValorZ 1. Método principal a. Declaraciones Variables n: Entero x, y, z: Real b. FOR n=1; n<=10; n++ 1. Llamar leerNumeros(x,y) 2. z = elevarPotencia(y,x) 3. Llamar imprimirNumeros(x,y,z) c. ENDFOR d. Fin Método principal

2. Método leerNumeros(Ref a, b: Real) a. Solicitar Numero 1, Numero 2 b. Leer a, b c. Fin Método leerNumeros

3. Método elevarPotencia(Val b, e: Real): Real a. Declaraciones Variables potencia: Real b. potencia = Exp(e * Ln (b)) c. return potencia d. Fin Método elevarPotencia

4. Método imprimirNumeros(Val x2, y2, z2: Real) a. Imprimir x2, y2, z2 b. Fin Método imprimirNumeros Fin Clase ValorZFin

Explicación:

1. Método principal a. Se declaran variables b. Inicia ciclo FOR desde n = 1 hasta 10 1. Llama al método leerNumeros(x,y); enviandole x y y como parámetros.


2. z = elevarPotencia(y,x); enviandole x y y como parámetros. Coloca en z el valor que devuelve el llamado del método elevarPotencia(y,x), a la

que se le envian los parámetros y y x. 3. Llama al método imprimirNumeros(x,y,z); enviandole x, y y z como pará-

metros. c. Fin del FOR d. Fin Método principal

2. Método leerNumeros(Ref a, b: Real) a. Solicita Numero 1, Numero 2 b. Lee a, b; los cuales se reflejan en x y y por ser parámetros por referencia. c. Fin Método leerNumeros

3. Método elevarPotencia(Val b, e: Real): Real Declara b y e como parámetros por valor, los cuales reciben los valores de y y x. a. Se declara la variable potencia b. Eleva b a la potencia e y coloca el resultado en potencia c. Regresa el valor de potencia d. Fin Método elevarPotencia

4. Método imprimirNumeros(Val x2, y2, z2: Real) Declara x2, y2, z2 como parámetros por valor, los cuales reciben los valores de

x, y, z. a. Se imprimen los valores de x2, y2, z2 b. Fin Método imprimirNumeros

Ejercicio 9.6.10

Elaborar un algoritmo que permita leer números enteros en una matriz de 4 × 3; imprimir la matriz y el elemento que al mismo tiempo sea el mayor de su renglón y el menor de su columna. Usar un arreglo de dos dimensiones como parámetro. A continuación se tiene el algoritmo de la solución:


Algoritmo MAYOR RENGLON MENOR COLUMNA Clase MayorRenMenorCol 1. Método principal a. Declaraciones Variables matriz: Arreglo[4][3] Entero b. Llamar leerMatriz(matriz) c. Llamar imprimirMatriz(matriz) d. Fin Método principal


2. Método leerMatriz(Ref mat: Arreglo[4][3] Entero) a. Declaraciones Variables r, c: Entero b. FOR r=0; r<=3; r++ 1. FOR c=0; c<=2; c++ a. Solicitar elemento mat[r][c] b. Leer mat[r][c] 2. ENDFOR c. ENDFOR d. Fin Método leerMatriz

3. Método imprimirMatriz(Ref ma: Arreglo[4][3] Entero) a. Declaraciones Variables re, co, r, c, ren, mayRen, menCol, reMa, coMa, reMe, coMe: Entero b. FOR re=0; re<=3; re++ 1. FOR co=0; co<=2; co++ a. Imprimir ma[re][co] 2. ENDFOR c. ENDFOR d. FOR ren=0; ren<=3; ren++ 1. mayRen = ma[ren,0] reMa = ren coMa = 0 2. FOR c=1; c<=2; c++ a. IF ma[ren][c] > mayRen THEN 1. mayRen = ma[ren][c] 2. reMa = ren 3. coMa = c b. ENDIF 3. ENDFOR 4. menCol = ma[0,coMa] reMe = 1 coMe = coMa 5. FOR r=1; r<=3; r++ a. IF ma[r][coMa] < menCol THEN 1. menCol = ma[r][coMa] 2. reMe = r 3. coMe = coMa b. ENDIF 6. ENDFOR 7. IF (reMa = reMe)AND(coMa = coMe) THEN a. Imprimir ma[reMa][coMa], reMa, coMa 8. ENDIF e. ENDFOR


f. Fin Método imprimirMatriz Fin Clase MayorRenMenorColFin

Explicación:

1. Método principal a. Se declaran variables b. Llama al método leerMatriz(matriz); envía matriz como parámetro. c. Llama al método imprimirMatriz(matriz); envía matriz como parámetro. d. Fin Método principal

2. Método leerMatriz(Ref mat: Arreglo[4][3] Entero) Declara mat como parámetro por referencia. Para conectarla con matriz a. Declara las variables r y c b. Inicia ciclo FOR desde r = 0 hasta 3 1. Inicia ciclo FOR desde c = 0 hasta 2 a. Solicita elemento mat[r,c] b. Lee mat[r,c] 2. Fin del FOR c. Fin del FOR d. Fin Método leerMatriz

3. Método imprimirMatriz(Ref ma: Arreglo[4][3] Entero) a. Declara las variables re, co, r, c, ren, mayRen, menCol, reMa, coMa, reMe, coMe: Entero b. Inicia ciclo FOR desde re = 0 hasta 3 1. Inicia ciclo FOR desde co = 0 hasta 2 a. Imprime elemento ma[re][co] 2. Fin del FOR c. Fin del FOR d. Inicia ciclo FOR desde ren = 0 hasta 3 1. Coloca en mayRen el elemento ma[ren,0] Coloca en reMa el valor de ren Coloca en coMa el valor 0 2. Inicia ciclo FOR desde c = 0 hasta 2 a. Si ma[ren][c] > mayRen Entonces 1. Coloca en mayRen el elemento ma[ren][c] 2. Coloca en reMa el valor de ren 3. Coloca en coMa el valor de c b. Fin del IF 3. Fin del FOR 4. Coloca en menCol el elemento ma[0,coMa] Coloca en reMe el valor 1 Coloca en coMe el valor de coMa 5. Inicia ciclo FOR desde r = 1 hasta 3


a. Si ma[r][coMa] < menCol Entonces 1. Coloca en menCol el elemento ma[r][coMa] 2. Coloca en reMe el valor de r 3. Coloca en coMe el valor de coMa b. Fin del IF 6. Fin del FOR 7. Si (reMa = reMe)AND(coMa = coMe) Entonces a. Imprime ma[reMa][coMa], reMa, coMa 8. Fin del IF e. Fin del FOR f. Fin Método imprimirMatriz

Ejercicio 9.6.11

Elaborar un algoritmo que lea números en una matriz de 4 × 4 e indique si es simétrica o no; es simétrica si el elemento i,j es igual al elemento j,i para todo par de valores de i y j. Utilizar un método para la lectura mediante parámetro por referencia, y otro método que regrese el valor 1 si es simétrica o 0 si no lo es. Usar un arreglo de dos dimensiones como parámetro. A continuación se tiene el algoritmo de la solución:


Algoritmo MATRIZ SIMETRICA Clase MatrizSimetrica 1. Método principal a. Declaraciones Variables matriz: Arreglo[4][4] Entero resultado: Entero b. Llamar leerMatriz(matriz) c. resultado = simetrica(matriz) d. Llamar imprimirMatriz(matriz) e. IF resultado = 1 THEN 1. Imprimir “LA MATRIZ ES SIMETRICA” f. ELSE 1. Imprimir “LA MATRIZ NO ES SIMETRICA” g. ENDIF h. Fin Método principal

2. Método leerMatriz(Ref mat: Arreglo[4][4] Entero) a. Declaraciones Variables r,c: Entero b. FOR r=0; r<=3; r++ 1. FOR c=0; c<=3; c++


a. Solicitar elemento mat[r][c] b. Leer mat[r][c] 2. ENDFOR c. ENDFOR d. Fin Método leerMatriz

3. Método simetrica(Val m: Arreglo[4][4] Entero): Entero a. Declaraciones Variables ren, col, resul: Entero b. resul = 1 c. FOR ren=0; ren<=3; ren++ 1. FOR col=0; col<=3; col++ a. IF m[ren][col] <> m[col][ren] THEN 1. resul = 0 b. ENDIF 2. ENDFOR d. ENDFOR e. return resul f. Fin Método simetrica

4. Método imprimirMatriz(Ref ma: Arreglo[4][4] Entero) a. Declaraciones Variables re, co: Entero b. FOR re=0; re<=3; re++ 1. FOR co=0; co<=3; co++ a. Imprimir ma[r][c] 2. ENDFOR c. ENDFOR d. Fin Método imprimirMatriz Fin Clase MatrizSimetricaFin

Explicación:

1. Método principal a. Se declaran variables b. Llama leerMatriz(matriz); envía matriz como parámetro. c. Coloca en resultado el valor que devuelva al llamar simetrica(matriz); envía matriz

como parámetro. d. Llama imprimirMatriz(matriz) envía matriz como parámetro. e. Si resultado =1Entonces 1. Imprime “LA MATRIZ ES SIMETRICA” f. Si no 1. Imprime “LA MATRIZ NO ES SIMETRICA” g. Fin del IF


h. Fin Método principal

2. Método leerMatriz(Ref mat: Arreglo[4][4] Entero) Declara mat como parámetro por referencia. Para conectarla con matriz a. Declara las variables r y c b. c. Lee los elementos de la matriz. d. Fin Método leerMatriz

3. Método simetrica(Val m: Arreglo[4][4] Entero): Entero Declara m como parámetro por referencia. Para conectarla con matriz a. Declara la variable resul b. Inicia asimetria con 1 c. ciclo FOR desde r = 0 hasta 3 1. ciclo FOR desde c = 0 hasta 3 a. Compara si m[r,c] <> m[c,r] Si es asi, Entonces 1. Coloca en resul el valor 0 b. Fin IF 2. Fin FOR d. Fin FOR e. Regresa el valor de resul f. Fin Método simetrica

4. Método imprimirMatriz(Ref ma: Arreglo[4][4] Entero) Declara ma como parámetro por referencia. Para conectarla con matriz a. ciclo FOR desde r = 0 hasta 3 1. ciclo FOR desde c = 0 hasta 3 a. Imprime ma[r,c] 2. Fin FOR b. Fin FOR c. Fin Método imprimirMatriz

Ejercicio 9.6.12

Elaborar un algoritmo que permita leer un número de tipo entero de cinco cifras; calcular e imprimir el dígito verificador. El dígito verificador es un número entre 0 y 9, que se obtiene a partir de un número en el que se toma en cuenta la posición que tiene cada dígito; se obtiene de la siguiente manera:

Si se tiene el número: 74621

Proceso 1 Se obtiene la suma de los productos: el primer número de la derecha multiplicado por dos, el siguiente a la izquierda por tres, el siguiente por cuatro, y así sucesivamente, hasta siete (el multiplicador vuelve a iniciar en 2, en caso de ser necesario).


7 4 6 2 1

1 × 2 = 2 2 × 3 = 6 6 × 4 = 24 4 × 5 = 20 7 × 6 = 42 94

Proceso 2 Se determina el residuo al dividir el producto entre once.

11 946

8)

Proceso 3 Si el residuo es cero o uno, entonces ése es el dígito verificador; de lo contrario el digito verificador será igual al resultado que se obtenga de once menos el residuo; en el ejemplo:

Digito verificador = 11 - 6 = 5

A continuación se presenta el algoritmo que realiza el proceso explicado anterior-mente.


Algoritmo DIGITO Clase Digito 1. Método principal a. Declaraciones Variables n, digiVerif: Entero b. Solicitar N c. Leer n d. digiVerif = calcularDigiVerif(n) e. Imprimir digiVerif f. Fin Método principal

2. Método calcularDigiVerif(Val nume: Entero) a. Declaraciones Variables i, producto, multiplicador, n2, e, digVeri, residuo: Entero numero: Cadena num: Carácter b. Cadena(nume,numero) c. producto = 0 d. multiplicador = 1 e. FOR i=Longitud(numero)-1; i>=0; i-- 1. multiplicador = multiplicador + 1


2. num = SubCadena(numero,i,1) 3. Valor(num,n2,e) 4. producto = producto + (n2 * multiplicador) f. ENDFOR g. residuo = producto h. WHILE residuo > = 11 a. residuo = residuo - 11 i. ENDWHILE j. IF (residuo = 0) OR (residuo = 1) THEN a. digVeri = residuo k. ELSE a. digVeri = 11 - residuo l. ENDIF m. return DigVeri n. Fin Método CalcularDigiVerif Fin Clase DigitoFin

Explicación:

1. Método principal a. Se declaran variables b. Solicita N c. Lee n d. Coloca en digiVerif = el valor devuelto por calcularDigiVerif(n), envía el parámetro

n. e. Imprime digiVerif f. Fin Método principal

2. Método calcularDigiVerif(Val nume : Entero) Declara nume como parámetro por valor, para conectarse con n. a. Declara variables b. Convierte nume a Cadena y lo coloca en numero c. Inicia producto en 0 d. Inicia multiplicador en 1 e. Ciclo FOR desde i = la longitud del numero menos 1, hasta 0 con decrementos de -1 1. Incrementa multiplicador en 1 2. Coloca en num la SubCadena(numero,i,1) 3. Convierte a numérico num y lo pone en n2 4. Incrementa producto con (n2 * multiplicador) f. Fin FOR g. Coloca en residuo el valor de producto h. Ciclo WHILE residuo > = 11 a. Le quita 11 a residuo i. Fin WHILE j. Si (residuo = 0) OR (residuo = 1) Entonces a. Coloca en digVeri el valor de residuo


k. Si no a. Coloca en digVeri el resultado de 11 - residuo l. Fin IF m. Regresa valor de DigVeri n. Fin Método calcularDigiVerif

Ejercicio 9.6.13

Elaborar un algoritmo que permita leer una frase u oración y que imprima si es un palín-dromo o no. Un palíndromo es una frase que se lee igual de izquierda a derecha que de derecha a izquierda . Por ejemplo: RADAR se lee igual de izquierda a derecha que de derecha a izquierda. Usar funciones cadena de caracteres. A continuación se tiene el algoritmo de la solución:


Algoritmo PALINDROMO Clase Palindromo 1. Método principal a. Declaraciones Variables frase, frase2: Cadena car: Carácter l: Entero b. Solicitar la frase c. Leer frase d. frase2 = “” e. FOR l=Longitud(frase)-1; l>=0; l-- 1. car = SubCadena(frase,l,1) 2. frase2 = frase2 + car f. ENDFOR g. IF frase = frase2 THEN 1. Imprimir “ES UN PALINDROMO” h. ELSE 1. Imprimir “NO ES UN PALINDROMO” i. ENDIF j. Fin Método principal Fin Clase PalindromoFin

Explicación:

1. Método principal a. Se declaran variables b. Solicita frase c. Lee frase


d. Inicia frase2 en nulo e. Inicia ciclo FOR desde l = Longitud(frase) menos 1, hasta 0 con decrementos de -1 1. Copia el siguiente carácter en car 2. Concatena en Frase2 el car f. Fin FOR g. Si frase = frase2 Entonces 1. Imprime “ ES UN PALINDROMO “ h. Si no 1. Imprime “ NO ES UN PALINDROMO “ i. Fin IF j. Fin Método principal

Ejercicio 9.6.14

Elaborar un algoritmo que lea una fecha en forma DDMMAAAA, es decir, DD son dos dígitos que indican el día MM son dos dígitos que indican el mes AAAA son cuatro dígitos que indican el año. Imprimir la fecha: Por ejemplo; si teclea 21082005 debe imprimir:

21 de Agosto de 2005

Usar funciones cadena de caracteres.

A continuación se tiene el algoritmo de la solución:


Algoritmo DICE FECHA Clase DiceFecha 1. Método principal a. Declaraciones fecha: Cadena[8] dia, mes2, anio: Cadena[2] anio: Cadena[4] nombreMes: Cadena[15] nuMes, x: Entero b. Solicitar fecha c. Leer fecha d. dia = SubCadena(fecha,1,2) mes2 = SubCadena(fecha,3,2) Valor(mes2,nuMes,x) anio = SubCadena(fecha,5,4) e. SWITCH nuMes 1: nombreMes = “Enero” 2: nombreMes = “Febrero” 3: nombreMes = “Marzo”


4: nombreMes = “Abril” 5: nombreMes = “Mayo” 6: nombreMes = “Junio” 7: nombreMes = “Julio” 8: nombreMes = “Agosto” 9: nombreMes = “Septiembre” 10: nombreMes = “Octubre” 11: nombreMes = “Noviembre” 12: nombreMes = “Diciembre” f. ENDSWITCH g. Imprimir dia, “ de “, nombreMes ,” de ”, anio h. Fin Método principal Fin Clase DiceFechaFin

Explicación:

1. Método principal a. Se declaran variables b. Solicita fecha c. Lee fecha d. Copia en dia los dos caracteres del día Copia en mes2 los dos caracteres del mes Convierte a numérico el mes Copia en anio los cuatro caracteres del año. e. Inicia SWITCH nuMes Si nuMes = 1: nombreMes = “Enero” Si nuMes = 2: nombreMes = “Febrero” Si nuMes = 3: nombreMes = “Marzo” Si nuMes = 4: nombreMes = “Abril” Si nuMes = 5: nombreMes = “Mayo” Si nuMes = 6: nombreMes = “Junio” Si nuMes = 7: nombreMes = “Julio” Si nuMes = 8: nombreMes = “Agosto” Si nuMes = 9: nombreMes = “Septiembre” Si nuMes = 10: nombreMes = “Octubre” Si nuMes = 11: nombreMes = “Noviembre” Si nuMes = 12: nombreMes = “Diciembre” f. Fin SWITCH g. Imprime dia, “ de “, nombreMes ,” de “, anio h. Fin Método principal

Ejercicio 9.6.15

Elaborar un algoritmo que lea el nombre de un empleado, el número de horas trabajadas y la cuota por hora; hacer y utilizar los métodos leerEntero, el cual permita leer un núme-


ro de tipo entero normal haciendo la validación, es decir, sólo permitir los dígitos del 0 al 9, el signo de menos y que esté en el rango –32768 al 32767 (tipo entero normal); leerAl-fabético, que sólo debe permitir la lectura de caracteres alfabéticos, el espacio y el punto; y leerReal, que sólo debe permitir la lectura de dígitos, el signo de menos y un punto decimal. Imprimir los tres datos leídos. Para leer los datos se deben utilizar métodos que regresan valor, es decir, devuelven el valor leído. Usar funciones de cadenas de caracteres para validar la entrada de datos. A continuación se tiene el algoritmo de la solución:


Algoritmo VALIDACION Clase Validacion 1. Método principal a. Declaraciones Variables nombreEmp: Cadena horasTrab: Entero cuotaHora: Real b. nombreEmp = leerAlfabetico() c. horasTrab = leerEntero() d. cuotaHora = leerReal() e. Imprimir nombreEmp, horasTrab, cuotaHora f. Fin Método principal

2. Método leerAlfabetico(): Cadena a. Declaraciones Variables nom: Cadena i, bandera: Entero car: Carácter b. DO 1. bandera = 1 2. Solicitar Nombre del empleado 3. Leer nom 4. FOR i=0; i<=Longitud(nom)-1; i++ a. car = SubCadena(nom,i,1) b. IF NOT(((car >= “a”)AND(car<=“z”))OR ((car>=“A”)AND(car<=”Z”))OR (car=“ “)OR(car=“.“)) THEN 1. bandera = 0 c. ENDIF 5. ENDFOR c. WHILE bandera <> 1 d. return nom e. Fin Método leerAlfabetico


3. Método leerEntero(): Entero a. Declaraciones Variables n, i, e, bandera: Entero numero: Cadena num: Carácter b. DO 1. DO a. bandera = 1 b. Solicitar Número de horas trabajadas c. Leer numero d. FOR i=0; i<=Longitud(numero)-1; i++ 1. num = SubCadena(numero,i,1) 2. IF NOT(((num>=“0”)AND(num<=“9”))OR (num=”-“)) THEN a. bandera = 0 3. ENDIF 4. IF (num=”-“)AND(i>0) THEN a. bandera = 0 5. ENDIF e. ENDFOR 2. WHILE bandera <> 1 3. n = Valor(numero,n,e) 4. IF (n < -32768)OR(n > 32767) THEN a. bandera = 0 5. ENDIF c. WHILE bandera <> 1 d. return n e. Fin Método leerEntero

4. Método leerReal(): Real a. Declaraciones Variables z: Real numero: Cadena i, e, puntos, bandera: Entero num: Carácter b. DO 1. bandera = 1 2. puntos = 0 3. Solicitar Cuota por hora 4. Leer numero 5. FOR i=0; i<=Longitud(numero)-1; i++ a. num = SubCadena(numero,i,1) b. IF NOT(((num>=“0”)AND(num<=“9”)) OR(num=”-“)OR(num=”.“)) THEN


1. bandera = 0 c. ENDIF d. IF (num=”-“)AND(i>0) THEN a. bandera = 0 e. ENDIF f. IF num = “.” THEN 1. puntos = puntos + 1 g. ENDIF 6. ENDFOR 7. IF puntos > 1 THEN a. bandera = 0 8. ENDIF c. WHILE bandera <> 1 d. n = Valor(numero,z,e) e. return n f. Fin Método leerReal Fin Clase ValidacionFin

Explicación:

1. Método Principal a. Se declaran variables del método principal b. Llama leerAlfabetico() y el valor que regresa lo coloca en nombreEmp c. Llama leerEntero() y el valor que regresa lo coloca en horasTrab d. Llama leerReal() y el valor que regresa lo coloca en cuotaHora e. Imprime nombreEmp, horasTrab, cuotaHora f. Fin Método principal

2. Método leerAlfabetico(): Cadena a. Se declaran variables b. Inicia ciclo DO 1. Inicia bandera con 1 2. Solicita Nombre del empleado 3. Lee nom 4. Inicia ciclo FOR desde i = 0 hasta Longitud(nom)-1 a. Copia en car el siguiente carácter b. Si car no es un carácter válido (letra, espacio o punto); Entonces 1. Coloca bandera en 0 c. Fin IF 5. Fin FOR c. Fin ciclo WHILE bandera <> 1 (no tecleó caracteres válidos); regresa al DO d. Regresa el valor de nom e. Fin Método leerAlfabetico Repite el ciclo de leer hasta que haya leído un dato alfabético sin errores.


3. Método leerEntero(): Entero a. Se declaran variables b. Inicia ciclo DO 1. Inicia ciclo DO a. Inicia bandera con 1 b. Solicita Número de horas trabajadas c. Lee numero d. Inicia ciclo FOR desde i = 0 hasta 4 1. Copia en num el siguiente carácter 2. Si num no es dígito entre 0 y 9; y no es el signo de menos Entonces a. Coloca bandera en 0 3. Fin IF 4. Si num es menos y no esta en el carácter 0 Entonces a. Coloca bandera en 0 5. Fin IF e. Fin FOR 2. Fin ciclo WHILE bandera <> 1 (no tecleó bien el número); regresa al DO 3. Copia en n el siguiente carácter 4. Si (n < -32768)OR(n > 32767) Entonces a. Coloca bandera en 0 5. Fin IF c. Fin ciclo WHILE bandera <> 1 (no esta en el rango del entero); regresa al DO d. Regresa el valor de n e. Fin Método leerEntero Repite el ciclo de leer hasta que haya leído un dato entero sin errores.

4. Método leerReal(): Real Declara z como parámetro por referencia. a. Se declaran variables b. Inicia ciclo DO 1. Coloca bandera en 1 2. Inicia puntos en 0 3. Solicitar Cuota por hora 4. Lee numero 5. Inicia ciclo FOR desde i = 0 hasta Longitud(numero)-1 a. Copia en num el siguiente carácter b. Si num no es dígito entre 0 y 9; y no es el signo de menos; ni el punto Enton-

ces 1. Coloca bandera en 0 c. Fin IF d. Si num es menos y no esta en el carácter 0 Entonces 1. Coloca bandera en 0 e. Fin IF f. Si num = “.” Entonces 1. Incrementa puntos en 1 g. Fin IF 6. Fin FOR


7. Si puntos > 1 Entonces a. Coloca bandera en 0 8. Fin IF c. Fin ciclo WHILE bandera <> 1 (no tecleó bien el número); regresa al DO d. Convierte numero a numérico y lo pone en n e. Regresa el valor de n f. Fin Método leerReal Repite el ciclo de leer hasta que haya leído un dato real sin errores.

Ejercicio 9.6.16

Elaborar un algoritmo que permita leer una frase u oración e imprimir cuántas veces se utilizó cada una de las vocales. Usar funciones cadena de caracteres y parámetros. A continuación se tiene el algoritmo de la solución:


Algoritmo VOCALES Clase Vocales 1. Método principal a. Declaraciones Variables frase: Cadena l, a, e, i, o, u: Entero car: Carácter b. a = 0; e = 0; i = 0; o = 0; u = 0 c. Solicitar Frase d. Leer frase e. FOR l=0; l<=Longitud(frase)-1; l++ 1. car = obtenerCaracter(frase,l) 2. IF (car=”a”)OR(car=”A”) THEN a. a = a + 1 3. ENDIF 4. IF (car=”e”)OR(car=”E”) THEN a. e = e + 1 5. ENDIF 6. IF (car=”i”)OR(car=”I”) THEN a. i = i + 1 7. ENDIF 8. IF (car=”o”)OR(car=”O”) THEN a. o = o + 1 9. ENDIF 10. IF (car=”u”)OR(car=”U”) THEN a. u = u + 1 11. ENDIF f. ENDFOR


g. Imprimir “A=”,a, ”E=”, e, “I=”, i, “O=”, o, “U=”, u h. Fin Método principal

2. Método obtenerCaracter(Val fra: Cadena; Ref i: Entero): Caracter a. Declaraciones Variables carAux: Carácter b. carAux = SubCadena(fra,i,1) c. return carAux d. Fin Método obtenerCaracter Fin Clase VocalesFin

Explicación:

1. Método principal a. Se declaran variables b. Inicia los contadores a = 0; e = 0; i = 0; o = 0; u = 0 c. Solicita Frase d. Lee frase e. Inicia ciclo FOR desde l = 0 hasta Longitud(frase)-1 1. Obtiene siguiente carácter y lo pone en car 2. Si (car=”a”)OR(car=”A”) Entonces a. a = a + 1 3. Fin IF 4. Si (car=”e”)OR(car=”E”) Entonces a. e = e + 1 5. Fin IF 6. Si (car=”i”)OR(car=”I”) Entonces a. i = i + 1 7. Fin IF 8. Si(car=”o”)OR(car=”O”) Entonces a. o = o + 1 9. Fin IF 10. Si (car=”u”)OR(car=”U”) Entonces a. u = u + 1 11. Fin IF f. Fin FOR g. Imprime “A=”, a, ”E=”, e, “I=”, i, “O=”, o, “U=”, u h. Fin Método principal

2. Método obtenerCaracter(Val fra: Cadena100; Ref i: Entero): Caracter Declara fra como parámetro por valor y por referencia i. a. Declara la variable carAux b. Copia en carAux el siguiente carácter


c. Regresa el valor de carAux d. Fin Método obtenerCaracter

Ejercicio 9.6.17

Elaborar un algoritmo que permita leer una frase u oración, que llame a un método que obtenga una palabra, al regresar al método principal que la imprima, esto se debe repetir hasta que se termine la frase. Usar funciones cadena de caracteres y parámetros. A continuación se tiene el algoritmo de la solución:


Algoritmo PALABRAS Clase Palabras 1. Método principal a. Declaraciones Variables frase : Cadena palabra: Cadena l: Entero b. Solicitar Frase c. Leer frase d. l = 0 e. DO 1. palabra = obtenerPalabra(frase,l) 2. Imprimir palabra f. WHILE l < Longitud(frase) g. Fin Método principal

2. Método obtenerPalabra(Val fra: Cadena; Ref c: Entero): Cadena a. Declaraciones Variables car: Carácter pal: Cadena b. pal = “” c. DO 2. car = SubCadena(fra,c,1) 3. IF car <> “ ” THEN a. pal = pal + car 4. ENDIF 5. c = c + 1 d. WHILE (car <> “ ”)AND(c <> Longitud(fra)) e. return pal f. Fin Método obtenerPalabra Fin Clase PalabrasFin


Explicación:

1. Método principal a. Se declaran variables b. Se solicita la Frase c. Se lee en frase d. Se inicia l en 0 e. Inicia DO 1. Obtiene la siguiente palabra en el método obtenerPalabra(frase,l) 2. Imprime la palabra f. Fin ciclo WHILE l < Longitud(frase) g. Fin Método principal

2. Método obtenerPalabra(Val fra: Cadena; Ref c: Entero): Cadena a. Se declaran variables b. Inicia ciclo DO 1. Inicia pal con nulo 2. Copia en car el carácter número c de fra 3. Si car es diferente de espacio; Entonces a. Concatena el car en pal 4. Fin del IF 5. Incrementa c en 1 c. Fin ciclo WHILE (car <> “ ”)AND(c <> Longitud(fra)); Regresa al DO d. Regresa el valor de pal e. Fin Función obtenerPalabra

Ejercicio 9.6.18

Elaborar un algoritmo que permita leer una frase u oración que llame a un método que obtenga una palabra, al regresar al método principal que la imprima, esto se debe repetir hasta que se termine la frase; y al fi nal, que imprima la palabra más larga y su longitud. Supóngase que no habrá dos o más palabras con el mismo tamaño. Usar funciones cadena de caracteres y parámetros. A continuación se tiene el algoritmo de la solución:


Algoritmo PALABRAS Y MAYOR Clase PalabrasMayor 1. Método principal a. Declaraciones Variables frase: Cadena palabra, palabraMayor: Cadena l, tamanioPal, mayorTamanio: Entero b. Solicitar Frase


c. Leer frase d. mayorTamanio = 0 l = 0 e. DO 1. palabra = obtenerPalabra(frase,l) 2. Imprimir palabra 3. TamanioPal = Longitud(palabra) 4. IF tamanioPal > mayorTamanio THEN a. mayorTamanio = tamanioPal b. palabraMayor = palabra 5. ENDIF f. WHILE l < Longitud(frase) g. Imprimir palabraMayor, mayorTamanio h. Fin Método principal

2. Método obtenerPalabra(Val fra: Cadena; Ref c: Entero): Cadena a. Declaraciones Variables car: Carácter pal: Cadena b. pal = “” c. DO 1. car = SubCadena(fra,c,1) 2. IF car <> “ ” THEN a. pal = pal + car 3. ENDIF 4. c = c + 1 d. WHILE (car <> “ ”)AND(c <> Longitud(fra)) e. return pal f. Fin Método obtenerPalabra Fin Clase PalabrasMayorFin

Explicación:

1. Método principal a. Se declaran variables b. Se solicita la Frase c. Se lee frase d. Se inicializa mayorTamanio en 0 Se inicializa l en 0 e. Inicia ciclo DO 1. Llama obtenerPalabra enviando frase y l como parámetros y la palabra que de-

vuelve la coloca en palabra. 2. Imprime palabra


3. Coloca en tamanioPal la longitud de palabra 4. Si tamanioPal > mayorTamanio Entonces a. Coloca en mayorTamanio el tamanioPal b. Coloca en palabraMayor el valor de palabra 5. Fin del IF f. Fin del ciclo WHILE l < Longitud(frase); regresa al DO g. Imprimir palabraMayor, mayorTamanio h. Fin Método principal

2. Método obtenerPalabra(Val fra: Cadena; Ref c: Entero): Cadena Declara fra y c como parámetros que se conectan con frase y l. a. Se declaran variables b. Inicia pal en nulo c. Inicia ciclo DO 1. Copia en car el siguiente carácter 2. Si car <> “ “ Entonces a. Concatena en pal el valor de car 3. Fin IF 4. Incrementa c en 1 d. Fin ciclo WHILE (car <> “ ”)AND(c <> Longitud(fra)); Regresa al DO e. Regresa el valor de pal f. Fin Método obtenerPalabra

Ejercicio 9.6.19

Elaborar un algoritmo que genere números aleatorios (al azar) y los guarde en una matriz de 20x10 (generará 200 números); y por último que los imprima. Usar un arreglo de dos dimensiones como parámetro. A continuación se tiene el algoritmo de la solución:


Algoritmo NUMEROS ALEATORIOS Clase NumerosAleatorios 1. Método principal a. Declaraciones Variables numeros: Arreglo[20][10] Real b. Llamar generarNumeros(numeros) c. Llamar imprimirMatriz(numeros) d. Fin Método principal

2. Método generarNumeros(Ref mat: Arreglo[20][10] Real) a. Declaraciones Variables r, c: Entero b. IniciaRandom


c. FOR r=0; r<=19; r++ 1. FOR c=0; c<=9; c++ a. mat[r][c] = Random 2. ENDFOR d. ENDFOR e. Fin Método generarNumeros

3. Método imprimirMatriz(Val ma: Arreglo[20][10] Real) a. Declaraciones Variables re, co: Entero b. FOR re=0; re<=19; re++ 1. FOR co=0; co<=9; co++ a. Imprimir ma[re][co] 2. ENDFOR c. ENDFOR d. Fin Método imprimirMatriz Fin Clase NumerosAleatoriosFin

Explicación:

1. Método principal a. Se declara la variable numeros que es un arreglo de 20,10 b. Llama generarNumeros c. Llama imprimirMatriz d. Fin Módulo Principal

2. Método GenerarNumeros a. Se declaran las variables r y c b. Inicia generador de números aleatorios Random c. Inicia ciclo FOR desde r = 0 hasta 19 1. Inicia ciclo FOR desde c = 0 hasta 9 a. Genera número Random y lo pone en mat[r][c] 2. Fin FOR d. Fin FOR e. Fin Método generarNumeros

3. Método imprimirMatriz a. Se declaran las variables re y co b. Inicia ciclo FOR desde re = 0 hasta 19 1. Inicia ciclo FOR desde co = 0 hasta 9 a. Imprime ma[re][co] 2. Fin FOR c. Fin FOR d. Fin Método imprimirMatriz


Nota:En estos últimos algoritmos se han elaborado diversos métodos que permiten hacer validaciones; es conveniente que el programador las utilice cotidianamente en los algoritmos que desarrolle, porque son indispensables para que nuestros algoritmos tengan una mejor calidad.

Capítulo 11


Ejercicio 11.4.4

Elaborar un algoritmo que calcule e imprima el precio de venta de un artículo. Se tienen los datos Descripción del artículo y Costo de producción. El precio de venta se calcula añadiéndole al costo el 120 % como utilidad y el 15 % de impuesto. A continuación se presenta el algoritmo de la solución:


Diagrama de clases

PrecioArticulo2

descripcion costo precioVta

establecerDescripcion() establecerCosto() calcularPrecioVta() obtenerDescipcion() obtenerPrecioVta()

EjecutaPrecioArticulo2

Algoritmo PRECIO DE VENTA Clase PrecioArticulo2 1. Declaraciones Datos descripcion: Cadena costo: Real precioVta: Real


2. Método establecerDescripcion(des: Cadena) a. descripcion = des b. Fin Método establecerDescripcion

3. Método establecerCosto(co: Real) a. costo = co b. Fin Método establecerCosto

4. Método calcularPrecioVta() a. precioVta = costo + (costo*1.2) + ((costo+(costo*1.2))*0.15) b. Fin Método calcularPrecioVta

5. Método obtenerDescripcion(): Cadena a. return descripcion b. Fin Método obtenerDescripcion

6. Método obtenerPrecioVta(): Real a. return precioVta b. Fin Método obtenerPrecioVta Fin Clase PrecioArticulo2

Clase EjecutaPrecioArticulo2 1. Método principal a. Declaraciones Variables desc: Cadena cos: Real b. Declarar, crear e iniciar objeto PrecioArticulo2 objArticulo = new PrecioArticulo2() c. Solicitar Descripción del artículo, Costo d. Leer desc, cos e. Establecer objArticulo.establecerDescripcion(desc) objArticulo.establecerCosto(cos) f. Calcular objArticulo.calcularPrecioVta() g. Imprimir objArticulo.obtenerDescripcion() objArticulo.obtenerPrecioVta() h. Fin Método principal Fin Clase EjecutaPrecioArticulo2Fin

Explicación:

El algoritmo tiene dos clases; la Clase PrecioArticulo2 y la clase EjecutaPrecioArticulo2. En la Clase PrecioArticulo2:

1. Se declaran los datos que representan la estructura de la clase:


descripcion para el nombre del artículo costo para el costo del artículo precioVta para el precio de venta del artículo2. Método establecerDescripcion(des: Cadena) Recibe en el parámetro des el valor que luego coloca en el dato descripcion.3. Método establecerCosto(co: Real) Recibe en el parámetro co el valor que luego coloca en el dato costo.4. Método calcularPrecioVta() Calcula el precio de venta del artículo5. Método obtenerDescripcion(): Cadena Retorna descripcion del artículo6. Método obtenerPrecioVta(): Real Retorna precioVta del artículoFin de la Clase PrecioArticulo2

En la Clase EjecutaPrecioArticulo2; en el Método principal:

a. Se declara: La variable desc para leer el nombre del artículo. La variable cos para leer el costo del artículo.b. Se declara el objeto objArticulo, usando como base a la clase PrecioArticulo2; dicho

objeto se crea e inicializa mediante el constructor por defecto PrecioArticulo2().c. Se solicitan Descripción del artículo y Costod. Se leen en desc y cose. Se llama al método establecerDescripcion(desc) del objeto objArticulo; para colocar

el valor de desc en el dato descripcion . Se llama al método establecerCosto(cos) del objeto objArticulo; para colocar el valor

de cos en el dato costo. f. Se llama al método calcularPrecioVta() del objeto objArticulo; para calcular el precio

de venta.g. Se llama al método obtenerDescripcion() del objeto objArticulo; para acceder e

imprimir el valor del dato descripcion . Se llama al método obtenerPrecioVta() del objeto objArticulo; para acceder e imprimir

el valor del dato precioVta.h. Fin del Método principalFin de la Clase EjecutaPrecioArticulo2Fin del algoritmo

Ejercicio 11.4.5

Dados los lados A y B de un triángulo rectángulo, según el teorema de Pitágoras, el cua-drado de la hipotenusa (C), es igual a la suma del cuadrado de los catetos (lados).

c² = a² + b²

Elaborar un algoritmo que lea el tamaño de los lados A y B, y calcule e imprima C (hipotenusa).


A continuación se presenta el algoritmo de la solución:


Diagrama de clases

Hipotenusa2

a: Real b: Real c: Real

establecerA() establecerB() calcularC() obtenerC()

EjecutaHipotenusa2

Algoritmo CALCULAR HIPOTENUSA Clase Hipotenusa2 1. Declaraciones Datos a: Real b: Real c: Real

2. Método establecerA(catetoA: Real) a. a = catetoA b. Fin Método establecerA

3. Método establecerB(catetoB: Real) a. b = catetoB b. Fin Método establecerB

4. Método calcularC() a. c = RaízCuad(Potencia(a,2) + Potencia(b,2)) b. Fin Método calcularC 5. Método obtenerC():Real a. return c b. Fin Método obtenerC Fin Clase Hipotenusa2

Clase EjecutaHipotenusa2 1. Método principal a. Declaraciones Variables


cateA, cateB: Real b. Declarar, crear e iniciar objeto Hipotenusa2 objHipotenusa = new Hipotenusa2() c. Solicitar Cateto A y Cateto B d. Leer cateA, cateB e. Establecer objHipotenusa.establecerA(cateA) objHipotenusa.establecerB(cateB) f. Calcular objHipotenusa.calcularC() g. Imprimir objHipotenusa.obtenerC() h. Fin Método principal Fin Clase EjecutaHipotenusa2Fin

Explicación:

El algoritmo tiene dos clases; la Clase Hipotenusa2 y la clase EjecutaHipotenusa2.

En la Clase Hipotenusa2:1. Se declaran los datos que representan la estructura de la clase: a. para el cateto a b. para el cateto b c. para la hipotenusa2. Método establecerA(catetoA: Real) Recibe en el parámetro catetoA el valor que luego coloca en el dato a.3. Método establecerB(catetoB: Real) Recibe en el parámetro catetoB el valor que luego coloca en el dato b.4. Método calcularC() Calcula la hipotenusa5. Método obtenerC():Real Retorna cFin de la Clase Hipotenusa2

En la Clase EjecutaHipotenusa2; en el Método principal:

a. Se declara: La variable cateA para leer el cateto a. La variable cateB para leer el cateto b.b. Se declara el objeto objHipotenusa, usando como base a la clase Hipotenusa2; dicho

objeto se crea e inicializa mediante el constructor por defecto Hipotenusa2().c. Se solicitan Cateto A y Cateto Bd. Se leen en cateA, cateBe. Se llama al método establecerA(cateA) del objeto objHipotenusa; para colocar el

valor de cateA en el dato a . Se llama al método establecerB(cateB) del objeto objHipotenusa; para colocar el valor

de cateB en el dato b. f. Se llama al método calcularC() del objeto objHipotenusa; para calcular la hipotenusa.


g. Se llama al método obtenerC() del objeto objHipotenusa; para acceder e imprimir el valor del dato c .

h. Fin del Método principalFin de la Clase EjecutaHipotenusa2Fin del algoritmo

Ejercicio 11.4.6

En los lenguajes de programación, las funciones seno, coseno y tangente, requieren que el argumento o parámetro que se les envíe, esté dado en radianes. Si el dato disponible está dado en grados, se puede hacer la conversión a radianes con la siguiente equivalencia:

1o = π

180 radianes

Para convertir de radianes a grados:

1 radián = 180π

grados

Elaborar un algoritmo que permita leer un número en radianes e imprima su equi-valencia en grados; asimismo, leer un número en grados e imprima su equivalencia en radianes. A continuación se presenta el algoritmo de la solución:


Diagrama de clases

RadianGrado2

radianes: Real grados: Real numRadianes: Real numGrados: Real

establecerRadianes() establecerGrados() calcularNumRadianes() calcularNumGrados() obtenerNumRadianes() obtenerNumGrados()

EjecutaRadianGrado2

Algoritmo CONVIERTE RADIANES A GRADOS Y GRADOS A RADIANES Clase RadianGrado2 1. Declaraciones Datos radianes: Real


grados: Real numRadianes: Real numGrados: Real

2. Método establecerRadianes(rad: Real) a. radianes = rad b. Fin Método establecerRadianes

3. Método establecerGrados(gra: Real) a. grados = gra b. Fin Método establecerGrados

4. Método calcularNumRadianes() a. Declaraciones Constantes PI = 3.145926536 b. numRadianes = grados*(PI/180) c. Fin Método calcularNumRadianes

5. Método calcularNumGrados() a. Declaraciones Constantes PI = 3.145926536 b. numGrados = radianes*(180/PI) c. Fin Método calcularNumGrados

6. Método obtenerNumRadianes():Real a. return numRadianes b. Fin Método obtenerNumRadianes

7. Método obtenerNumGrados():Real a. return numGrados b. Fin Método obtenerNumGrados Fin Clase RadianGrado2

Clase EjecutaRadianGrado2 1. Método principal a. Declaraciones Variables radian, grad: Real b. Declarar, crear e iniciar objeto RadianGrado2 objRadianGrado = new RadianGrado2() c. Solicitar Número de radianes y Número de grados d. Leer radian, grad e. Establecer objRadianGrado.establecerRadianes(radian) objRadianGrado.establecerGrados(grad) f. Calcular objRadianGrado.calcularNumRadianes()


objRadianGrado.calcularNumGrados() g. Imprimir objRadianGrado.obtenerNumRadianes() objRadianGrado.obtenerNumGrados() h. Fin Método principal Fin Clase EjecutaRadianGrado2Fin

Explicación:

El algoritmo tiene dos clases; la Clase RadianGrado2 y la clase EjecutaRadianGrado2.

En la Clase RadianGrado2:1. Se declaran los datos que representan la estructura de la clase: radianes para los radianes grados para los grados numRadianes para el número de radianes numGrados para el número de grados2. Método establecerRadianes(rad: Real) Recibe en el parámetro rad el valor que luego coloca en el dato radianes.3. Método establecerGrados(gra: Real) Recibe en el parámetro gra el valor que luego coloca en el dato grados.4. Método calcularNumRadianes() Se declara la constante PI Calcula la equivalencia en número de radianes5. Método calcularNumGrados() Se declara la constante PI Calcula la equivalencia en número de grados6. Método obtenerNumRadianes():Real Retorna numRadianes7. Método obtenerNumGrados():Real Retorna numGradosFin de la Clase RadianGrado2

En la Clase EjecutaRadianGrado2; en el Método principal:

a. Se declara: La variable radian para leer el número de radianes. La variable grad para leer el número de grados.b. Se declara el objeto objRadianGrado, usando como base a la clase RadianGrado2; dicho

objeto se crea e inicializa mediante el constructor por defecto RadianGrado2().c. Se solicitan Número de radianes y Número de gradosd. Se leen en radian, grade. Se llama al método establecerRadianes(radian) del objeto objRadianGrado; para

colocar el valor de radian en el dato radianes . Se llama al método establecerGrados(grad) del objeto objRadianGrado; para colocar

el valor de grad en el dato grados. f. Se llama al método calcularNumRadianes() del objeto objRadianGrado; para calcular

el número de radianes.


Se llama al método calcularNumGrados() del objeto objRadianGrado; para calcular el número de grados.

g. Se llama al método obtenerNumRadianes() del objeto objRadianGrado; para acceder e imprimir el valor del dato numRadianes.

Se llama al método obtenerNumGrados() del objeto objRadianGrado; para acceder e imprimir el valor del dato numGrados.

h. Fin del Método principalFin de la Clase EjecutaRadianGrado2Fin del algoritmo

Capítulo 12


Ejercicio 12.4.4

Elaborar un algoritmo que lea cinco números y calcule e imprima el mayor. Se supone que son números diferentes. Restricciones: No usar ELSE ni AND. Usando IF-THEN. A continuación se presenta el algoritmo de la solución:


Diagrama de clases

Mayor5Numeros2

numA numB numC numD numE nuMayor

establecerA() establecerB() establecerC() establecerD() establecerE() calcularNuMayor() obtenerNuMayor()

EjecutaMayor5Numeros2

Algoritmo MAYOR 5 NUMEROS Clase Mayor5Numeros2 1. Declaraciones


Datos numA, numB, numC, numD, numE, nuMayor: Entero

2. Método establecerNumA(a: Entero) a. numA = a b. Fin Método establecerNumA

3. Método establecerNumB(b: Entero) a. numB = b b. Fin Método establecerNumB

4. Método establecerNumC(c: Entero) a. numC = c b. Fin Método establecerNumC

5. Método establecerNumD(d: Entero) a. numD = d b. Fin Método establecerNumD

6. Método establecerNumE(e: Entero) a. numE = e b. Fin Método establecerNumE

7. Método calcularNuMayor() a. nuMayor = numA b. IF numB > nuMayor THEN a. nuMayor = numB c. ENDIF d. IF numC > nuMayor THEN a. nuMayor = numC e. ENDIF f. IF numD > nuMayor THEN a. nuMayor = numD g. ENDIF h. IF numE > nuMayor THEN a. nuMayor = numE i. ENDIF j. Fin Método calcularNuMayor 8. Método obtenerNuMayor(): Entero a. return nuMayor b. Fin Método obtenerNuMayor Fin Clase Mayor5Numeros2

Clase EjecutaMayor5Numeros2 1. Método principal a. Declaraciones


Variables n1, n2, n3, n4, n5: Real b. Declarar, crear e iniciar objeto Mayor5Numeros2 objMayor5Numeros= new Mayor5Numeros2() c. Solicitar Numero 1, Numero 2, Numero 3, Numero 4 y Numero 5 d. Leer n1, n2, n3, n4, n5 e. Establecer objMayor5Numeros.establecerNumA(n1) objMayor5Numeros.establecerNumB(n2) objMayor5Numeros.establecerNumC(n3) objMayor5Numeros.establecerNumD(n4) objMayor5Numeros.establecerNumE(n5) f. Calcular objMayor5Numeros.calcularNuMayor() g. Imprimir objMayor5Numeros.obtenerNuMayor() h. Fin Método principal Fin Clase EjecutaMayor5Numeros2Fin

Explicación:

El algoritmo tiene dos clases; la Clase Mayor5Numeros2 y la clase EjecutaMayor5Nu-meros2.

En la Clase Mayor5Numeros2:1. Se declaran los datos que representan la estructura de la clase: numA, numB, numC, numD, numE para cada uno de los 5 números nuMayor para número mayor2. Método establecerNumA(a: Entero) Recibe en el parámetro a el valor que luego coloca en el dato numA.3. Método establecerNumB(b: Entero) Recibe en el parámetro b el valor que luego coloca en el dato numB.4. Método establecerNumC(c: Entero) Recibe en el parámetro c el valor que luego coloca en el dato numC.5. Método establecerNumD(d: Entero) Recibe en el parámetro d el valor que luego coloca en el dato numD.6. Método establecerNumE(e: Entero) Recibe en el parámetro e el valor que luego coloca en el dato numE.7. Método calcularNuMayor() Calcula el mayor en nuMayor a. Coloca numA en nuMayor b. Si numB > nuMayor Entonces a. Coloca numB en nuMayor c. Fin del IF d. Si numC > nuMayor Entonces a. Coloca numC en nuMayor e. Fin del IF f. Si numD > nuMayor Entonces


a. Coloca numD en nuMayor g. Fin del IF h. Si numE > nuMayor Entonces a. Coloca numE en nuMayor i. Fin del IF j. Fin Método calcularNuMayor8. Método obtenerNuMayor():Entero a. Retorna nuMayorFin de la Clase Mayor5Numeros2

En la Clase EjecutaMayor5Numeros2; en el Método principal:

a. Se declara: Las variables n1, n2, n3, n4, n5 para leer los 5 números.b. Se declara el objeto objMayor5Numeros, usando como base a la clase Mayor5Nume-

ros2; dicho objeto se crea e inicializa mediante el constructor por defecto Mayor5Nu-meros2().

c. Se solicitan Numero 1, Numero 2, Numero 3, Numero 4 y Numero 5d. Se leen en n1, n2, n3, n4, n5e. Se llama al método establecerNumA(n1) del objeto objMayor5Numeros; para colocar

el valor de n1 en el dato numA. Se llama al método establecerNumB(n2) del objeto objMayor5Numeros; para colocar

el valor de n2 en el dato numB. Se llama al método establecerNumC(n3) del objeto objMayor5Numeros; para colocar

el valor de n3 en el dato numC. Se llama al método establecerNumD(n4) del objeto objMayor5Numeros; para colocar

el valor de n4 en el dato numD. Se llama al método establecerNumE(n5) del objeto objMayor5Numeros; para colocar

el valor de n5 en el dato numE.f. Se llama al método calcularNuMayor() del objeto objMayor5Numeros; para calcular

el mayor.g. Se llama al método obtenerNuMayor() del objeto objMayor5Numeros; para acceder

e imprimir el valor del dato nuMayor.h. Fin del Método principalFin de la Clase EjecutaMayor5Numeros2Fin del algoritmo

Ejercicio 12.4.5

Elaborar un algoritmo que lea el tamaño de un ángulo en grados e imprimir si es:

Agudo si es menor a 90° Recto si es igual a 90° Obtuso si es mayor que 90° pero menor que 180° Llano si es igual a 180° Concavo si es mayor que 180° pero menor que 360°


Utilizar IF-THEN.



Diagrama de clases

TipoAngulo2

tamAngulo tipoAngulo

establecerTamAngulo() calcularTipoAngulo() obtenerTipoAngulo()

EjecutaTipoAngulo2

Algoritmo TIPO ANGULO Clase TipoAngulo2 1. Declaraciones Datos tamAngulo: Real tipoAngulo: Cadena

2. Método establecerTamAngulo(ang: Real) a. tamAngulo = ang b. Fin Método establecerTamAngulo

3. Método calcularTipoAngulo() a. IF tamAngulo < 90 THEN 1. tipoAngulo = “Agudo” b. ENDIF c. IF tamAngulo = 90 THEN 1. tipoAngulo = “Recto” d. ENDIF e. IF (tamAngulo>90)AND(tamAngulo<180) THEN 1. tipoAngulo = “Obtuso” f. ENDIF g. IF tamAngulo = 180 THEN 1. tipoAngulo = “Llano” h. ENDIF i. IF (tamAngulo>180)AND(tamAngulo<360) THEN 1. tipoAngulo = “Concavo” j. ENDIF k. Fin Método calcularTipoAngulo


4. Método obtenerTipoAngulo(): Cadena a. return tipoAngulo b. Fin Método obtenerTipoAngulo Fin Clase TipoAngulo2

Clase EjecutaTipoAngulo2 1. Método principal a. Declaraciones Variables angulo: Real b. Declarar, crear e iniciar objeto TipoAngulo2 objAngulo = new TipoAngulo2() c. Solicitar Tamaño del angulo d. Leer angulo e. Establecer objAngulo.establecerTamAngulo(angulo) f. Calcular objAngulo.calcularTipoAngulo() g. Imprimir objAngulo.obtenerTipoAngulo() h. Fin Método principal Fin Clase EjecutaTipoAngulo2Fin

Explicación:

El algoritmo tiene dos clases; la Clase TipoAngulo2 y la clase EjecutaTipoAngulo2.

En la Clase TipoAngulo2:1. Se declaran los datos que representan la estructura de la clase: tamAngulo para el tamaño del ángulo tipoAngulo para el tipo de angulo2. Método establecerTamAngulo(ang: Real) Recibe en el parámetro ang el valor que luego coloca en el dato tamAngulo.3. Método calcularTipoAngulo() a. Si tamAngulo < 90 Entonces 1. Coloca “Agudo” en tipoAngulo b. Fin del IF c. Si tamAngulo = 90 Entonces 1. Coloca “Recto” en tipoAngulo d. Fin del IF e. Si (tamAngulo>90) y (tamAngulo<180) Entonces 1. Coloca “Obtuso” en tipoAngulo f. Fin del IF g. Si tamAngulo = 180 Entonces 1. Coloca “Llano” en tipoAngulo h. Fin del IF i. Si (tamAngulo>180) y (tamAngulo<360) Entonces 1. Coloca “Concavo” en tipoAngulo j. Fin del IF


k. Fin Método calcularTipoAngulo4. Método obtenerTipoAngulo(): Cadena a. Retorna tipoAnguloFin de la Clase TipoAngulo2

En la Clase EjecutaTipoAngulo2; en el Método principal:

a. Se declara: La variable angulo para leer el tamaño del angulo. b. Se declara el objeto objAngulo, usando como base a la clase TipoAngulo2; dicho

objeto se crea e inicializa mediante el constructor por defecto TipoAngulo2().c. Solicita el Tamaño del angulod. Se lee en anguloe. Se llama al método establecerTamAngulo(angulo) del objeto objAngulo; para colocar

el valor de angulo en el dato tamAngulo.f. Se llama al método calcularTipoAngulo() del objeto objAngulo; para calcular el tipo

de angulo.g. Se llama al método obtenerTipoAngulo() del objeto objAngulo; para acceder e

imprimir el valor del dato tipoAngulo.h. Fin del Método principalFin de la Clase EjecutaTipoAngulo2Fin del algoritmo

Ejercicio 12.4.6

La ecuación de la segunda ley de Newton:

F = ma

Donde:

F es la fuerza que actúa sobre el objeto (cuerpo), en gramos por centímetro cua-drado.

m es la masa del cuerpo (en gramos). a es la aceleración en centímetros por segundo cuadrado.

y dice; que la fuerza (F) que actúa sobre un cuerpo se obtiene multiplicando la masa por la aceleración. Se puede calcular la aceleración (a) si se tienen los datos F y m; con la fórmula:

a =

F

m

Se puede calcular la masa (m) si se tienen los datos fuerza (F) y aceleración (a), con la fórmula:

m =

F

a


Elaborar un algoritmo que pregunte lo que desea calcular; fuerza (F), masa (m) o aceleración (a). Si es F, se leen los datos m y a. Si es a, se leen los datos F y m. Si es m, se leen los datos F y a. Usando IF-THEN. A continuación se presenta el algoritmo de la solución:


Diagrama de clases

LeyNewton2

fuerza masa aceleracion

establecerFuerza() establecerMasa() establecerAceleracion() calcularFuerza() calcularMasa() calcularAceleracion() obtenerFuerza() obtenerMasa() obtenerAceleracion()

EjecutaLeyNewton2

Algoritmo SEGUNDA LEY NEWTON Clase LeyNewton2 1. Declaraciones Datos fuerza, masa, aceleracion: Real

2. Método establecerFuerza(fu: Real) a. fuerza = fu b. Fin Método establecerFuerza

3. Método establecerMasa(ma: Real) a. masa = ma b. Fin Método establecerMasa

4. Método establecerAceleracion(acel: Real) a. aceleracion = acel b. Fin Método establecerAceleracion

5. Método calcularFuerza() a. fuerza = masa * aceleracion b. Fin Método calcularFuerza


6. Método calcularMasa() a. masa = fuerza / aceleracion b. Fin Método calcularMasa

7. Método calcularAceleracion() a. aceleracion = fuerza / masa b. Fin Método calcularAceleracion

8. Método obtenerFuerza(): Real a. return fuerza b. Fin Método obtenerFuerza

9. Método obtenerMasa(): Real a. return masa b. Fin Método obtenerMasa

10. Método obtenerAceleracion(): Real a. return aceleracion b. Fin Método obtenerAceleracion Fin Clase LeyNewton2

Clase EjecutaLeyNewton2 1. Método principal a. Declaraciones Variables f, a, m: Real resp: Carácter b. Declarar, crear e iniciar objeto LeyNewton2 objNewton = new LeyNewton2() c. Imprimir “¿QUÉ DESEA CALCULAR? “ “¿FUERZA(F), ACELERACION(A), MASA(M) ?: “ d. Leer resp e. IF resp = “F” THEN 1. Solicitar MASA 2. Leer m 3. Solicitar ACELERACION 4. Leer a 5. Establecer objNewton.establecerMasa(m) objNewton.establecerAceleracion(a) 6. Calcular objNewton.calcularFuerza() 7. Imprimir objNewton.obtenerFuerza() f. ENDIF g. IF resp = “A” THEN 1. Solicitar MASA 2. Leer m 3. Solicitar FUERZA 4. Leer f


5. Establecer objNewton.establecerMasa(m) objNewton.establecerFuerza(f) 6. Calcular objNewton.calcularAceleracion() 7. Imprimir objNewton.obtenerAceleracion() h. ENDIF i. IF resp = “M” THEN 1. Solicitar FUERZA 2. Leer f 3. Solicitar ACELERACION 4. Leer a 5. Establecer objNewton.establecerFuerza(f) objNewton.establecerAceleracion(a) 6. Calcular objNewton.calcularMasa() 7. Imprimir objNewton.obtenerMasa() j. ENDIF k. Fin Método principal Fin Clase EjecutaLeyNewton2Fin

Explicación:

El algoritmo tiene dos clases; la Clase LeyNewton2 y la clase EjecutaLeyNewton2.

En la Clase LeyNewton2:1. Se declaran los datos que representan la estructura de la clase: fuerza para el dato fuerza masa para el dato masa aceleración para el dato aceleración2. Método establecerFuerza(fu: Real) Recibe en el parámetro fu el valor que luego coloca en el dato fuerza.3. Método establecerMasa(ma: Real) Recibe en el parámetro ma el valor que luego coloca en el dato masa.4. Método establecerAceleracion(acel: Real) Recibe en el parámetro acel el valor que luego coloca en el dato aceleracion.5. Método calcularFuerza() Calcula fuerza 6. Método calcularMasa() Calcula masa 7. Método calcularAceleracion() Calcula aceleracion 8. Método obtenerFuerza(): Real Retorna fuerza9. Método obtenerMasa(): Real Retorna masa10.Método obtenerAceleracion(): Real Retorna aceleracionFin de la Clase LeyNewton2


En la Clase EjecutaLeyNewton2; en el Método principal:

a. Se declara: La variable f para leer la fuerza La variable a para leer la aceleracion La variable m para leer la masa La variable resp para leer la respuesta a la pregunta ¿Qué desea calcular?b. Se declara el objeto objNewton, usando como base a la clase LeyNewton2; dicho

objeto se crea e inicializa mediante el constructor por defecto LeyNewton2().c. Pregunta “¿QUÉ DESEA CALCULAR? “ “¿FUERZA(F), ACELERACION(A), MASA(M) ?: “d. Lee en resp la respuestae. Si resp = “F” Entonces 1. Solicita MASA 2. Leer en m 3. Solicita ACELERACION 4. Leer en a 5. Se llama al método establecerMasa(m) del objeto objNewton; para colocar el valor

de m en el dato masa. Se llama al método establecerAceleracion(a) del objeto objNewton; para colocar el

valor de a en el dato aceleracion. 6. Se llama al método calcularFuerza() del objeto objNewton; para calcular la fuerza. 7. Se llama al método obtenerFuerza() del objeto objNewton; para acceder e imprimir

el valor del dato fuerza.f. Fin del IFg. Si resp = “A” Entonces 1. Solicita MASA 2. Leer en m 3. Solicita FUERZA 4. Leer en f 5. Se llama al método establecerMasa(m) del objeto objNewton; para colocar el valor

de m en el dato masa. Se llama al método establecerFuerza(f) del objeto objNewton; para colocar el

valor de f en el dato fuerza. 6. Se llama al método calcularAceleracion() del objeto objNewton; para calcular la

aceleracion. 7. Se llama al método obtenerAceleracion() del objeto objNewton; para acceder e

imprimir el valor del dato aceleracion.h. Fin del IFi. Si resp = “M” Entonces 1. Solicita FUERZA 2. Leer en f 3. Solicita ACELERACION 4. Leer en a 5. Se llama al método establecerFuerza(f) del objeto objNewton; para colocar el valor

de f en el dato fuerza. Se llama al método establecerAceleracion(a) del objeto objNewton; para colocar el


valor de a en el dato aceleracion. 6. Se llama al método calcularMasa() del objeto objNewton; para calcular la masa. 7. Se llama al método obtenerMasa() del objeto objNewton; para acceder e imprimir

el valor del dato masa.j. Fin del IFk. Fin del Método principalFin de la Clase EjecutaLeyNewton2Fin del algoritmo

Ejercicio 12.4.7

Una empresa vende hojas de hielo seco, con las condiciones siguientes:

Si el cliente es tipo 1 se le descuenta el 5 % Si el cliente es tipo 2 se le descuenta el 8 % Si el cliente es tipo 3 se le descuenta el 12 % Si el cliente es tipo 4 se le descuenta el 15 %

Cuando el cliente realiza una compra se generan los datos siguientes:

Nombre del cliente Tipo de cliente (1,2,3,4) Cantidad de hojas Precio por hoja

Elabore un algoritmo que lea estos datos, haga cálculos e imprima:

Nombre del cliente Sub total a pagar (Cantidad de hojas × Precio por hoja) Descuento (El porcentaje correspondiente del Sub total a pagar) Neto a pagar (Sub total – Descuento)

Usando SWITCH.



Diagrama de clases


Cliente2

nombreClie tipoClie cantidad precioUni subTotal descuento netoPagar

establecerNombreClie() establecerTipoClie() establecerCantidad() establecerPrecioUni() calcularSubTotal() calcularDescuento() calcularNetoPagar() obtenerNombreClie() obtenerSubTotal() obtenerDescuento() obtenerNetoPagar()

EjecutaCliente2

Algoritmo CLIENTE HOJAS HIELO SECO Clase Cliente2 1. Declaraciones Datos nombreClie: Cadena tipoClie, cantidad: Entero precioUni, subTotal, descuento, netoPagar: Real

2. Método establecerNombreClie(nom: Cadena) a. nombreClie = nom b. Fin Método establecerNombreClie

3. Método establecerTipoClie(tipo: Entero) a. tipoClie = tipo b. Fin Método establecerTipoClie

4. Método establecerCantidad(can: Entero) a. cantidad = can b. Fin Método establecerCantidad

5. Método establecerPrecioUni(pre: Real) a. precioUni = pre b. Fin Método establecerPrecioUni


6. Método calcularSubTotal() a. subTotal = cantidad * precioUni b. Fin Método calcularSubTotal

7. Método calcularDescuento() a. SWITCH tipoClie 1: descuento = subTotal * 0.05 2: descuento = subTotal * 0.08 3: descuento = subTotal * 0.12 4: descuento = subTotal * 0.15 b. ENDSWITCH c. Fin Método calcularDescuento

8. Método calcularNetoPagar() a. totalPagar = subTotal - descuento b. Fin Método calcularTotalPagar

9. Método obtenerNombreClie(): Cadena a. return nombreClie b. Fin Método obtenerNombreClie

10. Método obtenerSubTotal(): Real a. return subTotal b. Fin Método obtenerSubTotal

11. Método obtenerDescuento(): Real a. return descuento b. Fin Método obtenerDescuento

12. Método obtenerNetoPagar(): Real a. return netoPagar b. Fin Método obtenerNetoPagar Fin Clase Cliente2

Clase EjecutaCliente2 1. Método principal a. Declaraciones Variables nomCli: Cadena tiCli, cant: Entero preUni: Real b. Declarar, crear e iniciar objeto Cliente2 objCliente = new Cliente2() c. Solicitar Nombre, Tipo cliente, Cantidad, Precio unitario d. Leer nomCli, tiCli, cant, preUni e. Establecer objCliente.establecerNombreClie(nomCli)


objCliente.establecerTipoClie(tiCli) objCliente.establecerCantidad(cant) objCliente.establecerPrecioUni(preUni) f. Calcular objCliente.calcularSubTotal() objCliente.calcularDescuento() objCliente.calcularNetoPagar() g. Imprimir objCliente.obtenerNombreClie() objCliente.obtenerSubTotal() objCliente.obtenerDescuento() objCliente.obtenerNetoPagar() h. Fin Método principal Fin Clase EjecutaCliente2Fin

Explicación:

El algoritmo tiene dos clases; la Clase Cliente2 y la clase EjecutaCliente2.

En la Clase Cliente2:1. Se declaran los datos que representan la estructura de la clase: nombreClie para el nombre del cliente tipoClie para el tipo de cliente cantidad para la cantidad de hojas compradas precioUni para el precio unitario subTotal para el sub total descuento para el descuento netoPagar para el neto a pagar2. Método establecerNombreClie(nom: Cadena) Recibe en el parámetro nom el valor que luego coloca en el dato nombreClie.3. Método establecerTipoClie(tipo: Entero) Recibe en el parámetro tipo el valor que luego coloca en el dato tipoClie.4. Método establecerCantidad(can: Entero) Recibe en el parámetro can el valor que luego coloca en el dato cantidad.5. Método establecerPrecioUni(pre: Real) Recibe en el parámetro pre el valor que luego coloca en el dato precioUni.6. Método calcularSubTotal() Calcula el subTotal a pagar 7. Método calcularDescuento() Calcula el descuento a. SWITCH tipoClie Si tipoClie=1: descuento = subTotal * 0.05 Si tipoClie=2: descuento = subTotal * 0.08 Si tipoClie=3: descuento = subTotal * 0.12 Si tipoClie=4: descuento = subTotal * 0.15 b. ENDSWITCH c. Fin Método calcularDescuento8. Método calcularNetoPagar()


Calcula el netoPagar a pagar 9. Método obtenerNombreClie():Cadena Retorna nombreClie10. Método obtenerSubTotal(): Real Retorna subTotal11. Método obtenerDescuento(): Real Retorna descuento12. Método obtenerNetoPagar(): Real Retorna netoPagarFin de la Clase Cliente2

En la Clase EjecutaCliente2; en el Método principal:

a. Se declara: La variable nomCli para leer el nombre del cliente. La variable tiCli para leer el tipo de cliente. La variable cant para leer la cantidad de hojas compradas. La variable preUni para leer el precio unitario por hoja.b. Se declara el objeto objCliente, usando como base a la clase Cliente2; dicho objeto se

crea e inicializa mediante el constructor por defecto Cliente2().c. Solicita Nombre, Tipo cliente, Cantidad, Precio unitariod. Lee en nomCli, tiCli, cant, preUnie. Se llama al método establecerNombreClie(nomCli) del objeto objCliente; para colocar

el valor de nomCli en el dato nombreClie. Se llama al método establecerTipoClie(tiCli) del objeto objCliente; para colocar el

valor de tiCli en el dato tipoClie. Se llama al método establecerCantidad(cant) del objeto objCliente; para colocar el

valor de cant en el dato cantidad. Se llama al método establecerPrecioUni(preUni) del objeto objCliente; para colocar el

valor de preUni en el dato precioUni. f. Se llama al método calcularSubTotal() del objeto objCliente; para calcular el sub total. Se llama al método calcularDescuento() del objeto objCliente; para calcular el des-

cuento. Se llama al método calcularNetoPagar() del objeto objCliente; para calcular el neto a

pagar.g. Se llama al método obtenerNombreClie() del objeto objCliente; para acceder e

imprimir el valor del dato nombreClie. Se llama al método obtenerSubTotal() del objeto objCliente; para acceder e imprimir

el valor del dato subTotal. Se llama al método obtenerDescuento() del objeto objCliente; para acceder e imprimir

el valor del dato descuento. Se llama al método obtenerNetoPagar() del objeto objCliente; para acceder e imprimir

el valor del dato netoPagar.h. Fin del Método principalFin de la Clase EjecutaCliente2Fin del algoritmo

Capítulo 13

13.1.2 Ejercicios resueltos para DO...WHILE (Continuación…)

Ejercicio 13.1.2.3

Elaborar un algoritmo que mida la infl ación que han tenido ciertos artículos y que imprima el siguiente reporte:

Analisis de infl acion

Articulo Precio anterior Precio actual Ptje. infl acion

XXXXXXXXXX 99,999.99 99,999.99 99.99 XXXXXXXXXX 99,999.99 99,999.99 99.99 . . . . . . . . XXXXXXXXXX 99,999.99 99,999.99 99.99

Promedio de infl ación: 99.99 Artículo con mayor infl ación : XXXXXXXXXXXXXXXXXXXXXXXXXXX Porcentaje mayor de infl ación : 99.99

Datos disponibles por cada artículo: Descripción Precio anterior Precio actual

Forma de calcular el porcentaje de infl ación:

Ptje. inflación = Precio actual - Precio anterior

Precio anterior × 100


13-2 Metodología de la Programación Orientada a Objetosz


Diagrama de clases

Articulo

articulo precioAnt precioAct ptjeInfla

establecerArticulo() establecerPrecioAnt() establecerPrecioAct() calcularPtjeInfla() obtenerArticulo() obtenerPrecioAnt() obtenerPrecioAct() obtenerPtjeInfla()

EjecutaArticulo

Algoritmo CALCULA INFLACION DE ARTICULOS Clase Articulo 1. Declaraciones Datos articulo : Cadena precioAnt: Real precioAct: Real ptjeInfla: Real

2. Método establecerArticulo(nom: Cadena) a. articulo = nom b. Fin Método establecerArticulo

3. Método establecerPrecioAnt(pAnt: Real) a. precioAnt = pAnt b. Fin Método establecerPrecioAnt

4. Método establecerPrecioAct(pAct: Real) a. precioAct = pAct b. Fin Método establecerPrecioAct

5. Método calcularPtjeInfla() a. ptjeInfla = ((precioAct-precioAnt)/precioAnt)*100 b. Fin Método calcularPtjeInfla

6. Método obtenerArticulo(): Cadena

Ejercicios resueltos para DO...WHILE (Continuación...) 13-3

a. return articulo b. Fin Método obtenerArticulo

7. Método obtenerPrecioAnt(): Real a. return precioAnt b. Fin Método obtenerPrecioAnt

8. Método obtenerPrecioAct(): Real a. return precioAct b. Fin Método obtenerPrecioAct

9. Método obtenerPtjeInfla(): Real a. return ptjeInfla b. Fin Método obtenerPtjeInfla Fin Clase Articulo

Clase EjecutaArticulo 1. Método principal a. Declaraciones Variables art, artMayor: Cadena totArticulos: Entero preAn, preAc, totInfla, mayorInfla, promInfla: Real otro: Carácter b. Imprimir encabezado c. totArticulos = 0 totInfla = 0 mayorInfla = 0 d. DO 1. Declarar, crear e iniciar objeto Articulo objArti = new Articulo() 2. Solicitar Artículo, precio actual y precio anterior 3. Leer art, preAn, preAc 4. Establecer objArti.establecerArticulo(art) objArti.establecerPrecioAnt(preAn) objArti.establecerPrecioAct(preAc) 5. Calcular objArti.calcularPtjeInfla() 6. Imprimir objArti.obtenerArticulo() objArti.obtenerPrecioAnt() objArti.obtenerPrecioAct() objArti.obtenerPtjeInfla() 7. IF objArti.obtenerPtjeInfla() > mayorInfla THEN a. mayorInfla = objArti.obtenerPtjeInfla() b. artMayor = objArti.obtenerArticulo() 8. ENDIF


9. totArticulos = totArticulos + 1 10. totInfl a = totInfl a+objArti.obtenerPtjeInfl a() 11. Preguntar “¿Desea procesar otro articulo(S/N)?” 12. Leer otro e. WHILE otro = “S” f. promInfl a = totInfl a / totArticulos g. Imprimir promInfl a, artMayor, mayorInfl a h. Fin Método principal Fin Clase EjecutaArticuloFin

Explicación:

El algoritmo tiene dos clases; la Clase Articulo y la clase EjecutaArticulo.

En la Clase Articulo:1. Se declaran los datos que representan la estructura de la clase: articulo para el nombre del articulo precioAnt para el precio anterior del articulo precioAct para el precio actual del articulo ptjeInfl a para el porcentaje de infl ación del articulo2. Método establecerArticulo(nom: Cadena) Recibe en el parámetro nom el valor que luego coloca en el dato articulo.3. Método establecerPrecioAnt(pAnt: Real) Recibe en el parámetro pAnt el valor que luego coloca en el dato precioAnt.4. Método establecerPrecioAct(pAct: Real) Recibe en el parámetro pAct el valor que luego coloca en el dato precioAct.5. Método calcularPtjeInfl a() Calcula ptjeInfl a (porcentaje de infl ación)6. Método obtenerArticulo(): Cadena Retorna articulo7. Método obtenerPrecioAnt(): Real Retorna precioAnt8. Método obtenerPrecioAct(): Real Retorna precioAct9. Método obtenerPtjeInfl a(): Real Retorna ptjeInfl aFin de la Clase Articulo

En la Clase EjecutaArticulo; en el Método principal:

a. Se declara: La variable art para leer el nombre del artículo. La variable preAn para leer el precio anterior. La variable preAc para leer el precio actual. La variable totArticulos para contar el total de artículos. La variable mayorInfl a para colocar la mayor infl ación. La variable artMayor para colocar el artículo con mayor infl ación.


La variable otro para controlar el ciclo repetitivob. Imprime encabezadoc. Inicia totArticulos, totInfla y mayorInfla en 0d. Inicia ciclo DO 1. Se declara el objeto objArti, usando como base a la clase Articulo; dicho objeto se

crea e inicializa mediante el constructor por defecto Articulo(). Observe que cada vez que entra al ciclo crea un nuevo objeto articulo. 2. Solicita Artículo, precio actual y precio anterior 3. Lee en art, preAn, preAc 4. Se llama al método establecerArticulo(art) del objeto objArti; para colocar el valor

de art en el dato articulo. Se llama al método establecerPrecioAnt(preAn) del objeto objArti; para colocar el

valor de preAn en el dato precioAnt. Se llama al método establecerPrecioAct(preAc) del objeto objArti; para colocar el

valor de preAc en el dato precioAct. 5. Se llama al método calcularPtjeInfla() del objeto objArti; para calcular el porcentaje

de inflación. 6. Se llama al método obtenerArticulo() del objeto objArti; para acceder e imprimir el

valor del dato articulo. Se llama al método obtenerPrecioAnt() del objeto objArti; para acceder e imprimir

el valor del dato precioAnt. Se llama al método obtenerPrecioAct() del objeto objArti; para acceder e imprimir

el valor del dato precioAct. Se llama al método obtenerPtjeInfla() del objeto objArti; para acceder e imprimir

el valor del dato ptjeInfla. 7. Si objArti.obtenerPtjeInfla() > mayorInfla Entonces a. mayorInfla = objArti.obtenerPtjeInfla() b. artMayor = objArti.obtenerArticulo() 8. Fin del IF 9. Incrementa totArticulos en 1 10. Se incrementa totInfla con ptjeInfla; que se accede llamando al método obtenerPtje

Infla() del objeto objArti. 11. Pregunta “¿Desea procesar otro articulo(S/N)?” 12. Lee en otro la respuestae. Fin del ciclo (WHILE desea = “S”). Si se cumple regresa al DO; si no, se sale del ciclo.f. Calcula el promedio de inflacióng. Imprime el promedio de inflación, el artículo que tiene la mayor inflación y el mayor

porcentaje de inflaciónh. Fin Método principalFin de la Clase EjecutaArticuloFin del algoritmo

Ejercicio 13.1.2.4

En una empresa manufacturera de mesas. Se tienen varios obreros, y por cada obrero los datos:



Cada obrero puede haber trabajado varios días, por cada día que trabajó, se tiene un dato: Cantidad de unidades fabricadas (construidas).

Cantidad de unidades fabricadas: --- Cantidad de unidades fabricadas: --- . Cantidad de unidades fabricadas: ---

Nota:cada cantidad fabricada es de un día de trabajo.


Cantidad de unidades fabricadas: --- Cantidad de unidades fabricadas: --- . Cantidad de unidades fabricadas: ---------------------

Elaborar un algoritmo que lea los datos de cada uno de los obreros y por cada obrero, la cantidad de unidades fabricadas de cada uno de los días que trabajó e imprima el si-guiente reporte:


Nombre del obrero Unidades producidas

XXXXXXXXXXXXXXXXXXXXXXXX 999 XXXXXXXXXXXXXXXXXXXXXXXX 999 . . . XXXXXXXXXXXXXXXXXXXXXXXX 999

Total 999 obreros 999

Nombre obrero mas productivo: XXXXXXXXXXXXXXXXXXXXXXX Produccion que fabrico: 999

Nombre obrero menos productivo: XXXXXXXXXXXXXXXXXXXXXXX Produccion que fabrico: 999


Cálculos:

Se lee el nombre de un obrero, luego cada una de las cantidades producidas, se suman estas cantidades para calcular UNIDADES PRODUCIDAS; en otras palabras, es la sumatoria de las cantidades producidas de todos los días que laboró. Al final se pide el TOTAL de obreros y el TOTAL de UNIDADES PRODUCUDAS por todos los obreros.



Diagrama de clases

Obrero1

nombreObr produccion

establecerNombreObr() establecerProduccion() obtenerNombreObr() obtenerProduccion()

EjecutaObrero1

Algoritmo CALCULA LA PRODUCCION DE VARIOS OBREROS Clase Obrero1 1. Declaraciones Datos nombreObr: Cadena produccion: Entero

2. Método establecerNombreObr(nom: Cadena) a. nombreObr = nom b. Fin Método establecerNombreObr

3. Método establecerProduccion(prod: Entero) a. produccion = prod b. Fin Método establecerProduccion

4. Método obtenerNombreObr(): Cadena a. return nombreObr b. Fin Método obtenerNombreObr

5. Método obtenerProduccion(): Real a. return produccion


b. Fin Método obtenerProduccion Fin Clase Obrero1

Clase EjecutaObrero1 1. Método principal a. Declaraciones Variables nombre, obrMayor, obrMenor: Cadena proDia, totProdObr, totProd, totObreros, mayorProd, menorProd: Entero otro, desea: Carácter b. Imprimir encabezado c. totObreros = 0 totProd = 0 mayorProd = 0 menorProd = 10000 d. DO 1. Declarar, crear e iniciar objeto Obrero1 objObrero = new Obrero1() 2. Solicitar Nombre 3. Leer nombre 4. totProdObr = 0 5. DO a. Solicitar Producción del dia b. Leer proDia c. totProdObr = totProdObr + proDia d. Preguntar “¿Desea procesar otro dia (S/N)?” e. Leer otro 6. WHILE otro = “S” 7. Establecer objObrero.establecerNombreObr(nombre) objObrero.establecerProduccion(totProdObr) 8. Imprimir objObrero.obtenerNombreObr() objObrero.obtenerProduccion() 9. IF objObrero.obtenerProduccion()>mayorProd THEN a. mayorProd = objObrero.obtenerProduccion() b. obrMayor = objObrero.obtenerNombreObr() 10. ENDIF 11. IF objObrero.obtenerProduccion()<menorProd THEN a. menorProd = objObrero.obtenerProduccion() b. obrMenor = objObrero.obtenerNombreObr() 12. ENDIF 13. totObreros = totObreros + 1 totProd = totProd+objObrero.obtenerProduccion() 14. Preguntar “¿Desea procesar otro obrero (S/N)?” 15. Leer desea e. WHILE desea = “S”


f. Imprimir totObreros, totProd, obrMayor, mayorProd, obrMenor, menorProd g. Fin Método principal Fin Clase EjecutaObrero1Fin

Explicación:

El algoritmo tiene dos clases; la Clase Obrero1 y la clase EjecutaObrero1.

En la Clase Obrero1:1. Se declaran los datos que representan la estructura de la clase:

nombreObr para el nombre del obrero produccion para la produccion del obrero2. Método establecerNombreObr(nom: Cadena) Recibe en el parámetro nom el valor que luego coloca en el dato nombreObr.3. Método establecerProduccion(prod: Entero) Recibe en el parámetro prod el valor que luego coloca en el dato produccion.4. Método obtenerNombreObr(): Cadena Retorna nombreObr5. Método obtenerProduccion(): Real Retorna produccionFin de la Clase Obrero1

En la Clase EjecutaObrero1; en el Método principal:

a. Se declara: La variable nombre para leer el nombre del obrero. La variable obrMayor para colocar el nombre del obrero más productivo. La variable obrMenor para colocar el nombre del obrero menos productivo. La variable proDia para leer la producción de cada día. La variable totObreros para contar el total de obreros. La variable totProdObr para calcular el total de producción del obrero. La variable totProd para calcular el total de producción de todos los obreros. La variable mayorProd para colocar el mayor totProdObr. La variable menorProd para colocar el menor totProdObr. La variable otro y desea para controlar los ciclos repetitivos.b. Imprime encabezadoc. Inicia totObreros, totProd, mayorProd en 0; y menorProd en 10000d. Inicia ciclo DO 1. Se declara el objeto objObrero, usando como base a la clase Obrero1; dicho objeto

se crea e inicializa mediante el constructor por defecto Obrero1(). Observe que cada vez que entra al ciclo crea un nuevo objeto obrero. 2. Solicita el nombre del obrero 3. Lee en nombre 4. Inicia totProdObr en 0


5. Inicia ciclo DO a. Solicita la producción del día b. Lee en proDia c. Incrementa totProdObr con proDia d. Pregunta “¿Desea procesar otro dia (S/N)?” e. Lee en otro la respuesta 6. Fin del ciclo (WHILE otro = “S”). Si se cumple regresa al DO; si no, se sale del

ciclo. 7. Se llama al método establecerNombreObr(nombre) del objeto objObrero; para

colocar el valor de nombre en el dato nombreObr. Se llama al método establecerProduccion(totProdObr) del objeto objObrero; para

colocar el valor de totProdObr en el dato produccion. 8. Se llama al método obtenerNombreObr() del objeto objObrero; para acceder e

imprimir el valor del dato nombreObr. Se llama al método obtenerProduccion() del objeto objObrero; para acceder e

imprimir el valor del dato produccion. 9. IF objObrero.obtenerProduccion()>mayorProd Entonces a. mayorProd = objObrero.obtenerProduccion() b. obrMayor = objObrero.obtenerNombreObr() 10. Fin del IF 11. Si objObrero.obtenerProduccion()<menorProd Entonces a. menorProd = objObrero.obtenerProduccion() b. obrMenor = objObrero.obtenerNombreObr() 12. Fin del IF 13. Incrementa totObreros en 1 Se incrementa totProd con produccion; que se accede llamando al método

obtenerProduccion() del objeto objObrero. 14. Pregunta “¿Desea procesar otro obrero (S/N)?” 15. Lee en desea la respuestae. Fin del ciclo (WHILE desea = “S”). Si se cumple regresa al DO; si no, se sale del ciclo.f. Imprime totObreros, totProd, obrMayor, mayorProd, obrMenor, menorProdg. Fin Método principalFin de la Clase EjecutaObrero1Fin del algoritmo

13.2.1 Ejercicios resueltos para FOR (Continuación…)

Ejercicio 13.2.1.3

Elaborar un algoritmo que pregunte a cuántos números se desea calcular el factorial; lea la cantidad en N. A continuación, debe leer un número e imprimir su factorial, luego leer otro, y así hasta leer los N números.



Ejercicios resueltos para FOR (Continuación...) 13-11

Diagrama de clases

Factorial3

numero factorial

establecerNumero() calcularFactorial() obtenerFactorial()

EjecutaFactorial3

Algoritmo FACTORIALES DE N NUMEROS Clase Factorial3 1. Declaraciones Datos numero: Entero factorial: Entero

2. Método establecerNumero(nu: Entero) a. numero = nu b. Fin Método establecerNumero

3. Método calcularFactorial() a. Declaraciones Variables i: Entero b. IF numero = 0 THEN 1. factorial = 1 c. ELSE 1. factorial = 1 2. FOR i=numero; i>=1; i-- a. factorial = factorial * i 3. ENDFOR d. ENDIF e. Fin Método calcularFactorial

4. Método obtenerFactorial() a. return = factorial b. Fin Método obtenerFactorial Fin Clase Factorial3

Clase EjecutaFactorial3 1. Método principal a. Declaraciones Variables


n, j, num: Entero b. Solicitar Cantidad de números a calcular factorial c. Leer n d. FOR j=1; j<=n; j++ 1. Declarar, crear e iniciar objeto Factorial3 objFactorial = new Factorial3() 2. Solicitar Número 3. Leer num 4. Establecer objFactorial.establecerNumero(num) 5. Calcular objFactorial.calcularFactorial() 6. Imprimir objFactorial.obtenerFactorial() e. ENDFOR f. Fin Método principal Fin Clase EjecutaFactorial3Fin

Explicación:

El algoritmo tiene dos clases; la Clase Factorial3 y la clase EjecutaFactorial3.

En la Clase Factorial3:1. Se declaran los datos que representan la estructura de la clase: numero para el número factorial para el factorial2. Método establecerNumero(nu: Entero) Recibe en el parámetro nu el valor que luego coloca en el dato numero.3. Método calcularFactorial() a. Declaraciones Variables i: Entero b. Si numero = 0 Entonces 1. factorial = 1 c. Si no 1. Inicia factorial en 1 2. Inicia ciclo FOR desde i=numero hasta 1 con decrementos de 1 a. Calcula factorial = factorial * i 3. Fin del FOR d. Fin del IF e. Fin Método calcularFactorial4. Método obtenerFactorial() Retorna factorialFin de la Clase Factorial3

En la Clase EjecutaFactorial3; en el Método principal:

a. Se declara: La variable num para leer el número.

Ejercicios resueltos para FOR (Continuación...) 13-13

La variable n para leer cuántos números son. La variable j para controlar el ciclo repetitivo.b. Solicita Cantidad de números a calcular factorialc. Lee en nd. Inicia ciclo FOR desde j=1 hasta n con incrementos de 1 1. Se declara el objeto objFactorial, usando como base a la clase Factorial3; dicho

objeto se crea e inicializa mediante el constructor por defecto Factorial3(). 2. Solicita el número 3. Lee en num 4. Se llama al método establecerNumero(num) del objeto objFactorial; para colocar

el valor de num en el dato numero. 5. Se llama al método calcularFactorial() del objeto objFactorial; para calcular el

factorial. 6. Se llama al método obtenerFactorial() del objeto objFactorial; para acceder e

imprimir el valor del dato factorial.e. Fin del FORf. Fin Método principalFin de la Clase EjecutaFactorial3Fin del algoritmo

Ejercicio 13.2.1.4

Elaborar un algoritmo similar al Ejercicio 13.1.2.4, del punto anterior; solo que ahora se tienen 15 obreros, y cada obrero trabajó seis días.



Diagrama de clases

Obrero2

nombreObr produccion

establecerNombreObr() establecerProduccion() obtenerNombreObr() obtenerProduccion()

EjecutaObrero2

Algoritmo CALCULA LA PRODUCCION DE 15 OBREROS Clase Obrero2 1. Declaraciones


Datos nombreObr: Cadena produccion: Entero

2. Método establecerNombreObr(nom: Cadena) a. nombreObr = nom b. Fin Método establecerNombreObr

3. Método establecerProduccion(prod: Entero) a. produccion = prod b. Fin Método establecerProduccion 4. Método obtenerNombreObr(): Cadena a. return nombreObr b. Fin Método obtenerNombreObr 5. Método obtenerProduccion(): Real a. return produccion b. Fin Método obtenerProduccion Fin Clase Obrero2

Clase EjecutaObrero2 1. Método principal a. Declaraciones Variables nombre, obrMayor, obrMenor: Cadena obrero, dia, proDia, totProdObr, totProd, totObreros, mayorProd, menorProd: Entero b. Imprimir encabezado c. totObreros = 0 totProd = 0 mayorProd = 0 menorProd = 10000 d. FOR obrero=1; obrero<=15; obrero++ 1. Declarar, crear e iniciar objeto Obrero2 objObrero = new Obrero2() 2. Solicitar Nombre 3. Leer nombre 4. totProdObr = 0 5. FOR dia=1; dia<=6; dia++ a. Solicitar Producción del dia b. Leer proDia c. totProdObr = totProdObr + proDia 6. ENDFOR 7. Establecer objObrero.establecerNombreObr(nombre) objObrero.establecerProduccion(totProdObr)

Ejercicios resueltos para WHILE (Continuación...) 13-15

8. Imprimir objObrero.obtenerNombreObr() objObrero.obtenerProduccion() 9. IF objObrero.obtenerProduccion()>mayorProd THEN a. mayorProd = objObrero.obtenerProduccion() b. obrMayor = objObrero.obtenerNombreObr() 10. ENDIF 11. IF objObrero.obtenerProduccion()<menorProd THEN a. menorProd = objObrero.obtenerProduccion() b. obrMenor = objObrero.obtenerNombreObr() 12. ENDIF 13. totObreros = totObreros + 1 totProd = totProd+objObrero.obtenerProduccion() e. ENDFOR f. Imprimir totObreros, totProd, obrMayor, mayorProd, obrMenor, menorProd g. Fin Método principal Fin Clase EjecutaObrero2Fin

Explicación:

Este algoritmo es similar al Ejercicio 13.1.2.4 lo único que cambia es la forma de controlar los ciclos. Ahora se están usando dos FOR en lugar de los dos DO; en consecuencia, también cambian las variables con las que se controlan, en lugar de otro y desea, ahora se usan obrero y día.

13.3.1 Ejercicios resueltos para WHILE (Continuación…)

Ejercicio 13.3.1.3

En una fábrica se tienen 10 estaciones de trabajo, y la producción hecha en número de unidades fabricadas en cada uno de los días de la semana; cada estación pudo haber trabajado cualquier cantidad de días en la semana.

Estación 1: Producción dia: --- Producción dia: --- .

. . Producción dia: ---

Estación 2: Producción dia: --- Producción dia: ---


. . . Producción dia: ---

Estación 10: Producción dia: --- Producción dia: --- . . . Producción dia: ---

Elaborar un algoritmo que lea el nivel de productividad, y los datos de la producción de cada una de las estaciones, e imprima el siguiente reporte:


Estacion Total produccion Nivel productividad

1 999 Deficiente 2 999 Bueno 3 ----- . ----- . ----- .

10 999 Excelente

Total 999

TOTAL PRODUCCION es la sumatoria de la producción de los días laborados.NIVEL PRODUCTIVIDAD es un comentario que indica DEFICIENTE, BUENO o EXCELENTE si el TOTAL PRODUCCION es menor, es igual o es mayor a 300 respectivamente.TOTAL es el total del TOTAL PRODUCCION de todas las estaciones de trabajo.



Diagrama de clases


Estacion

numEstacion totProduccion nivProductividad

establecerNumEstacion() establecerTotProduccion() calcularNivProductividad() obtenerNumEstacion() obtenerTotProduccion() obtenerNivProductividad()

EjecutaEstacion

Algoritmo ESTACIONES DE TRABAJO Clase Estacion 1. Declaraciones Datos numEstacion: Entero totProduccion: Entero nivProductividad: Cadena

2. Método establecerNumEstacion(num: Entero) a. numEstacion = num b. Fin Método establecerNumEstacion

3. Método establecerTotProduccion(tProd: Entero) a. totProduccion = tProd b. Fin Método establecerTotProduccion

4. Método calcularNivProductividad() a. IF totProduccion < 300 THEN 1. nivProductividad = “DEFICIENTE” b. ELSE 1. IF totProduccion = 300 THEN a. nivProductividad = “BUENO” 2. ELSE a. nivProductividad = “EXCELENTE” 3. ENDIF c. ENDIF d. Fin Método calcularNivProductividad

5. Método obtenerNumEstacion(): Entero a. return numEstacion b. Fin Método obtenerNumEstacion

6. Método obtenerTotProduccion(): Entero


a. return totProduccion b. Fin Método obtenerTotProduccion

7. Método obtenerNivProductividad(): Cadena a. return nivProductividad b. Fin Método obtenerNivProductividad Fin Clase Estacion

Clase EjecutaEstacion 1. Método principal a. Declaraciones Variables hay: Carácter estacion, proDia, totProd, toTotProd: Entero b. Imprimir encabezado c. toTotProd = 0 d. FOR estacion=1; estacion<=10; estacion++ 1. Declarar, crear e iniciar objeto Estacion objEstacion = new Estacion() 2. totProd = 0 3. Preguntar “¿HAY DIA DE PRODUCCION (S/N)?” 4. Leer hay 5. WHILE hay = “S” a. Solicitar Producción del día b. Leer proDia c. totProd = totProd + proDia d. Preguntar “¿HAY DIA DE PRODUCCION (S/N)?” e. Leer hay 6. ENDWHILE 7. Establecer objEstacion.establecerNumEstacion(estacion) objEstacion.establecerTotProduccion(totProd) 8. Calcular objEstacion.calcularNivProductividad() 9. Imprimir objEstacion.obtenerNumEstacion() objEstacion.obtenerTotProduccion() objEstacion.obtenerNivProductividad() 10. toTotProd = toTotProd + objEstacion.obtenerTotProduccion() e. ENDFOR f. Imprimir toTotProd g. Fin Método principal Fin Clase EjecutaEstacionFin

Explicación:

El algoritmo tiene dos clases; la Clase Estacion y la clase EjecutaEstacion.


En la Clase Estacion:1. Se declaran los datos que representan la estructura de la clase: numEstacion para el número que identifica a la estación totProduccion para la producción hecha por la estación nivProductividad para el nivel de productividad de la estación2. Método establecerNumEstacion(num: Entero) Recibe en el parámetro num el valor que luego coloca en el dato numEstacion.3. Método establecerTotProduccion(tProd: Entero) Recibe en el parámetro tProd el valor que luego coloca en el dato totProduccion.4. Método calcularNivProductividad() a. Si totProduccion < 300 Entonces 1. Coloca en nivProductividad “DEFICIENTE” b. Si no 1. Si totProduccion = 300 Entonces a. Coloca en nivProductividad “BUENO” 2. Si no a. Coloca en nivProductividad “EXCELENTE” 3. Fin del IF c. Fin del IF d. Fin Método calcularNivProductividad5. Método obtenerNumEstacion():Entero Retorna numEstacion6. Método obtenerTotProduccion():Entero Retorna totProduccion7. Método obtenerNivProductividad(): Cadena Retorna nivProductividadFin de la Clase Estacion

En la Clase EjecutaEstacion; en el Método principal:

a. Se declara: La variable estacion para controlar el ciclo de estaciones de 1 a 10 La variable proDia para leer la cantidad de unidades fabricadas por cada día La variable totProd para calcular el total de producción de cada estación La variable toTotProd para calcular el total de producción de todas las estaciones La variable hay para controlar el ciclo repetitivob. Imprime el encabezadoc. Inicia toTotProd en 0d. Inicia FOR desde estacion=1 hasta 10 con incrementos de 1 1. Se declara el objeto objEstacion, usando como base a la clase Estacion; dicho objeto

se crea e inicializa mediante el constructor por defecto Estacion(). Observe que cada vez que entra al ciclo crea un nuevo objeto estación. 2. Inicia totProd en 0 3. Pregunta “¿HAY DIA DE PRODUCCION (S/N)?” 4. Lee en hay la respuesta 5. Inicia ciclo WHILE mientras hay = “S” a. Solicita la Producción del día


b. Lee en proDia c. Incrementa totProd con proDia d. Pregunta “¿HAY DIA DE PRODUCCION (S/N)?” e. Lee en hay la respuesta 6. Fin del WHILE 7. Se llama al método establecerNumEstacion(estacion) del objeto objEstacion; para

colocar el valor de estacion en el dato numEstacion. Se llama al método establecerTotProduccion(totProd) del objeto objEstacion; para

colocar el valor de totProd en el dato totProduccion. 8. Se llama al método calcularNivProductividad() del objeto objEstacion; para

calcular el nivel de productividad. 9. Se llama al método obtenerNumEstacion() del objeto objEstacion; para acceder e

imprimir el valor del dato numEstacion. Se llama al método obtenerTotProduccion() del objeto objEstacion; para acceder e

imprimir el valor del dato totProduccion. Se llama al método obtenerNivProductividad() del objeto objEstacion; para acceder

e imprimir el valor del dato nivProductividad. 10. Se incrementa toTotProd con el totProduccion de la estación; mismo que se accede

llamando al método obtenerTotProduccion() del objeto objEstacion.e. Fin del FORf. Imprime toTotProdg. Fin Método principalFin de la Clase EjecutaEstacionFin del algoritmo

Capítulo 14


Ejercicio 14.1.4

En este ejemplo se elabora un algoritmo que soluciona el mismo problema del ejercicio anterior, pero con una estructura diferente.


Diagrama de clases

Obrero5

nombreObr produccion[30] promProd totArriba prodMayor diaMayor

leerNombreObr() leerProduccion() calcularPromProd() calcularTotArriba() calcularProdMayorDiaMayor() imprimirNombreObr() imprimirProduccion() imprimirPromProd() imprimirTotArriba() imprimirProdMayor() imprimirDiaMayor()

EjecutaObrero5


Algoritmo PRODUCCION PROMEDIO DE OBRERO Clase Obrero5 1. Declaraciones Datos nombreObr: Cadena produccion: Arreglo[30] Entero promProd: Real totArriba, prodMayor, diaMayor: Entero

2. Método leerNombreObr() a. Solicitar nombre del obrero b. Leer nombreObr c. Fin Método leerNombreObr

3. Método leerProduccion() a. Declaraciones Variables i: Entero b. FOR i=0; i<=29; i++ 1. Solicitar producción del día i+1 2. Leer produccion[i] c. ENDFOR d. Fin Método leerProduccion

4. Método calcularPromProd() a. Declaraciones Variables n, sumaProd: Entero b. sumaProd = 0 c. FOR n=0; n<=29; n++ 1. sumaProd = sumaProd + produccion[n] d. ENDFOR e. promProd = sumaProd / 30 f. Fin Método calcularPromProd

5. Método calcularTotArriba() a. Declaraciones Variables j: Entero b. totArriba = 0 c. FOR j=0; j<=29; j++ 1. IF produccion[j] > promedio THEN a. totArriba = totArriba + 1 2. ENDIF d. ENDFOR e. Fin Método calcularTotArriba

6. Método calcularProdMayorDiaMayor() a. Declaraciones


Variables m: Entero b. prodMayor = 0 c. FOR m=0; m<=29; m++ 1. IF produccion[m] > prodMayor THEN a. prodMayor = produccion[m] b. diaMayor = m 2. ENDIF d. ENDFOR e. Fin Método calcularProdMayorDiaMayor

7. Método imprimirNombreObr() a. Imprimir nombreObr b. Fin Método imprimirNombreObr

8. Método imprimirProduccion() a. Declaraciones Variables i: Entero b. FOR i=0; i<=29; i++ 1. Imprimir producion[i] c. ENDFOR d. Fin Método imprimirProduccion

9. Método imprimirPromProd() a. Imprimir promProd b. Fin Método imprimirPromProd

10. Método imprimirTotArriba() a. Imprimir totArriba b. Fin Método imprimirTotArriba

11. Método imprimirProdMayor() a. Imprimir prodMayor b. Fin Método imprimirProdMayor

12. Método imprimirDiaMayor() a. Imprimir diaMayor b. Fin Método imprimirDiaMayor Fin Clase Obrero5

Clase EjecutaObrero5 1. Método principal a. Declarar, crear e iniciar objeto Obrero5 objObrero = new Obrero5() b. Leer objObrero.leerNombreObr() objObrero.leerProduccion() c. Calcular objObrero.calcularPromProd() objObrero.calcularTotArriba()


objObrero.calcularProdMayorDiaMayor() d. Imprimir objObrero.imprimirNombreObr() objObrero.imprimirProduccion() objObrero.imprimirPromProd() objObrero.imprimirTotArriba() objObrero.imprimirProdMayor() objObrero.imprimirDiaMayor() e. Fin Método principal Fin Clase EjecutaObrero5Fin

Explicación:

El algoritmo tiene dos clases; la Clase Obrero5 y la clase EjecutaObrero5.

En la Clase Obrero51. Se declaran los datos que representan la estructura de la clase: nombreObr para el nombre del obrero produccion que es un arreglo de 30 elementos de tipo entero para los 30 días de pro-

ducción del obrero. La variable totArriba para el total de días arriba del promedio La variable prodMayor para la producción mayor La variable diaMayor para el día de la producción mayor La variable promProd para promedio de producción2. Método leerNombreObr() a. Solicita el nombre del obrero b. Lee en nombreObr c. Fin del Método leerNombreObr3. Método leerProduccion() a. Declara la variable i para controlar el ciclo b. Inicia ciclo FOR desde i=0 hasta 29 con incrementos de 1 1. Solicita producción del día i+1 2. Lee en produccion[i] c. Fin del ciclo FOR d. Fin del Método leerProduccion4. Método calcularPromProd() a. Declara: La variable n para controlar el ciclo La variable sumaProd para calcular la sumatoria de los 30 días de producción b. Inicia sumaProd en 0 c. Inicia ciclo FOR desde n=0 hasta 29 con incrementos de 1 1. Incrementa sumaProd con produccion[n] d. Fin del ciclo FOR e. Calcula promProd = sumaProd / 30 f. Fin del Método calcularPromProd5. Método calcularTotArriba() a. Declara la variable j para controlar el ciclo


b. Inicia totArriba en 0 c. Inicia ciclo FOR desde j=0 hasta 29 con incrementos de 1 1. Si produccion[j] > promedio Entonces a. Incrementa totArriba en 1 2. Fin del IF d. Fin del ciclo FOR e. Fin del Método calcularTotArriba6. Método calcularProdMayorDiaMayor() a. Declara la variable m para controlar el ciclo b. Inicia prodMayor en 0 c. Inicia ciclo FOR desde m=0 hasta 29 con incrementos de 1 1. Si produccion[m] > prodMayor Entonces a. Coloca en prodMayor el valor de produccion[m] b. Coloca en diaMayor el valor de m 2. Fin del IF d. Fin del ciclo FOR e. Fin Método calcularProdMayorDiaMayor7. Método imprimirNombreObr() a. Imprime nombreObr b. Fin del Método imprimirNombreObr8. Método imprimirProduccion() a. Declara la variable i para controlar el ciclo b. Inicia ciclo FOR desde i=0 hasta 29 con incrementos de 1 1. Imprime producion[i] c. Fin del ciclo FOR d. Fin del Método imprimirProduccion9. Método imprimirPromProd() a. Imprime promProd b. Fin del Método imprimirPromProd10. Método imprimirTotArriba() a. Imprime totArriba b. Fin del Método imprimirTotArriba11. Método imprimirProdMayor() a. Imprime prodMayor b. Fin del Método imprimirProdMayor12. Método imprimirDiaMayor() a. Imprime diaMayor b. Fin del Método imprimirDiaMayorFin de la Clase Obrero5

En la Clase EjecutaObrero5; en el Método principal:a. Se declara el objeto objObrero, usando como base a la clase Obrero5; dicho objeto se

crea e inicializa mediante el constructor por defecto Obrero5().b. Se llama al método leerNombreObr() del objeto objObrero; en el cual lee el nombre

del obrero. Se llama al método leerProduccion() del objeto objObrero; en el cual lee la producción

de los 30 días del obrero.


c. Se llama al método calcularPromProd() del objeto objObrero; en el cual calcula el promedio de producción del obrero.

Se llama al método calcularTotArriba() del objeto objObrero; en el cual calcula el total de días con producción arriba del promedio del obrero.

Se llama al método calcularProdMayorDiaMayor() del objeto objObrero; en el cual calcula la producción mayor y el día de la producción mayor del obrero.

d. Se llama al método imprimirNombreObr() del objeto objObrero; para acceder e im-primir el valor del dato nombreObr.

Se llama al método imprimirProduccion() del objeto objObrero; para acceder e im-primir el valor del dato produccion.

Se llama al método imprimirPromProd() del objeto objObrero; para acceder e imprimir el valor del dato promProd.

Se llama al método imprimirTotArriba() del objeto objObrero; para acceder e imprimir el valor del dato totArriba.

Se llama al método imprimirProdMayor() del objeto objObrero; para acceder e impri-mir el valor del dato prodMayor.

Se llama al método imprimirDiaMayor() del objeto objObrero; para acceder e imprimir el valor del dato diaMayor.

e. Fin Método principalFin de la Clase EjecutaObrero5Fin del algoritmo


Ejercicio 14.2.4

En este ejemplo se elabora un algoritmo que soluciona el mismo problema del ejercicio 14.2.2, pero con una estructura diferente.


Diagrama de clases

Matrices2

matriz1[5][5] matriz2[5][5] matriz3[5][5]

leerMatriz1() leerMatriz2() calcularMatriz3() imprimirMatriz1() imprimirMatriz2() imprimirMatriz3()

EjecutaMatrices2


Algoritmo SUMA MATRICES Clase Matrices2 1. Declaraciones Datos matriz1: Arreglo[5][5] Entero matriz2: Arreglo[5][5] Entero matriz2: Arreglo[5][5] Entero

2. Método leerMatriz1() a. Declaraciones Variables ren, col: Entero b. FOR ren=0; ren<=4; ren++ 1. FOR col=0; col<=4; col++ a. Solicitar matriz1[ren][col] b. Leer matriz1[ren][col] 2. ENDFOR c. ENDFOR d. Fin Método leerMatriz1

3. Método leerMatriz2() a. Declaraciones Variables r, c: Entero b. FOR r=0; r<=4; r++ 1. FOR c=0; c<=4; c++ a. Solicitar matriz2[r][c] b. Leer matriz2[r][c] 2. ENDFOR c. ENDFOR d. Fin Método leerMatriz2

4. Método calcularMatriz3() a. Declaraciones Variables re, co: Entero b. FOR re=0; re<=4; re++ 1. FOR co=0; co<=4; co++ a. matriz3[re][co] = matriz1[re][co] + matriz2[re][co] 2. ENDFOR c. ENDFOR d. Fin Método calcularMatriz3

5. Método imprimirMatriz1() a. Declaraciones Variables ren, col: Entero


b. FOR ren=0; ren<=4; ren++ 1. FOR col=0; col<=4; col++ a. Imprimir matriz1[ren][col] 2. ENDFOR c. ENDFOR d. Fin Método imprimirMatriz1

6. Método imprimirMatriz2() a. Declaraciones Variables r, c: Entero b. FOR r=0; r<=4; r++ 1. FOR c=0; c<=4; c++ a. Imprimir matriz2[r][c] 2. ENDFOR c. ENDFOR d. Fin Método imprimirMatriz2

7. Método imprimirMatriz3() a. Declaraciones Variables re, co: Entero b. FOR re=0; re<=4; re++ 1. FOR co=0; co<=4; co++ a. Imprimir matriz3[re][co] 2. ENDFOR c. ENDFOR d. Fin Método imprimirMatriz3 Fin Clase Matrices2

Clase EjecutaMatrices2 1. Método principal a. Declarar, crear e iniciar objeto Matrices2 objMatrices = new Matrices2() b. Leer objMatrices.leerMatriz1() objMatrices.leerMatriz2() c. Calcular objMatrices.calcularMatriz3() d. Imprimir objMatrices.imprimirMatriz1() objMatrices.imprimirMatriz2() objMatrices.imprimirMatriz3() e. Fin Método principal Fin Clase EjecutaMatrices2Fin

Explicación:

El algoritmo tiene dos clases; la Clase Matrices2 y la clase EjecutaMatrices2.


En la Clase Matrices2:1. Se declaran los datos que representan la estructura de la clase: matriz1 que es un arreglo de 5x5 elementos de tipo entero para la matriz 1. matriz2 que es un arreglo de 5x5 elementos de tipo entero para la matriz 2. matriz3 que es un arreglo de 5x5 elementos de tipo entero para la matriz 3.

2. Método leerMatriz1() a. Se declaran las variables ren y col para controlar los ciclos repetitivos b. Inicia ciclo FOR desde ren=0 hasta 4 con incrementos de 1 1. Inicia ciclo FOR desde col=0 hasta 4 con incrementos de 1 a. Solicita matriz1[ren][col] b. Lee en matriz1[ren][col] 2. Fin del ciclo FOR c. Fin del ciclo FOR d. Fin Método leerMatriz1

3. Método leerMatriz2() a. Se declaran las variables r y c para controlar los ciclos repetitivos b. Inicia ciclo FOR desde r=0 hasta 4 con incrementos de 1 1. Inicia ciclo FOR desde c=0 hasta 4 con incrementos de 1 a. Solicita matriz2[r][c] b. Lee en matriz2[r][c] 2. Fin del ciclo FOR c. Fin del ciclo FOR d. Fin Método leerMatriz2

4. Método calcularMatriz3() a. Se declaran las variables re y co para controlar los ciclos repetitivos b. Inicia ciclo FOR desde re=0 hasta 4 con incrementos de 1 1. Inicia ciclo FOR desde co=0 hasta 4 con incrementos de 1 a. Calcula matriz3[re][co] sumando matriz1[re][co] y matriz2[re][co] 2. Fin del ciclo FOR c. Fin del ciclo FOR d. Fin Método calcularMatriz3

5. Método imprimirMatriz1() a. Se declaran las variables ren y col para controlar los ciclos repetitivos b. Inicia ciclo FOR desde ren=0 hasta 4 con incrementos de 1 1. Inicia ciclo FOR desde col=0 hasta 4 con incrementos de 1 a. Imprime matriz1[ren][col] 2. Fin del ciclo FOR c. Fin del ciclo FOR d. Fin Método imprimirMatriz1

6. Método imprimirMatriz2() a. Se declaran las variables r y c para controlar los ciclos repetitivos


b. Inicia ciclo FOR desde r=0 hasta 4 con incrementos de 1 1. Inicia ciclo FOR desde c=0 hasta 4 con incrementos de 1 a. Imprime matriz2[r][c] 2. Fin del ciclo FOR c. Fin del ciclo FOR d. Fin Método imprimirMatriz2

7. Método imprimirMatriz3() a. Se declaran las variables re y co para controlar los ciclos repetitivos b. Inicia ciclo FOR desde re=0 hasta 4 con incrementos de 1 1. Inicia ciclo FOR desde co=0 hasta 4 con incrementos de 1 a. Imprime matriz3[re][co] 2. Fin del ciclo FOR c. Fin del ciclo FOR d. Fin Método imprimirMatriz3Fin de la Clase Matrices2

En la Clase EjecutaMatrices2; en el Método principal:

a. Se declara el objeto objMatrices, usando como base a la clase Matrices2; dicho objeto se crea e inicializa mediante el constructor por defecto Matrices2().

b. Se llama al método leerMatriz1() del objeto objMatrices; para leer los valores del dato matriz1.

Se llama al método leerMatriz2() del objeto objMatrices; para leer los valores del dato matriz2.

c. Se llama al método calcularMatriz3() del objeto objMatrices; para calcular los valores del dato matriz3.

d. Se llama al método imprimirMatriz1() del objeto objMatrices; en el cual se imprimen los valores del dato matriz1.

Se llama al método imprimirMatriz2() del objeto objMatrices; en el cual se imprimen los valores del dato matriz2.

Se llama al método imprimirMatriz3() del objeto objMatrices; en el cual se imprimen los valores del dato matriz3.

e. Fin Método principalFin de la Clase EjecutaMatrices2Fin del algoritmo

Capítulo 15


Ejercicio 15.4.2

Elaborar un algoritmo que ofrezca un menú de opciones, mediante el cual se pueda escoger calcular el área y perímetro de las fi guras geométricas: triángulo, cuadrado, rectángulo y círculo. Una vez seleccionada la opción, que permita solicitar y leer el nombre de la fi gura y los datos necesarios para calcular el área y el perímetro correspondiente e imprimir el nombre de la fi gura el área y el perímetro.

Area de triángulo =

Base × Altura2

Perímetro de triángulo = Lado A + Lado B + Lado CArea de cuadrado = Lado²Perímetro de cuadrado = 4 x Lado Area de círculo = πr²Perímetro de círculo = 2πrArea de rectángulo = Base x AlturaPerímetro de rectángulo = 2(Base + Altura)

Debe ofrecer el siguiente menú de opciones, donde esta solicitando la opción deseada:

AREAS Y PERIMETROS DE FIGURAS GEOMETRICAS

1. TRIANGULO2. CUADRADO3. RECTANGULO4. CIRCULO5. FIN

OPCION:


A continuación se tiene el diagrama de clases de la solución:


Diagrama de clases

Triangulo2

baseTria alturaTria areaTria, perimTria ladoA, ladoB, ladoC

establecerBaseTria() establecerAlturaTria() establecerLadoA() establecerLadoB() establecerLadoC() calcularAreaTria() calcularPerimTria() obtenerAreaTria() obtenerPerimTria()

Figura2

# NomFigura

establecerNomFigura() obtenerNomFigura()

EjecutaFigura2

Cuadrado2

ladoCuad areaCuad perimCuad

establecerLadoCuad() calcularAreaCuad() calcularPerimCuad() obtenerAreaCuad() obtenerPerimCuad()

Rectangulo2

baseRecta alturaRecta areaRecta perimRecta

establecerBaseRecta() establecerAlturaRecta() calcularAreaRecta() calcularPerimRecta() obtenerAreaRecta() obtenerPerimRecta()

Circulo2

radioCirc areaCirc perimCirc

establecerRadioCirc() calcularAreaCirc() calcularPerimCirc() obtenerAreaCirc() obtenerPerimCirc()


Explicación:

Se tiene la clase controlador EjecutaFigura2, la cual utiliza al modelo, que está formado por cinco clases jerarquizadas:

1. La clase Figura2 que es la superclase o clase principal, tiene el dato nomFigura; y los métodos establecerNomFigura() y obtenerNomFigura(); para establecer y obtener el dato respectivamente. Figura2 es la superclase que solo se utiliza para derivar otras clases (subclases), a través del mecanismo de herencia; es por ello que a su dato nomFigura se le antepuso el símbolo # el cual indica que el dato es protegido (protected); los datos deben ser protegidos para que se puedan heredar.

2. La clase Triangulo2 que es una subclase que se deriva de la superclase Figura2, tiene los datos: baseTria, alturaTria, areaTria, perimTria, ladoA, ladoB y ladoC; y los métodos establecerBaseTria(), establecerAlturaTria(), establecerLadoA(), establecerLadoB(), establecerLadoC(), calcularAreaTria(), calcularPerimTria(), obtenerAreaTria() y obtenerPerimTria(); para establecer la base, establecer la altura, establecer el lado A, establecer el lado B, establecer el lado C, calcular el área, calcular el perímetro, obtener el valor del área y obtener el valor del perímetro del triángulo respectivamente. Al derivarse de Figura2, Triangulo2 hereda el dato y los métodos de Figura2 a través del mecanismo de herencia.

3. La clase Cuadrado2 que es una subclase que se deriva de la superclase Figura2, tiene los datos: ladoCuad, areaCuad y perimCuad; y los métodos establecerLadoCuad(), calcularAreaCuad(), calcularPerimCuad(), obtenerAreaCuad() y obtenerPerimCuad(); para establecer el lado, calcular el área, calcular el perímetro, obtener el valor del área y obtener el valor del perímetro del cuadrado respectivamente. Al derivarse de Figura2, Cuadrado2 hereda el dato y los métodos de Figura2 a través del mecanismo de herencia.

4. La clase Rectangulo2 que es una subclase que se deriva de la superclase Figura2, tiene los datos: baseRecta, alturaRecta, areaRecta y perimRecta; y los métodos estable-cerBaseRecta(), establecerAlturaRecta(), calcularAreaRecta(), calcularPerimRecta(), obtenerAreaRecta() y obtenerPerimRecta(); para establecer la base, establecer la al-tura, calcular el área, calcular el perímetro, obtener el valor del área y obtener el valor del perímetro del rectángulo respectivamente. Al derivarse de Figura2, Rectangulo2 hereda el dato y los métodos de Figura2 a través del mecanismo de herencia.

5. La clase Circulo2 que es una subclase que se deriva de la superclase Figura2, tiene los datos: radioCirc, areaCirc y perimCirc; y los métodos establecerRadioCirc(), cal-cularAreaCirc(), calcularPerimCirc(), obtenerAreaCirc() y obtenerPerimCirc(); para establecer el radio, calcular el área, calcular el perímetro, obtener el valor del área y obtener el valor del perímetro del círculo respectivamente. Al derivarse de Figura2, Circulo2 hereda el dato y los métodos de Figura2 a través del mecanismo de heren-cia.

A continuación se tiene el algoritmo de la solución en pseudocódigo:



Algoritmo AREAS Y PERIMETROS DE FIGURAS GEOMETRICAS Clase Figura2 1. Declaraciones Datos # nomFigura: Cadena

2. Método establecerNomFigura(nom: Cadena) a. nomFigura = nom b. Fin Método establecerNomFigura

3. Método obtenerNomFigura(): Cadena a. return nomFigura b. Fin Método obtenerNomFigura Fin Clase Figura2

Clase Triangulo2 hereda de Figura2 1. Declaraciones Datos baseTria: Real alturaTria: Real areaTria: Real ladoA, ladoB, ladoC: Real perimTria: Real

2. Método establecerBaseTria(base: Real) a. baseTria = base b. Fin Método establecerBaseTria

3. Método establecerAlturaTria(altura: Real) a. alturaTria = altura b. Fin Método establecerAlturaTria

4. Método establecerLadoA(a: Real) a. ladoA = a b. Fin Método establecerLadoA

5. Método establecerLadoB(b: Real) a. ladoB = b b. Fin Método establecerLadoB

6. Método establecerLadoC(c: Real) a. ladoC = c b. Fin Método establecerLadoC

7. Método calcularAreaTria()


a. areaTria = (baseTria * alturaTria) / 2 b. Fin Método calcularAreaTria

8. Método calcularPerimTria() a. perimTria = ladoA + ladoB + ladoC b. Fin Método calcularPerimTria

9. Método obtenerAreaTria(): Real a. return areaTria b. Fin Método obtenerAreaTria

10. Método obtenerPerimTria(): Real a. return perimTria b. Fin Método obtenerPerimTria Fin Clase Triangulo2

Clase Cuadrado2 hereda de Figura2 1. Declaraciones Datos ladoCuad: Real areaCuad: Real perimCuad: Real

2. Método establecerLadoCuad(lado: Real) a. ladoCuad = lado b. Fin Método establecerLadoCuad

3. Método calcularAreaCuad() a. areaCuad = Potencia(ladoCuad, 2) b. Fin Método calcularAreaCuad

4. Método calcularPerimCuad() a. perimCuad = 4 * ladoCuad b. Fin Método calcularPerimCuad

5. Método obtenerAreaCuad(): Real a. return areaCuad b. Fin Método obtenerAreaCuad

6. Método obtenerPerimCuad(): Real a. return perimCuad b. Fin Método obtenerPerimCuad Fin Clase Cuadrado2

Clase Rectangulo2 hereda de Figura2 1. Declaraciones Datos


baseRecta: Real alturaRecta: Real areaRecta: Real perimRecta: Real

2. Método establecerBaseRecta(base: Real) a. baseRecta = base b. Fin Método establecerBaseRecta

3. Método establecerAlturaRecta(altura: Real) a. alturaRecta = altura b. Fin Método establecerAlturaRecta

4. Método calcularAreaRecta() a. areaRecta = baseRecta * alturaRecta b. Fin Método calcularAreaRecta

5. Método calcularPerimRecta() a. perimRecta = 2 * (baseRecta + alturaRecta) b. Fin Método calcularPerimRecta

6. Método obtenerAreaRecta(): Real a. return areaRecta b. Fin Método obtenerAreaRecta

7. Método obtenerPerimRecta(): Real a. return perimRecta b. Fin Método obtenerPerimRecta Fin Clase Rectangulo2

Clase Circulo2 hereda de Figura2 1. Declaraciones Datos radioCirc: Real areaCirc: Real perimCirc: Real

2. Método establecerRadioCirc(radio: Real) a. radioCirc = radio b. Fin Método establecerRadioCirc

3. Método calcularAreaCirc() a. areaCirc = 3.1416 * Potencia(radioCirc, 2) b. Fin Método calcularAreaCirc

4. Método calcularPerimCirc() a. perimCirc = 2 * 3.1416 * radioCirc b. Fin Método calcularPerimCirc


5. Método obtenerAreaCirc(): Real a. return areaCirc b. Fin Método obtenerAreaCirc

6. Método obtenerPerimCirc(): Real a. return perimCirc b. Fin Método obtenerPerimCirc Fin Clase Circulo2

Clase EjecutaFigura2 1. Método principal a. Declaraciones Variables nombre: Cadena opcion: Entero bas, alt, rad, lad, laA, laB, laC: Real b. DO 1. Imprimir MENU



OPCION:

2. Leer opcion 3. Solicitar Nombre de la figura 4. Leer nombre 5. SWITCH opcion 1: a. Crear objeto Triangulo2 objFigura= new Triangulo2() b. Solicitar Base, Altura, Lado A, Lado B y Lado C c. Leer bas, alt, laA, laB, laC d. Establecer objFigura.establecerNomFigura(nombre) objFigura.establecerBaseTria(bas) objFigura.establecerAlturaTria(alt) objFigura.establecerLadoA(laA) objFigura.establecerLadoB(laB) objFigura.establecerLadoC(laC) e. Calcular objFigura.calcularAreaTria() objFigura.calcularPerimTria()


f. Imprimir objFigura.obtenerNomFigura() objFigura.obtenerAreaTria() objFigura.obtenerPerimTria()

2: a. Crear objeto Cuadrado2 objFigura = new Cuadrado2() b. Solicitar Lado c. Leer lad d. Establecer objFigura.establecerNomFigura(nombre) objFigura.establecerLadoCuad(lad) e. Calcular objFigura.calcularAreaCuad() objFigura.calcularPerimCuad() f. Imprimir objFigura.obtenerNomFigura() objFigura.obtenerAreaCuad() objFigura.obtenerPerimCuad()

3: a. Crear objeto Rectangulo2 objFigura= new Rectangulo2() b. Solicitar Base, Altura c. Leer bas, alt d. Establecer objFigura.establecerNomFigura(nombre) objFigura.establecerBaseRecta(bas) objFigura.establecerAlturaRecta(alt) e. Calcular objFigura.calcularAreaRecta() objFigura.calcularPerimRecta() f. Imprimir objFigura.obtenerNomFigura() objFigura.obtenerAreaRecta() objFigura.obtenerPerimRecta()

4: a. Crear objeto Circulo2 objFigura = new Circulo2() b. Solicitar Radio c. Leer rad d. Establecer objFigura.establecerNomFigura(nombre) objFigura.establecerRadioCirc(rad) e. Calcular objFigura.calcularAreaCirc() objFigura.calcularPerimCirc() f. Imprimir objFigura.obtenerNomFigura() objFigura.obtenerAreaCirc() objFigura.obtenerPerimCirc() 6. ENDSWITCH c. WHILE opcion <> 5 d. Fin Método principal Fin Clase EjecutaFigura2Fin


Explicación:

Este algoritmo tiene seis clases; la superclase Figura2.

La superclase no se usa para crear instancias u objetos; en consecuencia, solo se uti-lizará para derivar otras clases a partir de ella. En la superclase Figura2:1. Se declaran los datos que representan la estructura de la clase:

nomFigura para el nombre de la figura2. Método establecerNomFigura(nom: Cadena) Recibe en el parámetro nom el valor que luego coloca en el dato nomFigura.3. Método obtenerNomFigura(): Cadena Retorna nomFiguraFin de la Clase Figura2

En la Clase Triangulo2 hereda de Figura2:

Las palabras “hereda de” quieren decir que la clase Triangulo2 se “deriva de” la super-clase Figura2; aplicando el mecanismo de herencia.1. Se declaran los datos que representan la estructura de la clase: baseTria para la base del triángulo alturaTria para la altura del triángulo areaTria para el área del triángulo ladoA para el lado A del triángulo ladoB para el lado B del triángulo ladoC para el lado C del triángulo perimTria para el perímetro del triángulo2. Método establecerBaseTria(base: Real) Recibe en el parámetro base el valor que luego coloca en el dato baseTria.3. Método establecerAlturaTria(altura: Real) Recibe en el parámetro altura el valor que luego coloca en el dato alturaTria.4. Método establecerLadoA(a: Real) Recibe en el parámetro a el valor que luego coloca en el dato ladoA.5. Método establecerLadoB(b: Real) Recibe en el parámetro b el valor que luego coloca en el dato ladoB.6. Método establecerLadoC(c: Real) Recibe en el parámetro c el valor que luego coloca en el dato ladoC.7. Método calcularAreaTria() Calcula el área del triángulo8. Método calcularPerimTria() Calcula el perímetro del triángulo9. Método obtenerAreaTria(): Real Retorna areaTria10. Método obtenerPerimTria(): Real Retorna perimTriaFin de la Clase Triangulo2

En la Clase Cuadrado2 hereda de Figura2:


Las palabras “hereda de” quieren decir que la clase Cuadrado2 se “deriva de” la super-clase Figura2; aplicando el mecanismo de herencia.1. Se declaran los datos que representan la estructura de la clase: ladoCuad para el lado del cuadrado areaCuad para el área del cuadrado perimCuad para el perímetro del cuadrado2. Método establecerLadoCuad(lado: Real) Recibe en el parámetro lado el valor que luego coloca en el dato ladoCuad.3. Método calcularAreaCuad() Calcula el área del cuadrado4. Método calcularPerimCuad() Calcula el perímetro del cuadrado5. Método obtenerAreaCuad(): Real Retorna areaCuad6. Método obtenerPerimCuad(): Real Retorna perimCuadFin de la Clase Cuadrado2

En la Clase Rectangulo2 hereda de Figura2:

Las palabras “hereda de” quieren decir que la clase Rectangulo2 se “deriva de” la su-perclase Figura2; aplicando el mecanismo de herencia.1. Se declaran los datos que representan la estructura de la clase: baseRecta para la base del rectángulo alturaRecta para la altura del rectángulo areaRecta para el área del rectángulo perimRecta para el perímetro del rectángulo2. Método establecerBaseRecta(base: Real) Recibe en el parámetro base el valor que luego coloca en el dato baseRecta.3. Método establecerAlturaRecta(altura: Real) Recibe en el parámetro altura el valor que luego coloca en el dato alturaRecta.4. Método calcularAreaRecta() Calcula el área del rectángulo 5. Método calcularPerimRecta() Calcula el perímetro del rectángulo 6. Método obtenerAreaRecta(): Real Retorna areaRecta7. Método obtenerPerimRecta(): Real Retorna perimRectaFin de la Clase Rectangulo2

En la Clase Circulo2 hereda de Figura2:

Las palabras “hereda de” quieren decir que la clase Circulo2 se “deriva de” la superclase Figura2; aplicando el mecanismo de herencia.1. Se declaran los datos que representan la estructura de la clase: radioCirc para el radio del círculo areaCirc para el área del círculo


perimCirc para el perímetro del círculo2. Método establecerRadioCirc(radio: Real) Recibe en el parámetro radio el valor que luego coloca en el dato radioCirc.3. Método calcularAreaCirc() Calcula el área del círculo4. Método calcularPerimCirc() Calcula el perímetro del círculo5. Método obtenerAreaCirc(): Real Retorna areaCirc6. Método obtenerPerimCirc(): Real Retorna perimCircFin de la Clase Circulo2

En la Clase EjecutaFigura2; en el Método principal:

a. Se declara: La variable nombre para leer el nombre de la figura La variable opcion para leer la opción que desee La variable bas para leer la base La variable alt para leer la altura La variable rad para leer el radio La variable lad para leer el lado del cuadrado La variable laA para leer el lado A del triángulo La variable laB para leer el lado B del triángulo La variable laC para leer el lado C del triángulob. Inicia ciclo DO 1. Imprime el MENU de opciones 2. Lee en opcion 3. Solicita el nombre de la figura 4. Lee en nombre 5. Inicia SWITCH opcion 1: a. Se declara el objeto objFigura, usando como base a la clase Triangulo2; dicho

objeto se crea e inicializa mediante el constructor por defecto Triangulo2(). b. Solicita Base, Altura, Lado A, Lado B y Lado C c. Lee en bas, alt, laA, laB, laC d. Se llama al método establecerNomFigura(nombre) del objeto objFigura; para

colocar el valor de nombre en el dato nomFigura. Se llama al método establecerBaseTria(bas) del objeto objFigura; para

colocar el valor de bas en el dato baseTria. Se llama al método establecerAlturaTria(alt) del objeto objFigura; para

colocar el valor de alt en el dato alturaTria. Se llama al método establecerLadoA(laA) del objeto objFigura; para colocar

el valor de laA en el dato ladoA. Se llama al método establecerLadoB(laB) del objeto objFigura; para colocar

el valor de laB en el dato ladoB. Se llama al método establecerLadoC(laC) del objeto objFigura; para colocar

el valor de laC en el dato ladoC.


e. Se llama al método calcularAreaTria() del objeto objFigura; para calcular el área del triángulo.

Se llama al método calcularPerimTria() del objeto objFigura; para calcular el perímetro del triángulo.

f. Se llama al método obtenerNomFigura() del objeto objFigura; para acceder e imprimir el valor del dato nomFigura.

Se llama al método obtenerAreaTria() del objeto objFigura; para acceder e imprimir el valor del dato areaTria.

Se llama al método obtenerPerimTria() del objeto objFigura; para acceder e imprimir el valor del dato perimTria.

2: a. Se declara el objeto objFigura, usando como base a la clase Cuadrado2; di-cho objeto se crea e inicializa mediante el constructor por defecto Cuadra-do2().

b. Solicita Lado c. Lee en lad d. Se llama al método establecerNomFigura(nombre) del objeto objFigura; para

colocar el valor de nombre en el dato nomFigura. Se llama al método establecerLadoCuad(lad) del objeto objFigura; para

colocar el valor de lad en el dato ladoCuad. e. Se llama al método calcularAreaCuad() del objeto objFigura; para calcular el

área del cuadrado. Se llama al método calcularPerimCuad() del objeto objFigura; para calcular

el perímetro del cuadrado. f. Se llama al método obtenerNomFigura() del objeto objFigura; para acceder e

imprimir el valor del dato nomFigura. Se llama al método obtenerAreaCuad() del objeto objFigura; para acceder e

imprimir el valor del dato areaCuad. Se llama al método obtenerPerimCuad() del objeto objFigura; para acceder e

imprimir el valor del dato perimCuad. 3: a. Se declara el objeto objFigura, usando como base a la clase Rectangulo2; dicho

objeto se crea e inicializa mediante el constructor por defecto Rectangu-lo2().

b. Solicita Base y Altura c. Lee en bas y alt d. Se llama al método establecerNomFigura(nombre) del objeto objFigura; para

colocar el valor de nombre en el dato nomFigura. Se llama al método establecerBaseRecta(bas) del objeto objFigura; para

colocar el valor de bas en el dato baseRecta. Se llama al método establecerAlturaRecta(alt) del objeto objFigura; para

colocar el valor de alt en el dato alturaRecta. e. Se llama al método calcularAreaRecta() del objeto objFigura; para calcular el

área del rectángulo. Se llama al método calcularPerimRecta() del objeto objFigura; para calcular

el perímetro del rectángulo. f. Se llama al método obtenerNomFigura() del objeto objFigura; para acceder e

imprimir el valor del dato nomFigura. Se llama al método obtenerAreaRecta() del objeto objFigura; para acceder e

imprimir el valor del dato areaRecta.


Se llama al método obtenerPerimRecta() del objeto objFigura; para acceder e imprimir el valor del dato perimRecta.

4: a. Se declara el objeto objFigura, usando como base a la clase Circulo2; dicho objeto se crea e inicializa mediante el constructor por defecto Circulo2().

b. Solicita el radio c. Lee en rad d. Se llama al método establecerNomFigura(nombre) del objeto objFigura; para

colocar el valor de nombre en el dato nomFigura. Se llama al método establecerRadioCirc(rad) del objeto objFigura; para

colocar el valor de rad en el dato radioCirc. e. Se llama al método calcularAreaCirc() del objeto objFigura; para calcular el

área del círculo. Se llama al método calcularPerimCirc() del objeto objFigura; para calcular el

perímetro del círculo. f. Se llama al método obtenerNomFigura() del objeto objFigura; para acceder e

imprimir el valor del dato nomFigura. Se llama al método obtenerAreaCirc() del objeto objFigura; para acceder e

imprimir el valor del dato areaCirc. Se llama al método obtenerPerimCirc() del objeto objFigura; para acceder e

imprimir el valor del dato perimCirc. 6. Fin del SWITCHc. Fin del ciclo (WHILE opcion <> 5). Si se cumple regresa al DO; si no, se sale del ciclo.d. Fin del Método principalFin de la Clase EjecutaFigura2Fin del algoritmo

Capítulo 16


Ejercicio 16.4.2

Elaborar un algoritmo que ofrezca un menú de opciones, mediante el cual se pueda escoger calcular el área y perímetro de las fi guras geométricas: triángulo, cuadrado, rectángulo y círculo. Una vez seleccionada la opción, que permita solicitar y leer el nombre de la fi gura y los datos necesarios para calcular el área y el perímetro correspondiente; e imprimir el nombre de la fi gura el área y el perímetro.

Area de triángulo =

Base × Altura2

Perímetro de triángulo = Lado A + Lado B + Lado CArea de cuadrado = Lado²Perímetro de cuadrado = 4 × Lado Area de círculo = πr²Perímetro de círculo = 2πrArea de rectángulo = Base × AlturaPerímetro de rectángulo = 2(Base + Altura)

Debe ofrecer el siguiente menú de opciones, donde esta solicitando la opción deseada:



OPCION:


A continuación se tiene el diagrama de clases de la solución:


Diagrama de clases

Triangulo4

baseTria alturaTria ladoA, ladoB, ladoC

establecerBaseTria() establecerAlturaTria() establecerLadoA() establecerLadoB() establecerLadoC() calcularArea() calcularPerim()

Figura4 {abstracta}

# nomFigura # area # perim

establecerNomFigura() obtenerNomFigura() *calcularArea() *calcularPerim() obtenerArea() obtenerPerim()

EjecutaFigura4

Cuadrado4

ladoCuad

establecerLadoCuad() calcularArea() calcularPerim()

Rectangulo4

baseRecta alturaRecta

establecerBaseRecta() establecerAlturaRecta() calcularArea() calcularPerim()

Circulo2

radioCirc

establecerRadioCirc() calcularArea() calcularPerim()


Explicación:

Se tiene la clase controlador EjecutaFigura4, la cual utiliza al modelo, que está formado por cinco clases jerarquizadas:

1. La clase Figura4 que es la superclase o clase principal; se esta defi niendo como una clase abstracta, tiene el dato nomFigura; al que se le antepuso el símbolo # el cual indica que el dato es protegido (protected), los datos deben ser protegidos para que se puedan heredar; y los métodos establecerNomFigura() y obtenerNomFigura(); para establecer y obtener el dato respectivamente. También tiene los datos area y perim; y los métodos *calcularArea(), *calcularPerim(), obtenerArea() y obtenerPerim(); para calcular el área, calcular el perímetro, obtener el área y obtener el perímetro respecti-vamente. En el caso de *calcularArea() y *calcularPerim(); con el asterisco se defi nen como métodos abstractos, esto signifi ca que aquí sólo se defi nen los encabezados de los métodos; y cada objeto, de las clases derivadas, los implementará de acuerdo con las especifi caciones que les correspondan: El objeto generado con Triangulo4, los cal-culará de una forma; El objeto generado con Cuadrado4, los calculará de otra forma; El objeto generado con Rectangulo4, los calculará de otra forma y El objeto generado con Circulo4, los calculará de otra forma. Aplicando el polimorfi smo; es decir, se tiene más de una forma (cuatro) de calcular tanto el área como el perímetro.

2. La clase Triangulo4 que es una subclase que se deriva de la superclase abstracta Fi-gura4, tiene los datos: baseTria, alturaTria, ladoA, ladoB y ladoC; y los métodos es-tablecerBaseTria(), establecerAlturaTria(), establecerLadoA(), establecerLadoB(), establecerLadoC(), calcularArea() y calcularPerim(); para establecer la base, estable-cer la altura, establecer el lado A, establecer el lado B, establecer el lado C, calcular el área y calcular el perímetro respectivamente. Al derivarse de Figura4, Triangulo4 hereda los datos y métodos de Figura4, a través del mecanismo de herencia; y, como está heredando los métodos abstractos *calcularArea() y *calcularPerim(), aquí los implementa utilizando la forma de calcular el área y el perímetro correspondientes al triángulo.

3. La clase Cuadrado4 que es una subclase que se deriva de la superclase Figura4, tiene el dato: ladoCuad; y los métodos establecerLadoCuad(), calcularArea() y calcularPe-rim(); para establecer el lado, calcular el área y calcular el perímetro respectivamente. Al derivarse de Figura4, Cuadrado4 hereda los datos y métodos de Figura4, a través del mecanismo de herencia; y, como está heredando los métodos abstractos *calcu-larArea() y *calcularPerim(), aquí los implementa utilizando la forma de calcular el área y el perímetro correspondientes al cuadrado.

4. La clase Rectangulo4 que es una subclase que se deriva de la superclase Figura4, tie-ne los datos: baseRecta y alturaRecta; y los métodos establecerBaseRecta(), estable-cer-AlturaRecta(), calcularArea() y calcularPerim(); para establecer la base, estable-cer la altura, calcular el área y calcular el perímetro respectivamente. Al derivarse de Figura4, Rectangulo4 hereda los datos y métodos de Figura4, a través del mecanismo de herencia; y, como está heredando los métodos abstractos *calcularArea() y *calcu-larPerim(), aquí los implementa utilizando la forma de calcular el área y el perímetro correspondientes al rectángulo.


5. La clase Circulo4 que es una subclase que se deriva de la superclase Figura4, tiene el dato: radioCirc; y los métodos establecerRadioCirc(), calcularArea() y calcularPe-rim(); para establecer el radio, calcular el área y calcular el perímetro respectivamen-te. Al derivarse de Figura4, Circulo4 hereda los datos y métodos de Figura4, a través del mecanismo de herencia; y, como está heredando los métodos abstractos *calcu-larArea() y *calcularPerim(), aquí los implementa utilizando la forma de calcular el área y el perímetro correspondientes al círculo.

A continuación se tiene el algoritmo de la solución en pseudocódigo:


Algoritmo AREAS Y PERIMETROS DE FIGURAS GEOMETRICAS Clase abstracta Figura4 1. Declaraciones Datos # nomFigura: Cadena # area: Real # perim: Real

2. Método establecerNomFigura(nom: Cadena) a. nomFigura = nom b. Fin Método establecerNomFigura

3. Método obtenerNomFigura(): Cadena a. return nomFigura b. Fin Método obtenerNomFigura

4. Método abstracto calcularArea()

5. Método abstracto calcularPerim()

6. Método obtenerArea(): Real a. return area b. Fin Método obtenerArea

7. Método obtenerPerim(): Real a. return perim b. Fin Método obtenerPerim Fin Clase Figura4

Clase Triangulo4 hereda de Figura4 1. Declaraciones Datos baseTria: Real alturaTria: Real ladoA, ladoB, ladoC: Real


2. Método establecerBaseTria(base: Real) a. baseTria = base b. Fin Método establecerBaseTria

3. Método establecerAlturaTria(altura: Real) a. alturaTria = altura b. Fin Método establecerAlturaTria

4. Método establecerLadoA(a: Real) a. ladoA = a b. Fin Método establecerLadoA

5. Método establecerLadoB(b: Real) a. ladoB = b b. Fin Método establecerLadoB

6. Método establecerLadoC(c: Real) a. ladoC = c b. Fin Método establecerLadoC 7. Método calcularArea() a. area = (baseTria * alturaTria) / 2 b. Fin Método calcularArea

8. Método calcularPerim() a. perim = ladoA + ladoB + ladoC b. Fin Método calcularPerim Fin Clase Triangulo4 Clase Cuadrado4 hereda de Figura4 1. Declaraciones Datos ladoCuad: Real

2. Método establecerLadoCuad(lado: Real) a. ladoCuad = lado b. Fin Método establecerLadoCuad

3. Método calcularArea() a. area = ladoCuad * ladoCuad b. Fin Método calcularArea

4. Método calcularPerim() a. perim = 4 * ladoCuad b. Fin Método calcularPerimFin Clase Cuadrado4


Clase Rectangulo4 hereda de Figura4 1. Declaraciones Datos baseRecta: Real alturaRecta: Real

2. Método establecerBaseRecta(base: Real) a. baseRecta = base b. Fin Método establecerBaseRecta

3. Método establecerAlturaRecta(altura: Real) a. alturaRecta = altura b. Fin Método establecerAlturaRecta

4. Método calcularArea() a. area = baseRecta * alturaRecta b. Fin Método calcularArea

5. Método calcularPerim() a. perim = 2 * (baseRecta + alturaRecta) b. Fin Método calcularPerim Fin Clase Rectangulo4

Clase Circulo4 hereda de Figura4 1. Declaraciones Datos radioCirc: Real

2. Método establecerRadioCirc(radio: Real) a. radioCirc = radio b. Fin Método establecerRadioCirc

3. Método calcularArea() a. area = 3.1416 * (radioCirc * radioCirc) b. Fin Método calcularArea

4. Método calcularPerim () a. perim = 2 * 3.1416 * radioCirc b. Fin Método calcularPerim Fin Clase Circulo4

Clase EjecutaFigura4 1. Método principal a. Declaraciones Variables nombre: Cadena opcion: Entero


bas, alt, rad, lad, laA, laB, laC: Real b. DO 1. Imprimir MENU



OPCION:

2. Leer opcion 3. Solicitar Nombre de la figura 4. Leer nombre 5. SWITCH opcion 1: a. Crear objeto Triangulo4 objFigura = new Triangulo4() b. Solicitar Base, Altura, Lado A, Lado B, Lado C c. Leer bas, alt, laA, laB, laC d. Establecer objFigura.establecerNomFigura(nombre) objFigura.establecerBaseTria(bas) objFigura.establecerAlturaTria(alt) objFigura.establecerLadoA(laA) objFigura.establecerLadoB(laB) objFigura.establecerLadoC(laC) e. Calcular objFigura.calcularArea() objFigura.calcularPerim() f. Imprimir objFigura.obtenerNomFigura() objFigura.obtenerArea() objFigura.obtenerPerim()

2: a. Crear objeto Cuadrado4 objFigura = new Cuadrado4() b. Solicitar Lado c. Leer lad d. Establecer objFigura.establecerNomFigura(nombre) objFigura.establecerLadoCuad(lad) e. Calcular objFigura.calcularArea() objFigura.calcularPerim() f. Imprimir objFigura.obtenerNomFigura()


objFigura.obtenerArea() objFigura.obtenerPerim()

3: a. Crear objeto Rectangulo4 objFigura= new Rectangulo4() b. Solicitar Base, Altura c. Leer bas, alt d. Establecer objFigura.establecerNomFigura(nombre) objFigura.establecerBaseRecta(bas) objFigura.establecerAlturaRecta(alt) e. Calcular objFigura.calcularArea() objFigura.calcularPerim() f. Imprimir objFigura.obtenerNomFigura() objFigura.obtenerArea() objFigura.obtenerPerim()

4: a. Crear objeto Circulo4 objFigura = new Circulo4() b. Solicitar Radio c. Leer rad d. Establecer objFigura.establecerNomFigura(nombre) objFigura.establecerRadioCirc(rad) e. Calcular objFigura.calcularArea() objFigura.calcularPerim() f. Imprimir objFigura.obtenerNomFigura() objFigura.obtenerArea() objFigura.obtenerPerim() 6. ENDSWITCH c. WHILE opcion <> 5 d. Fin Método principal Fin Clase EjecutaFigura4Fin

Explicación:

Este algoritmo tiene seis clases; la Clase abstracta Figura4.

Que una clase es abstracta signifi ca que tiene al menos un método abstracto, por tanto no se pueden crear instancias u objetos de dicha clase; en consecuencia solo se utilizará para derivar otras clases a partir de ella. En la Clase abstracta Figura4:1. Se declaran los datos que representan la estructura de la clase: nomFigura para el nombre de la figura (# protegido para heredarlo) area para el área de la fi gura (# protegido para heredarlo) perim para el perímetro de la fi gura (# protegido para heredarlo)


2. Método establecerNomFigura(nom: Cadena) Recibe en el parámetro nom el valor que luego coloca en el dato nomFigura.3. Método obtenerNomFigura(): Cadena Retorna nomFigura4. Método abstracto calcularArea() Se define el método abstracto calcularArea() para calcular el área de la figura; abstracto

significa que aquí se define solo el encabezado del método, esto es, sin acciones. Será en otro momento donde se implementará completamente el método, de acuerdo a la figura que corresponda. Aplicando el polimorfismo; es decir, se tiene más de una forma (cuatro) de calcular el área.

5. Método abstracto calcularPerim() Se define el método abstracto calcularPerim() para calcular el perímetro de la figura;

abstracto significa que aquí se define solo el encabezado del método, es decir, sin acciones. Será en otro momento donde se implementará completamente el método, de acuerdo a la figura que corresponda. Aplicando el polimorfismo; es decir, se tiene más de una forma (cuatro) de calcular el perímetro.

6. Método obtenerArea(): Real Retorna area7. Método obtenerPerim(): Real Retorna perimFin de la Clase Figura4

En la Clase Triangulo4 hereda de Figura4:

Las palabras “hereda de” quieren decir que la clase Triangulo4 se “deriva de” la super-clase Figura4; aplicando el mecanismo de herencia.1. Se declaran los datos que representan la estructura de la clase: baseTria para la base del triángulo alturaTria para la altura del triángulo laA para el lado A del triángulo laB para el lado B del triángulo laC para el lado C del triángulo2. Método establecerBaseTria(base: Real) Recibe en el parámetro base el valor que luego coloca en el dato baseTria.3. Método establecerAlturaTria(altura: Real) Recibe en el parámetro altura el valor que luego coloca en el dato alturaTria.4. Método establecerLadoA(a: Real) Recibe en el parámetro a el valor que luego coloca en el dato ladoA.5. Método establecerLadoB(b: Real) Recibe en el parámetro b el valor que luego coloca en el dato ladoB.6. Método establecerLadoC(c: Real) Recibe en el parámetro c el valor que luego coloca en el dato ladoC.7. Método calcularArea() Calcula el área. Aquí se implemente el método abstracto en el que calcula el área de

la forma que le corresponde al triángulo; es decir, multiplicando base por altura y dividiendo entre 2.

8. Método calcularPerim()


Calcula el perímetro. Aquí se implemente el método abstracto en el que calcula el perímetro de la forma que le corresponde al triángulo; es decir, sumando los tres lados.

Fin de la Clase Triangulo4

En la Clase Cuadrado4 hereda de Figura4:

Las palabras “hereda de” quieren decir que la clase Cuadrado4 se “deriva de” la super-clase Figura4; aplicando el mecanismo de herencia.1. Se declaran los datos que representan la estructura de la clase: ladoCuad para el lado del cuadrado2. Método establecerLadoCuad(lado: Real) Recibe en el parámetro lado el valor que luego coloca en el dato ladoCuad.3. Método calcularArea() Calcula el área. Aquí se implemente el método abstracto en el que calcula el área de la

forma que le corresponde al cuadrado; es decir, elevando el lado al cuadrado.4. Método calcularPerim() Calcula el perímetro. Aquí se implemente el método abstracto en el que calcula el

perímetro de la forma que le corresponde al cuadrado; es decir, multiplicando 4 por el lado del cuadrado.

Fin de la Clase Cuadrado4

En la Clase Rectangulo4 hereda de Figura4:

Las palabras “hereda de” quieren decir que la clase Rectangulo4 se “deriva de” la su-perclase Figura4; aplicando el mecanismo de herencia.1. Se declaran los datos que representan la estructura de la clase: baseRecta para la base del rectángulo alturaRecta para la altura del rectángulo2. Método establecerBaseRecta(base: Real) Recibe en el parámetro base el valor que luego coloca en el dato baseRecta.3. Método establecerAlturaRecta(altura: Real) Recibe en el parámetro altura el valor que luego coloca en el dato alturaRecta.4. Método calcularArea() Calcula el área. Aquí se implemente el método abstracto en el que calcula el área de la

forma que le corresponde al rectángulo; es decir, multiplicando base por altura.5. Método calcularPerim() Calcula el perímetro. Aquí se implemente el método abstracto en el que calcula el

perímetro de la forma que le corresponde al rectángulo; es decir, sumando la base más la altura y multiplicando por 2.

Fin de la Clase Rectangulo4

En la Clase Circulo4 hereda de Figura4:

Las palabras “hereda de” quieren decir que la clase Circulo4 se “deriva de” la superclase Figura4; aplicando el mecanismo de herencia.1. Se declaran los datos que representan la estructura de la clase: radioCirc para el radio del círculo


2. Método establecerRadioCirc(radio: Real) Recibe en el parámetro radio el valor que luego coloca en el dato radioCirc.3. Método calcularArea() Calcula el área. Aquí se implemente el método abstracto en el que calcula el área de la

forma que le corresponde al círculo; es decir, multiplicando PI por radio al cuadrado.4. Método calcularPerim() Calcula el perímetro. Aquí se implemente el método abstracto en el que calcula el

perímetro de la forma que le corresponde al círculo; es decir, multiplicando 2 por PI por radio.

Fin de la Clase Circulo4

En la Clase EjecutaFigura4; en el Método principal:

a. Se declara: La variable nombre para leer el nombre de la figura La variable opcion para leer la opción que desee La variable bas para leer la base La variable alt para leer la altura La variable rad para leer el radio La variable lad para leer el lado La variable laA para leer el lado A del triángulo La variable laB para leer el lado B del triángulo La variable laC para leer el lado C del triángulob. Inicia ciclo DO 1. Imprime el MENU de opciones 2. Lee en opcion 3. Solicita el nombre de la figura 4. Lee en nombre 5. Inicia SWITCH opcion 1: a. Se declara el objeto objFigura, usando como base a la clase Triangulo4; dicho

objeto se crea e inicializa mediante el constructor por defecto Triangulo4(). b. Solicita Base, Altura, Lado A, Lado B, Lado C c. Lee en bas, alt, laA, laB, laC d. Se llama al método establecerNomFigura(nombre) del objeto objFigura; para

colocar el valor de nombre en el dato nomFigura. Se llama al método establecerBaseTria(bas) del objeto objFigura; para

colocar el valor de bas en el dato baseTria. Se llama al método establecerAlturaTria(alt) del objeto objFigura; para

colocar el valor de alt en el dato alturaTria. Se llama al método establecerLadoA(laA) del objeto objFigura; para colocar

el valor de laA en el dato ladoA. Se llama al método establecerLadoB(laB) del objeto objFigura; para colocar

el valor de laB en el dato ladoB. Se llama al método establecerLadoC(laC) del objeto objFigura; para colocar

el valor de laC en el dato ladoC. e. Se llama al método calcularArea() del objeto objFigura; para calcular el área

del triángulo.


Se llama al método calcularPerim() del objeto objFigura; para calcular el perímetro del triángulo.

f. Se llama al método obtenerNomFigura() del objeto objFigura; para acceder e imprimir el valor del dato nomFigura.

Se llama al método obtenerArea() del objeto objFigura; para acceder e imprimir el valor del dato area.

Se llama al método obtenerPerim() del objeto objFigura; para acceder e imprimir el valor del dato perim.

2: a. Se declara el objeto objFigura, usando como base a la clase Cuadrado4; dicho objeto se crea e inicializa mediante el constructor por defecto Cuadrado4().

b. Solicita Lado c. Lee en lad d. Se llama al método establecerNomFigura(nombre) del objeto objFigura; para

colocar el valor de nombre en el dato nomFigura. Se llama al método establecerLadoCuad(lad) del objeto objFigura; para

colocar el valor de lad en el dato ladoCuad. e. Se llama al método calcularArea() del objeto objFigura; para calcular el área

del cuadrado. Se llama al método calcularPerim() del objeto objFigura; para calcular el

perímetro del cuadrado. f. Se llama al método obtenerNomFigura() del objeto objFigura; para acceder e

imprimir el valor del dato nomFigura. Se llama al método obtenerArea() del objeto objFigura; para acceder e

imprimir el valor del dato area. Se llama al método obtenerPerim() del objeto objFigura; para acceder e im-

primir el valor del dato perim. 3: a. Se declara el objeto objFigura, usando como base a la clase Rectangulo4;

dicho objeto se crea e inicializa mediante el constructor por defecto Rectangulo4().

b. Solicita Base y Altura c. Lee en bas y alt d. Se llama al método establecerNomFigura(nombre) del objeto objFigura; para

colocar el valor de nombre en el dato nomFigura. Se llama al método establecerBaseRecta(bas) del objeto objFigura; para colo-

car el valor de bas en el dato baseRecta. Se llama al método establecerAlturaRecta(alt) del objeto objFigura; para co-

locar el valor de alt en el dato alturaRecta. e. Se llama al método calcularArea() del objeto objFigura; para calcular el área

del rectángulo. Se llama al método calcularPerim() del objeto objFigura; para calcular el

perímetro del rectángulo. f. Se llama al método obtenerNomFigura() del objeto objFigura; para acceder e


imprimir el valor del dato area. Se llama al método obtenerPerim() del objeto objFigura; para acceder e

imprimir el valor del dato perim.


4: a. Se declara el objeto objFigura, usando como base a la clase Circulo4; dicho objeto se crea e inicializa mediante el constructor por defecto Circulo4().

b. Solicita el radio c. Lee en rad d. Se llama al método establecerNomFigura(nombre) del objeto objFigura; para

colocar el valor de nombre en el dato nomFigura. Se llama al método establecerRadioCirc(rad) del objeto objFigura; para

colocar el valor de rad en el dato radioCirc. e. Se llama al método calcularArea() del objeto objFigura; para calcular el área

del círculo. Se llama al método calcularPerim() del objeto objFigura; para calcular el

perímetro del círculo. f. Se llama al método obtenerNomFigura() del objeto objFigura; para acceder e


imprimir el valor del dato area. Se llama al método obtenerPerim() del objeto objFigura; para acceder e

imprimir el valor del dato perim. 6. Fin del SWITCHc. Fin del ciclo (WHILE opcion <> 5). Si se cumple regresa al DO; si no, se sale del

ciclo.d. Fin del Método principalFin de la Clase EjecutaFigura4

Fin del algoritmo

Nota:Este problema de áreas y perímetros de fi guras geométricas es el mismo que se planteó en el capítulo anterior, la diferencia como se soluciona; es que aquí, los datos area y perim están defi nidos en la superclase abstracta Figura4, asimismo los métodos *calcularArea() y *calcularPerim(), como métodos abstractos; y los métodos obtenerArea() y obtenerPerim(). Que el método es abstracto signifi ca que aquí está defi nido, pero no implementado; y el cálculo tanto del área como del perim se realizará ya sea como está implementado en la clase Triangulo4, Cuadrado4, Rectangulo4 o de la forma como está implementado en la clase Circulo4, de acuerdo al tipo de fi gura que se esté procesando; aplicando el polimorfi smo.

ejercicios resueltos - elaboración de algoritmos

Education