L3 TD1 Grupo 3 BMA20 P FINAL

Universidad Nacional de Ingeniería
Facultad de Ingeniería Eléctrica y Electrónica

Laboratorio 3 - Tarea Domiciliaria 1
Curso: Algoritmos y Estructuras de Datos II - BMA20(P)
Profesor: Segundo Gamarra

Grupo: 3
Estudiantes:
Torres Trigueros, Alfredo José Julián
Gonzales Morales, Alexander Daniel
Veli Misayauri, Junior Edgar
Granados Pomalia, Geraldine Nicol
Perez Lazo, Renzo Esteban
Nieto Castro, Henrry
Romero Reyes, Angel Fernando
Pelaez Angulo, Alvaro
Espinoza Espiritu, Hector Junior
Copyright © 2013 John Smith
P UBLISHED BY P UBLISHER
BOOK - WEBSITE . COM
Licensed under the Creative Commons Attribution-NonCommercial 3.0 Unported License (the
“License”). You may not use this file except in compliance with the License. You may obtain a
copy of the License at http://creativecommons.org/licenses/by-nc/3.0. Unless required
by applicable law or agreed to in writing, software distributed under the License is distributed on an
“AS IS ” BASIS , WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and limitations under the License.
First printing, March 2013

Índice general
I Datos del estudiante participante
1 DNI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2 Carnet Universitario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
II Torres Trigueros, Alfredo José Julian
3 P1- Sec1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1 Pseudocódigo 25
3.2 Diagrama de flujo 25
3.3 Diagrama de N/S 26
3.4 Código fuente 26
4 P2- Sec10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
5 P3- Sec19 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
6 P4- Sel1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
7 P5- Sel10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
8 P6- Rep19 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
8.2 Prueba 41
9 P7- Rep10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
9.2 Prueba 44
10 P8- Rep19 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
10.2 Prueba 47
11 P9- Arr10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
11.2 Prueba 50
12 P10- Arr1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
12.2 Prueba 52
III Gonzales Morales, Alexander Daniel
13 P1 - Sel2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
13.1 Esquema 57
13.3 Código Python 59
13.4 Ejecución 60
14 P2 - Sel11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
14.1 Esquema 63
14.4 Ejecución 66
15 P3 - Rep11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
15.1 Esquema 68
15.4 Ejecución 70
16 P4 - Rep20 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
16.1 Esquema 71
16.4 Ejecución 73
17 P5 - Arr2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
17.1 Esquema 75
17.4 Ejecución 78
18 P6 - Arr11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
18.1 Esquema 81
18.4 Ejecución 84
IV Veli Misayauri, Junior Edgar
19 P1- Sec3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
20 P2- Sec12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
21 P3- Sec21 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
22 P4- Sel12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
23 P5- Sel3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
24 P6- Rep21 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

25 P7- Rep12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

26 P8- Arr12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

V Granados Pomalia, Geraldine Nicol
27 P1- Sec4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

27.2 Diagrama N/S 113
27.4 Código de fuente 115
28 P2- Sec13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

29 P3- Sec22 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

30 P4- Sel13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

31 P5- Sel4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

32 P6-Rep22 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
33 P7-Rep13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
34 P8-Arr13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
35 P9-Arr4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
VI Perez Lazo, Renzo Esteban
36 P1-Sec5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
36.1 Pseudocodigo 155
36.2 Esquema 156
36.3 Codigo Fuente 156
36.4 Ejecucion 156
37 P2-Sec14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
37.2 Esquema 159
37.4 Ejecucion 160
38 P3-Sec23 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
38.1 Esquema 161
38.4 Ejecucion 162
39 P4-SeL14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
39.1 Esquema 163
39.4 Ejecucion 165
40 P5-SeL5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
40.1 Esquema 166
40.4 Ejecucion 168
41 P6-Rep1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
41.2 Esquema 170
41.4 Ejecucion 171
42 P7-Rep14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
42.2 Esquema 174
42.4 Ejecucion 175
43 P8-Rep3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
43.2 Esquema 177
43.4 Ejecucion 178
44 P9-Arr13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
44.1 Esquema 179
44.4 Ejecucion 181
45 P10-Arr4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
45.2 Esquema 184
45.4 Ejecucion 186
VII Nieto Castro, Henrry
46 P1-Sec6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
VIII Romero Reyes Angel Fernando
47 P1 - Sec7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
48 P2 - Sec16 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
49 P3 - Sel7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
50 P4 - Sel16 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
51 P5 - Sel20 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
IX Pelaez Angulo Alvaro Ivan
52 P1 - Sec8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
53 P2 - Sec17 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
54 P3 - Sel21 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
55 P4 - Sel17 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
56 P5 - Sel8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
57 P6 - Rep4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
58 P7 - Rep17 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
59 P8 - Arr21 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
60 P9 - Arr17 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
61 P10 - Arr8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

X Espinoza Espiritu Hector Junior
62 Problema 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
62.3 Diagrama de NS 254
62.4 Codigo en Python 254
63 Problema 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
64 Problema 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
65 Problema 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
66 Problema 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
67 Problema 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
68 Problema 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
69 Problema 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
I
Datos del estudiante
participante
1 DNI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2 Carnet Universitario . . . . . . . . . . . . . . . . . . 20
1. DNI
A19: Torres Trigueros, Alfredo José Julian - DNI: 72776930
Figura 1.1: Torres Trigueros (DNI).

17
A20: Gonzales Morales, Alexander Daniel - DNI: 47541507
Figura 1.2: Gonzales Morales (DNI).
A21: Veli Misayauri, Junior Edgar - DNI: 77152579
Figura 1.3: Veli Misayauri (DNI).
A22: Granados Pomalia, Geraldine Nicol - DNI: 75852117
Figura 1.4: Granados Pomalia (DNI).

18 Capítulo 1. DNI
A23: Perez Lazo, Renzo Esteban - DNI: 78334210
Figura 1.5: Perez Lazo (DNI).
A24: Nieto Castro, Henrry - DNI: 70120805
A25: Romero Reyes, Angel Fernando - DNI: 70860285
Figura 1.7: Romero Reyes (DNI).

19
A26: Pelaez Angulo, Alvaro Ivan - DNI: 73479927
Figura 1.8: Pelaez Angulo (DNI).
A27: Espinoza Espiritu, Hector Junior - DNI: 71279075

2. Carnet Universitario
A19: Torres Trigueros, Alfredo José Julian - Código UNI: 20192606D
Figura 2.1: Torres Trigueros (CU).

21
A20: Gonzales Morales, Alexander Daniel - Código UNI: 20140374E
Figura 2.2: Gonzales Morales (CU).
A21: Veli Misayauri, Junior Edgar - Código UNI: 20191297H
Figura 2.3: Veli Misayauri (CU).
A22: Granados Pomalia, Geraldine Nicol - Código UNI: 20191277G
Figura 2.4: Granados Pomalia (CU).

22 Capítulo 2. Carnet Universitario
A23: Perez Lazo, Renzo Esteban - Código UNI: 20191168C
Figura 2.5: Perez Lazo (CU).
A24: Nieto Castro, Henrry - Código UNI: 20181368J
Figura 2.6: Gonzales Morales (CU).
A25: Romero Reyes, Angel Fernando - Código UNI: 20200208I
Figura 2.7: Romero Reyes (CU).

23
A26: Pelaez Angulo, Alvaro Ivan - Código UNI: 20194516B
Figura 2.8: Pelaez Angulo (CU).
A27: Espinoza Espiritu, Hector Junior - Código UNI: 20191358G
Figura 2.9: Espinoza Espiritu (CU).

II
Torres Trigueros, Alfredo José
3 P1- Sec1
Julian . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1 Pseudocódigo
3.2 Diagrama de flujo
3.3 Diagrama de N/S
3.4 Código fuente
4 P2- Sec10 . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.1 Pseudocódigo
4.3 Diagrama de N/S
4.4 Código fuente
5 P3- Sec19 . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.1 Pseudocódigo
5.3 Diagrama de N/S
5.4 Código fuente
6 P4- Sel1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
6.1 Pseudocódigo
6.3 Diagrama de N/S
6.4 Código fuente
7 P5- Sel10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
7.1 Pseudocódigo
7.3 Diagrama de N/S
7.4 Código fuente
8 P6- Rep19 . . . . . . . . . . . . . . . . . . . . . . . . . . 41
8.1 Código fuente
8.2 Prueba
9 P7- Rep10 . . . . . . . . . . . . . . . . . . . . . . . . . . 44
9.1 Código fuente
9.2 Prueba
10 P8- Rep19 . . . . . . . . . . . . . . . . . . . . . . . . . . 47
10.1 Código fuente
10.2 Prueba
11 P9- Arr10 . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
11.1 Código fuente
11.2 Prueba
12 P10- Arr1 . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
12.1 Código fuente
12.2 Prueba
3. P1- Sec1
Realice un diagrama de flujo y pseudocódigo que representen el algoritmo para obtener

el área de un triángulo.
3.1 Pseudocódigo
Algoritmo SEC1
Definir B,H,A Como Real
Escribir 'Programa para el cálculo
del área un triángulo'
Escribir 'Ingrese medida de la base en cm'
Leer B
Escribir 'Ingrese medida de la altura en cm'
Leer H
A <- B*H/2
Escribir 'El área del triángulo es de ',A,' cm2'
FinAlgoritmo

26 Capítulo 3. P1- Sec1
Figura 3.1: Diagrama de Flujo de SEC1
3.3 Diagrama de N/S
Figura 3.2: Diagrama N/S de SEC1
3.4 Código fuente

def valor():
while 1:
try:
M=float(input("Ingrese valor: "))
except:
M=float(input("Ingrese un número positivo: "))
else:
break
return M
def gen():
while 1:
try:
B=float(input("Ingrese un número positivo: "))
except:
else:
break
return B
print("Programa para el cálculo del área un triángulo")
print("Ingrese la medida de la base en cm: ")
B=valor()
while B<=0:
B=gen()
print("Ingrese la medida de la altura en cm: ")
H=valor()
while H<=0:
H=gen()
A=B*H/2
mensaje="El area del triangulo es {:.2f} cm2"
print(mensaje.format(A))
4. P2- Sec10
La CONAGUA requiere determinar el pago que debe realizar una persona por el total
de metros cúbicos que consume de agua. Realice un diagrama de flujo y pseudocódigo que
representen el algoritmo que permita determinar ese pago.
4.1 Pseudocódigo
Algoritmo SEC10
Definir C,L,T Como Real
Escribir 'Programa para el pago del agua'
Escribir 'Costo del agua en soles por metro cubico'
Leer C
Escribir 'Cantidad de agua consumida en m3'
Leer L
T <- C*L
Escribir 'El pago por el agua es de ',T,' soles'
FinAlgoritmo
4.3 Diagrama de N/S

4.4 Código fuente

print("Programa para el pago del agua")
C=float(input("Costo del agua en soles por metro cubico: "))
L=float(input("Cantidad de agua consumida en m3: "))
T=C*L
mensaje="El pago por el agua es de {:.2f} soles"
print(mensaje.format(T))
5. P3- Sec19
Realice el diagrama de flujo y pseudocódigo que representen el algoritmo para encontrar

el área de un cuadrado.
5.1 Pseudocódigo
Algoritmo SEC19
Definir L,A Como Real
Escribir 'Programa para el cálculo del área un cuadrado'
Escribir 'Ingrese medida del lado en cm'
Leer L
A <- L^2
Escribir 'El área del cuadrado es de ',A,' cm2'
FinAlgoritmo

5.3 Diagrama de N/S
5.4 Código fuente

def valor():
while 1:
try:
M=float(input("Ingrese valor: "))
except:
M=float(input("Ingrese un número positivo: "))
else:
break
return M
def gen():
while 1:
try:
except:
else:
break
return B
print("Programa para el pago del agua")
print("Costo del agua en soles por metro cubico: ")
C=valor()
while C<=0:
C=gen()
print("Cantidad de agua consumida en m3: ")
L=valor()
while L<=0:
L=gen()
T=C*L
mensaje="El pago por el agua es de {:.2f} soles"
print(mensaje.format(T))
6. P4- Sel1
Realice un algoritmo para determinar si una persona puede votar con base en su edad en
las próximas elecciones. Construya el diagrama de flujo, el pseudocódigo y el diagrama N/S.
6.1 Pseudocódigo
Algoritmo SEL1
Definir E Como Entero
Escribir 'Programa para evaluar edad en elecciones'
Escribir 'Escriba su edad'
Leer E
Si E<18
Escribir "Eres muy joven para votar"
SiNo
Si E>70
Escribir "Si quieres puedes votar"
SiNo
Escribir "Puedes votar"
FinSi
FinSi
FinAlgoritmo
Figura 6.1: Diagrama de Flujo de SEL1
6.3 Diagrama de N/S

36 Capítulo 6. P4- Sel1
6.4 Código fuente

def valor():
while 1:
try:
M=int(input("Ingrese valor: "))
except:
M=int(input("Ingrese un número entero positivo: "))
else:
break
return M
def gen():
while 1:
try:
B=int(input("Ingrese un número entero positivo: "))
except:
else:
break
return B
def elec(a):
if a<18:
m = "Eres muy joven para votar"
elif E>70:
m = "Si quieres puedes votar"
else:
m = "Puedes votar"
return m
print("Programa para evaluar edad en elecciones")
print("Escriba su edad: ")
E=valor()
while E<=0:
E=gen()
mensaje=elec(E)
print(mensaje)
7. P5- Sel10
Represente un algoritmo mediante un diagrama de flujo y el pseudocódigo para determi-

nar a qué lugar podrá ir de vacaciones una persona, considerando que la línea de autobuses
“La tortuga” cobra por kilómetro recorrido. Se debe considerar el costo del pasaje tanto de
ida, como de vuelta; los datos que se conocen y que son flujos fijos son: México, 750km; P.V.,
800 km; Acapulco, 1200 km, y Cancún, 1800 km. También se debe considerar la posibilidad
de tener que quedarse en casa.
7.1 Pseudocódigo
Algoritmo SEL10
Definir CK, D, K Como Real
Escribir 'Programa para evaluar viajes'
Escribir 'Escriba el costo en soles por km'
Leer CK
Escribir 'Escriba el dinero disponible'
Leer D
K=D/CK
Si K>1800 Entonces
Escribir 'Puedes ir a México, P.V, Acapulco o Cancún'
SiNo
Si K>1200 Entonces
Escribir 'Puedes ir a México, P.V o Acapulco'
SiNo
Si K>800 Entonces
Escribir 'Puedes ir a México o P.V.'
SiNo
Si K>750 Entonces
Escribir 'Puedes ir a México'
SiNo
Escribir 'Quedáte en casa'
FinSi
FinSi
FinSi
FinSi
FinAlgoritmo
7.3 Diagrama de N/S
7.4 Código fuente

def valor():
while 1:
try:
M=int(input("Ingrese valor: "))
except:
M=int(input("Ingrese un número entero positivo: "))
else:
break
return M
def gen():
while 1:
try:
except:
else:
break
return B
def cond(a):
if a>1800:
m = "Puedes ir a México, P.V, Acapulco o Cancún"
elif a>1200:
m = "Puedes ir a México, P.V o Acapulco"
elif a > 800:
mensaje = "Puedes ir a México o P.V."
elif a > 750:
m = "Puedes ir a México"
else:
m = "Quedáte en casa"
return m
print("Programa para evaluar viajes")
print("Escriba el costo en soles por km: ")
CK=valor()
while CK<=0:
CK=gen()
print("Escriba el dinero disponible, en soles: ")
D=valor()
while D<=0:
D=gen()
K=D/CK
mensaje=cond(K)
print(mensaje)
8. P6- Rep19
El gerente de una compañía automotriz desea determinar el impuesto que va a pagar por
cada uno de los automóviles que posee, además del total que va a pagar por cada categoría y
por todos los vehículos, basándose en la siguiente clasificación:
Los vehículos con clave 1 pagan 10 % de su valor.
Realice un algoritmo para obtener la información y represéntelo mediante diagrama de flujo,
pseudocódigo y diagrama N/S. Los datos son la clave y costo de cada uno.
8.1 Código fuente

8.2 Prueba
42 Capítulo 8. P6- Rep19
Figura 8.1: Código de Rep19

8.2 Prueba 43

9. P7- Rep10
Los directivos de equis escuela requieren determinar cuál es la edad promedio de cada
uno de los M salones y cuál es la edad promedio de toda la escuela. Realice un algoritmo
para determinar estos promedios y represente la solución mediante el diagrama de flujo, el
pseudocódigo y el diagrama N/S.
9.1 Código fuente

9.2 Prueba
9.2 Prueba 45


10. P8- Rep19
El gerente de una compañía automotriz desea determinar el impuesto que va a pagar por
cada uno de los automóviles que posee, además del total que va a pagar por cada categoría y
por todos los vehículos, basándose en la siguiente clasificación:
Realice un algoritmo para obtener la información y represéntelo mediante diagrama de flujo,
pseudocódigo y diagrama N/S. Los datos son la clave y costo de cada uno.
10.1 Código fuente

10.2 Prueba

10.2 Prueba 49

11. P9- Arr10
Realice un algoritmo que lea dos vectores de cien elementos y que calcule la suma de éstos
guardando su resultado en otro vector, el cual se debe presentar en forma impresa.
11.1 Código fuente

11.2 Prueba
11.2 Prueba 51
Figura 11.1: Código de Arr10

12. P10- Arr1
Realice y represente mediante un diagrama de flujo el algoritmo para obtener la matriz

transpuesta de cualquier matriz de orden M x N.
12.1 Código fuente

12.2 Prueba
12.2 Prueba 53
Figura 12.1: Código de Arr1

54 Capítulo 12. P10- Arr1

III
Gonzales Morales, Alexander
Daniel
13 P1 - Sel2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
13.1 Esquema
13.2 Pseudocódigo
13.3 Código Python
13.4 Ejecución
14 P2 - Sel11 . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
14.1 Esquema
14.2 Pseudocódigo
14.3 Código Python
14.4 Ejecución
15 P3 - Rep11 . . . . . . . . . . . . . . . . . . . . . . . . . . 68
15.1 Esquema
15.2 Pseudocódigo
15.3 Código Python
15.4 Ejecución
16 P4 - Rep20 . . . . . . . . . . . . . . . . . . . . . . . . . . 71
16.1 Esquema
16.2 Pseudocódigo
16.3 Código Python
16.4 Ejecución
17 P5 - Arr2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
17.1 Esquema
17.2 Pseudocódigo
17.3 Código Python
17.4 Ejecución
18 P6 - Arr11 . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
18.1 Esquema
18.2 Pseudocódigo
18.3 Código Python
18.4 Ejecución
13. P1 - Sel2
Se tienen dos matrices cuadradas (de 12 filas y 12 columnas cada una). Realice un algorit-
mo que lea los arreglos y que determine si la diagonal principal de la primera es igual a la
diagonal principal de la segunda. (Diagonal principal es donde los subíndices I, J son iguales).
Represente la solución mediante el diagrama de flujo y el pseudocódigo.
13.1 Esquema 57
13.1 Esquema
Figura 13.1: Pseudocódigo Arr11.

58 Capítulo 13. P1 - Sel2
13.2 Pseudocódigo
Figura 13.2: Diagrama de flujo Arr11.

13.3 Código Python
Figura 13.3: Diagrama N/S Arr11.

13.4 Ejecución
Figura 13.4: Código fuente Arr11.
Figura 13.5: Ejecución del código fuente Arr11, diagonales principales diferentes.
13.4 Ejecución 61
Figura 13.6: Ejecución del código fuente Arr11, diagonales principales iguales.
14. P2 - Sel11
14.1 Esquema 63
14.1 Esquema

14.2 Pseudocódigo

14.3 Código Python

14.4 Ejecución
14.4 Ejecución 67
15. P3 - Rep11
Realice un algoritmo y represéntelo mediante un diagrama de flujo para obtener una

función exponencial, la cual está dada por: ex = 1 + x/1! + x2 /2! + x3 /3! + ...
15.1 Esquema
Figura 15.1: Pseudocódigo Rep11.

15.2 Pseudocódigo
Figura 15.2: Diagrama de flujo Rep11.
15.3 Código Python
Figura 15.3: Diagrama N/S Rep11.

70 Capítulo 15. P3 - Rep11
15.4 Ejecución
Figura 15.4: Código fuente Rep11.
.
.
Figura 15.5: Ejecución del código fuente Rep11, con x = 1.
Figura 15.6: Ejecución del código fuente Rep11, con x = 2.

16. P4 - Rep20
Realice un algoritmo para obtener el seno de un ángulo y represéntelo mediante diagrama

de flujo, pseudocódigo y diagrama N/S. sen(x) = x − x3 /3! + x5 /5! − x7 /7! + ...
16.1 Esquema
Figura 16.1: Pseudocódigo Rep20.

16.2 Pseudocódigo
Figura 16.2: Diagrama de flujo Rep20.
16.3 Código Python
Figura 16.3: Diagrama N/S Rep20.

16.4 Ejecución 73
16.4 Ejecución
Figura 16.4: Código fuente Rep20.
.
.
Figura 16.5: Ejecución del código fuente Rep20, con x = 1,5708.
Figura 16.6: Ejecución del código fuente Rep20, con x = 3,1416.

17. P5 - Arr2
Realice y represente mediante un diagrama de flujo el algoritmo para obtener el producto

de dos matrices de orden M x N y P x Q.
17.1 Esquema 75
17.1 Esquema

76 Capítulo 17. P5 - Arr2
17.2 Pseudocódigo

17.3 Código Python

17.4 Ejecución
Figura 17.5: Ejecución del código fuente Arr2, N igual a P.

17.4 Ejecución 79
Figura 17.6: Ejecución del código fuente Arr2, N diferente de P.

18. P6 - Arr11
18.1 Esquema 81
18.1 Esquema

18.2 Pseudocódigo

18.3 Código Python

18.4 Ejecución
18.4 Ejecución 85
IV
Veli Misayauri, Junior Edgar
19 P1- Sec3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
19.1 Pseudocódigo
19.3 Diagrama de N/S
19.4 Código fuente
20 P2- Sec12 . . . . . . . . . . . . . . . . . . . . . . . . . . 90
20.1 Pseudocódigo
20.4 Código fuente
21 P3- Sec21 . . . . . . . . . . . . . . . . . . . . . . . . . . 93
21.1 Pseudocódigo
21.4 Código fuente
22 P4- Sel12 . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
22.1 Pseudocódigo
22.4 Código fuente
23 P5- Sel3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
23.1 Pseudocódigo
23.4 Código fuente
24 P6- Rep21 . . . . . . . . . . . . . . . . . . . . . . . . . 102

24.1 Pseudocódigo
24.4 Código fuente
25 P7- Rep12 . . . . . . . . . . . . . . . . . . . . . . . . . 105

25.1 Pseudocódigo
25.4 Código fuente
26 P8- Arr12 . . . . . . . . . . . . . . . . . . . . . . . . . . 108

26.1 Pseudocódigo
26.4 Código fuente
19. P1- Sec3
Una empresa que contrata personal requiere determinar la edad de las personas que
solicitan trabajo, pero cuando se les realiza la entre- vista sólo se les pregunta el año en que
nacieron. Realice el diagrama de flujo y pseudocódigo que representen el algoritmo para
solucionar este problema.
19.1 Pseudocódigo
Algoritmo SEC3
Definir añoDeNacimiento,añoActual,edad Como Entero
añoActual <- 2023
Escribir 'Ingrese el año de nacimiento:'
Leer añoDeNacimiento
edad <- añoActual-añoDeNacimiento
Escribir 'La edad es: ',edad
FinAlgoritmo

19.4 Código fuente

añoActual = 2023
añoDeNacimiento = int(input("Ingrese el año de nacimiento: "))
edad = añoActual - añoDeNacimiento
print("La edad es: ", edad)
Figura 19.3: Compilacion del codigo fuente SEC3

20. P2- Sec12
Realice un diagrama de flujo y pseudocódigo que representen el algoritmo para deter-

minar cuánto pagará finalmente una persona por un artículo equis, considerando que tiene
un descuento de 20 %, y debe pagar 15 % de IVA (debe mostrar el precio con descuento y el
precio final).
20.1 Pseudocódigo
Algoritmo SEC12
Definir precioArticulo, descuento, precioConDescuento, iva, precioFinal como
,→ reales
Escribir "Ingrese el precio del artículo:"
Leer precioArticulo
descuento <- precioArticulo * 0.2
precioConDescuento <- precioArticulo - descuento
iva <- precioConDescuento * 0.15
precioFinal <- precioConDescuento + iva
Escribir "Precio con descuento: ", precioConDescuento
Escribir "Precio final: ", precioFinal
FinAlgoritmo

20.4 Código fuente

precioArticulo = float(input("Ingrese el precio del artículo: "))
descuento = precioArticulo * 0.2
precioConDescuento = precioArticulo - descuento
iva = precioConDescuento * 0.15
precioFinal = precioConDescuento + iva
print("Precio con descuento:", precioConDescuento)

print("Precio final:", precioFinal)

21. P3- Sec21
Realice un diagrama de flujo y pseudocódigo que representen el algoritmo para determi-

nar aproximadamente cuántos meses, semanas, días y horas ha vivido una persona.
21.1 Pseudocódigo
Algoritmo SEC21
Definir añoNacimiento,mesNacimiento,diaNacimiento,horaNacimiento Como Entero
Definir añoActual,mesActual,diaActual,horaActual Como Entero
Definir mesesVividos,semanasVividas,diasVividos,horasVividas Como Entero
Escribir 'Ingrese su año de nacimiento:'
Leer añoNacimiento
Escribir 'Ingrese su mes de nacimiento:'
Leer mesNacimiento
Escribir 'Ingrese su día de nacimiento:'
Leer diaNacimiento
Escribir 'Ingrese su hora de nacimiento:'
Leer horaNacimiento
añoActual <- 2023
mesActual <- 5
diaActual <- 5
horaActual <- 8
mesesVividos <- (añoActual-añoNacimiento)*12+(mesActual-mesNacimiento)
semanasVividas <- (diaActual-diaNacimiento+mesesVividos*30) // 7
diasVividos <- (diaActual-diaNacimiento+mesesVividos*30) MOD 7
horasVividas <- (horaActual-horaNacimiento+diasVividos*24)
Escribir 'Ha vivido aproximadamente:'
Escribir mesesVividos,'meses'
Escribir semanasVividas,'semanas'
Escribir diasVividos,'días'
Escribir horasVividas,'horas'
FinAlgoritmo

21.4 Código fuente

from datetime import datetime
fecha_nacimiento = input("Ingrese su fecha de nacimiento en formato dd/mm/yyyy: ")

fecha_actual = datetime.now()
fecha_nacimiento = datetime.strptime(fecha_nacimiento, "%d/%m/%Y")
diferencia = fecha_actual - fecha_nacimiento
dias_vividos = diferencia.days
horas_vividas = diferencia.seconds // 3600
minutos_vividos = (diferencia.seconds // 60) % 60
segundos_vividos = diferencia.seconds % 60
meses_vividos = dias_vividos // 30
semanas_vividas = dias_vividos // 7
print(f"Usted ha vivido aproximadamente {meses_vividos} meses, {semanas_vividas} semanas,

,→ {dias_vividos} días, {horas_vividas} horas, {minutos_vividos} minutos y
,→ {segundos_vividos} segundos.")

22. P4- Sel12
Realice un algoritmo que permita determinar el sueldo semanal de un trabajador con

base en las horas trabajadas y el pago por hora, considerando que a partir de la hora número
41 y hasta la 45, cada hora se le paga el doble, de la hora 46 a la 50, el triple, y que trabajar
más de 50 horas no está permitido. Represente el algoritmo mediante el diagrama de flujo, el
pseudocódigo y el diagrama N/S.
22.1 Pseudocódigo
Algoritmo SEL12
Definir horasTrabajadas, pagoHora, sueldoSemana Como Real
Escribir "Ingrese las horas trabajadas en la semana:"

Leer horasTrabajadas
Escribir "Ingrese el pago por hora:"

Leer pagoHora
Si horasTrabajadas <= 40 Entonces

sueldoSemana <- horasTrabajadas * pagoHora
Sino
sueldoSemana <- (40 * pagoHora) + ((horasTrabajadas - 40) * (pagoHora * 2))
Sino
sueldoSemana <- (40 * pagoHora) + (5 * (pagoHora * 2)) + ((horasTrabajadas
,→ - 45) * (pagoHora * 3))
Sino
Escribir "Horas trabajadas exceden el límite permitido de 50 horas"
Fin Si
Fin Si
Fin Si
Escribir "El sueldo semanal es: ", sueldoSemana

FinAlgoritmo
Figura 22.2: Diagrama N/S de SEL12

22.4 Código fuente

horasTrabajadas = float(input("Ingrese las horas trabajadas en la semana: "))
pagoHora = float(input("Ingrese el pago por hora: "))
if horasTrabajadas <= 40:

sueldoSemana = horasTrabajadas * pagoHora
elif horasTrabajadas <= 45:
sueldoSemana = (40 * pagoHora) + ((horasTrabajadas - 40) * (pagoHora * 2))
sueldoSemana = (40 * pagoHora) + (5 * (pagoHora * 2)) + ((horasTrabajadas - 45) *
,→ (pagoHora * 3))
else:
sueldoSemana = 0
print("Horas trabajadas exceden el límite permitido de 50 horas")
print("El sueldo semanal es:", sueldoSemana)
Figura 22.3: Compilacion del codigo fuente SEL12

23. P5- Sel3
El 14 de febrero una persona desea comprarle un regalo al ser querido que más aprecia en
ese momento, su dilema radica en qué regalo puede hacerle, las alternativas que tiene son las
siguientes: Regalo Costo Tarjeta $10.00 o menos Chocolates $11.00 a $100.00 Flores $101.00 a
$250.00 Anillo Más de $251.00 Se requiere un diagrama de flujo con el algoritmo que ayude
a determinar qué regalo se le puede comprar a ese ser tan especial por el día del amor y la
amistad.
23.1 Pseudocódigo
Algoritmo SEL3
Definir costo Como Real
Escribir "Ingrese el costo del regalo que desea comprar:"

Leer costo
Si costo <= 10 Entonces

Escribir "Le sugerimos comprar una tarjeta."
Sino Si costo <= 100 Entonces
Escribir "Le sugerimos comprar chocolates."
Sino Si costo <= 250 Entonces
Escribir "Le sugerimos comprar flores."
Sino
Escribir "Le sugerimos comprar un anillo."
Fin Si
Fin Si
Fin Si
FinAlgoritmo
Figura 23.2: Diagrama N/S de SEL3
23.4 Código fuente

horasTrabajadas = float(input("Ingrese las horas trabajadas en la semana: "))
pagoHora = float(input("Ingrese el pago por hora: "))
if horasTrabajadas <= 40:

sueldoSemana = horasTrabajadas * pagoHora
sueldoSemana = (40 * pagoHora) + ((horasTrabajadas - 40) * (pagoHora * 2))
sueldoSemana = (40 * pagoHora) + (5 * (pagoHora * 2)) + ((horasTrabajadas - 45) *
,→ (pagoHora * 3))
else:
sueldoSemana = 0
print("Horas trabajadas exceden el límite permitido de 50 horas")
print("El sueldo semanal es:", sueldoSemana)

24. P6- Rep21
Realice un algoritmo para determinar qué cantidad de dinero hay en un monedero, consi-
derando que se tienen monedas de diez, cinco y un peso, y billetes de diez, veinte y cincuenta
pesos. Represéntelo mediante diagrama de flujo, pseudocódigo y diagrama N/S.
24.1 Pseudocódigo
Algoritmo REP21
Definir total, monedasDiez, monedasCinco, monedasUno, billetesDiez, billetesVeinte,
,→ billetesCincuenta como Entero
total <- 0
Escribir "Ingrese la cantidad de monedas de diez pesos:"

Leer monedasDiez
Escribir "Ingrese la cantidad de monedas de cinco pesos:"

Leer monedasCinco
Escribir "Ingrese la cantidad de monedas de un peso:"

Leer monedasUno
Escribir "Ingrese la cantidad de billetes de diez pesos:"

Leer billetesDiez
Escribir "Ingrese la cantidad de billetes de veinte pesos:"

Leer billetesVeinte
Escribir "Ingrese la cantidad de billetes de cincuenta pesos:"

Leer billetesCincuenta
total <- (monedasDiez * 10) + (monedasCinco * 5) + monedasUno + (billetesDiez * 10) +

,→ (billetesVeinte * 20) + (billetesCincuenta * 50)
Escribir "La cantidad total de dinero en el monedero es:", total

FinAlgoritmo
Figura 24.1: Diagrama de Flujo de REP21
Figura 24.2: Diagrama N/S de REP21

24.4 Código fuente

def calcular_cantidad_dinero():
total = 0
monedas_diez = int(input("Ingrese la cantidad de monedas de diez pesos: "))

monedas_cinco = int(input("Ingrese la cantidad de monedas de cinco pesos: "))
monedas_uno = int(input("Ingrese la cantidad de monedas de un peso: "))
billetes_diez = int(input("Ingrese la cantidad de billetes de diez pesos: "))

billetes_veinte = int(input("Ingrese la cantidad de billetes de veinte pesos: "))
billetes_cincuenta = int(input("Ingrese la cantidad de billetes de cincuenta pesos:
,→ "))
total = (monedas_diez * 10) + (monedas_cinco * 5) + monedas_uno + (billetes_diez * 10)

,→ + (billetes_veinte * 20) + (billetes_cincuenta * 50)
print("La cantidad total de dinero en el monedero es:", total)
calcular_cantidad_dinero()
Figura 24.3: Compilacion del codigo fuente REP21

25. P7- Rep12
Se desea saber el total de una caja registradora de un almacén, se conoce el número de bi-
lletes y monedas, así como su valor. Realice un algoritmo para determinar el total. Represente
la solución mediante el diagrama de flujo, el pseudocódigo y el diagrama N/S.
25.1 Pseudocódigo
Algoritmo REP12
Definir total, billetes, monedas como Entero
Definir valorBillete, valorMoneda como Real
total <- 0
Escribir "Ingrese el valor de cada billete:"

Leer valorBillete
Escribir "Ingrese el valor de cada moneda:"

Leer valorMoneda
Escribir "Ingrese la cantidad de billetes:"

Leer billetes
Escribir "Ingrese la cantidad de monedas:"

Leer monedas
total <- (billetes * valorBillete) + (monedas * valorMoneda)
Escribir "El total de la caja registradora es:", total

FinAlgoritmo
Figura 25.1: Diagrama de Flujo de REP12

Figura 25.2: Diagrama N/S de REP12
25.4 Código fuente

def calcular_total_caja_registradora():
total = 0
valor_billete = float(input("Ingrese el valor de cada billete: "))

valor_moneda = float(input("Ingrese el valor de cada moneda: "))
billetes = int(input("Ingrese la cantidad de billetes: "))

monedas = int(input("Ingrese la cantidad de monedas: "))
total = (billetes * valor_billete) + (monedas * valor_moneda)
print("El total de la caja registradora es:", total)
calcular_total_caja_registradora()
Figura 25.3: Compilacion del codigo fuente REP12

26. P8- Arr12
Se desea saber el total de una caja registradora de un almacén, se conoce el número de bi-
lletes y monedas, así como su valor. Realice un algoritmo para determinar el total. Represente
la solución mediante el diagrama de flujo, el pseudocódigo y el diagrama N/S.
26.1 Pseudocódigo
Algoritmo ARR12
Definir matriz[12, 19] como Entero
Para fila <- 1 hasta 12 Hacer

Para columna <- 1 hasta 19 Hacer
Escribir "Ingrese el elemento en la posición [", fila, ",", columna, "]:"
Leer matriz[fila, columna]
Si matriz[fila, columna] < 0 Entonces

matriz[fila, columna] <- 0
FinSi
FinPara
FinPara
Escribir "La matriz con los elementos negativos cambiados a cero es:"
Para fila <- 1 hasta 12 Hacer
Para columna <- 1 hasta 19 Hacer
Escribir matriz[fila, columna]
FinPara
FinPara
FinAlgoritmo
Figura 26.1: Diagrama de Flujo de ARR12

110 Capítulo 26. P8- Arr12
Figura 26.2: Diagrama N/S de ARR12
26.4 Código fuente

def calcular_total_caja_registradora():
total = 0
valor_billete = float(input("Ingrese el valor de cada billete: "))

valor_moneda = float(input("Ingrese el valor de cada moneda: "))
billetes = int(input("Ingrese la cantidad de billetes: "))

monedas = int(input("Ingrese la cantidad de monedas: "))
total = (billetes * valor_billete) + (monedas * valor_moneda)
print("El total de la caja registradora es:", total)
calcular_total_caja_registradora()
Figura 26.3: Compilacion del codigo fuente ARR12

V
Granados Pomalia,
27 P1- Sec4
27.1
Geraldine
Pseudocódigo
. . . . . . . . . . . . . . . . . . . . . . . . . . . 112
27.2
27.3
Nicol
Diagrama N/S
Diagrama de flujo
27.4 Código de fuente
28 P2- Sec13 . . . . . . . . . . . . . . . . . . . . . . . . . . 116

28.1 Pseudocódigo
28.2 Diagrama N/S
29 P3- Sec22 . . . . . . . . . . . . . . . . . . . . . . . . . . 120

29.1 Pseudocódigo
29.2 Diagrama N/S
30 P4- Sel13 . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

30.1 Pseudocódigo
30.2 Diagrama N/S
31 P5- Sel4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

31.1 Pseudocódigo
31.2 Diagrama N/S
32 P6-Rep22 . . . . . . . . . . . . . . . . . . . . . . . . . . 133
32.1 Pseudocódigo
32.2 Diagrama N/S
33 P7-Rep13 . . . . . . . . . . . . . . . . . . . . . . . . . . 139
33.1 Pseudocódigo
33.2 Diagrama N/S
34 P8-Arr13 . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
34.1 Pseudocódigo
34.2 Diagrama N/S
35 P9-Arr4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
35.1 Pseudocódigo
35.2 Diagrama N/S
27. P1- Sec4
Un estacionamiento requiere determinar el cobro que debe aplicar a las personas que lo
utilizan. Considere que el cobro es con base en las horas que lo disponen y que las fracciones de
hora se toman como completas y realice un diagrama de flujo y pseudocódigo que representen
el algoritmo que permita determinar el cobro.
Con base en lo que se requiere determinar se puede establecer que las variables requeridas para
la solución del problema son las mostradas en la siguiente tabla:
Nombre Descripción Tipo

C Costo por hora Real
H Número de horas Entero
M Número de minutos Entero
Cobro Monto a cobrar Real
Tiempo Horas y fracciones Entero
Tabla 27.1: Variables utilizadas
El pseudocódigo que representa el algoritmo correspondiente a la solución de este problema

mediante la utilización de la lógica repetitiva.
27.1 Pseudocódigo
1. Inicio
2. Declarar variables C, H, M, Cobro, Tiempo
3. Escribir 'Programa para el cálculo del cobro en un estacionamiento'
4. Escribir 'Introduzca el costo por hora'
5. Leer C
6. Escribir 'Introduzca el número de horas dispuesto'
7. Leer H
8. Escribir 'Introduzca el número de minutos dispuesto'
9. Leer M
10. Hacer Tiempo= H+M/M
11. Hacer Cobro = C*Tiempo
12. Escribir 'El cobro es de:' ,Cobro, 'soles'
13. Fin
El diagrama N/S que representa el algoritmo correspondiente a la solución de este problema

27.2 Diagrama N/S

La solución de este problema mediante usando lógica secuencial, se puede establecer mediante
el siguiente diagrama de flujo.
Inicio
Declarar
variables C, H, M, Cobro, Tiempo
'Programa para el cálculo del cobro en un

estacionamiento'
'Introduzca el costo por hora'
Leer C
'Introduzca el número de horas dispuesto'
Leer H
'Introduzca el número de minutos dispuesto'
Leer M
Tiempo= H+M/M
Cobro = C*Tiempo
'El cobro es de:’, Cobro,

'soles'
Fin
Figura 27.2: Diagrama de flujo de SEC4
Finalmente, se tiene el siguiente código en Phyton usando funciones, así como la salida de
estos al correr el código.
1 # -* - coding : utf -8 -* -
2 """ L3_TD1_Problema _1
3
4 Automatically generated by Colaboratory .
5
6 Original file is located at
7 https :// colab . research . google . com / drive /1
q9vbp5rPfbdH6jC3h4jbqiGcsLTDcZDl
8 """
9
10 def c a l c u l a r _ c o b r o _ e s t a c i o n a m i e n t o (C , H , M ) :
11 Tiempo = H + M / M
12 Cobro = C * Tiempo
13 return Cobro
14
15 def datos () :
16 print ( ' Programa para el c l c u l o del cobro en un estacionamiento ')
17
18 C = int ( input ( ' Introduzca el costo por hora : ') )
19 H = int ( input ( ' Introduzca el n m e r o de horas dispuesto : ') )
20 M = int ( input ( ' Introduzca el n m e r o de minutos dispuesto : ') )
21
22 Cobro = c a l c u l a r _ c o b r o _ e s t a c i o n a m i e n t o (C , H , M )
23 print ( ' El cobro es de : ' , Cobro , ' soles ')
24
25 datos ()
Figura 27.3: Salida del código fuente

28. P2- Sec13
Realice un diagrama de flujo y pseudocódigo que representen el algoritmo para determi-

nar cuánto dinero ahorra una persona en un año si considera que cada semana ahorra 15 %
de su sueldo (considere cuatro semanas por mes y que no cambia el sueldo).

S Sueldo Real
AS Ahorro semanal Real
P Porcentaje de aho- Real
rro del sueldo
AA Ahorro anual Real

28.1 Pseudocódigo
1. Inicio
2. Declarar variables S, AS, P, AA
3. Escribir 'Programa para el cálculo del ahorro anual de una persona'
4. Hacer P=15%
5. Escribir 'Introduzca el valor de su sueldo'
6. Leer S
7. Hacer AS= 15%*S
8. Hacer AA= 48*AS
9. Escribir 'El ahorro anual será:, AA, 'soles'
10. Fin

28.2 Diagrama N/S
Figura 28.1: Diagrama N/S

Inicio
Declarar variables S, AS, P, AA
'Programa para el cálculo del ahorro anual de

una persona'
P=15%
'Introduzca el valor de su
sueldo'
Leer S
AS= 15%*S
AA= 48*AS
'El ahorro anual será:’, AA,

'soles'
Fin
Figura 28.2: Diagrama de flujo
1 # -* - coding : utf -8 -* -
3
5
7 https :// colab . research . google . com / drive /1 E -
QAlxYI55i_cT8HiSlbiLYUOLRWAlhL
8 """
9
10 def c a l cular _ahor ro_anu al ( S ) :
11 P = 0.15
12 AS = P * S
13 AA = 48 * AS
14 return AA
15
16 def imprimir () :
17 print ( ' Programa para el c l c u l o del ahorro anual de una persona ')
18
19 S = int ( input ( ' Introduzca el valor de su sueldo : ') )
20
21 AA = calcu lar_a horro_ anual ( S )
22 print ( ' El ahorro anual s e r : ' , AA , ' soles ')
23
24 imprimir ()

29. P3- Sec22
Se requiere un algoritmo para determinar el costo que tendrá realizar una llamada te-
lefónica con base en el tiempo que dura la llamada y en el costo por minuto. Represente la
solución mediante el diagrama de flujo y pseudocódigo.

C Costo por minuto Real
Costo Costo de la llamada Real
M Número de minutos Real
que dura la llamada

29.1 Pseudocódigo
1. Inicio
2. Declarar variables C, Costo, M
3. Escribir 'Programa para el cálculo del costo de una llamada'
4. Escribir 'Introduzca el valor de costo por minuto'
5. Leer C
6. Escribir '¿Cuántos minutos duró la llamada?'
7. Leer M
8. Hacer Costo = C*M
9. Escribir 'El costo de la llamada es de:' ,Costo, 'soles'
10. Fin

29.2 Diagrama N/S

Inicio
Declarar variables C, Costo, M
'Programa para el cálculo del costo de una

llamada'
'Introduzca el valor del costo por minuto'
Leer C
'¿Cuántos minutos duró la llamada?'
Leer M
Costo=C*M
'El ahorro de la llamada es

de:’, Costo, 'soles'
Fin
1 # -* - coding : utf -8 -* -
3
5
TswjgB2QNJG6CFbhik0ditE5vsMmdcNb
8 """
9
10 def c a l cul ar _co sto _l lam ad a (C , M ) :
11 Costo = C * M
12 return Costo
13
14 def resultado () :
15 print ( ' Programa para el c l c u l o del costo de una llamada ')
16
17 C = int ( input ( ' Introduzca el valor de costo por minuto : ') )
18 M = int ( input ( ' Cuntos minutos d u r la llamada ? ') )
19
20 costo_llamada = ca lc ula r_c os to_ ll ama da (C , M )
21 print ( ' El costo de la llamada es de : ' , costo_llamada , ' soles ')
22
23 resultado ()

30. P4- Sel13
El dueño de un estacionamiento requiere un diagrama de flujo con el algoritmo que le

permita determinar cuánto debe cobrar por el uso del estacionamiento a sus clientes. Las
tarifas que se tienen son las siguientes:
Las dos primeras horas a $5.00 cu.
Las siguientes tres a $4.00 cu.
Las cinco siguientes a $3.00 cu.
Después de diez horas el costo por cada una es de dos pesos.

CE Cobro por el uso del Real
estacionamiento
T Número de horas Real

mediante la utilización de la lógica selectiva.
30.1 Pseudocódigo
1. Inicio
2. Declarar variables CE, T
3. Escribir 'Programa para el cálculo del cobro del uso del estacionamiento'
4. Escribir '¿Cuánto tiempo uso el estacionamiento?'
5. Leer T
6. Si T >= 2
Entonces
Si T>=5
Entonces
Si T>=10
Entonces
CE=5*2+4*3+3*5+2*(T-10)
Sino
CE=5*2+4*3+3*(T-5)
FinCompara
Sino
CE=5*2+4*(T-2)
FinCompara
Sino
CE=5*T
7. FinCompara
8. Escribir 'El cobro del uso del estacionamiento es:' ,'$',CE
9. Fin

30.2 Diagrama N/S

La solución de este problema usando lógica selectiva se puede establecer mediante el siguiente
diagrama de flujo.
Inicio
Declarar variables CE, T
'Programa para el cálculo del cobro del uso

del estacionamiento'
'¿Cuánto tiempo uso el estacionamiento?'
Leer T
V F
T>=2
V F
T>=5 CE=5*T
V F CE=5*2+4*(T-2)
T>=10
CE=5*2+4*3+3*5+2*(T-10) CE=5*2+4*3+3*(T-5)
'El cobro del uso del estacionamiento es:', '$', CE
Fin
1 # -* - coding : utf -8 -* -
3
5
nHDM9UpB3j_caRrRmcHiQ03awm0ThZPu
8 """
9
10 def c a l c u l a r _ c o b r o _ e s t a c i o n a m i e n t o ( T ) :
11 if T >= 2:
12 if T >= 5:
13 if T >= 10:
14 CE = 5*2 + 4*3 + 3*5 + 2*( T -10)
15 else :
16 CE = 5*2 + 4*3 + 3*( T -5)
17 else :
18 CE = 5*2 + 4*( T -2)
19 else :
20 CE = 5* T
21 return CE
22
24 print ( ' Programa para el c l c u l o del cobro del uso del estacionamiento '
)
25
26 T = int ( input ( ' Cunto tiempo uso el estacionamiento ? ') )
27
28 c o b ro_est aciona mient o = c a l c u l a r _ c o b r o _ e s t a c i o n a m i e n t o ( T )
29 print ( ' El cobro del uso del estacionamiento es : $ ' ,
c o b r o_est acion amient o )
30
31 imprimir ()

31. P5- Sel4
Los alumnos de una escuela desean realizar un viaje de estudios, pero requieren determi-
nar cuánto les costará el pasaje, considerando que las tarifas del autobús son las siguientes: si
son más de 100 alumnos, el costo es de $20; si son entre 50 y 100, $35; entre 20 y 49, $40, y si
son menos de 20 alumnos, $70 por cada uno. Realice el algoritmo para determinar el costo
del pasaje de cada alumno.
Represente el algoritmo mediante el diagrama de flujo, el pseudocódigo y el diagrama NS.

A Número de alum- Entero
nos
CP Costo del Pasaje Real
por Alumno

31.1 Pseudocódigo
1. Inicio
2. Definir A, CP
3. Escribir 'Programa para evaluar el costo de pasaje para cada alumno'
4. Escribir 'Escriba el número de alumnos'
5. Leer A
6. Si A<=20
Entonces
CP=70
Sino
Si 20<A<49
Entonces
CP=40
Sino
Si 50<=A<=100
Entonces
CP=35
Sino
CP=20
FinCompara
FinCompara
7. FinCompara
8. Escribir 'El costo del pasaje por alumno es:' ,'$',CP
9. Fin

31.2 Diagrama N/S

La solución de este problema mediante el uso de lógica selectiva se puede establecer mediante
Inicio
Declarar variables A, CP
'Programa para evaluar el costo de pasaje por

cada alumno'
'Escriba el número de alumnos'
Leer A
V F
A<=20
CP=70 V F
20<A<49
CP=40 V F
50<=A<=100
CP=35 CP=20
'El costo del pasaje por alumno es:', '$', CP
Fin
1 # -* - coding : utf -8 -* -
3
5
DTsi3WtLFDO75zAK4Ad9ytth9Wb4sr2
8 """
9
10 def e v a luar_costo_pasaje ( A ) :
11 if A <= 20:
12 CP = 70
13 elif 20 < A < 49:
14 CP = 40
15 elif 50 <= A <= 100:
16 CP = 35
17 else :
18 CP = 20
19 return CP
20
22 print ( ' Programa para evaluar el costo de pasaje para cada alumno ')
23
24 A = int ( input ( ' Escriba el n m e r o de alumnos : ') )
25
26 c os to_pasaje_alumno = evaluar_costo_pasaje ( A )
27 print ( ' El costo del pasaje por alumno es : $ ' , costo_pasaje_alumno )
28
29 imprimir ()

32. P6-Rep22
El banco “Bandido de peluche” desea calcular para cada uno de sus N clientes su saldo
actual, su pago mínimo y su pago para no generar intereses. Además, quiere calcular el monto
de lo que ganó por concepto interés con los clientes morosos. Los datos que se conocen d cada
cliente son: saldo anterior, monto de las compras que realizó y pago que depositó en el corte
anterior. Para calcular el pago mínimo se considera 15 % del saldo actual, y el pago para no
generar intereses corresponde a 85 % del saldo actual, considerando que el saldo actual debe
incluir 12 % de los intereses causados por no realizar el pago mínimo y $200 de multa por el
mismo motivo. Realice el algoritmo correspondiente y represéntelo mediante diagrama de
flujo y pseudocódigo.

N número de clientes Entero
intereses_morosos monto total de intereses ganados Flotante
cliente número de cliente actual en el bucle Entero
saldo_anterior saldo anterior Flotante
compras monto de las compras realizadas Flotante
pago_deposito pago depositado en el corte anterior Flotante
saldo_actual saldo actual Flotante
intereses intereses por no realizar el pago mínimo Flotante
multa monto de la multa por no realizar el pago mínimo Flotante
saldo_actualizado saldo actualizado Flotante
pago_minimo monto del pago mínimo Flotante
pago_no_intereses monto del pago para no generar intereses Flotante

134 Capítulo 32. P6-Rep22

32.1 Pseudocódigo
1. Leer N
2. Hacer intereses_morosos= 0
3. Hacer cliente=1
4. Mientras cliente <= N
Leer saldo_anterior
Leer compras
Leer pago_deposito
Hacer saldo_actual = saldo_anterior - compras - pago_deposito

Hacer intereses = saldo_actual * 0.12
Hacer multa = 200
Hacer saldo_actualizado = saldo_actual + intereses + multa
Hacer pago_minimo = saldo_actualizado * 0.15
Hacer pago_no_intereses = saldo_actualizado * 0.85
Escribir línea en blanco
Escribir "-------------------------------------------------------------------"
Escribir "Cliente: " + cliente
Escribir "Saldo actual: $" + saldo_actualizado
Escribir "Pago mínimo: $" + pago_minimo
Escribir "Pago para no generar intereses: $" + pago_no_intereses
Escribir "-------------------------------------------------------------------"
Escribir línea en blanco
Si pago_deposito < pago_minimo
Entonces
Hacer intereses_morosos = intereses_morosos + intereses
Hacer cliente = cliente + 1
Fin mientras
8. Escribir línea en blanco
9. Escribir "------------------------------------------------------------"
10. Escribir "El banco Bandido de Peluche ganó $" + intereses_morosos + " por concepto de
,→ intereses con clientes morosos."
11. Escribir "-----------------------------------------------------------"
12. Fin

32.2 Diagrama N/S

La solución de este problema mediante el uso de lógica repetitiva se puede establecer mediante
Inicio
intereses_morosos = 0
cliente = 1
cliente <= N
"El banco Bandido de Peluche ganó $" +

saldo_anterior intereses_morosos + " por concepto de intereses con
clientes morosos."
compras
Fin
pago_deposito
saldo_actual = saldo_anterior - compras - pago_deposito
intereses = saldo_actual * 0.12
multa = 200
saldo_actualizado = saldo_actual + intereses + multa
pago_minimo = saldo_actualizado * 0.15
pago_no_intereses = saldo_actualizado * 0.85
"Cliente: " + cliente
"Saldo actual: $" + saldo_actualizado
"Pago mínimo: $" + pago_minimo
"Pago para no generar intereses: $" + pago_no_intereses
V F
pago_deposito<pago_minimo
intereses_morosos = intereses_morosos
+ intereses
cliente = cliente + 1
Figura 32.2: Diagrama de flujo de Rep22
1 # -* - coding : utf -8 -* -
3
5
JZcaEDdzPpiIqrv6lpBGqwW6y41nvIG3
8 """
9
10 def c a l c u l a r _ i n t e r e s e s _ m o r o s o s ( N ) :
11 cliente = 1
12 intereses_morosos = 0
13
14 while cliente <= N :
15 saldo_anterior = float ( input ( " Ingrese el saldo anterior del cliente
{}: " . format ( cliente ) ) )
16 compras = float ( input ( " Ingrese el monto de las compras del cliente
{}: " . format ( cliente ) ) )
17 pago_deposito = float ( input ( " Ingrese el pago depositado en el corte
anterior del cliente {}: " . format ( cliente ) ) )
18
19 saldo_actual = saldo_anterior - compras - pago_deposito
20 intereses = saldo_actual * 0.12
21 multa = 200
22
23 saldo_actualizado = saldo_actual + intereses + multa
24 pago_minimo = saldo_actualizado * 0.15
25 pago_no_intereses = saldo_actualizado * 0.85
26
27 print ()
28 print ( " - - - - - - - - - - - - - - - - - - - - " )
29 print ( " Cliente {}: " . format ( cliente ) )
30 print ( " Saldo actual : $ {:.2 f } " . format ( saldo_actualizado ) )
31 print ( " Pago m n i m o : $ {:.2 f } " . format ( pago_minimo ) )
32 print ( " Pago para no generar intereses : $ {:.2 f } " . format (
pago_no_intereses ) )
33 print ( " - - - - - - - - - - - - - - - - - - - - " )
34 print ()
35
36 if pago_deposito < pago_minimo :
37 intereses_morosos += intereses
38
39 cliente += 1
40
41 return intereses_morosos
42
44 N = int ( input ( " Ingrese el n m e r o de clientes : " ) )
45 intereses_ganados = c a l c u l a r _ i n t e r e s e s _ m o r o s o s ( N )
Figura 32.3: Salida del código fuente Rep22

33. P7-Rep13
Un vendedor ha realizado N ventas y desea saber cuántas fueron por 10,000 o menos,
cuántas fueron por más de 10,000 pero por menos de 20,000, y cuánto fue el monto de las
ventas de cada una y el monto global. Realice un algoritmo para determinar los totales.
Represente la solución mediante diagrama de flujo, pseudocódigo y diagrama N/S.

N Representa el número de ventas Entero
contador Indica el número de venta actual en el bucle Entero
ventas_menor_10000 Almacena la cantidad de ventas con un monto menor Entero
o igual a 10000
ventas_10000_20000 Almacena la cantidad de ventas con un monto mayor Entero
a 10000 pero menor a 20000
monto_total Representa el monto total de todas las ventas Flotante
venta Representa el monto de la venta actual Flotante

33.1 Pseudocódigo
1. Inicio
2. Leer N
3. Hacer contador = 1
4. Hacer ventas_menor_10000 = 0
5. Hacer ventas_10000_20000 = 0
6. Hacer monto_total = 0
7. Mientras contador <= N
Leer venta
Hacer monto_total = monto_total + venta
Si venta <= 10000

Entonces
Hacer ventas_menor_10000 = ventas_menor_10000 + 1
Sino 10000 < venta < 20000
Hacer ventas_10000_20000 = ventas_10000_20000 + 1
Fin de comparación
contador = contador + 1
Fin Mientras
8. Escribir "Ventas por 10,000 o menos:", ventas_menor_10000
9. Escribir "Ventas por más de 10,000 pero menos de 20,000:", ventas_10000_20000
10. Escribir "Monto total de ventas:", monto_total
11. Fin

33.2 Diagrama N/S

La solución de este problema mediante el uso de lógica repetitiva se puede establecer mediante
Inicio
contador = 1
ventas_menor_10000
=0
ventas_10000_20000
=0 "Ventas por 10,000 o menos:",
ventas_menor_10000
monto_total = 0
"Ventas por más de 10,000

pero menos de 20,000:",
contador<= N ventas_10000_20000
venta
"Monto total de ventas:",
monto_total
monto_total = monto_total + venta
V F
venta <= 10000 Fin
ventas_menor_10000 =
V F
ventas_menor_10000 + 1
10000 < venta < 20000
ventas_10000_20000 =
ventas_10000_2000 + 1 ventas_10000_20000 =
ventas_10000_2000 + 0
Figura 33.2: Diagrama de flujo de Rep13
1 # -* - coding : utf -8 -* -
3
5
7 https :// colab . research . google . com / drive /1 - KImys1HauPIrRBpx1A -9
n6VVowbXsVq
8 """
9
10 def analizar_ventas ( N ) :
11 contador = 1
12 ve ntas_menor_10000 = 0
13 ve ntas_10000_20000 = 0
14 monto_total = 0
15
16 while contador <= N :
17 venta = float ( input ( " Ingrese el monto de la venta : " ) )
18
19 monto_total += venta
20
21 if venta <= 10000:
22 ventas_menor_10000 += 1
23 elif venta > 10000 and venta < 20000:
24 ventas_10000_20000 += 1
25
26 contador += 1
27
28 return ventas_menor_10000 , ventas_10000_20000 , monto_total
29
30 def mostrar () :
31 N = int ( input ( " Ingrese el n m e r o de ventas : " ) )
32 ventas_menor_10000 , ventas_10000_20000 , monto_total = analizar_ventas ( N
)
33
34 print ( " Ventas por 10 ,000 o menos : " , ventas_menor_10000 )
35 print ( " Ventas por m s de 10 ,000 pero menos de 20 ,000: " ,
ve nt as_10000_20000 )
36 print ( " Monto total de ventas : " , monto_total )
37
38 mostrar ()
Figura 33.3: Salida del código fuente Rep13

34. P8-Arr13
Se tiene en un arreglo cien elementos representando calificaciones de los estudiantes de

una escuela. Realice un algoritmo que lea el arreglo y calcule la calificación promedio del
grupo, además, que cuente los estudiantes que obtuvieron calificaciones arriba del promedio
del grupo. Represéntelo mediante diagrama de flujo, diagrama N/S y pseudocódigo.

N Representa el número de estudiantes Entero
calificaciones Almacena las calificaciones de los estudiantes Arreglo
suma Almacena la suma de las calificaciones Entero
estudiantesa rriba p romedio
Cuenta el número de estudiantes con calificaciones Entero
por encima del promedio

mediante la utilización de arreglos.
34.1 Pseudocódigo
1. Inicio
2. Desde I=1 hasta I=100
Leer calificaciones [I]
Fin desde
3. Hacer suma = 0
4. Hacer estudiantes_arriba_promedio = 0
5. Desde I=1 hasta I=100
Hacer suma = suma + calificaciones [I]
Si calificacion > suma/100
Hacer estudiantes_arriba_promedio = estudiantes_arriba_promedio +
,→ 1
Fin compara
Fin desde
6. Escribir "Calificación promedio del grupo:", suma/100
7. Escribir "Estudiantes con calificaciones por encima del promedio:",
,→ estudiantes_arriba_promedio
8. Fin

34.2 Diagrama N/S

146 Capítulo 34. P8-Arr13
La solución de este problema mediante el uso de arreglos se puede establecer mediante el

siguiente diagrama de flujo.
Inicio ENTRADA PROCESO SALIDA
V V
I=1 I=1 "Calificación
suma = 0 estudiantes_arriba_promedio = 0
promedio del
I > 100 I > 100 grupo:", suma/100
I=I+1 I=I+1
F
calificaciones [I] F
suma = suma +
Se lee el valor I calificaciones [I]
"Estudiantes con calificaciones
por encima del promedio:",
estudiantes_arriba_promedio
calificacion >
suma/100
Se acumula el valor I
estudiantes_arriba_promedio += 1
Figura 34.2: Diagrama de flujo de Arr13

1 # -* - coding : utf -8 -* -
3
5
7 https :// colab . research . google . com / drive /18 dlwh -
S2Z4dlmstOI_zQ2cwjhLfSoxj1
8 """
9
10 import random
11
12 def g e n era r_ cal ifi ca cio ne s ( N ) :
13 calificaciones = []
14 for _ in range ( N ) :
15 calificacion = random . randint (0 , 20)
16 calificaciones . append ( calificacion )
17 return calificaciones
18
19 def cal cular_promedio ( calificaciones ) :
20 suma = sum ( calificaciones )
21 promedio = suma / len ( calificaciones )
22 return promedio
23
24 def c o n t a r _ e s t u d i a n t e s _ a r r i b a _ p r o m e d i o ( calificaciones , promedio ) :
25 estudiantes_arriba_promedio = 0
26 for calificacion in calificaciones :
27 if calificacion > promedio :
28 e s t u d i a n t e s _ a r r i b a _ p r o m e d i o += 1
29 return e s t u d i a n t e s _ a r r i b a _ p r o m e d i o
30
32 N = 100
33 calificaciones = g en era r_ cal ifi ca cio ne s ( N )
34 promedio = calcular_promedio ( calificaciones )
35 estudiantes_arriba_promedio = contar_estudiantes_arriba_promedio (
calificaciones , promedio )
36
37 print ( " C a l i f i c a c i n promedio del grupo : " , promedio )
38 print ( " Estudiantes con calificaciones por encima del promedio : " ,
estudiantes_arriba_promedio )
39
40 imprimir ()
Figura 34.3: Salida del código fuente Arr13

35. P9-Arr4
Realice un algoritmo para obtener una matriz como el resultado de la resta de dos matri-
ces de orden M x N. Represéntelo mediante diagrama de flujo y pseudocódigo.

I Contador y subíndice Entero
J Contador y subíndice Entero
A, B Nombres de los arreglos por restar Entero
C Nombre del arreglo resultante Entero
M Número de renglones del arreglo Entero
N Número de columnas del arreglo Entero

35.1 Pseudocódigo
1. Inicio.
2. Leer M, N
3. Desde I = 1 hasta I = M
Desde J = 1 hasta J = N
Leer A [I, J], B [I, J]
Fin desde
Fin desde
Hacer C [I, J] = A [I, J] - B [I, J]
Fin desde
Fin desde
Escribir C [I, J]
Fin desde
Fin desde
6. Fin

35.2 Diagrama N/S

La solución de este problema mediante el uso de arreglos se puede establecer mediante el

siguiente diagrama de flujo.
Figura 35.2: Diagrama de flujo de Arr13
1 # -* - coding : utf -8 -* -
3
5
7 https :// colab . research . google . com / drive /1 aSQxVqPZ09VwS9 -
fBXOMO_LBfU0CbPd6
8 """
9
10 def ing resar_matrices () :
11 M = int ( input ( " Ingrese el n m e r o de filas M : " ) )
12 N = int ( input ( " Ingrese el n m e r o de columnas N : " ) )
13
14 A = []
15 B = []
16 for i in range ( M ) :
17 fila_A = []
18 fila_B = []
19 for j in range ( N ) :
20 elemento_A = int ( input ( " Ingrese el elemento A [{} , {}]: " . format
( i +1 , j +1) ) )
21 elemento_B = int ( input ( " Ingrese el elemento B [{} , {}]: " . format
( i +1 , j +1) ) )
22 fila_A . append ( elemento_A )
23 fila_B . append ( elemento_B )
24 A . append ( fila_A )
25 B . append ( fila_B )
26
27 return A , B
28
29 def restar_matrices (A , B ) :
30 M = len ( A )
31 N = len ( A [0])
32
33 C = []
34 for i in range ( M ) :
35 fila_C = []
36 for j in range ( N ) :
37 elemento_C = A [ i ][ j ] - B [ i ][ j ]
38 fila_C . append ( elemento_C )
39 C . append ( fila_C )
40
41 return C
42
43 def imprimir_matriz ( matriz , nombre ) :
44 print ()
45 print ( " La matriz " , nombre , " es : " )
46 for fila in matriz :
Figura 35.3: Salida del código fuente Arr4

36 P1-Sec5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
36.1 Pseudocodigo
36.2 Esquema
36.3 Codigo Fuente
36.4 Ejecucion
VI
Perez Lazo, Renzo Esteban
37 P2-Sec14 . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
37.1 Pseudocodigo
37.2 Esquema
37.3 Codigo Fuente
37.4 Ejecucion
38 P3-Sec23 . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
38.1 Esquema
38.2 Pseudocodigo
38.3 Codigo Fuente
38.4 Ejecucion
39 P4-SeL14 . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
39.1 Esquema
39.2 Pseudocodigo
39.3 Codigo Fuente
39.4 Ejecucion
40 P5-SeL5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
40.1 Esquema
40.2 Pseudocodigo
40.3 Codigo Fuente
40.4 Ejecucion
41 P6-Rep1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
41.1 Pseudocodigo
41.2 Esquema
41.3 Codigo Fuente
41.4 Ejecucion
42 P7-Rep14 . . . . . . . . . . . . . . . . . . . . . . . . . . 172
42.1 Pseudocodigo
42.2 Esquema
42.3 Codigo Fuente
42.4 Ejecucion
43 P8-Rep3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
43.1 Pseudocodigo
43.2 Esquema
43.3 Codigo Fuente
43.4 Ejecucion
44 P9-Arr13 . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
44.1 Esquema
44.2 Pseudocodigo
44.3 Codigo Fuente
44.4 Ejecucion
45 P10-Arr4 . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
45.1 Pseudocodigo
45.2 Esquema
45.3 Codigo Fuente
45.4 Ejecucion
36. P1-Sec5
Pinturas “La brocha gorda” requiere determinar cuánto cobrar por trabajos de pintura.
Considere que se cobra por m2 y realice un dia grama de flujo y pseudocódigo que representen
el algoritmo que le permita ir generando presupuestos para cada cliente.
36.1 Pseudocodigo
Algoritmo SEC5
Definir precio por metro cuadrado ppm2
Escribir "Ingrese la cantidad de metros cuadrados a pintar:"
Leer m2
precio = pp2*m2
Escribir "Se tendra que cobrar: " precio
FinAlgoritmo
156 Capítulo 36. P1-Sec5
36.2 Esquema
Figura 36.1: Esquema de SEC5
36.3 Codigo Fuente

1 def cobro(metros,precio):
2 c=metros*precio
3 return c
4 ppm2 = 100
5 m2 = int(input("Ingrese el numero de metros cuadrados a pintar: "))
6 p = cobro(m2,ppm2)
7 print("Se debe cobrar:", p)
36.4 Ejecucion
36.4 Ejecucion 157

37. P2-Sec14
Una empresa desea determinar el monto de un cheque que debe proporcionar a uno de sus
empleados que tendrá que ir por equis número de días a la ciudad de Monterrey; los gastos
que cubre la empresa son: hotel, comida y 100.00 pesos diarios para otros gastos. El monto
debe estar desglosado para cada concepto. Realice un diagrama de flujo y pseudocódigo que
representen
37.1 Pseudocodigo
Algoritmo SEC14
Definir precio por dia del hotel, precio por dia de la comida, precio por otros gastos
,→ = 100
Escribir "Ingrese el número de días que estará el empleado en Monterrey: "
Leer dias_en_monterrey
monto_hotel = costo_hotel_diario * dias_en_monterrey
monto_comida = costo_comida_diario * dias_en_monterrey
monto_otros_gastos = costo_otros_gastos_diario * dias_en_monterrey
monto_total = monto_hotel + monto_comida + monto_otros_gasto
Escribir "El monto para el hotel sera:", monto_hotel
Escribir "El monto para la comida sera:", monto_comida
Escribir "El monto de otros gastos sera:", monto_otros_gastos
Escribir "El Monto total:", monto_total
FinAlgoritmo
37.2 Esquema 159
37.2 Esquema
37.3 Codigo Fuente

1 def hotel(cxdia,dias):
2 h=cxdia*dias
3 return h
4
5 def comida(cxdia,dias):
6 c=cxdia*dias
7 return c
8
9 def otros(cxdia,dias):
10 o=cxdia*dias
11 return o
12
13 dias_en_monterrey = int(input("Ingrese el número de días que estará el empleado en
,→ Monterrey: "))
14
15 costo_hotel_diario = 800.00
16 costo_comida_diario = 200.00
17 costo_otros_gastos_diario = 100.00
18
19 monto_hotel = hotel(costo_hotel_diario,dias_en_monterrey)
20 monto_comida = comida(costo_comida_diario,dias_en_monterrey)
21 monto_otros_gastos = 22 otros(costo_otros_gastos_diario,dias_en_monterrey)
22
23 monto_total = monto_hotel + monto_comida + monto_otros_gastos
24
25 print("El monto para el hotel sera:", monto_hotel)
26 print("El monto para la comida sera:", monto_comida)
27 print("El monto de otros gastos sera:", monto_otros_gastos)
28 print("El Monto total:", monto_total)
37.4 Ejecucion

38. P3-Sec23
El hotel “Cama Arena” requiere determinar lo que le debe cobrar a un huésped por
su estancia en una de sus habitaciones. Realice un diagrama de flujo y pseudocódigo que
representen el algoritmo para determinar ese cobro.
38.1 Esquema

38.2 Pseudocodigo
Algoritmo SEC14
Definir precio por noche del hotel
Escribir "Ingrese el número de noches que estuvo el huesped: "
Leer noches
costo = precio_noche*noches
Escribir "El costo total sera:", costo
FinAlgoritmo
38.3 Codigo Fuente

1 # Definir el costo por noche
2 precio_noche = 100
3 # Pedir al usuario el número de noches que se quedó el huésped en la habitación
4 noches = int(input("Ingrese el número de noches que se quedó el huésped: "))
5 # Calcular el costo total de la estancia
6 costo = precio_noche*noches
7 # Imprimir el monto total que debe cobrar el hotel al huésped
8 print("El monto total que debe cobrar el hotel al huésped es", costo,"soles")
38.4 Ejecucion

39. P4-SeL14
Realice un algoritmo que, con base en una calificación proporcionada (0-10), indique con letra
la calificación que le corresponde: 10 es “A”, 9 es “B”, 8 es “C”, 7 y 6 son “D”, y de 5 a 0 son “F”.
Represente el diagrama de flujo, el pseudocódigo y el diagrama N/S correspondiente.
39.1 Esquema
Figura 39.1: Esquema de SEL 14

164 Capítulo 39. P4-SeL14
39.2 Pseudocodigo
Algoritmo sel14
Escribir "Ingrese la nota:"
Leer n
Si n=10 Entonces
Escribir "La calificacion es A"
SiNo
Si n=9 Entonces
Escribir "La calificacion es B"
SiNo
Si n=8 Entonces
Escribir "La calificacion es C"
SiNo
Si n=7 Entonces
Escribir "La calificacion es D"
SiNo
Si n=6 Entonces
Escribir "La calificacion es E"
SiNo
Si n=5 Entonces
Escribir "La calificacion es F"
FinSi
FinSi
FinSi
FinSi
FinSi
FinSi
FinAlgoritmo
39.3 Codigo Fuente

1 n = int(input("Ingrese la nota: "))
2 if(n==10):
3 print("La calificacion es A")
4 else:
5 if(n==9):
6 print("La calificacion es B")
7 else:
8 if(n==8):
9 print("La calificacion es C")
10 else:
11 if(n==7):
12 print("La calificacion es D")
13 else:
14 if(n==6):
15 print("La calificacion es E")
16 else:
17 print("La calificacion es F")
39.4 Ejecucion

40. P5-SeL5
Se tiene el nombre y la edad de tres personas. Se desea saber el nombre y la edad de la persona
de menor edad. Realice el algoritmo correspondiente y represéntelo con un diagrama de flujo,
pseudocódigo y diagrama N/S.
40.1 Esquema

40.2 Pseudocodigo
Algoritmo sel14
Escribir "Ingrese la nota:"
Leer n
Si n=10 Entonces
Escribir "La calificacion es A"
SiNo
Si n=9 Entonces
Escribir "La calificacion es B"
SiNo
Si n=8 Entonces
Escribir "La calificacion es C"
SiNo
Si n=7 Entonces
Escribir "La calificacion es D"
SiNo
Si n=6 Entonces
Escribir "La calificacion es E"
SiNo
Si n=5 Entonces
Escribir "La calificacion es F"
FinSi
FinSi
FinSi
FinSi
FinSi
FinSi
FinAlgoritmo
168 Capítulo 40. P5-SeL5
40.3 Codigo Fuente

1 n1 = input("Ingrese el primer nombre: ")
2 e1 = int(input("Ingrese su edad: "))
3 n2 = input("Ingrese el segundo nombre: ")
5 n3 = input("Ingrese el tercer nombre: ")
7 if(e1<e2):
8 if(e1<e3):
9 print("El menor es",n1,"y tiene",e1,"años")
10 else:
11 print("El menor es",n3,"y tiene",e3,"años")
12 else:
13 if(e2<e3):
14 print("El menor es", n2, "y tiene", e2, "años")
15 else:
16 print("El menor es", n3, "y tiene", e3, "años")
40.4 Ejecucion

41. P6-Rep1
Un profesor tiene un salario inicial de $1500, y recibe un incremento de 10 % anual

durante 6 años. ¿Cuál es su salario al cabo de 6 años? ¿Qué salario ha recibido en cada uno
de los 6 años? Realice el algoritmo y represente la solución mediante el diagrama de flujo, el
pseudocódigo y el diagrama N/S, utilizando el ciclo apropiado.
41.1 Pseudocodigo
Algoritmo Rep1
Definir SalIni, incremento, años, SalAc Como Real
SalIni <- 1500
incremento <- 0.1
años <- 6
SalAc <- SalIni
Escribir "Salario al cabo de 6 años: ", SalAc
Escribir "Salario recibido en cada año:"
Para n <- 1 Hasta años Con Paso 1 Hacer
aumento <- SalAc * incremento
SalAc <- SalAc + aumento
Escribir "Año ", n, ": ", SalAc
Fin Para
FinAlgoritmo
41.2 Esquema
Figura 41.1: Esquema de Rep1

41.3 Codigo Fuente

1 SalIni = 1500
2 incremento = 0.1
3 años = 6
4 SalAc = SalIni
5 print("Salario al cabo de 6 años:", SalAc)
6 print("Salario recibido en cada año:")
7 for n in range(1, años+1):
8 aumento = SalAc * incremento
9 SalAc = SalAc + aumento
10 print(f"Año {n} : {SalAc:.2f}")
41.4 Ejecucion
Figura 41.2: Compilacion del codigo fuente Rep1

42. P7-Rep14
Realice un algoritmo para leer las calificaciones de N alumnos y determine el número de

aprobados y reprobados. Represéntelo mediante diagrama de flujo, pseudocódigo y diagrama
N/S.
42.1 Pseudocodigo
Algoritmo Notas
repetir
escribir "Ingrese la cantidad de Alumnos: "
leer n
si n no es entero entonces
escribir "Error detectado. Ingrese un número"
fin si
hasta que verdadero
d = 0
a = 0
para contador = 1 hasta n con paso 1 hacer

repetir
escribir "Ingrese la nota del alumno ", contador, ": "
leer N
si N no es entero entonces
escribir "Error detectado. Ingrese un número"
fin si
hasta que verdadero
si N < 10 entonces
d = d + 1
sino
a = a + 1
fin si
fin para
escribir "Hay ", a, " aprobados y ", d, " desaprobados"

FinAlgoritmo
42.2 Esquema
Figura 42.1: Esquema de Rep13

42.3 Codigo Fuente

1 while True:
2 try:
3 n=int(input("Ingrese la cantidad de Alumnos: "))
4 except:
5 print("Error detectado. Ingrese un numero")
6 else:
7 break
8
9 d=0
10 a=0
11 for contador in range(n):
12 while True:
13 try:
14 N= int(input(f"Ingrese la nota del alumno {contador+1}: "))
15 if(N<10):
16 d=d+1
17 else:
18 a=a+1 19
20 except:
21 print("Error detectado. Ingrese un numero")
22 else:
23 break
24
25 print(f"Hay {a} aprobados y {d} desaprobados")
42.4 Ejecucion

43. P8-Rep3
Se requiere un algoritmo para determinar, de N cantidades, cuántas son cero, cuántas son
menores a cero, y cuántas son mayores a cero. Realice el diagrama de flujo, el pseudocódigo y
el diagrama N/S para representarlo, utilizando el ciclo apropiado.
43.1 Pseudocodigo
Algoritmo Rep3
Definir n, neg, pos, cero Como Entero
Escribir "Ingrese la cantidad de numeros que evaluara: "
Leer n
neg <- 0
pos <- 0
cero <- 0
Para i <- 1 Hasta n Con Paso 1 Hacer
Escribir "Ingrese un numero: "
Leer N
Si N = 0 Entonces
cero <- cero + 1
Sino Si N < 0 Entonces
neg <- neg + 1
Sino
pos <- pos + 1
Fin Si
Fin Si
Fin Para
Escribir "Hay ", cero, " numeros iguales a 0, ", neg, " numeros menores a 0 y ",
,→ pos, " mayores a 0"
FinAlgoritmo
43.2 Esquema 177
43.2 Esquema

43.3 Codigo Fuente

1 n=int(input("Ingrese la cantidad de numeros que evaluara: "))
2 neg=0
3 pos=0
4 cero=0
5 for i in range(n):
6 N=int(input("Ingrese un numero: "))
7 if(N==0):
8 cero=cero+1
9 elif(N<0):
10 neg=neg+1
11 else:
12 pos=pos+1
13 print(f"Hay {cero} numeros iguales a 0, {neg} numeros menores a 0 y {pos} mayores a
,→ 0")
43.4 Ejecucion

44. P9-Arr13
Se tiene en un arreglo de cien elementos representando calificaciones de los estudiantes de

una escuela. Realice un algoritmo que lea el arreglo y calcule la calificación promedio del grupo,
además, que cuente los estudiantes que obtuvieron calificaciones arriba del promedio del grupo.
Represéntelo mediante diagrama de flujo, diagrama N/S y pseudocódigo.
44.1 Esquema

44.2 Pseudocodigo
Algoritmo Arr13
Definir calificaciones Como Arreglo de Enteros
Definir notas Como Arreglo de Enteros
Definir probabilidades Como Arreglo de Reales
Definir suma, con Como Entero
Definir n, i Como Entero
Definir promedio Como Real
notas <- [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
probabilidades <- [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9,
,→ 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9]
Para i <- 1 Hasta 100 Hacer
calificacion <- AleatorioElegido(notas, probabilidades)
AgregarElemento(calificaciones, calificacion)
Fin Para
suma <- 0
con <- 0
n <- Longitud(calificaciones)
Para i <- 1 Hasta n Hacer
suma <- suma + ObtenerElemento(calificaciones, i)
Fin Para
promedio <- suma / n

Para i <- 1 Hasta n Hacer
Si ObtenerElemento(calificaciones, i) > promedio Entonces
con <- con + 1
Fin Si
Fin Para
Escribir calificaciones
Escribir "Calificación promedio del grupo:", promedio
Escribir "Estudiantes con calificaciones por encima del promedio:", con
Fin Algoritmo
44.3 Codigo Fuente

1 import random
2 import numpy as np
3 calificaciones = []
4 # Se genera el arreglo con las 100 calificaciones pero se altera las probabilidaddes
,→ para que sea menos probable sacar entre 0 y 5 de nota
5 notas = np.arange(0,21,1)
6 probabilidades = [0.1] * 6 + [0.9] * 15
7 for i in range(100):
8 calificacion = random.choices(notas, weights=probabilidades)[0]
9 calificaciones.append(calificacion)
10 suma=0
11 con = 0
12 n=np.size(calificaciones)
14 suma = suma + calificaciones[i]
15 promedio = suma/n
17 if calificaciones[i] > promedio:
18 con = con+1
19 print(calificaciones)
20 print("Calificación promedio del grupo:", promedio)
21 print("Estudiantes con calificaciones por encima del promedio:", con)
44.4 Ejecucion
Figura 44.2: Compilacion del codigo fuente Arr13

45. P10-Arr4
Realice un algoritmo para obtener una matriz como el resultado de la resta de dos matrices de
orden M x N. Represéntelo mediante diagrama de flujo y pseudocódigo.
45.1 Pseudocodigo
Algoritmo Arr13
Escribir "Ingrese el numero de filas para las matrices "
Leer m
Escribir "Ingrese el numero de columnas para las matrices "
Leer n
Dimension M1(m,n)
Dimension M2(m,n)
Dimension M3(m,n)
Para f <- 1 Hasta m Hacer
Para c <- 1 Hasta n Hacer
Escribir "Ingrese el valor para la fila ", f, " y la columna ", c,
,→ " de la primera Matriz: "
Leer valor
valor = M1[f,c]
Fin Para
Fin Para
Escribir "La primera matriz es:"

Escribir M1[f,c]
Fin Para
Fin Para

Escribir "Ingrese el valor para la fila ", f, " y la columna ", c,
,→ " de la segunda Matriz: "
Leer M2[f,c]
Fin Para
Fin Para
Escribir "La segunda matriz es:"

Escribir M2[f,c]
Fin Para
Fin Para

M3[f,c] <- M2[f,c] - M1[f,c]
Fin Para
Fin Para
Escribir "La segunda matriz menos la primera matriz sale:"

Escribir M3[f,c]
Fin Para
Fin Para
Fin Algoritmo
45.2 Esquema
Figura 45.1: Esquema de Arr4

45.3 Codigo Fuente

1 import numpy as np
2 m=int(input("Ingrese el numero de filas de la matriz: "))
3 n=int(input("Ingrese el numero de columnas de la matriz: "))
4 M1=np.zeros((m,n))
5 M2=np.zeros((m,n))
6 for f in range(m):
7 for c in range(n):
8 M1[f][c]=int(input(f"Ingrese el valor para la fila {f} y la columna {c} de la
,→ primera Matriz: "))
9 print("La primera matriz es:")
10 print(M1)
11 for f in range(m):
12 for c in range(n):
13 M2[f][c]=int(input(f"Ingrese el valor para la fila {f} y la columna {c} de la
,→ segunda Matriz: "))
14 print("La segunda matriz es:")
15 print(M2)
16 M3=M2-M1
17 print("La segunda matriz menos la primera matriz sale")
18 print(M3)
45.4 Ejecucion
Figura 45.2: Compilacion del codigo fuente Arr4

VII
Nieto Castro, Henrry
46 P1-Sec6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
46.1 Pseudocodigo
46.4 Codigo Fuente
46. P1-Sec6
Se requiere determinar la hipotenusa de un triángulo rectángulo. ¿Cómo sería el diagrama

de flujo y el pseudocódigo que representen el algoritmo para obtenerla? Recuerde que por
Pitágoras se tiene que:
A2 + B2 = C 2
46.1 Pseudocodigo
Algoritmo SEC5
Leer A
Leer B
C = raíz_cuadrada(A^2 + B^2)
Mostrar C
FinAlgoritmo

46.4 Codigo Fuente
1 #Definir un valor por el precio de metro cuadrado
2 ppm2 = 100
3 # Pedir al usuario el precio por metro cuadrado y la cantidad de 4 metros cuadrados
5 m2 = int(input("Ingrese el numero de metros cuadrados a pintar: "))
6 # Calcular el precio a cobrar
7 p = ppm2*m2
8 # Imprimir el precio total del trabajo
9 print("Se debe cobrar:", p)
Compilacion:

VIII
Romero Reyes Angel
Fernando
47 P1 - Sec7 . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
47.1 Pseudocódigo
47.3 Diagrama N/S
47.4 Código fuente
48 P2 - Sec16 . . . . . . . . . . . . . . . . . . . . . . . . . 194
48.1 Pseudocódigo
48.3 Diagrama N/S
48.4 Código fuente
49 P3 - Sel7 . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
49.1 Pseudocódigo
49.3 Diagrama N/S
49.4 Código fuente
50 P4 - Sel16 . . . . . . . . . . . . . . . . . . . . . . . . . . 202
50.1 Pseudocódigo
50.3 Diagrama N/S
50.4 Código fuente
51 P5 - Sel20 . . . . . . . . . . . . . . . . . . . . . . . . . . 207
51.1 Pseudocódigo
51.3 Diagrama N/S
51.4 Código fuente
47. P1 - Sec7
La compañía de autobuses “La curva loca” requiere determinar el costo que tendrá
el boleto de un viaje sencillo, esto basado en los kilómetros por recorrer y en el costo por
kilómetro. Realice un diagrama de flujo y pseudocódigo que representen el algoritmo para tal
fin.
La tabla de variables:
Figura 47.1: Tabla de variables del ejercicio 1
47.1 Pseudocódigo
Figura 47.2: Pseudocódigo del ejercicio 1

192 Capítulo 47. P1 - Sec7
Figura 47.3: Diagrama de flujo del ejercicio 1
47.3 Diagrama N/S
Figura 47.4: Diagrama N/S del ejercicio 1
47.4 Código fuente

#Entrada de datos
N=int(input('Ingrese el numero de kilometros a recorrer: '))
C=int(input('Ingrese el costo por kilometro: '))
#Proceso
B=N*C
#Salida
print('El costo por boleto es: ',B)
Al compilar los códigos obtenemos:
Figura 47.5: Compilación de los códigos del ejercicio 1

48. P2 - Sec16
Realice pseudocódigo y diagrama de flujo que representen el algoritmo para preparar

una torta.
48.1 Pseudocódigo
48.3 Diagrama N/S

48.4 Código fuente

#Entrada de datos
Ha=int(input('Ingrese la cantidad de harina: '))
M=int(input('Ingrese la cantidad de manteca: '))
Hu=int(input('Ingrese la cantidad de huevo: '))
A=int(input('Ingrese la cantidad de azucar: '))
V=int(input('Ingrese la cantidad de vainilla: '))
#Proceso
M1=M+A
M2=M1+Hu
M3=M2+Ha+V
Molde=M3
#Salida
print('Al hornear tendrá un peso de : ',Molde)

49. P3 - Sel7
El presidente de la república ha decidido estimular a todos los estudiantes de una univer-

sidad mediante la asignación de becas mensuales, para esto se tomarán en consideración los
siguientes criterios: Para alumnos mayores de 18 años con promedio mayor o igual a 9, la beca
será de 2000.00; con promedio mayor o igual a 7.5, de 1000.00; para los promedios menores de
7.5 pero mayores o iguales a 6.0, de 500.00; a los demás se les enviará una carta de invitación
incitándolos a que estudien más en el próximo ciclo escolar. A los alumnos de 18 años o
menores de esta edad, con promedios mayores o iguales a 9, se les dará 3000; con promedios
menores a 9 pero mayores o iguales a 8, 2000; para los alumnos con promedios menores a 8
pero mayores o iguales a 6, se les dará 100, y a los alumnos que tengan promedios menores a
6 se les enviará carta de invitación. Realice el algoritmo correspondiente y represéntelo con
un diagrama de flujo.
49.1 Pseudocódigo
Figura 49.2: Pseudocódigo del ejercicio 3 parte 1

Figura 49.3: Pseudocódigo del ejercicio 3 parte 2

49.3 Diagrama N/S
49.4 Código fuente

#Entrada
E=int(input('Ingrese la edad: '))
N=float(input('Ingrese la nota: '))
#Proceso
if E>18:
if N>=9:
B=2000
elif N>=7.5:
B=1000
elif N>=6:
B=500
else:
B=0
else:
if N>=9:
B=3000
elif N>=6:
B=100
else:
B=0
#Salida
if B>0:
print('El estudiante recibirá una beca de ',B)
else:
print('Estudie más el próximo ciclo escolar')
Figura 49.6: Compilación de los códigos del ejercicio 3, parte 1

50. P4 - Sel16
Ejercicio 3.16 El secretario de educación ha decidido otorgar un bono por desempeño a

todos los profesores con base en la puntuación siguiente:
Realice un algoritmo que permita determine el monto de bono que percibirá un profesor
(debe capturar el valor del salario mínimo y los puntos del profesor). Represente el algoritmo
mediante el diagrama de flujo, el pseudocódigo y el diagrama N/S.
203

50.1 Pseudocódigo


50.3 Diagrama N/S
50.4 Código fuente

#Entrada
Pu=int(input('Ingrese la cantidad de puntos: '))
#Proceso/Salida
if Pu>150:
print('El profesor percibirá 3 salario mínimos')
elif Pu>100:
print('El profesor percibirá 2 salario mínimos')
else:
print('El profesor percibirá 1 salario')

51. P5 - Sel20
Realice un algoritmo para resolver el siguiente problema: una fábrica de pantalones desea
calcular cuál es el precio final de venta y cuánto ganará por los N pantalones que produzca
con el corte de alguno de sus modelos, para esto se cuenta con la siguiente información:
a) Tiene dos modelos A y B, tallas 30, 32 y 36 para ambos modelos.
b) Para el modelo A se utiliza 1.50 m de tela, y para el B 1.80 m.
c) Al modelo A se le carga 80 por ciento del costo de la tela, por mano de obra. Al modelo B se
le carga 95 por ciento del costo de la tela, por el mismo concepto.
d) A las tallas 32 y 36 se les carga 4 por ciento del costo generado por mano de obra y tela, sin
importar el modelo.
e) Cuando se realiza el corte para fabricar una prenda sólo se hace de un solo modelo y una
sola talla.
f) Finalmente, a la suma de estos costos se les carga 30 por ciento, que representa la ganancia
extra de la tienda

51.1 Pseudocódigo


51.3 Diagrama N/S

51.4 Código fuente

#Entrada
M=str(input('Ingrese el modelo (A o B): '))
T=int(input('Ingrese la talla (30, 32 o 36: '))
N=int(input('Ingrese el numero de pantalones: '))
C=float(input('Ingrese el precio por metro de tela: '))
#Proceso
if M=="A":
PT = 1.5 * C
MO = 0.8 * PT
else:
PT = 1.8 * C
MO = 0.95 * PT
P1 = PT + MO
if T==30:
P2 = P1
else:
P2 = 1.04 * PT
PF = 1.3 * P2
G = N * (PF-PT)
#Salida
print('El precio final de venta será ', PF)
print("La ganancia por la venta de "+str(N)+"
pantalones será "+str(G))

52 P1 - Sec8 . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
52.1 Pseudocódigo
52.3 Diagrama N/S
52.4 Código fuente
IX
Pelaez Angulo
53 P2 - Sec17
Alvaro Ivan . . . . . . . . . . . . . . . . . . . . . . . . . 216
53.1 Pseudocódigo
53.3 Diagrama N/S
53.4 Código fuente
54 P3 - Sel21 . . . . . . . . . . . . . . . . . . . . . . . . . . 219
54.1 Pseudocódigo
54.3 Diagrama N/S
54.4 Código fuente
55 P4 - Sel17 . . . . . . . . . . . . . . . . . . . . . . . . . . 223
55.1 Pseudocódigo
55.3 Diagrama N/S
55.4 Código fuente
56 P5 - Sel8 . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
56.1 Pseudocódigo
56.3 Diagrama N/S
56.4 Código fuente
57 P6 - Rep4 . . . . . . . . . . . . . . . . . . . . . . . . . . 232
57.1 Pseudocódigo
57.3 Diagrama N/S
57.4 Código fuente
58 P7 - Rep17 . . . . . . . . . . . . . . . . . . . . . . . . . 237
58.1 Pseudocódigo
58.3 Diagrama N/S
58.4 Código fuente
59 P8 - Arr21 . . . . . . . . . . . . . . . . . . . . . . . . . . 240
59.1 Pseudocódigo
59.3 Diagrama N/S
59.4 Código fuente
60 P9 - Arr17 . . . . . . . . . . . . . . . . . . . . . . . . . . 244
60.1 Pseudocódigo
60.3 Diagrama N/S
60.4 Código fuente
61 P10 - Arr8 . . . . . . . . . . . . . . . . . . . . . . . . . . 249

61.1 Pseudocódigo
61.3 Diagrama N/S
61.4 Código fuente
52. P1 - Sec8
Se requiere determinar el tiempo que tarda una persona en llegar de una ciudad a otra en
bicicleta, considerando que lleva una velocidad constante. Realice un diagrama de flujo y
pseudocódigo que representen el algoritmo para tal fin.
Para la resolución de este problema se utilizaron las siguientes variables:
v: Velocidad constante
d: Distancia entre ciudades
Tiempo: Tiempo del recorrido
52.1 Pseudocódigo
Figura 52.1: Pseudocódigo para determinar el tiempo de recorrido

Figura 52.2: Diagrama de flujo para determinar el tiempo de recorrido
52.3 Diagrama N/S
Figura 52.3: Diagrama N/S para determinar el tiempo de recorrido
52.4 Código fuente

Uilizando funciones se realizó el siguiente código:
v= 0
d= 0
Tiempo= 0
def pedirDatos(msg):
t=float(input(msg))
return t
def datos(a,b,c):
print("Velocidad de la persona:",a,"m/s")
print("Distancia entre ciudades:", b, "m")
print("Tiempo que demora:", c, "s")
v=pedirDatos("Ingrese la velocidad de la persona en m/s: ")
d=pedirDatos("Ingrese la distancia entre las ciudades en metros: ")

Tiempo=round(d/v,2)
print("")
datos(v,d,Tiempo)
Figura 52.4: Codificacion del problema 8 en Python

53. P2 - Sec17
Realice pseudocódigo y diagrama de flujo que representen el algoritmo para confeccionar

una prenda de vestir.
Diseño: Diseño de la prenda

Medidas: Medidas del usuario
Tela: Tipo de tela de la prenda
53.1 Pseudocódigo
Figura 53.1: Pseudocódigo para confeccionar una prenda de vestir

Figura 53.2: Diagrama de flujo para confeccionar una prenda de vestir
53.3 Diagrama N/S
Figura 53.3: Diagrama N/S para confeccionar una prenda de vestir

53.4 Código fuente

t=str(input(msg))
return t
def datos(msg1, msg2, msg3):
print("El diseño a utilizar es:",msg1)
print("Las medidas deberán ser:", msg2)
print("La tela de la prenda debe ser:", msg3)
Diseño=pedirDatos("Ingrese el diseño: ")
Medidas=pedirDatos("Ingrese las medidas: ")
Tela=pedirDatos("Ingrese el tipo de tela: ")
print("")
datos(Diseño,Medidas,Tela)
print("Cortando las piezas de",Tela,"segun el diseño de",Diseño)
print("Ensamblando las piezas con maquina de coser...")
print("Probando la prenda en el usuario...")

54. P3 - Sel21
El banco “Bandido de peluche” desea calcular para uno de sus clientes el saldo actual, el pago
mínimo y el pago para no generar intereses. Los datos que se conocen son: saldo anterior
del cliente, monto de las compras que realizó y el pago que depositó en el corte anterior.
Para calcular el pago mínimo se debe considerar 15 % del saldo actual, y para no generar
intereses corresponde 85 % del saldo actual, considerando que este saldo debe incluir 12 %
de los intereses causados por no realizar el pago mínimo y $200 por multa por el mismo
motivo. Realice el algoritmo correspondiente y represéntelo mediante el diagrama de flujo y
pseudocódigo.
saldoActual: Saldo actual del cliente

pagoMinimo: Pago mínimo del cliente
pagoNoIntereses: Pago para no generar intereses
saldoAnterior: Saldo anterior del cliente
montoCompras: Monto de las compras que realizó
pagoCorteAnterior: Pago que depositó en el corte anterior
pagoMinimoAnterior: Pago mínimo anterior del cliente
54.1 Pseudocódigo
Figura 54.1: Pseudocódigo para determinar el saldo actual y el pago mínimo de los clientes
Figura 54.2: Diagrama de flujo para determinar el saldo actual y el pago mínimo de los clientes
54.3 Diagrama N/S
Figura 54.3: Diagrama N/S para determinar el saldo actual, el pago mínimo y el pago para no
generar intereses de los clientes
54.4 Código fuente

class Cliente():
persona=0
saldoAnterior = 0
montoCompras= 0
pagoCorteAnterior= 0
saldoActual=0
pagoMinimo=0
pagoNoIntereses=0
def informacion(self):
mensaje1= ("El saldo actual de la persona {} es de ${}")
print(mensaje1.format(self.persona,self.saldoActual))
mensaje2 = ("El pago minimo es de ${}")
print(mensaje2.format(self.pagoMinimo))
mensaje3 = ("El pago para no generar intereses es de ${}")
print(mensaje3.format(self.pagoNoIntereses))
def calculoPagos(self):
temp=input("Ingrese el saldo anterior del cliente: ")
self.saldoAnterior=int(temp)
temp1 = input("Ingrese el monto de las compras que realizó el cliente: ")
self.montoCompras = int(temp1)
temp2 = input("Ingrese el pago que depositó el cliente en el corte anterior: ")
self.pagoCorteAnterior = int(temp2)
pagoMinimoAnterior=0.15*self.saldoAnterior
if self.pagoCorteAnterior>=pagoMinimoAnterior:
self.saldoActual = self.saldoAnterior + self.montoCompras -
,→ self.pagoCorteAnterior
print("")
print("No se le aplicarán impuestos al cliente")
else:
self.saldoActual = self.saldoAnterior + self.montoCompras -
,→ self.pagoCorteAnterior + 0.12*self.saldoAnterior + 200
print("")
print("Se le aplicarán impuestos al cliente")
self.pagoMinimo=0.15*self.saldoActual
self.pagoNoIntereses=0.85*self.saldoActual
self.informacion()
cliente1= Cliente()
cliente1.persona=1
cliente1.calculoPagos()
print("")
cliente2= Cliente()
cliente2.persona=2
cliente2.calculoPagos()

55. P4 - Sel17
Realice un algoritmo y represéntelo mediante el diagrama de flujo, el pseudocódigo y el

diagrama N/S que permitan determinar qué paquete se puede comprar una persona con el
dinero que recibirá en diciembre, considerando lo siguiente:
Paquete A. Si recibe $50,000 o más se comprará una televisión, un modular, tres pares
de zapatos, cinco camisas y cinco pantalones.
Paquete B. Si recibe menos de $50,000 pero más (o igual) de $20,000, se comprará una
grabadora, tres pares de zapatos, cinco camisas y cinco pantalones.
Paquete C. Si recibe menos de $20,000 pero más (o igual) de $10,000, se comprará dos
pares de zapatos, tres camisas y tres pantalones.
Paquete D. Si recibe menos de $10,000, se tendrá que conformar con un par de zapatos,
dos camisas y dos pantalones.
dinero: Dinero recibido en diciembre

paqueteA: Contenido del paquete A
paqueteB: Contenido del paquete B
paqueteC: Contenido del paquete C
paqueteD: Contenido del paquete D
paquete: Paquete que puede comprar
55.1 Pseudocódigo
Figura 55.1: Pseudocódigo para determinar qué paquete se puede comprar una persona
Figura 55.2: Diagrama de flujo para determinar qué paquete se puede comprar una persona
55.3 Diagrama N/S
Figura 55.3: Diagrama N/S para determinar qué paquete se puede comprar una persona
55.4 Código fuente

class Paquetes():
persona=0
dinero = 0
paqueteA="Una television, un modular, tres pares de zapatos, cinco camisas y cinco
,→ pantalones."
paqueteB="Una grabadora, tres pares de zapatos, cinco camisas y cinco pantalones."
paqueteC="Dos pares de zapatos, tres camisas y tres pantalones."
paqueteD="Un par de zapatos, dos camisas y dos pantalones."
paquete=" "
mensaje1= ("El dinero de la persona {} es de ${}")
print(mensaje1.format(self.persona,self.dinero))
def calculoPaquete(self):
temp=input("Ingrese el dinero recibido de la persona: ")
self.dinero=int(temp)
if self.dinero>=50000:
self.paquete=self.paqueteA
elif self.dinero>=20000:
self.paquete=self.paqueteB
elif self.dinero>=10000:
self.paquete = self.paqueteC
else:
self.paquete = self.paqueteD
self.informacion()
mensaje3 = ("Con lo cual podrá comprar: {}")
print(mensaje3.format(self.paquete))
persona1= Paquetes()
persona1.persona=1
persona1.calculoPaquete()
persona2.persona=2
persona3.persona=3
Figura 55.4: Codificacion del problema 17 usando POO en Python

56. P5 - Sel8
Cierta empresa proporciona un bono mensual a sus trabajadores, el cual puede ser por su
antigüedad o bien por el monto de su sueldo (el que sea mayor), de la siguiente forma: Cuando
la antigüedad es mayor a 2 años, pero menor a 5, se otorga 20 % de su sueldo; cuando es de 5
años o más, 30 %. Ahora bien, el bono por concepto de sueldo, si éste es menor a $1000, se da
25 % de éste, cuando éste es mayor a $1000, pero menor o igual a $3500, se otorga 15 % de
su sueldo, para más de $3500. 10 %. Realice el algoritmo correspondiente para calcular los
dos tipos de bono, asignando el mayor, y represéntelo con un diagrama de flujo y pseudocódigo.
antiguedad: Antigüedad del trabajor

sueldo: Sueldo del trabajador
bonoAntiguedad: Bono por antigüedad
bonoSueldo: Bono por sueldo
bono: Mayor de los dos bonos
56.1 Pseudocódigo
Figura 56.1: Pseudocódigo para calcular y asignar los bonos de los trabajadores

Figura 56.2: Diagrama de flujo para calcular y asignar los bonos de los trabajadores
56.3 Diagrama N/S
Figura 56.3: Diagrama N/S para calcular y asignar los bonos de los trabajadores
56.4 Código fuente

class Bonos():
trabajador = 0
antiguedad=0
sueldo=0
bonoAntiguedad=0
bonoSueldo=0
bono=0
mensaje1= ("Para el trabajador {}:")
print(mensaje1.format(self.trabajador))
mensaje2 = ("* Tiene una antiguedad de {} año(s)")
print(mensaje2.format(self.antiguedad))
mensaje3=("* Tiene un sueldo de: ${}")
print(mensaje3.format(self.sueldo))
def calculoBono(self):
temp=input("Ingrese la antiguedad: ")
self.antiguedad=int(temp)
temp1 = input("Ingrese el sueldo: ")
self.sueldo = int(temp1)
if self.antiguedad<2:
self.bonoAntiguedad=0
elif self.antiguedad<5:
self.bonoAntiguedad=0.2*self.sueldo
else:
self.bonoAntiguedad = 0.3 * self.sueldo
if self.sueldo<1000:
self.bonoSueldo=0.25*self.sueldo
elif self.antiguedad<=3500:
self.bonoSueldo=0.15*self.sueldo
else:
self.bonoSueldo = 0.1 * self.sueldo
if self.bonoAntiguedad>self.bonoSueldo:
self.bono=self.bonoAntiguedad
else:
self.bono=self.bonoSueldo
self.informacion()
mensaje3 = ("* Tiene un bono de: ${}")
print(mensaje3.format(self.bono))
trabajador1= Bonos()
trabajador1.trabajador=1
trabajador1.calculoBono()
Figura 56.4: Codificacion del problema 8 usando POO en Python

57. P6 - Rep4
Una compañía fabrica focos de colores (verdes, blancos y rojos). Se desea contabilizar, de
un lote de N focos, el número de focos de cada color que hay en existencia. Desarrolle un
algoritmo para determinar esto y represéntelo mediante el diagrama de flujo, el pseudocódigo
y el diagrama N/S, utilizando el ciclo apropiado.
N: Numero de focos
A: Matriz con los colores de cada foco del lote
i: Contador
verde: Numero de focos verdes
rojo: Numero de focos rojos
blanco: Numero de focos blancos
t: Valor ingresado del color del foco
57.1 Pseudocódigo
Figura 57.1: Pseudocódigo para determinar el número de focos de cada color

Figura 57.2: Diagrama de flujo para determinar el número de focos de cada color
57.3 Diagrama N/S
Figura 57.3: Diagrama N/S para determinar el número de focos de cada color que hay en existencia
57.4 Código fuente

N=int(input("Ingrese el valor de N: "))
A=[]
i=0
verde=0
blanco=0
rojo=0
while (i<N):
A.append(input("Ingrese el color del foco: "))
if A[i]=="verde":
verde=verde+1
elif A[i]=="blanco":
blanco=blanco+1
else:
rojo=rojo+1
i=i+1
print("La cantidad de focos verdes es:",verde)
print("La cantidad de focos blancos es:",blanco)
print("La cantidad de focos rojos es:",rojo)
Figura 57.4: Problema 4 en Python

58. P7 - Rep17
Realice un algoritmo para obtener la tabla de multiplicar de un entero K comenzando desde

el 1. Represéntelo mediante diagrama de flujo, pseudocódigo y diagrama N/S.

K: Numero entero a realizar la tabla de multiplicar
i: Contador
P: Producto
58.1 Pseudocódigo
Figura 58.1: Pseudocódigo para obtener la tabla de multiplicar de un entero K

Figura 58.2: Diagrama de flujo para obtener la tabla de multiplicar de un entero K
58.3 Diagrama N/S
Figura 58.3: Diagrama N/S para obtener la tabla de multiplicar de un entero K

58.4 Código fuente

K=0
i=1
P=0
def pedirEntero(msg):
t=int(input(msg))
return t
K=pedirEntero("Ingrese el valor de K: ")
while (i<=12):
P=i*K
print(K,"x",i,"=",P)
i=i+1

59. P8 - Arr21
Realice un algoritmo que a partir de la matriz del problema anterior encuentre cuántos
elementos tienen valor par y cuántos valores impares. Represéntelo mediante diagrama,
diagrama N/S y pseudocódigo.
59.1 Pseudocódigo
Figura 59.1: Pseudocódigo para calcular cuántos elementos tienen valor par e impar
Figura 59.2: Diagrama de flujo para calcular cuántos elementos tienen valor par y cuantos tienen
valor impar
59.3 Diagrama N/S

Figura 59.3: Diagrama N/S para calcular cuántos elementos tienen valor par y cuantos tienen valor
impar
59.4 Código fuente

import numpy as np
A=np.zeros((5,5))
for i in range(5):
t=int(input("Ingrese un numero: "))
A[i][i]=t
print("")
print("La matriz es:")
print(A)
print("")
P=1
for i in range(5):
P=P*A[i][i]
print("El producto de la diagonal principal es: ",P)
print("")
par=0
impar=0
for i in range(5):
if A[i][i]%2==0:
par=par+1
else:
impar=impar+1
print("Cantidad de numeros pares:",par)
print("Cantidad de numeros impares:",impar)

60. P9 - Arr17
Una compañía de transporte cuenta con cinco choferes, de los cuales se conoce: nombre, horas
trabajadas cada día de la semana (seis días) y sueldo por hora. Realice un algoritmo que:
Calcule el total de horas trabajadas a la semana para cada trabajador.
Calcule el sueldo semanal para cada uno de ellos.
Calcule el total que pagará la empresa.
Indique el nombre del trabajador que labora más horas el día lunes.
Imprima un reporte con todos los datos anteriores.
nombres: Matriz de los nombres de los 5 choferes

horasTrabajadas: Horas trabajadas cada día de la semana (seis días)
sueldo: Sueldo por hora
i,j: Contadores
S: Suma de las horas trabajadas a la semana
totalHoras: Matriz con el total de horas de cada chofer
sueldoSemanal: Matriz del sueldo semanal para cada uno de ellos
sueldoTotal: Total que pagará la empresa
q: Posición en donde se encuentra el nombre del chofer que trabaja más horas los lunes
M: El mayor numero de horas trabajada los lunes
60.1 Pseudocódigo
Figura 60.1: Pseudocódigo para imprimir el reporte de una compañía de transporte

Figura 60.2: Diagrama de flujo para imprimir el reporte de una compañía de transporte
60.3 Diagrama N/S

Figura 60.3: Diagrama N/S para imprimir el reporte de una compañía de transporte
60.4 Código fuente

import numpy as np
nombres=np.array(["Pedro", "Juan", "Carlos", "Jose", "Maria"])
print("Choferes:",nombres)
print("")
horasTrabajadas=np.array([[4,6,8,7,8,7],[7,8,8,8,6,6],[5,5,6,7,5,8],[8,5,8,7,7,7],[6,6,6,8,8,5]])
print("Total de horas trabajadas a la semana:")
totalHoras=np.zeros(5)
for i in range (5):

S=0
for j in range(6):
S=S+horasTrabajadas[i][j]
print("Para",nombres[i],": ",horasTrabajadas[i]," en total: ",S)
totalHoras[i]=S
print("")
sueldo=np.array([6,7,6,7,8])
print("Sueldo semanal:")
sueldoSemanal=np.zeros(5)
for i in range (5):
sueldoSemanal[i]=totalHoras[i]*sueldo[i]
print("Para",nombres[i],"con sueldo por hora",sueldo[i],": $",sueldoSemanal[i])
print("")
print("Total que pagará la empresa:")
sueldoTotal=np.zeros(5)
for i in range (5):
sueldoTotal[i]=sueldoSemanal[i]*4
print("Para",nombres[i],": $",sueldoTotal[i])
print("")
q=0
M=0
for i in range (5):
if horasTrabajadas[i][0]>M:
M=horasTrabajadas[i][0]
q=i
print("El que labora mas los lunes es:",nombres[q],"con:",M,"horas")
print("")

61. P10 - Arr8
Realice un algoritmo que lea un vector y a partir de él forme un segundo vector, de tal forma
que el primer elemento pase a ser el segundo, el segundo pase a ser el tercero, el último pase a
ser el primero, y así sucesivamente. Represéntelo mediante un diagrama de flujo.

n: Tamaño del vector
i,j: Contadores
A: Vector inicial
B: Vector final
61.1 Pseudocódigo
Figura 61.1: Pseudocódigo para mover elementos de un vector

Figura 61.2: Diagrama de flujo para mover elementos de un vector
61.3 Diagrama N/S
Figura 61.3: Diagrama N/S para mover elementos de un vector
61.4 Código fuente

import numpy as np
t=int(input(msg))
return t
n=pedirDatos("Ingrese el tamaño del vector: ")
A=np.zeros(n)
for i in range (n):
A[i]=pedirDatos("Ingrese el valor "+str(i+1)+": ")

print(A)
B=np.zeros(n)
B[0]=A[n-1]
for j in range (1,n):
B[j]=A[j-1]
print(B)

X
Espinoza Espiritu Hector Junior
62 Problema 1 . . . . . . . . . . . . . . . . . . . . . . . . 253
62.1 Pseudocódigo
62.3 Diagrama de NS
62.4 Codigo en Python
63 Problema 2 . . . . . . . . . . . . . . . . . . . . . . . . 255
63.1 Pseudocódigo
63.3 Diagrama de NS
64 Problema 3 . . . . . . . . . . . . . . . . . . . . . . . . 259
64.1 Pseudocódigo
64.3 Diagrama de NS
65 Problema 4 . . . . . . . . . . . . . . . . . . . . . . . . 261
65.1 Pseudocódigo
65.3 Diagrama de NS
66 Problema 5 . . . . . . . . . . . . . . . . . . . . . . . . 267
66.1 Pseudocódigo
66.3 Diagrama de NS
67 Problema 6 . . . . . . . . . . . . . . . . . . . . . . . . 269
67.1 Pseudocódigo
67.3 Diagrama de NS
68 Problema 7 . . . . . . . . . . . . . . . . . . . . . . . . 273
68.1 Pseudocódigo
68.3 Diagrama de NS
69 Problema 8 . . . . . . . . . . . . . . . . . . . . . . . . 276
69.1 Pseudocódigo
69.3 Diagrama de NS
62. Problema 1
2.9 Se requiere determinar el costo que tendrá realizar una llamada te¬lefónica con base en el
tiempo que dura la llamada y en el costo por minuto. Realice un diagrama de flujo y pseudocódigo
que represen¬ten el algoritmo para tal fin.
62.1 Pseudocódigo
Proceso CostoDeUnaLlamadaTelefonica
Escribir Sin Saltar Ïngresa el valor de costo por minuto:";
Leer costo por minuto;
Escribir Sin Saltar Ïngresa el valor de tiempo en minutos:";
Leer tiempo en minutos;
costo <- tiempo en minutos*costo por minuto;
Escribir "Valor de costo: ", costo;
FinProceso

254 Capítulo 62. Problema 1
62.3 Diagrama de NS

63. Problema 2
2.18 Realice pseudocódigo y diagrama de flujo que representen el algo¬ritmo para preparar un
pastel.
63.1 Pseudocódigo
Algoritmo torta
Repetir
Escribir "¿Que ingredientes necesitas para hacer tortas?"
Escribir "2 ½ tazas de harina, presiona (s) si lo tienes o (n) si no todavía"
Repetir
Leer Ingrediente1
Hasta Que Ingrediente1 = s o Ingrediente1 = n
Escribir "3 cucharadas de polvo para hornea, presiona (s) si lo tienes o (n) si no todavía"
Repetir
Leer Ingrediente2
Escribir "1/4 de cucharada de sal, presiona (s) si lo tienes o (n) si no todavía"
Repetir
Leer Ingrediente3
Escribir "1 1/4 taza de azúcar, presiona (s) si lo tienes o (n) si no todavía"
Repetir
Leer Ingrediente4
Escribir "1 taza de manteca, 10 huevos, 5 ¼ taza de leche y 1 ¼ taza de vainilla, presiona (s) si lo
tienes o (n) si no todavía"
Repetir
Leer Ingrediente5
Hasta Que Ingrediente1 = s y Ingrediente2 = s y Ingrediente3 = s y Ingrediente4 = s y Ingrediente5

=s
Repetir
Escribir .Antes de empezar precalienta el horno a 180 grados, presiona (s) si lo hiciste o (n) si no
todavía"
Repetir
Leer paso1
Hasta Que paso1 = s o paso1 = n
Escribir Çoge el molde para tortas o dos cacerolas redondas y pon grasa y harina en él, presiona (s)
si lo hiciste o (n) si no todavía"
Repetir
Leer paso2
Escribir .Ahora coge la harina, el polvo de hornear y sal y revuelvelo todo en un recipiente grande,
presiona (s) si lo hiciste o (n) si no todavía"
Repetir
Leer paso3
Escribir "Seguidamente, coge el azúcar, la manteca, los huevos, la leche y la vainilla en un recipiente
separado, y mezclalo todo, presiona (s) si lo hiciste o (n) si no todavía"
Repetir
Leer paso4
Escribir Çoge el primer recipiente con los productos secos y mezclalos con la ultima masa hecha.
Coge la batidora y mezcla a velocidad media unos 2 o 3 minutos las dos masas hasta que queden
homogénea, presiona (s) si lo hiciste o (n) si no todavía"
Repetir
Leer paso5
Hasta Que paso1 = s y paso2 = s y paso3 = s y paso4 = s y paso5 = s
Escribir Üna vez tenemos la mezcla, colocala en la cacerola reparada para hornear durante 25 ? 30
minutos, presiona (s) si lo hiciste o (n) si no todavía"
Repetir
Leer paso6
Escribir “Para saber si la torta esta lista, ¡utiliza un palillo y ubícalo en el centro de la torta si sale
limpio ya tienes la torta hecha!, presiona (s) si lo hiciste o (n) si no todavía"
Repetir
Leer paso7
Si paso7 = s Entonces
Escribir a tienes la torta hecha"
2
Fin Si
FinAlgoritmo

63.3 Diagrama de NS

64. Problema 3
3.18 Realice un algoritmo y represéntelo mediante el diagrama de flujo, el pseudocódigo y el

diagrama N/S que permitan determinar la can¬tidad del bono navideño que recibirá un empleado
de una tienda, considerando que si su antigüedad es mayor a cuatro años o su suel¬do es menor de
dos mil pesos, le corresponderá 25 porciento de su sueldo, y en caso contrario sólo le corresponderá
20 porciento de éste.
64.1 Pseudocódigo
Proceso BonoNavideno
Escribir Sin Saltar "Digitar el valor de sueldo:";
Leer sueldo;
Escribir Sin Saltar "Digitar el valor de antiguedad:";
Leer antiguedad;
Si antiguedad>4 O sueldo<2000 Entonces
bononavideno <- sueldo*0.25;
SiNo
bononavideno <- sueldo*0.2;
FinSi
Escribir "Bono navideno: ", bononavideno;
FinProceso
64.3 Diagrama de NS

65. Problema 4
3.9 Una compañía de seguros para autos ofrece dos tipos de póliza: co¬bertura amplia (A) y
daños a terceros (B). Para el plan A, la cuota base es de $ 1,200, y para el B, de $ 950. A ambos
planes se les carga 10 porciento del costo si la persona que conduce tiene por hábito beber alcohol,
5 porciento si utiliza lentes, 5 porciento si padece alguna enfermedad como de eficiencia cardiaca o
diabetes–, y si tiene más de 40 años, se le carga 20 porciento, de lo contrario sólo 10 porciento.
Todos estos cargos se realizan sobre el costo base. Realice diagrama de flujo y diagrama N/S que
represente el algoritmo para determinar cuánto le cuesta a una persona contratar una póliza.
65.1 Pseudocódigo
Proceso SeguroPorCoberturaAmpliaYDanosATerceros
Escribir Sin Saltar Ïngresa el valor de edad:";
Leer edad;
Escribir "Selecciona el valor de tipo de poliza.";
Escribir "1.- A cobertura amplia";
Escribir "2.- B daños a terceros";
Escribir Sin Saltar ":";
Repetir
Leer tipodepoliza;
Si tipodepoliza<1 O tipodepoliza>2 Entonces
Escribir Sin Saltar "Valor incorrecto. Ingrésalo nuevamente.: ";
FinSi
Hasta Que tipodepoliza>=1 Y tipodepoliza<=2;
Escribir "Selecciona el valor de toma alcohol.";
Escribir "1.- si";
Escribir "2.- no";
Repetir
Leer tomaalcohol;
Si tomaalcohol<1 O tomaalcohol>2 Entonces

FinSi
Hasta Que tomaalcohol>=1 Y tomaalcohol<=2;
Escribir "Selecciona el valor de utiliza lentes.";
Escribir "1.- si";
Escribir "2.- no";
Repetir
Leer utilizalentes;
Si utilizalentes<1 O utilizalentes>2 Entonces
FinSi
Hasta Que utilizalentes>=1 Y utilizalentes<=2;
Escribir "Selecciona el valor de padece enfermedad.";
Escribir "1.- si";
Escribir "2.- no";
Repetir
Leer padeceenfermedad; Si padeceenfermedad<1 O padeceenfermedad>2 Entonces
FinSi
Hasta Que padeceenfermedad>=1 Y padeceenfermedad<=2;
Si tipodepoliza = 1 Entonces
cuota <- 1200;
SiNo
cuota <- 950;
FinSi
cargos <- 0;
Si tomaalcohol = 1 Entonces
cargos <- cargos+cuota*0.1;
FinSi
Si utilizalentes = 1 Entonces
FinSi
Si padeceenfermedad = 1 Entonces
FinSi
Si edad>40 Entonces
SiNo
FinSi
costodelapoliza <- cuota+cargos;
Escribir "Valor de cargos: ", cargos;
Escribir "Valor de costo de la poliza: ", costodelapoliza;
Escribir "Valor de cuota: ", cuota;
FinProceso

65.3 Diagrama de NS

66. Problema 5
4.18 En 1961, una persona vendió las tierras de su abuelo al gobierno por la cantidad de $1500.
Suponga que esta persona ha colocado el dinero en una cuenta de ahorros que paga 15 % anual.
¿Cuánto vale ahora su inversión? P(1+i)n .Realiceunalgoritmoparaobtenerestevaloryrepresntelomediantediagramade
66.1 Pseudocódigo
Proceso TierrasVendidasEn1961
n = 2021-1961;
P = 1500.0;
i = 15.0/100.0;
ahorros <- P*(1.0+i)n ;
Escribir”ValordeP : ”, P;
Escribir”Valordeahorros : ”, ahorros;
Escribir”Valordei : ”, i;
Escribir”Valorden : ”, n;
FinProceso
66.3 Diagrama de NS

67. Problema 6
4.22 El banco “Bandido de peluche” desea calcular para cada uno de sus N clientes su saldo
actual, su pago mínimo y su pago para no generar intereses. Además, quiere calcular el monto de lo
que ganó por concepto interés con los clientes morosos. Los datos que se conocen de cada cliente
son: saldo anterior, monto de las compras que realizó y pago que depositó en el corte anterior. Para
calcular el pago mínimo se considera 15 % del saldo actual, y el pago para no generar intereses
corresponde a 85 % del saldo actual, considerando que el saldo actual debe incluir 12 % de los
intereses causados por no realizar el pago mínimo y $200 de multa por el mismo motivo. Realice el
algoritmo correspondiente y represéntelo mediante diagrama de flujo y pseudocódigo.
67.1 Pseudocódigo
Proceso BancoBandidoDePelucheDeNClientes
ganaciaporintereses <- 0;
Escribir Sin Saltar Ïngresa el valor de n:";
Leer n;
Para i<-1 Hasta n Con Paso 1 Hacer
Escribir "PROCESO ", i;
Escribir Sin Saltar Ïngresa el valor de compras realizadas:";
Leer comprasrealizadas;
Escribir Sin Saltar Ïngresa el valor de pago del corte anterior:";
Leer pagodelcorteanterior;
Escribir Sin Saltar Ïngresa el valor de saldo anterior:";
Leer saldoanterior;
Si saldoanterior*0.15>pagodelcorteanterior Entonces
intereses <- saldoanterior*0.12;
multa <- 200;
SiNo
intereses <- 0;
multa <- 0;
FinSi
saldoactual <- saldoanterior+comprasrealizadas-pagodelcorteanterior+intereses+multa;
pagominimo <- saldoactual*0.15;
pagoparanogenerarintereses <- saldoactual*0.85;
ganaciaporintereses <- ganaciaporintereses+intereses;
Escribir "Valor de intereses: ", intereses;
Escribir "Valor de multa: ", multa;
Escribir "Valor de pago minimo: ", pagominimo;
Escribir "Valor de pago para no generar intereses: ", pagoparanogenerarintereses;
Escribir "Valor de saldo actual: ", saldoactual;
Escribir ;
FinPara
Escribir "Valor de ganacia por intereses: ", ganaciaporintereses;
FinProceso

67.3 Diagrama de NS

68. Problema 7
5.18 Se tiene un arreglo de seis filas y ocho columnas y se sabe que se tiene un elemento
negativo. Realice un algoritmo que indique la posición que ese elemento ocupa en el arreglo (en la
fila y la columna en la que se encuentra ese elemento). Represéntelo mediante diagrama, diagra¬ma
N/S y pseudocódigo.
68.1 Pseudocódigo
Algoritmo detarea
definir x,matriz Como Entero
Dimension matriz[6,8]
a=1
para f = 1 Hasta 6 Con Paso 1 Hacer
para c = 1 Hasta 8 Con Paso 1 Hacer
Escribir Ïngresa un numero: ",a leer matriz(f,c)
a=a+1
FinPara
FinPara
Escribir matriz(f,c), Sin Saltar
FinPara
Escribir
FinPara
si matriz(f,c) <0 Entonces
Escribir .El numero negativo se encuentra en la Fila: ",f,çolumna: ",c
FinSi
FinPara
FinPara
FinAlgoritmo
68.3 Diagrama de NS

69. Problema 8
5.9 Se tiene un arreglo de 15 filas y 12 columnas. Realice un algoritmo que permita leer el
arreglo y que calcule y presente los resultados siguientes: El menor elemento del arreglo; la suma
de los elementos de las cinco primeras filas del arreglo; y el total de elementos negativos en las
co¬lumnas de la quinta a la nueve.
69.1 Pseudocódigo
Algoritmo detarea
Definir f,c,numeromenor,contador,matriz Como Entero
Definir suma Como Real
Dimension matriz[15,12]
matriz(f,c) = azar(100) +1
Escribir matriz(f,c)
FinPara
FinPara
numeromenor = 0
si f == 1 y c == 1 Entonces
numeromenor = matriz(f,c)
SiNo
si matriz(f,c) <numeromenor Entonces
numeromenor = matriz(f,c)
FinSi
FinSi
FinPara
FinPara
suma = 0
suma = suma + matriz(f,c)
FinPara
FinPara
contador = 0
si matriz(f,c) <0 Entonces
FinSi
FinPara
FinPara
Escribir .El menor elemento de la matriz es: ",numeromenor
Escribir "La suma de las 5 primeras filas es: ",suma
Escribir "Los numeros negativos de la columns 5 a la 9 es: ",contador
FinAlgoritmo

69.3 Diagrama de NS

L3 TD1 Grupo 3 BMA20 P FINAL

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

L3 TD1 Grupo 3 BMA20 P FINAL

Cargado por

Copyright:

Formatos disponibles

Universidad Nacional de Ingeniería

Facultad de Ingeniería Eléctrica y Electrónica

Profesor: Segundo Gamarra

BOOK - WEBSITE . COM

First printing, March 2013

I Datos del estudiante participante

II Torres Trigueros, Alfredo José Julian

III Gonzales Morales, Alexander Daniel

IV Veli Misayauri, Junior Edgar

24 P6- Rep21 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

25 P7- Rep12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

26 P8- Arr12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

27 P1- Sec4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

28 P2- Sec13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

29 P3- Sec22 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

30 P4- Sel13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

31 P5- Sel4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

VI Perez Lazo, Renzo Esteban

VII Nieto Castro, Henrry

VIII Romero Reyes Angel Fernando

IX Pelaez Angulo Alvaro Ivan

61 P10 - Arr8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

X Espinoza Espiritu Hector Junior

A19: Torres Trigueros, Alfredo José Julian - DNI: 72776930

Figura 1.1: Torres Trigueros (DNI).

A20: Gonzales Morales, Alexander Daniel - DNI: 47541507

Figura 1.2: Gonzales Morales (DNI).

A21: Veli Misayauri, Junior Edgar - DNI: 77152579

Figura 1.3: Veli Misayauri (DNI).

A22: Granados Pomalia, Geraldine Nicol - DNI: 75852117

Figura 1.4: Granados Pomalia (DNI).

A23: Perez Lazo, Renzo Esteban - DNI: 78334210

Figura 1.5: Perez Lazo (DNI).

A24: Nieto Castro, Henrry - DNI: 70120805

Figura 1.6: Gonzales Morales (DNI).

A25: Romero Reyes, Angel Fernando - DNI: 70860285

Figura 1.7: Romero Reyes (DNI).

A26: Pelaez Angulo, Alvaro Ivan - DNI: 73479927

Figura 1.8: Pelaez Angulo (DNI).

A27: Espinoza Espiritu, Hector Junior - DNI: 71279075

Figura 1.9: Gonzales Morales (DNI).

A19: Torres Trigueros, Alfredo José Julian - Código UNI: 20192606D

Figura 2.1: Torres Trigueros (CU).

A20: Gonzales Morales, Alexander Daniel - Código UNI: 20140374E

Figura 2.2: Gonzales Morales (CU).

A21: Veli Misayauri, Junior Edgar - Código UNI: 20191297H

Figura 2.3: Veli Misayauri (CU).

A22: Granados Pomalia, Geraldine Nicol - Código UNI: 20191277G

Figura 2.4: Granados Pomalia (CU).

A23: Perez Lazo, Renzo Esteban - Código UNI: 20191168C

Figura 2.5: Perez Lazo (CU).

A24: Nieto Castro, Henrry - Código UNI: 20181368J

Figura 2.6: Gonzales Morales (CU).

A25: Romero Reyes, Angel Fernando - Código UNI: 20200208I

Figura 2.7: Romero Reyes (CU).

A26: Pelaez Angulo, Alvaro Ivan - Código UNI: 20194516B

Figura 2.8: Pelaez Angulo (CU).

A27: Espinoza Espiritu, Hector Junior - Código UNI: 20191358G

Figura 2.9: Espinoza Espiritu (CU).

Realice un diagrama de flujo y pseudocódigo que representen el algoritmo para obtener

3.2 Diagrama de flujo

Figura 3.1: Diagrama de Flujo de SEC1

3.3 Diagrama de N/S