Ejercicios de Programacin con las instrucciones bsicas

Para cada ejercicio escriba y pruebe un programa en la ventana de edicin de Python.

1.- Dados el radio y la altura de un cilindro, calcule el rea total y el volumen.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# Importando modulos
from math import*
# Entrada de Datos
radio = float(input("Ingrese el radio del cilindro: "))
altura = float(input("Ingrse la altura del cilindro: "))
# Calculo del area total
area_de_la_base = pi * pow(radio, 2)
area_lateral = (2 * pi * radio) * altura
area_total = area_de_la_base + area_lateral
# Calculo del Volumen
volumen = area_de_la_base * altura
# Salida de Resultados
print("El area total del cilindro es: ", area_total,
"\nEl volumen del cilindro es: ", volumen)

2.- Se tiene un recipiente cilndrico con capacidad en litros. Su altura es dada en metros. Determine el
dimetro de la base.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#Importando modulos
from math import *
# Entrada de Datos
capacidad_en_litros = float(input("Ingrese la capacidad del cilindro en litros: "))
altura = float(input("Ingrese la altura del cilindro en metros: "))
""" Calculo del diametro del cilindro
La capacidad hace referencia al volumen. La formula del volumen del cilindro es:
V = (PI*radio^2)* altura. El radio es igual al diametro dividido entre 2.
Replanteamos la formula usando el diametro.
V = (PI*(diametro/2)^2)* altura. Despejamos del diametro de la formula
(V / altura) = PI *(diametro/2)^2
(V / (PI *altura) = (diametro/2)^2
(diametro/2) = raiz cuadrada(V / (PI* altura))
diametro = (raiz cuadrada(V / (PI* altura))) * 2
Antes de aplicar la formula convertimos la capacidad en litros a metros cbicos
1Litro = 0.001 metros cubicos. Por lo tanto el factor de conversion es 0.001
"""
# Proceso
factor_conversion = 0.001

22
23
24
25
26
27
28

capacidad_en_metros_cubicos = capacidad_en_litros * factor_conversion

volumen = capacidad_en_metros_cubicos
diametro = (sqrt(volumen/(pi * altura))) * 2
# Salida de Resultados
print("El diametro del cilindro es: %5.3f" % diametro)

3.- Dadas las tres dimensiones de un bloque rectangular, calcule y muestre su rea total y su volumen.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# Entrada de Datos
print("Ingrese las dimensiones del bloque")
base = float(input("base: "))
altura = float(input("altura: "))
profundidad = float(input("profundidad: "))
# Calculo del Area Total
area_de_la_base = base * profundidad
area_cara_frontal = base * altura
area_cara_lateral_derecha = profundidad * altura
area_lateral = (2 * area_cara_frontal) + (2 * area_cara_lateral_derecha)
area_total = (2 * area_de_la_base) + area_lateral
# Calculo del Volumen
volumen = base * altura * profundidad
# Salida de Resultados
print("El area total del bloque es %5.2f.\n
El volumen del bloque es: %5.2f" % (area_total, volumen))

4.- El examen de una materia es el 70% de la nota total. Las lecciones constituyen el 20%, y las tareas el
10% de la nota total. Ingrese como datos la nota del examen calificado sobre 100 puntos, la nota de una
leccin calificada sobre 10 puntos, y las notas de tres tareas calificadas cada una sobre 10 puntos. Calcule
la calificacin total sobre 100 puntos.
1
2
3
4
5
6
7
8
9
10
11
12
13

# Entrada de Datos
examen = float(input("Ingrese la calificacion del examen(sobre 100 puntos): "))
leccion = float(input("Ingrese la calificacion de la leccion(sobre 10 puntos): "))
tarea1 = float(input("Ingrese la calificacion de la tarea 1(sobre 10 puntos): "))
tarea2 = float(input("Ingrese la calificacion de la tarea 2(sobre 10 puntos): "))
tarea3 = float(input("Ingrese la calificacion de la tarea 3(sobre 10 puntos): "))
"""
Regla de tres: Si 100 es al 100%, x es al 70% -> x = (70 * 100) / 100
x = Valor del examen sobre 100 puntos = 70
Ponderacion
Regla de tres: Si 100 es a 1, 70 es a x -> x = 70 /100
"""
ponderacion_examen = 70/100

14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

"""
Regla de tres: Si 100 es al 100%, x es al 20% -> x = (20 * 100) / 100
x = Valor de la leccion sobre 100 puntos = 20
Ponderacion
Regla de tres: Si 10 es a 1, 20 es a x -> x = 20 /10 = 2
"""
ponderacion_leccion = 2
"""
Valor de las tareas es igual al 10% de 100, es decir 10 puntos
Como las tareas son calificadas sobre 10 puntos, solo es necesario promediar
"""
# Calculo Calificacion Total
tareas_promedio = (tarea1 + tarea2 + tarea3) / 3
calificacion_total = (examen * ponderacion_examen) +
(leccion * ponderacion_leccion) + tareas_promedio
# Salida de Resultados
print("La calificacion total sobre 100 puntos es: %2.2f" % calificacion_total)

5.- Un ingeniero desea tener una cantidad de dlares acumulados en su cuenta de ahorros para su retiro
luego de una cantidad de aos de trabajo. Para este objetivo planea depositar un valor mensualmente.
Suponga que el banco acumula el capital mensualmente mediante la siguiente frmula:
(1 + ) 1
= [
]

En donde,
A = Valor acumulado
P = Valor de cada depsito mensual
n = Cantidad de depsitos mensuales
x = Tasa de inters mensual
Calcule el valor acumulado ingresando como datos valores para P, n, x.
1
# Entrada de Datos
2
P = float(input("Ingrese el valor para cada deposito mensual(dolares): "))
3
n = int(input("Ingrese la cantidad de depositos mensuales(entero): "))
4
x = float(input("Ingrese la tasa de interes mensual(en porcentaje): "))
5
x /= 100
6
7
# Calculo del valor acumulado
8
A = P * ((pow(1+x, n) - 1) / x)
9
10
# Salida de Resultados
11
print("El valor acumulado es de: %8.2f" % A)
12
6.- Lea la abscisa y ordenada de dos puntos P, Q en el plano: (a, b), (c, d). Estos puntos y el origen
conforman un tringulo. Calcule y encuentre el rea del tringulo.
Frmula de la distancia del punto P al punto Q: = (c a)2 + (d b)2
Frmula del rea del tringulo: = ( )( )( ) , t = (x+y+z)/2

x, y, z representan el valor de cada lado del tringulo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# Importando funcion sqrt del modulo math

from math import sqrt
# Entrada de Datos
Px = int(input("Ingrese la abscisa del punto P(entero): "))
Py = int(input("Ingrese la ordenada del punto P(entero): "))
Qx = int(input("Ingrese la abscisa del punto Q(entero): "))
Qy = int(input("Ingrese la abscisa del punto Q(entero): "))
origen_x = 0
origen_y = 0
# Calculo de los lados del triangulo
"""
x = Distancia del punto P al punto Q
y = Distancia del origen al punto P
z = Distancia del origen al punto Q
"""
x = sqrt(pow(Qx - Px, 2) + pow(Qy - Py, 2))
y = sqrt(pow(Px - origen_x, 2) + pow(Py - origen_y, 2))
z = sqrt(pow(Qx - origen_x, 2) + pow(Qy - origen_y, 2))
# Calculo del Semiperimetro
# t = Semiperimetro
t = (x+y+z) / 2
# Calculo del area del triangulo
# S = area_del_triangulo
area_del_triangulo = sqrt(t * (t-x) * (t-y) * (t-z))
# Salida de Resultados
print("El area del tringulo es %8.2f" % area_del_triangulo)

Ejercicios de Programacin con los operadores para aritmtica entera

Para cada ejercicio escriba y pruebe un programa en la ventana de edicin de Python.
1.- Dado un nmero entero (das), determine y muestre el equivalente en aos, meses y das sobrantes.
Por simplicidad suponga que un ao tiene 365 das y que cada mes tiene 30 das. Use los operadores // y
% para obtener cociente y residuo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Entrada de Datos
dias = int(input("Ingrese el numero de dias(entero): "))
equivalencia_anio_en_dias = 365
equivalencia_mes_en_dias = 30
# Calculo de equivalencia
numero_de_anios = dias // equivalencia_anio_en_dias
numero_de_meses = (dias % equivalencia_anio_en_dias) //
equivalencia_mes_en_dias
residuo_de_dias = (dias % equivalencia_anio_en_dias) % equivalencia_mes_en_dias
# Salida de Resultados
print(dias, "dias equivalen a", numero_de_anios, "anios", numero_de_meses,
"meses", residuo_de_dias, "dias")

2.- Lea dos nmeros de tres cifras cada uno. Sume la cifra central del primero con la cifra central del
segundo nmero y muestre el resultado.
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Entrada de Datos
numero1 = int(input("Ingrese un primer numero entero de tres cifras: "))
numero2 = int(input("Ingrese un segundo numero entero de tres cifras: "))
# Cifras Centrales
numero1_cifra_central = (numero1 // 10) % 10
numero2_cifra_central = (numero2 // 10) % 10
# Suma de cifras centrales
suma = numero1_cifra_central + numero2_cifra_central
# Salida de Resultados
print("La suma de las cifras centrales es: ", suma)

3.- Dado un nmero entero (cantidad de dlares), mostrar el valor equivalente usando la menor
cantidad de billetes de 100, 50, 20, 10, 5, 1.
1
2
3
4

# Entrada de Datos
dinero_en_dolares = int(input("Ingrese una cantidad de dinero en dolares(entero): "))
# Calculo de equivalencia en billetes de 100, 50, 20, 10, 5 y 1

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

billetes_de_100 = dinero_en_dolares // 100

billetes_de_50 = (dinero_en_dolares % 100) // 50
billetes_de_20 = ((dinero_en_dolares % 100) % 50) // 20
billetes_de_10 = (((dinero_en_dolares % 100) % 50) % 20) // 10
billetes_de_5 = ((((dinero_en_dolares % 100) % 50) % 20) % 10) // 5
billetes_de_1 = ((((dinero_en_dolares % 100) % 50) % 20) % 10) % 5
# Salida de Resultados
print("La cantidad de dinero en dolares es: ", dinero_en_dolares)
print("Y su equivalencia con el menor numero de billetes es: ")
print(billetes_de_100, "billetes de 100 que suman", billetes_de_100 * 100)
print(billetes_de_50, "billetes de 50 que suman", billetes_de_50 * 50)
print(billetes_de_20, "billetes de 20 que suman", billetes_de_20 * 20)
print(billetes_de_10, "billetes de 10 que suman", billetes_de_10 * 10)
print(billetes_de_5, "billetes de 5 que suman", billetes_de_5 * 5)
print(billetes_de_1, "billetes de 1 que suman", billetes_de_1)

Ejercicios de Programacin Algoritmos secuenciales y decisiones

1.- Encuentre todos los nmeros naturales entre 1 y 100 tales que la suma de sus dgitos d como
resultado un numero primo.
Ejemplo: 34: 3 + 4 = 7 debe mostrar el 34 pues 7 es un nmero primo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# Mensaje de Informacion
print("\n*** Programa que lista los numeros entre 1 y 100 tal que la suma de los ***\n"
"\t\t digitos de cada numero da como resultado un numero primo\n")
print('\t "Lista de numeros naturales enteros que cumplen con la condicion"\n')
print("\t\t\t\t Numero ---> Suma de sus Digitos\n")
# Algoritmo
for i in range(2, 101):
numero = i
suma_de_digitos = 0
# Bloque de Codigo que determina la suma de los digitos de un numero
while numero//10 != 0:
suma_de_digitos += numero % 10
numero //= 10
suma_de_digitos += numero % 10
if suma_de_digitos == 1:
Continue
residuo = 1
division = 2
while division < suma_de_digitos:
residuo = suma_de_digitos % divisin
if residuo == 0:
Break
division += 1
if residuo != 0:
print("\t\t\t\t\t %2d" % i, "\t\t\t\t\t%2d" % suma_de_digitos")