Taller de Estructura Repetitivas y Arreglos.

Presentado por:
Alejandra Rodríguez Mogollón cod:537654
Juan Sebastián Garzón cod:537864
Camilo Escobar Leiva cod:302959
Isabela Méndez

Presentado a:
Ing. Fernando Gutiérrez P.

Universidad Cooperativa de Colombia, sede Ibagué

Herramientas computaciones para interpretación para resultados
Facultad de Ingeniería Civil
2019
 1. En un grupo N de registros, se tiene las notas de: Algoritmos, Herramientas Comp. Y Calculo
Multivariado, de cada uno de los estudiantes. Diseñe un programa que obtenga la nota
promedio de cada estudiante.
import numpy as np
sumadenotas = float(0.0)
promedionotas = float(0.0)
notasestudiantes= np.array([[5.0, 3.0, 4.0], [4.0, 2.0, 5.0], [4.0, 2.0, 2.0],[2.0, 5.0, 5.0]])

listaestudiantes= np.array(["Alejandra Rodriguez", "Sebastian Garzon", "Isabela Mendez","Camilo

Escobar" ])

for i in range(notasestudiantes.shape[0]):
sumadenotas = 0.0
for o in range(notasestudiantes.shape[1]):
sumadenotas += notasestudiantes[i,o]
promedionotas = sumadenotas/notasestudiantes.shape[1]
print(listaestudiantes[i], ": ", round( promedionotas, 2))

Solución:
Alejandra Rodriguez : 4.0
Sebastian Garzon : 3.67
Isabela Mendez : 2.67
Camilo Escobar : 4.0

2. Desarrolle un programa que lea tres registros, donde cada uno de ellos contenga las ordenas
y abscisas de tres puntos sobre el plano cartesiano e investigue si los tres puntos forman una
línea recta.
import math
i=o
for i in range(3):
if(i == 0):
print("1era coordenada")
a1 = float(input("x = "))
b1 = float(input("y = "))
print("")
else:
if(i == 1):
print("2da coordenada")
a2 = float(input("x = "))
b2 = float(input("y = "))
print("")
else:
print("3era coordenada")
a3 = float(input("x = "))
b3 = float(input("y = "))
print("")
ab = math.sqrt((a2-a1)**2+(b2-b1)**2)
bc = math.sqrt((a3-a2)**2+(b3-b2)**2)
abybc= ab + bc
ac =math.sqrt((b3-b1)**2+(b3-b1)**2)
if(abybc==ac):
print("Los puntos ingresados pasan por la misma línea")
else:
print("Lo sentimos: Los puntos ingresados no pasan por la misma línea")

solución:

1era coordenada
x=6
y=6

2da coordenada
x=6
y=6

3era coordenada
x=6
y=6

Los puntos ingresados pasan por la misma línea

3. Diseñe un programa que permita definir en un proyecto la cantidad de computadores nuevos

a adquirir, según el presupuesto establecido para esta compra. Explique su respuesta y diseñe
el programa.
presupuesto = int(input("Ingrese el presupuesto para la compra de computadores: "))
precioporpc = int(input("Ingrese el precio de un computador: "))
i=0
comprar = 0
cantidad = 0
for i in range(presupuesto):
comprar += precioporpc
if(comprar>presupuesto):
comprar = comprar - precioporpc
cantidad = comprar / precioporpc
print("Se pueden comprar", int(cantidad),"computadores")
break

Solución:

Ingrese el presupuesto para la compra de computadores: 5000000

Ingrese el precio de un computador: 300000
Se pueden comprar 16 computadores
 4. Varias volquetas de una escombrera recorren la ciudad llevando y recogiendo material,
cuando se recibe en la oficina de despacho la llamada de una obra, se informa a una volqueta
la ubicación de la obra para un servicio, mediante coordenadas, lo mismo que la ubicación
de todas las volquetas. La Oficina despacho es el punto (0,0) u origen de las coordenadas. Se
sabe que existe N volquetas en el servicio. Realice un programa que, dada la información
necesaria, informe las coordenadas de la volqueta más próxima al punto de una obra.

import numpy as np
import random
import math

i=0
o=0
p=0

distancia = 0
distanciamenor = 0
volquetas = np.array([[0, 0],
[0, 0],
[0, 0],
[0, 0],
[0, 0]])

while(i <= volquetas.shape[0]-1):

while(o <= volquetas.shape[1]-1):
volquetas[i,o] = random.randint(2,80)
o += 1
i += 1
o=0

i=0
o=0
while(i <= volquetas.shape[0]-1):
distancia = math.sqrt((volquetas[i, o]-0)**2+(volquetas[i, o+1]-0)**2)
if(i == 0):
distanciamenor = distancia
i += 1
else:
if(distancia < distanciamenor):
p=i
distanciamenor = distancia
distancia = 0
i += 1

i=0
o=0
while(i <= volquetas.shape[0]-1):
print("Volqueta", i+1, ": [", volquetas[i, o], ",", volquetas[i, o+1],"]")
i += 1

print("Volqueta más cerca: ", p+1)

Solución:

Volqueta 1: [ 25, 20]

Volqueta 2: [ 14, 41]
Volqueta 3: [ 73, 51]
Volqueta 4: [ 79, 23]
Volqueta 5: [ 43, 72]
Volqueta más cerca: 1

5. Se desea invertir una cantidad de dinero de manera que llegue a ser X pesos en Y años. Si la
tasa actual de interés es de R%, entonces la cantidad a invertir (el valor presente X) está dado
por la siguiente formula: X Div (1+0.01*R).

cifra = int(input("Digite la cifra que es necesaria: "))

años = int(input("En cuantos años: "))

i=0

while(i < años):

cifra = cifra/(1+0.01*10)
i +=1

print("Se deben invertir ", round(cifra))

Solución:

Digite la cifra que es necesaria: 7

En cuantos años: 23
Se deben invertir 1

6. Por cada uno de los N estudiantes de una Universidad, donde cada uno cursa 4 cursos se tiene
los siguientes datos: Código del estudiante: Numero de créditos de curso 1 y Nota Def;
Numero de créditos de curso 2; Nota Def; Numero de créditos de curso 3 y Nota Def; Numero
de créditos de curso 4 y Nota Def. Realizar un programa que halle para cada estudiante el
número de créditos cursados y el promedio de notas.

import numpy as np

estudiantes = np.array([[63411],
[34762],
[17439]])

curso1 = np.array([[4, 2.8],

[2, 4.5],
[3, 1.0]])

curso2 = np.array([[4, 4.5],

[2, 3.6],
[4, 3.9]])
curso3 = np.array([[2, 4.1],
[2, 2.5],
[4, 5.0]])

curso4 = np.array([[4, 3.9],

[3, 2.7],
[3, 1.1]])
i=0

print("Estudiante promedio de creditos vistos promedio de notas")

while(i <= estudiantes.shape[0]-1 ):
sumanotas = 0
acumulador = 0
promedion = 0
promedioc = 0

sumanotas = curso1[i,1] + curso2[i,1] + curso3[i,1] + curso4[i,1]

acumulador = curso1[i,0] + curso2[i,0] + curso3[i,0] + curso4[i,1]
promedion = round(sumanotas/4, 1)
promedioc = round(acumulador/4, 1)
print(estudiantes[i], " ", promedioc, " ", promedion)
i += 1

Solución:

Estudiante promedio de créditos vistos promedio de notas

[63411] 3.5 3.8
[34762] 2.2 3.3
[17439] 3.0 2.8

7. Un departamento de incorporación de Marina requiere conocer de una cantidad de notas de

sus cadetes, cuántos de ellos y quienes, tienen notas mayores o iguales a 10 y cuántos menores
de 5. ¿Qué solución propondría usted, utilizando la Estructura While True-Break, que le
permita a esta oficina obtener dichas estadísticas? Diseñe la interfaz gráfica.
import numpy as np

mayor = ""
menor = ""
i=0
condicion = True
cadetes= np.array([["Cadete 1", "11"],
["Cadete 2", "18"],
["Cadete 3", "24"],
["Cadete 4", "6"],
["Cadete 5", "8"],
["Cadete 6", "3"],
["Cadete 7", "12"],
["Cadete 8", "17"],
["Cadete 9", "10"],
 ["Cadete 10", "2"]])

while(condicion == True):
if(int(cadetes[i,1]) > 10):
mayor += cadetes[i,0] + ": " + cadetes[i,1] + "\n"
else:
if(int(cadetes[i,1]) < 5):
menor += cadetes[i,0] + ": " + cadetes[i,1] + "\n"

i += 1
if(i == cadetes.shape[0]):
break
print("Cadetes con nota mayor a 10: ")
print(mayor)
print("")
print("Cadetes con nota menor a 5: ")
print(menor)

solución:

Cadetes con nota mayor a 10:

Cadete 1: 11
Cadete 2: 18
Cadete 3: 24
Cadete 7: 12
Cadete 8: 17

Cadetes con nota menor a 5:

Cadete 6: 3
Cadete 10: 2

8. En la UCI tienen datos de registros de sus pacientes, entre ellos el código e información de
hermanos de los familiares. ¿Qué solución plantearía usando el ciclo repeat para conocer
cuántos pacientes a la fecha tienen hermanos y cuantos no tienen; calcule el promedio de
número de hermanos de los pacientes?

import numpy as np

condicion = True
Hermanos = 0
PromHermanos = 0
NoHermanos = 0
i=0
pacientes = np.array([[45, 6],
[32, 4],
[26, 12],
[14, 9],
[18, 8]])
while(condicion == True):
if(pacientes[i,1] >= 1):
Hermanos += 1
PromHermanos += pacientes[i,1]
if(i == pacientes.shape[0]-1):
break
i += 1
NoHermanos = pacientes.shape[0] - Hermanos
PromHermanos = PromHermanos/pacientes.shape[0]
print("UCI")
print("Pacientes con hermanos: ", Hermanos)
print("Pacientes sin hermanos: ", NoHermanos)
print("Promedio de hermanos por paciente: ", int(round(PromHermanos)))

solución:

UCI
Pacientes con hermanos: 5
Pacientes sin hermanos: 0
Promedio de hermanos por paciente: 8

9. Lea las coordenadas de u, v de la ubicación de una base Militar y las coordenadas x, y de n

Puesto de vigilancia. Encuentre cual es la distancia del puesto más alejado de la Base.

import numpy as np
import math

tam = int(input("Ingrese el numero de puestos de vigilancia a evaluar: "))

m=4
a = np.zeros((tam, m))
puesto = np.zeros_like(a)

distancia = 0
distanciamayor = 0
i=0
a=0

print("Ingrese la coordenada indicada de cada puesto de vigilancia \n")

for i in range(tam):

puesto[i,0] = int(input("x: "))

puesto[i,1] = int(input("y: "))

distancia = math.sqrt((puesto[i,0] - 0)**2+(puesto[i, 1]-0)**2)

if(distancia > distanciamayor):

distanciamayor = distancia
a = i+1
print("El puesto mas alejado de la base es el puesto ", a, "(", round(distanciamayor),"kmts)")

Solución:
Ingrese el número de puestos de vigilancia a evaluar: 2
Ingrese la coordenada indicada de cada puesto de vigilancia
x: 3
y: 2
x: 1
y: 5
El puesto más alejado de la base es el puesto 2 (5 kmts)

10. Se tienen una lista de las coordenadas x, y de n puntos en un plano. Lea sucesivamente las
coordenadas de cada punto y acumule las distancias del punto al origen. Muestre la
distancia total acumulada.
import numpy as np
import math

coordenadas = np.array ([[5, 2],

[7, 3],
[5, 5],
[6, 9],
[1, 8]])

distancias = 0
distanciasacum = 0
i=0
for i in range(coordenadas.shape[0]):
distancias = math.sqrt((coordenadas[i,0] - 0)**2+(coordenadas[i, 1]-0)**2)
distanciasacum += distancias
distancias = 0

print("La distancia acumulada es: ", round(distanciasacum, 1))

Solución:

La distancia acumulada es: 39.0

11. La plataforma de un transporte tiene capacidad para llevar hasta m kilos. Se tiene una lista
ordenada en forma creciente con el peso de n paquetes. Determine cuantos paquetes pueden
ser transportados. La elección debe hacerse comenzando con los paquetes de menor peso.
import numpy as np

condicion = True
opc = int(input("Ingrese el peso maximo que soporta el camión en toneladas: "))
vec = np.array([1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 4])
pesmax = 0
i=0
while(condicion == True):
pesmax += vec[i]
if(pesmax > opc):
pesmax = pesmax - vec[i]
print("El camión puede llevar: ", i, "paquetes")
condicion = False
i += 1

solución:

Ingrese el peso maximo que soporta el camión en toneladas: 10

El camión puede llevar: 6 paquetes
12. - Realizar un arreglo Bidimensional que permita obtener el valor de las ventas de
apartamentos en un Edificio, en una matriz de 12 ventas, donde sume las Columnas y
Filas; siendo las Filas el valor de las ventas en 4 días y las Columnas el valor de las 4
semanas.

import numpy as np

ventas = np.array([[70000000, 30000000, 60000000, 40000000],

[40000000, 30000000, 40000000, 80000000],
[30000000, 70000000, 30000000, 10000000],
[10000000, 40000000, 60000000, 20000000]])
i=0
for i in range(ventas.shape[0]):
condicion = True
o=0
suma = 0
while (condicion == True):
suma += ventas[i,o]
if(o+1 == ventas.shape[1]):
print("Dia ", i+1, ": ", suma)
condicion = False
o += 1

print("")
i=0
for i in range(ventas.shape[0]):
condicion = True
o=0
suma = 0
while (condicion == True):
suma += ventas[o,i]
if(o+1 == ventas.shape[1]):
print("Semana ", i+1, ": ", suma)
condicion = False
o += 1
 Solución:

Dia 1: 200000000
Dia 2: 190000000
Dia 3: 140000000
Dia 4: 130000000

Semana 1: 150000000
Semana 2: 170000000
Semana 3: 190000000
Semana 4: 150000000

13. Escriba un programa para controlar la cantidad de contenedores en un patio. Ingrese como dato
la cantidad inicial y ofrezca las siguientes opciones:
1. Salida de contenedores
2. Llegada de contenedores
3. Cantidad actual de contenedores
4. Terminar el control
En cada repetición el operador elige la opción ingresando el número y la cantidad de
contenedores.
tam = int(input("Ingrese el numero maximo de contenedores que caben en el parqueadero: "))
condicion = True

while(condicion == True):
opc = int(input("¿Que desea hacer?: \n 1). Registrar salida contenedores \n 2). Registrar entrada
contenedores \n 3). Ver cantidad de contenedores \n 4) Salir "))

if(opc == 1):
print("(Hay", tam," contenedores en el parqueadero)")
opc2 = int(input("¿Cuantos contenedores salieron?"))
tam = tam - opc2
else:
if(opc == 2):
print("(Hay", tam," contenedores en el parqueadero)")
opc2 = int(input("¿Cuantos contenedores ingresaron?"))
tam = tam + opc2
else:
if(opc == 3):
print("Hay", tam, "contenedores en el parqueadero")
else:
if(opc == 4):
break
Solución:

Ingrese el numero maximo de contenedores que caben en el parqueadero: 80

¿Que desea hacer?:
1). Registrar salida contenedores
2). Registrar entrada contenedores
3). Ver cantidad de contenedores
4) Salir 2
(Hay 80 contenedores en el parqueadero)
¿Cuantos contenedores ingresaron?56
¿Que desea hacer?:
1). Registrar salida contenedores
2). Registrar entrada contenedores
3). Ver cantidad de contenedores
4) Salir 1
(Hay 136 contenedores en el parqueadero)
¿Cuantos contenedores salieron?39
¿Que desea hacer?:
1). Registrar salida contenedores
2). Registrar entrada contenedores
3). Ver cantidad de contenedores
4) Salir 3
Hay 97 contenedores en el parqueadero