P3

March 21, 2025

1 P3
Esteban Escobar 11144332

[6]: # 1.Semáforo
x=int(input('Introduzca un número del 1 al 3.\n'))

if (x==1):
print('rojo')
elif (x==2):
print('amarillo')
elif(x==3):
print('verde')
else:
print('Se introdujo un caracter incorrecto.')

verde

[7]: # 2.triangulo rectangulo

import math

def calcular_hipotenusa(cateto1, cateto2):

return math.sqrt(cateto1**2 + cateto2**2) #teorema de pitagoras

[8]: # 3.Venta de tornillos

def calcular_precio(cajas):
precio = 0
if cajas < 100:
precio = 2
elif cajas>101 and cajas<200:
precio=1.5
else:
precio=1
return precio

ncajas=int(input('Introduzca el número de cajas que desea comprar.\n'))

1
 print(f'Al comprar {ncajas} cajas, el precio por caja es de␣
↪{calcular_precio(ncajas)}, lo que suma un total de␣

↪{calcular_precio(ncajas)*ncajas}.')

Al comprar 200 cajas, el precio por caja es de 1, lo que suma un total de 200.

[9]: # 4.Número de monedas

def calcular_monedas(monto):
if monto>=1 and monto<=100:
monedas_disponibles=[25,10,5,1]
monedas = []
for moneda in monedas_disponibles:
monedas.append(monto//moneda) #División entera
monto = monto % moneda #Residuo

return monedas
else:
return 'El monto debe estar entre 1 y 100.'

monto=int(input('Introduzca el monto.\n'))
calcular_monedas(monto)

[9]: [0, 0, 0, 4]

[10]: #5. Algoritmo de Heron de Alejandria

def algoritmo_heron(objetivo, valor_inicial, tolerancia):
x = valor_inicial
while abs(x**2 - objetivo) >= tolerancia: #Loop hasta alcanzar tolerancia␣
↪deseada

x = (x + objetivo/x) / 2
return x

algoritmo_heron(40, 6, 0.0001)

[10]: 6.324561403508772

[11]: # 6. Mayor entero impar

def mayor_entero_impar(l):
mayor = 0
for i in l:
if i%2!=0 and i>mayor: #Si es impar y mayor al actual
mayor = i

if mayor==0: #Si no hay impares

return -1
else:
return mayor

2
 l = [1,2,3,4,5,6,7,8,9,10]
mayor_entero_impar(l)

[11]: 9

[12]: #7. Factorial:

# Versión utilizando la instrucción for
def factorial_for(n):
factorial = 1
for i in range(1, n + 1):#Iteración de 1 a n
factorial *= i #Multiplicación acumulativa
return factorial

# Versión utilizando la instrucción while

def factorial_while(n):
factorial = 1
i = 1
while i <= n: #Iteración de 1 a n
factorial *= i #Multiplicación acumulativa
i += 1
return factorial

[13]: # 8. Multiplos de 3
#Con la instrucción for
def sumar_multiplos_de_3_for(vector):
suma = 0
for elemento in vector:
if elemento % 3 == 0:
suma += elemento
return suma

l=[21, 31, 48, 24, 85, 20, 23, 18, 23, 44]

print('usando for:',sumar_multiplos_de_3_for(l))

#Con filtrado de numpy

import numpy as np
def sumar_multiplos_de_3_numpy(vector):
return np.sum(np.array(vector)[np.array(vector) % 3 == 0])

l=[21, 31, 48, 24, 85, 20, 23, 18, 23, 44]

print('usando numpy:',sumar_multiplos_de_3_numpy(l))

usando for: 111

usando numpy: 111

3
[14]: #9. Sucesion de Fibonacci:
def fibonacci(n):
a, b = 0, 1
for i in range(n):
print(a, end=' ')
a, b = b, a + b

[15]: #10. El número pi

import math
def aproximacion_pi(tolerancia):
sum=0
i=1
while abs(math.sqrt(sum*16+8)-math.pi)>=tolerancia: #Loop hasta alcanzar␣
↪tolerancia deseada

sum+=1/(((2*i-1)**2)*(2*i+1)**2) #Suma acumulativa de la serie que␣

↪usaremos para aproximar pi

i+=1
return math.sqrt(sum*16+8)

aproximacion_pi(0.00001)

[15]: 3.141582761174048

[16]: #11. Cubos perfectos:

numero = int(input('Introduzca un número.\n'))
cubo_perfecto = False
i = 0

while i**3 <= numero: #Iteración hasta que el cubo sea mayor al número
if i**3 == numero: #Si el cubo es igual al número
cubo_perfecto = True
break
i += 1

if cubo_perfecto:
print(f'El número {numero} es un cubo perfecto.')
else:
print(f'El número {numero} no es un cubo perfecto.')

El número 2 no es un cubo perfecto.

[17]: #12. Muchos cubos perfectos:

def cuboPerfecto(n):
i = 0
cubos = []
while i**3 <= n: #Iteración hasta que el cubo sea mayor al número
cubos.append(i**3) #Añadir cubo a la lista

4
 i += 1
return cubos

l = np.arange(101)
cubos_perfectos = [x for x in l if x in cuboPerfecto(l[-1])]
print(cubos_perfectos)

[0, 1, 8, 27, 64]

[18]: # 13. Bisección

import math
def biseccion(f, a, b, n):
for i in range(1,n): #Iteración de 1 a n
if f(a)==0:
return a
elif f(b)==0:
return b
elif f(a)*f(b)<0: #Si hay cambio de signo en el intervalo
if f((a+b)/2)*f(b)<0:
a=(a+b)/2 #Nuevo intervalo
else:
b=(a+b)/2

else:
return 'No hay raices en ese intervalo.'

return (a+b)/2

f= lambda x: math.e**x-5*x #Función a evaluar

math.e**biseccion(f, 0, 2, 10)

[18]: 1.2966261542951754

[19]: #14. Numeros binarios a decimal:

def bin2dec(binario):
decimal = 0
for lugar, digito in enumerate(reversed(binario)): #Enumerar y revertir el␣
↪binario

decimal += int(digito) * (2 ** lugar) #Suma acumulativa de la␣

↪conversión a decimal

return decimal

bin2dec('10011')

[19]: 19

5
[20]: # 15. Numeros decimales a binario:

def dec2bin(decimal):
binario = ''
while decimal > 0: #Loop hasta que el decimal sea 0
binario = str(decimal % 2) + binario #Agregar el residuo al binario
decimal = decimal // 2 #División entera del decimal
return binario

dec2bin(19)

[20]: '10011'

[21]: #16. Probabilidad de fallo mecaanico

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

registro = np.random.choice([1, 2,0], size=100, p=[0.1, 0.05, 0.85]) #Generar␣

↪100 valores aleatorios con los valores y probabilidades dados

#Escribir en el documento
with open('datos.csv', 'w') as archivo:
for i, r in enumerate(registro, start=1):
archivo.write(f"{i},{r}\n")

df = pd.read_csv("datos.csv", names=['i', 'r']) #Leer el archivo

df['r'].value_counts().plot(kind='bar') #Graficar la frecuencia de los valores

[21]: <Axes: xlabel='r'>

6
[22]: #17. Ecuacion de estado de un gas:

import numpy as np
import matplotlib.pyplot as plt

# Constantes
a = 2.45e-2
b = 2e-7
k = 3.5e-3

# Variacion del volumen

v_values = np.linspace(10, 100, 500)

# Variacion de la temperatura
T_values = np.linspace(100, 600, 6)

plt.figure(figsize=(8, 6))

for T in T_values: #Iterar sobre los valores de temperatura generando las␣

↪gráfiacs

p_values = (k * T) / (v_values - b) - a / v_values**2

7
 plt.plot(v_values, p_values, label=f"T = {T:.0f}")

plt.xlabel("v")
plt.ylabel("p")
plt.title("grafico vp")
plt.legend()
plt.grid()
plt.show()

[23]: #18. Criba de Eratostenes:

#Vector con numeros del 1 al 1000

n = 1000
numeros = np.arange(1, n + 1) #Vector con numeros del 1 al 1000

#Criba de Eratostenes
for i in range(2,1000):
for k in range(1,int(1000/i)): #Iterar sobre los múltiplos de i
numeros[i+k*i-1]=0 #Marcar múltiplos como 0 en el array

8
 print(numeros[numeros!=0]) #Imprimir los números primos

[ 1 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59
61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149
151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241
251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353
359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461
463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587
593 599 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691
701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823
827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947
953 967 971 977 983 991 997]

[24]: #19. Lineas de campo de una carga puntual:

import numpy as np
import matplotlib.pyplot as plt

# Constante de Coulomb
k = 8.99e9

# Carga puntual en (0,0)

q = 1e-9

# Malla de puntos en la región fijada

x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)

# Componentes
Ex = k * q * X / (X**2 + Y**2)**(3/2)
Ey = k * q * Y / (X**2 + Y**2)**(3/2)

plt.figure(figsize=(8, 8))
plt.streamplot(X, Y, Ex, Ey, color='b', linewidth=1)
plt.scatter(0, 0, color='r', s=100) # Carga
plt.xlim(-5, 5)
plt.ylim(-5, 5)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Líneas del campo eléctrico creado por una carga puntual')
plt.grid()
plt.show()

9
10