232 Fundamentos iniciales de lógica de programación I.

Algoritmos en PSeInt y Python

4. Solución a los ejercicios propuestos

A continuación, la solución de los ejercicios del numeral 1.3.3.
a. 2 + 3 * 4
2 + 12
14

b. 10 ^ 2 ^ 2 / 7
100 ^ 2 / 7
10000 / 7
1428.5714285714 ≈ 1428.57

c. 42 / 2 / 3 / 7 ^ 3
42 / 2 / 3 / 343
21 / 3 / 343
7 / 343
0.0204081632 ≈ 0.02

d. 8 + 7 * 3 + 4 * 6
8 + 21 + 4 * 6
8 + 21 + 24
29 + 24
53

e. 5 ^ 3 + 120 – 3 ^ 5
125 + 120 – 3 ^ 5
125 + 120 – 243
245 – 243
2
 Solución a los ejercicios propuestos 233

f. 12 + 3 * 7 + 5 * 4
12 + 21 + 5 * 4
12 + 21 + 20
33 + 20
53

g. 4 + 5 ^ 2 – 500 + 20 ^ 2 * 10
4 + 25 – 500 + 20 ^ 2 * 10
4 + 25 – 500 + 400 * 10
4 + 25 – 500 + 4000
29 – 500 + 4000
–471 + 4000
3529

h. (4 ^ 3 + 2 * 40 – 140) ^ 2
(64 + 2 * 40 – 140) ^ 2
(64 + 80 – 140) ^ 2
(144 – 140) ^ 2
4^2
16

i. 5 + (25 * 2 + 5 * 8 / 2 – 10) * 2
5 + (50 + 5 * 8 / 2 – 10) * 2
5 + (50 + 40 / 2 – 10) * 2
5 + (50 + 20 – 10) * 2
5 + (70 – 10) * 2
5 + 60 * 2
5 + 120
125
234 Fundamentos iniciales de lógica de programación I. Algoritmos en PSeInt y Python

j. 2 * 25 / 5 + 5 ^ 2 – 5
2 * 25 / 5 + 25 – 5
2 * 5 + 25 – 5
10 + 25 – 5
35 – 5
30

k. 15 – ((4 * 5 + (8 / 2 – 5) * 2) + 8 * 10 / 2)
15 – ((4 * 5 + (4 – 5) * 2) + 8 * 10 / 2)
15 – ((4 * 5 + (–1) * 2) + 8 * 10 / 2)
15 – ((4 * 5 –1 * 2) + 8 * 10 / 2)
15 – ((20 – 1 * 2) + 8 * 10 / 2)
15 – ((20 – 2) + 8 * 10 / 2)
15 – (18 + 8 * 10 / 2)
15 – (18 + 80 / 2)
15 – (18 + 40)
15 – 58
–43

l. 2 – 5 * 12 / 2 + 8
2 – 60 / 2 + 8
2 – 30 + 8
–28 + 8
–20

m. (8 ^ 2 + 3 * 10 + 5) – (6 ^ 2 – 2 * 5 – 6)
(64 + 3 * 10 + 5) – (6 ^ 2 – 2 * 5 – 6)
(64 + 30 + 5) – (6 ^ 2 – 2 * 5 – 6)
(64 + 5) – (6 ^ 2 – 2 * 5 – 6)
 Solución a los ejercicios propuestos 235

99 – (6 ^ 2 – 2 * 5 – 6)
99 – (36 – 2 * 5 – 6)
99 – (36 – 10 – 6)
99 – (26 – 6)
99 – 20
79

n. (33 + 5 * 3 ^ 5 + 11 * 3 + 14) / (3 + 2)
(33 + 5 * 243 + 11 * 3 + 14) / (3 + 2)
(33 + 1215 + 11 * 3 + 14) / (3 + 2)
(33 + 1215 + 33 + 14) / (3 + 2)
(1248 + 33 + 14) / (3 + 2)
(1281 + 14) / (3 + 2)
1295 / (3 + 2)
1295 / 5
259

o. (2 * 5 * 3 * 4 ^ 2) / (48 / 2 ^ 2 – 20 + 2 ^ 2) / 10
(2 * 5 * 3 * 16) / (48 / 2 ^ 2 – 20 + 2 ^ 2) / 10
(10 * 3 * 16) / (48 / 2 ^ 2 – 20 + 2 ^ 2) / 10
(30 * 16) / (48 / 2 ^ 2 – 20 + 2 ^ 2) / 10
480 / (48 / 2 ^ 2 – 20 + 2 ^ 2) / 10
480 / (48 / 4 – 20 + 2 ^ 2) / 10
480 / (48 / 4 – 20 + 4) / 10
480 / (12 – 20 + 4) / 10
480 / (–8 + 4) / 10
480 / (–4) / 10
–120 / 10
–12
236 Fundamentos iniciales de lógica de programación I. Algoritmos en PSeInt y Python

p. 4 ^ 2 + 3 ^ 2 * 2 ^ 2 + 5 ^ 3 – 4 ^ ((7 * 3 mod 9) mod 25)

4 ^ 2 + 3 ^ 2 * 2 ^ 2 + 5 ^ 3 – 4 ^ ((21 mod 9) mod 25)
4 ^ 2 + 3 ^ 2 * 2 ^ 2 + 5 ^ 3 – 4 ^ (3 mod 25)
4^2+3^2*2^2+5^3–4^3
16 + 3 ^ 2 * 2 ^ 2 + 5 ^ 3 – 4 ^ 3
16 + 9 * 2 ^ 2 + 5 ^ 3 – 4 ^ 3
16 + 9 * 4 + 5 ^ 3 – 4 ^ 3
16 + 9 * 4 + 125 – 4 ^ 3
16 + 9 * 4 + 125 – 64
16 + 36 + 125 – 64
52 + 125 – 64
177 – 64
113

q. (4 – (9 * 8 * 5 mod 3) * 3) / (100 mod 8 mod 3)

(4 – (72 * 5 mod 3) * 3) / (100 mod 8 mod 3)
(4 – (360 mod 3) * 3) / (100 mod 8 mod 3)
(4 – 0 * 3) / (100 mod 8 mod 3)
(4 – 0) / (100 mod 8 mod 3)
4 / (100 mod 8 mod 3)
4 / (4 mod 3)
4/1
4

r. 208 / 4 / (455 * 2 / 5 mod 4 + 50)

208 / 4 / (910 / 5 mod 4 + 50)
208 / 4 / (182 mod 4 + 50)
208 / 4 / (2 + 50)
208 / 4 / 52
 Solución a los ejercicios propuestos 237

52 / 52
1

s. (17 / 7 * 2) + (4 * 3 / 5 – 2) – (40 / 3 / 2 – 5)
(2.428 * 2) + (4 * 3 / 5 – 2) – (40 / 3 / 2 – 5)
4.85 + (4 * 3 / 5 – 2) – (40 / 3 / 2 – 5)
4.85 + (12 / 5 – 2) – (40 / 3 / 2 – 5)
4.85 + (2.4 – 2) – (40 / 3 / 2 – 5)
4.85 + 0.4 – (40 / 3 / 2 – 5)
4.85 + 0.4 – (13.33 / 2 – 5)
4.85 + 0.4 – (6.66 – 5)
4.85 + 0.4 – 1.66
5.25 – 1.66
3.59

t. 4 ^ 2 * 5 * 3 – 8 – 152 – (5 ^ 3 * 10 \ 4) mod 2 * 4
4 ^ 2 * 5 * 3 – 8 – 152 – (125 * 10 \ 4) mod 2 * 4
4 ^ 2 * 5 * 3 – 8 – 152 – (1250 \ 4) mod 2 * 4
4 ^ 2 * 5 * 3 – 8 – 152 – 312 mod 2 * 4
16 * 5 * 3 – 8 – 152 – 312 mod 2 * 4
80 * 3 – 8 – 152 – 312 mod 2 * 4
240 – 8 – 152 – 312 mod 2 * 4
240 – 8 – 152 – 312 mod 8
240 – 8 – 152 – 0
232 – 152 – 0
80 – 0
80
238 Fundamentos iniciales de lógica de programación I. Algoritmos en PSeInt y Python

u. 8 * (4 – 3 ^ 2) ^ 2 – 9 * (3 ^ 4 – 4 ^ 3) ^ 3
8 * (4 – 9) ^ 2 – 9 * (3 ^ 4 – 4 ^ 3) ^ 3
8 * (–5) ^ 2 – 9 * (3 ^ 4 – 4 ^ 3) ^ 3
8 * 25 – 9 * (3 ^ 4 – 4 ^ 3) ^ 3
8 * 25 – 9 * (81 – 4 ^ 3) ^ 3
8 * 25 – 9 * (81 – 64) ^ 3
8 * 25 – 9 * 17 ^ 3
8 * 25 – 9 * 4913
200 – 9 * 4913
200 – 44217
–44017

v. (4 + 2 * 9 / 5) – (2 ^ 2 * 8) / 2 ^ 2
(4 + 18 / 5) – (2 ^ 2 * 8) / 2 ^ 2
(4 + 3.6) – (2 ^ 2 * 8) / 2 ^ 2
7.6 – (2 ^ 2 * 8) / 2 ^ 2
7.6 – (4 * 8) / 2 ^ 2
7.6 – 32 / 2 ^ 2
7.6 – 32 / 4
7.6 – 8
–0.4

w. 8 ^ 2 / 4 ^ 3 mod 10 ^ 2 / 5 + 100
64 / 4 ^ 3 mod 10 ^ 2 / 5 + 100
64 / 64 mod 10 ^ 2 / 5 + 100
64 / 64 mod 100 / 5 + 100
1 mod 100 / 5 + 100
1 mod 20 + 100
1 + 100
101
 Solución a los ejercicios propuestos 239

x. (80 / 8) ^ 2 – 4 / 2 + (20 / 4) ^ 3
10 ^ 2 – 4 / 2 + (20 / 4) ^ 3
10 ^ 2 – 4 / 2 + 5 ^ 3
100 – 4 / 2 + 5 ^ 3
100 – 4 / 2 + 125
100 – 2 + 125
98 + 125
223

y. 89 + (66 ^ 2 mod 2.011 + 400) ^ (2 mod 8) / 3 ^ (3 + 2)

89 + (4356 mod 2011 + 400) ^ (2 mod 8) / 3 ^ (3 + 2)
89 + (334 + 400) ^ (2 mod 8) / 3 ^ (3 + 2)
89 + 734 ^ (2 mod 8) / 3 ^ (3 + 2)
89 + 734 ^ 2 / 3 ^ (3 + 2)
89 + 734 ^ 2 / 3 ^ 5
89 + 538756 / 3 ^ 5
89 + 538756 / 243
89 + 2217.102
2306.102

z. 14 – (7 + 4 * 3 – (–2) ^ 2 * 2 – 6) + (2 ^ 2 + 6 – 5 * 3)
14 – (7 + 4 * 3 – 4 * 2 – 6) + (2 ^ 2 + 6 – 5 * 3)
14 – (7 + 12 – 4 * 2 – 6) + (2 ^ 2 + 6 – 5 * 3)
14 – (7 + 12 – 8 – 6) + (2 ^ 2 + 6 – 5 * 3)
14 – (19 – 8 – 6) + (2 ^ 2 + 6 – 5 * 3)
14 – (11 – 6) + (2 ^ 2 + 6 – 5 * 3)
14 – 5 + (2 ^ 2 + 6 – 5 * 3)
14 – 5 + (4 + 6 – 5 * 3)
14 – 5 + (4 + 6 – 15)
14 – 5 + (10 – 15)
240 Fundamentos iniciales de lógica de programación I. Algoritmos en PSeInt y Python

14 – 5 + (–5)
14 – 5 – 5
9–5
4

A continuación, la solución de los ejercicios del numeral 1.4.4.

a.  2/3 + 2/4 + 3/5

b. y +  y + x/(z + 5)

c. +  x^2/a^2 + y^2/b^2

d.  (x^2/a^2 + y^2)/b^2

e.  (x^2 + y^2)/(a^2 + b^2 )

f.  a^2 * (c^2- 2*m + y^2)/2^2

g.  ((x ^ 2 + 3*x*y)/(a^2 + y^2 ))/b^2

h.  a ^2* (a^2 – c^2 )/z

i.  ((a ^2+b* x+ c^3)/x)^2

j. – x^2 .  b*h/2 + y^2/2 – x^2* (8*x*4/2)

k.  ((a ^2 – 2*m*n^2 – n^3)/(p*q*r))^2

l. + –  a/b^2 + (a/b)^2 – ((m^2* n^3)/(4*x))^3

 Solución a los ejercicios propuestos 241

Convertir las siguientes expresiones algorítmicas a expresiones mate-

máticas:

m. 7 * (1 + y)  7 (1+y )

n. a ^ 3 + b ^ 3  a3 + b3

o. (x + y) / (u + w / a) 

p. a ^ 3 + 3 * a ^ 2 * b + 3 * a * b ^ 2 + b ^ 3  a3 + 3a2 b + 3ab2 + b3

q. (a + b) ^ 2 – (a – b ^ 2)  (a+b)2 – (a – b2 )

r. x – y ^ 2 * (x – y) ^ (2 – n ^ 3)  x – y2 (x – y)2 – n3

s. (a / b) + (c / a) + c  + + c

t. a / (b + c) / (a / b + c) 

A continuación, la solución de los ejercicios del numeral 1.7.5.

a. ‘A’  Alfabético – Carácter (Un solo carácter comillas sencillas)

b. –89  Numérico – Entero (Número sin decimales)

c. “125”  Alfabético – Cadena (Varios caracteres comillas dobles)

d. “–9”  Alfabético – Cadena (Varios caracteres comillas dobles)

e. –5  Numérico – Entero (Número sin decimales)

242 Fundamentos iniciales de lógica de programación I. Algoritmos en PSeInt y Python

f. 0  Numérico – Entero o Lógico (Número sin decimales o booleano)

g. 125.00  Numérico – Real (Número con decimales)

h. 4.000  Numérico – Entero (Número sin decimales)

i. ‘+’  Alfabético – Carácter (Un solo carácter comillas sencillas)

j. “9.12”  Alfabético – Cadena (Varios caracteres comillas dobles)

k. 325  Numérico – Entero (Número sin decimales)

l. “Lógica”  Alfabético – Cadena (Varios caracteres comillas dobles)

m. –5698.2  Numérico – Real (Número con decimales)

n. V  Lógico o booleano (Valor booleano Verdadero)

o. 2,333  Numérico – Real (Número con decimales)

p. Falso  Lógico o booleano (Valor booleano Falso)

q. 0.0005  Numérico – Real (Número con decimales)

r. 30000  Numérico – Entero (Número sin decimales)

s. “Sí”  Alfabético – Cadena (Varios caracteres comillas dobles)

t. –500.00  Numérico – Real (Número con decimales)

A continuación, la solución de los ejercicios del numeral 1.7.6

a. 3 < 6  Verdadero (3 es mayor que 6).

b. 5 >= 10  Falso (5 no es mayor o igual que 10).

c. ‘A’ > ‘Z’  Falso (La letra ‘A’ no es mayor que la ‘Z’).
 Solución a los ejercicios propuestos 243

d. ‘8’ > ‘700’  Verdadero (‘8’ es mayor que ‘7’. Cuando se comparan
cadena de caracteres, se hace una comparación carácter por carácter, no
la cadena completa).

e. 8 <> 8  Falso (8 no es diferente de 8. Es igual).

f. 64 >= 64  Verdadero (64 es igual a 64. Cuando se pone el operador

>=, se evalúa si es mayor, si no se cumpla, pasa a evaluar si es igual).

g. ‘8’ > ‘7’  Verdadero (‘8’ es mayor que ‘7’).

h. 45 mod 2 = 0  Falso (45 mod 2 = 0  1 = 0  Falso).

i. 2 ^ 4 <> 84  Verdadero (2 ^ 4 <> 84  16 <> 84  Verdadero).

j. 85.36 = 85.34 V 235 = 114  Falso (85.36=85.34 V 235=114  Falso

V Falso  Falso.

k. ~ (‘A’ >= ‘Z’ V ‘8’ <= ‘0’)  Verdadero (~ (‘A’ >= ‘Z’ V ‘8’ <=
‘0’)  ~ (Falso V Falso)  ~ Falso  Verdadero).

l. 12 <> 15 Λ 111<= 114  Verdadero (12 <> 15 Λ 111<= 114  Verda-

dero Λ Verdadero  Verdadero)

m. ~ (17 < 698 Λ ‘J’ <> ‘K’)  Falso (~ (17 < 698 Λ ‘J’ <> ‘K’)  ~
(Verdadero Λ Verdadero)  ~ (Verdadero)  Falso).

n. 158 >= 158 Λ 256 <= 256  Verdadero (158 >= 158 Λ 256 <= 256 
Verdadero Λ Verdadero  Verdadero).

o. 25 > 12 V 0 > 14  Verdadero (25 > 12 V 0 > 14  Verdadero V Fal-

so  Verdadero).

p. p. 25 > 12 Λ 0 > 14  Falso (25 > 12 Λ 0 > 14  Verdadero Λ Falso

 Falso).

q. q. 3 ^ 2 = 36 / 6 + 3  Verdadero (3 ^ 2 = 36 / 6 + 3  9 = 36 / 6 + 3
 9 = 6 + 3  9 = 9  Verdadero).

r. r. 5 * 4 + 2 > 45 mod 13  Verdadero (5 * 4 + 2 > 45 mod 13  20 +

2 > 45 mod 13  20 + 2 > 6  22 > 6  Verdadero).
244 Fundamentos iniciales de lógica de programación I. Algoritmos en PSeInt y Python

A continuación, la solución de los ejercicios del numeral 1.7.10.

a. $Sueldo  Incorrecta ($)

b. A  Correcta
c. cElUlAr  Correcta
d. Dir_casa  Correcta
e. Edad  Correcta
f. Notas  Correcta
g. N–Tel  Incorrecta (–)
h. SB512  Correcta
i. Tel  Correcta
j. c@rreo  Incorrecta (@)
k. Apellido paterno  Incorrecta ( )
l. Nombre  Correcta
m. 2Salarios  Incorrecta (2)
n. Pensión  Incorrecta (Ó)
o. N1  Correcta
p. Primera/Nota  Incorrecta (/)
q. 1Nota  Incorrecta (1)
r. Año  Incorrecta (Ñ)
 Anexos

Anexo 1. Fórmulas generales de figuras geométricas.

Fórmulas de figuras geométricas 1.

Fuente: Spiegel (1991).
246 Fundamentos iniciales de lógica de programación I. Algoritmos en PSeInt y Python

Fórmulas de figuras geométricas 2.

Fuente: Spiegel (1991).
 Anexos 247

Fórmulas de figuras geométricas 3.

Fuente: Spiegel (1991).
248 Fundamentos iniciales de lógica de programación I. Algoritmos en PSeInt y Python

Anexo 2. Fórmulas de conversión de temperaturas.

Importante:
• La temperatura Rankine no es muy usada actualmente.
• La escala de temperatura Kelvin no tiene el símbolo grados (°), debido
a que es una escala de temperatura termodinámica (absoluta).
• Punto de ebullición agua: 100 º C (212 ° F).
• Punto de congelación agua: 0° C (32° F).
• Temperatura corporal promedio del cuerpo humano: 37° C (98.6° F).
• Temperatura ambiente confortable: de 20° C a 25° C (de 68° Fa 77° F).
 Anexos 249

Anexo 3. Equivalencias de longitud.

250 Fundamentos iniciales de lógica de programación I. Algoritmos en PSeInt y Python

Anexo 4. Equivalencias de masa.