Ejercicio 1 ¶
Nombre: Luis Fernando Apáez Álvarez
# SOLUCION
import numpy as np
# Le pedimos al usuario que ingrese los valores t1, t2, g1 y g2
print('Por favor introduzca los valores correspondientes a\n\
(t1, g1) y (t2, g2) referentes a las latitudes y longitudes \
de dicho puntos. ')
t1 = float(input('Ingrese el valor de t1: '))
g1 = float(input('Ingrese el valor de g1: '))
t2 = float(input('Ingrese el valor de t2: '))
g2 = float(input('Ingrese el valor de g2: '))
# Formamos dos listas con los valores que ingreso el usuario
pt1 = [t1, g1]
pt2 = [t2, g2]
# Creamos una funcion para convertir de grados a radianes
def conversor(grados) -> float:
return grados * (np.pi / 180)
# Creamos una funcion para calcular la distancia solicitada
def distancia_puntos(p1, p2):
# Convertimos a radianes los grados de las latitudes
# y longitudes
# t1 y g1:
p1[0] = conversor(p1[0])
p1[1] = conversor(p1[1])
# t2 y g2:
p2[0] = conversor(p2[0])
p2[1] = conversor(p2[1])
# Calculos
arg = (( np.sin(p1[0]) * np.sin(p2[0]) ) +
( np.cos(p1[0]) * np.cos(p2[0]) *
np.cos( p1[1] - p2[1]) ))
dist = 6371.01 * np.arccos(arg)
# Retornamos la distancia
return dist
# Regresamos al usuario la distancia de los puntos que ingreso
print(f"La distancia entre los puntos que \
ingresaste es de {distancia_puntos(pt1, pt2)} kms")
Por favor introduzca los valores correspondientes a (t1, g1) y (t2, g2) referentes a las latitudes y longitudes de dicho puntos. Ingrese el valor de t1: 19.005 Ingrese el valor de g1: 98.36 Ingrese el valor de t2: 18.36 Ingrese el valor de g2: 100.6 La distancia entre los puntos que ingresaste es de 246.6090793450189 kms
# SOLUCION
# Le pedimos al usuario que ingrese el numero correspondiente
# a la medida en pies
print('Por favor introduzca el número referente a \n\
la medida en pies ')
num_pies = float(input("Medida en pies: "))
# De pies a pulgadas
num_pulgadas = num_pies * 12
# De pies a yardas
num_yardas = num_pies * 0.33333
# De pies a millas
num_millas = num_pies * 0.000189
# De pies a centimetros
num_cm = num_pies * 30.48
# De pies a metros
num_m = num_pies * 0.3048
# De pies a kilometros
num_km = num_pies * 0.0003048
# Lista que guarda toda la informacion anterior
info_conver = [num_pulgadas, num_yardas, num_millas, num_cm, num_m, num_km]
medidas = ["Pulgadas", "Yardas", "Millas", "Centímetros", "Metros", "Kilómetros"]
# Regresamos la informacion anterior al usuario mediante una "tabla" (solo
# por cuestiones un poco esteticas)
guiones = "-" * 52
print(f"|{guiones}|")
print("|{:^52}|".format(f"# Pies: {num_pies}"))
print(f"|{guiones}|")
print("|{:^15}|{:^36}|".format("Medida", "Conversión"))
print(f"|{guiones}|")
# Recorremos la informacion de manera simultanea de las listas
# info_conver y medidas y se la mostramos al usuario
for i in range(len(info_conver)):
print("|{:^15}|{:^36}|".format(medidas[i], info_conver[i]))
print(f"|{guiones}|")
Por favor introduzca el número referente a la medida en pies Medida en pies: 10000 |----------------------------------------------------| | # Pies: 10000.0 | |----------------------------------------------------| | Medida | Conversión | |----------------------------------------------------| | Pulgadas | 120000.0 | |----------------------------------------------------| | Yardas | 3330.0 | |----------------------------------------------------| | Millas | 1.8900000000000001 | |----------------------------------------------------| | Centímetros | 304800.0 | |----------------------------------------------------| | Metros | 3048.0 | |----------------------------------------------------| | Kilómetros | 3.0479999999999996 | |----------------------------------------------------|
# SOLUCION
# Le pedimos al usuario que ingrese el numero de segundos
print('Por favor introduzca el número de segundos')
s = float(input("s: "))
# Primero calculamos el numero de dias:
# cociente obtenido de dividir s / 86400
# (1 dia = 86400 segundos)
# (dia_cociente = numero de dias)
dia_cociente = s // 86400
# (dia_resto: segundos sobrantes)
dia_resto = s % 86400
# A partir de dia_resto, calculamos las horas
# (1 hora = 3600 segundos)
# (hora_cociente = numero de horas)
hora_cociente = dia_resto // 3600
# (hora_resto: segundos sobrantes)
hora_resto = dia_resto % 3600
# A partir de hora_resto, calculamos los minutos
# (1 minuto = 60 segundos)
# (minuto_cociente = numero de minutos)
minuto_cociente = hora_resto // 60
# (minuto_resto: segundos sobrantes)
minuto_resto = hora_resto % 60
# A partir de minuto_resto, obtenemos los segundos que
# nos sobran
segundo_resto = minuto_resto
# Numero total de dias calculados (pasado a cadena de texto)
dia = str(int(dia_cociente))
hora = ""
minuto = ""
segundo = ""
# Numero total de horas calculadas (pasado a cadena de texto)
if (hora_cociente < 10):
hora = "0" + str(int(hora_cociente))
else:
hora = str(int(hora_cociente))
# Numero total de minutos calculados (pasado a cadena de texto)
if (minuto_cociente< 10):
minuto = "0" + str(int(minuto_cociente))
else:
minuto = str(int(minuto_cociente))
# Numero total de segundos restantes (pasado a cadena de texto)
if (segundo_resto < 10):
segundo = "0" + str(int(segundo_resto))
else:
segundo = str(int(segundo_resto))
# Mostramos el resultado requerido:
print(f"{dia} : {hora} : {minuto} : {segundo}")
Por favor introduzca el número de segundos s: 31536000 365 : 00 : 00 : 00
# SOLUCION:
# Le pedimos al usuario que ingrese los 5 numeros
print("Ingrese los 5 números separados por comas y sin espacios.\n\
Por ejemplo: 1,2,3,4,5 ó 4,6,7,2,4 etcétera")
valores_ini = input("Números: ").split(",")
# Convertimos las cadenas de texto a flotantes
valores = [float(i) for i in valores_ini]
# Lista auxiliar de 0 para ir colocando los elementos
# ordenados
valores_ordenados = [0.0 for i in range(5)]
# Detectamos el maximo y minimo de la lista <valores>
for j in valores:
lista_menores = []
lista_mayores = []
for i in valores:
# Para cada i separamos los numeros
# de <valores> que son:
# - Menores a i:
if j < i:
lista_mayores.append(i)
# - Mayores a i:
elif j > i:
lista_menores.append(i)
# Si en <valores> no hay nadie mayor a j
# entonces j es maximo
if len(lista_mayores) == 0:
maximo = j
# Si en <valores> no hay nadie menor a j
# entonces j es minimo
elif len(lista_menores) == 0:
minimo = j
# Asignamos la primera posicion al minimo y la ultima
# al maximo
valores_ordenados[0] = minimo
valores_ordenados[-1] = maximo
# Determinaremos la posicion del resto de numeros
# viendo cuantas veces ocurre que un numero dado
# es mayor a alguno otro. Por ejemplo, de la lista
# valores = [-3, 7, 3, 5, 10], para el numero 5
# tenemos que:
# 5 > -3
# 5 > 3
# Por lo cual el 5 ocupara la posicion de indice 2
# de la lista ordenada. El 3 ocupara la posicion de indice
# 1, etcetera.
for i in valores:
contador = 0
for j in valores:
# Contamos cuantas veces, un numero dado,
# es mayor al resto mediante
if i > j:
contador += 1
# Excluimos al minimo y al maximo porque ya los contemplamos
# antes
if contador != 0 and contador != len(valores):
valores_ordenados[contador] = i
# Si el usuario ingresa numeros repetidos entonces nuestra lista
# ordenada tendra al menos un cero. Por ejemplo, si consideramos
# la lista [5.0, 7.0, 7.0, 7.0, -3.0], entonces nuestra lista
# ordenada sera [-3.0, 5.0, 7.0, 0.0, 7.0]. De tal manera, siempre
# que tengamos ceros sera porque el usuario ingreso numeros repetidos.
# Para resolver lo anterior detectaremos los numeros repetidos
# Declaramos una lista auxiliar
auxiliar = []
# Lista que almacenara los numeros repetidos
repetidos = []
for i in valores:
if i not in auxiliar:
# Numeros no repetidos
auxiliar.append(i)
else:
# Numeros repetidos
repetidos.append(i)
# Dependiendo del numero de veces que se repite un numero
# actuaremos:
for i in range(len(valores_ordenados)):
# Cuando solo tenemos una numero repetido
if valores_ordenados[i] == 0.0 and len(repetidos) == 1:
# Lo colocamos en el lugar del cero que veamos
valores_ordenados[i] = repetidos[0]
# Cuando tenenemos dos numeros distintos repetidos
elif valores_ordenados[i] == 0.0 and len(repetidos) == 2:
# Si el primero es menor que el otro
if repetidos[0] < repetidos[1]:
# Colocamos al menor en el primero que veamos
valores_ordenados[i] = repetidos[0]
# Colocamos al mayor en la posicion simetrica
valores_ordenados[i+2] = repetidos[1]
# Si el primero es mayor que el otro
elif repetidos[0] > repetidos[1]:
# Colocamos al menor en el cero actual
valores_ordenados[i] = repetidos[1]
# Colocamos al mayor en la posicion simetrica
valores_ordenados[i+2] = repetidos[0]
# Cuando tenenemos dos numeros distintos repetidos y uno de
# ellos se repite una vez mas, por ejemplo [3,7,7,7,3], entonces
# uno en los numeros repetidos solo estaran el maximo y minimo
elif valores_ordenados[i] == 0.0 and len(repetidos) == 3:
# Contaremos cuantas veces se repite cada numero
count_max = 0
count_min = 0
for k in repetidos:
if k == maximo:
count_max += 1
else:
count_min += 1
# Si se repite dos veces:
if count_max == 2:
valores_ordenados[i] = minimo
valores_ordenados[i+2] = maximo
elif count_min == 2:
valores_ordenados[i] = minimo
valores_ordenados[i+1] = minimo
# Si se repite tres veces:
elif count_min == 3:
valores_ordenados[i] = minimo
valores_ordenados[i+1] = minimo
valores_ordenados[i+2] = minimo
elif count_max == 3:
valores_ordenados[i] = maximo
valores_ordenados[i+1] = maximo
valores_ordenados[i+2] = maximo
# Si solo la lista tiene numeros repetidos
elif len(repetidos) == 4:
valores_ordenados = valores_ini
# Si no tenemos repetidos no haremos nada
elif valores_ordenados[i] == 0.0 and len(repetidos) == 0:
continue
print(valores_ordenados)
Ingrese los 5 números separados por comas y sin espacios. Por ejemplo: 1,2,3,4,5 ó 4,6,7,2,4 etcétera Números: 0,0,-1,9,-2 [-2.0, -1.0, 0.0, 0.0, 9.0]
# SOLUCION
# Mensaje inicial al usuario
print("Conversor de años humanos a años perrunos")
num = float(input("Número de años (humanos): "))
# Variable auxiliar
resultado = 0
# Determinamos los anios perrunos
if num > 2.0:
resultado = 21 + 4 * (num - 2)
print(resultado)
elif (num <= 2.0) and (num >= 0.0):
resultado = num * 10.5
print(resultado)
else:
print("Error")
Conversor de años humanos a años perrunos Número de años (humanos): 11 57.0
# SOLUCION
# Le pedimos al usuario la informacion de su ecuacion
print("Bienvenido a la calculadora de raíces reales \
de una ecuación cuadrática")
a = float(input("Ingrese el valor de a: "))
b = float(input("Ingrese el valor de b: "))
c = float(input("Ingrese el valor de c: "))
# Calculo del discriminante
disc = (b ** 2) - (4 * a * c)
# Determinamos la naturaleza de las ecuaciones
if disc >= 0:
print("Las raíces son reales")
else:
print("Las raíces son complejas")
# Calculamos las raices reales
if disc == 0:
x1 = ( -b + (disc) ** 0.5 ) / (2 * a)
print(f"Tu ecuación tiene una solución real y es: {x1}")
elif disc > 0:
x1 = ( -b + (disc) ** 0.5 ) / (2 * a)
x2 = ( -b - (disc) ** 0.5 ) / (2 * a)
print(f"Tu ecuación tiene dos soluciones reales: x1={x1}, x2={x2}")
else:
# Como disc < 0 consideramos -disc
disc_pos = - disc
parte_real = - b / (2 * a)
parte_imaginaria = ( (disc_pos) ** 0.5 ) / (2 * a)
x1 = f"{parte_real} + ({parte_imaginaria})i"
x2 = f"{parte_real} + ({-parte_imaginaria})i"
print(f"Tu ecuación tiene dos soluciones complejas: x1={x1}, x2={x2}")
Bienvenido a la calculadora de raíces reales de una ecuación cuadrática Ingrese el valor de a: 1 Ingrese el valor de b: 2 Ingrese el valor de c: 2 Las raíces son complejas Tu ecuación tiene dos soluciones complejas: x1=-1.0 + (1.0)i, x2=-1.0 + (-1.0)i
# SOLUCION
# Le pedimos al usuario que ingrese la coleccion de numeros
print("Ingrese los números de su colección, separados por comas y sin espacios.\n\
Por ejemplo: 1,2,3,4,5 ó 4,6,-7,2,4,0,10 etcétera")
# Creamos una lista con los numeros que el usuario ingresara
col_numeros = input("Números: ").split(",")
# Convertimos las cadenas de texto a flotantes
col_numeros = [float(i) for i in col_numeros]
# Declaramos una variable auxiliar
suma = 0
# Sumaremos todos los numeros de la lista <col_numeros>
for i in col_numeros:
suma += i
# Calculamos el promedio
promedio = suma / len(col_numeros)
# Regresamos el promedio de los numeros de su coleccion al usuario
print(f"El promedio de la colección de números que ingresó es de: {promedio}")
Ingrese los números de su colección, separados por comas y sin espacios. Por ejemplo: 1,2,3,4,5 ó 4,6,-7,2,4,0,10 etcétera Números: 0,7,8,9,-5,2.5 El promedio de la colección de números que ingresó es de: 3.5833333333333335
# SOLUCION
# Le solicitamos al usuario el numero decimal
# a convertir a base tres
numero = int(input("Ingrese el número decimal a convertir: "))
# Variable auxiliar para almacenar el valor original que
# el usuario ingreso
n = numero
# Caso en que el numero ingresado es menor a 3
if (n < 3) and (n >= 0):
# Mostramos el numero en base tres
print(f"El número decimal {n} en base tres está dado por: {n}")
# Caso en que el numero ingresado es mayor o igual a 3
elif n >= 3:
# Creamos dos listas auxiliares:
# almacenara los resultados de estar dividiendo <numero>
# entre 3
cocientes = []
# almacenara los residuos
residuos = []
# A <numero> lo dividimos entre 3, a dicho resultado lo
# volvemos a asignar a <numero> y volvemos a dividir entre 3,
# y asi sucesivamente miestras que numero >= 3:
while numero >= 3:
# Agregamos los residuos resultantes
residuos.append(numero % 3)
# Reasignamos a <numero> el cociente obtenido de dividir
# <numero> entre 3
numero = numero // 3
# Agregamos los cocientes resultantes
cocientes.append(numero)
# Declaramos una variable auxiliar para ir "uniendo" los residuos
# obtenidos y el ultimo cociente
aux = str(cocientes[-1])
# Longitud de la lista residuos
long = len(residuos)
# Unimos de "derecha a izquierda" los residuos
for i in range(long):
aux += str(residuos[long - i - 1])
# Mostramos el numero en base tres
print(f"El número decimal {n} en base tres está dado por: {aux}")
else:
print("¡Error!")
Ingrese el número decimal a convertir: 1452 El número decimal 1452 en base tres está dado por: 1222210
# SOLUCION
# Le pedimos al usuario que ingrese el numero n correspondiente
# a la n-esima aproximacion
n = int(input("Ingrese el valor de n: "))
# La n-esima aproximacion correspondera a la k-esima posicion, donde
# 3: posicion 0
# 4 / 2 x 3 x 4: posicion 1, (4 / 2(1) x (2(1)+1) x (2(1)+2))
# -4 / 4 x 5 x 6: posicion 2 (4 / 2(2) x (2(2)+1) x (2(2)+2))
# k-esima posicion
k = n - 1
# Aproximacion inicial (1-esima aproximacion | 0-esima posicion)
suma = 3
# Variable auxiliar para determinar el signo
signo = 0
# Si el usuario quiere la 1-esima aproximacion
if n == 1:
print(f"La {n}-ésima aproximación al número pi es: {suma}")
# Si el usuario quiere la n-esima aproximacion (n>1)
elif n > 1:
while k > 0:
# Determinamos el signo del sumando
if k % 2 == 0:
signo = -1
else:
signo = 1
# Realizamos una suma en bucle
suma += (4 * signo) / ( (2 * k) * ((2 * k) + 1) * ((2 * k) + 2) )
# Restamos en uno a la k, es decir, recorremos los sumandos
# de la posicion n - 1 hasta la posicion 1
k -= 1
# Mensaje final al usuario
print(f"La {n}-ésima aproximación al número pi es: {suma}")
else:
print("¡Error! Ingresaste mal la información")
Ingrese el valor de n: 1000 La 1000-ésima aproximación al número pi es: 3.141592653839795
Solución:
Si el uso de ; para separar instrucciones es válido, la respuesta es:
import random as rd; n = 1000000; n_pares = [( 2 * rd.random() - 1, 2 * rd.random() -1 ) for i in range(n)]; print( ( 4 * len([par for par in n_pares if ((par[0] ** 2) + (par[1] ** 2) < 1)]) ) / n )
3.140516
Si no es válido, la respuesta sería:
import random as rd
n = 1000000
n_pares = [( 2 * rd.random() - 1, 2 * rd.random() -1 ) for i in range(n)]
print( ( 4 * len([par for par in n_pares if ((par[0] ** 2) + (par[1] ** 2) < 1)]) ) / n )