1.

Realizar el programa u algoritmo que determine todos los valores de m y n que

cumplen con la condición m^2+1232=3^n

import math

def find_values():

values = []

for m in range(100): # Considerando valores de m hasta 100

for n in range(100): # Considerando valores de n hasta 100

if math.pow(m, 2) + 1232 == math.pow(3, n):

values.append((m, n))

return values

result = find_values()

print(result)

2.

import math

def check_equality(x):

cos_x = math.cos(x)

cos_2x = math.cos(2*x)

cos_3x = math.cos(3*x)

equation_result = cos_x**2 + cos_2x**2 + cos_3x**2

return equation_result == 1

def find_values():

values = []

for x in range(0, 360): # Probando valores de x en el rango de 0 a 359 grados

x_radians = math.radians(x) # Convertir el valor de x a radianes

if check_equality(x_radians):

values.append(x)
 return values

result = find_values()

print(result)

3. Realizar el programa u algoritmo que ingrese dos fecha y muestre como resultados la
lista de sábados y domingo que hay entre esas dos fechas

import datetime

def find_weekend_days(start_date, end_date):

weekend_days = []
current_date = start_date

while current_date <= end_date:

if current_date.weekday() == 5: # 5 representa el sábado
weekend_days.append(current_date)
elif current_date.weekday() == 6: # 6 representa el domingo
weekend_days.append(current_date)

current_date += datetime.timedelta(days=1)

return weekend_days

# Pedir al usuario las fechas de inicio y fin en formato 'dd/mm/yyyy'

start_date_str = input("Ingrese la fecha de inicio (dd/mm/yyyy): ")
end_date_str = input("Ingrese la fecha de fin (dd/mm/yyyy): ")

# Convertir las cadenas de fecha en objetos de fecha

start_date = datetime.datetime.strptime(start_date_str, "%d/%m/%Y")
end_date = datetime.datetime.strptime(end_date_str, "%d/%m/%Y")

# Encontrar los días de fin de semana entre las fechas dadas

weekend_days = find_weekend_days(start_date, end_date)

# Imprimir los días de fin de semana encontrados

for day in weekend_days:
print(day.strftime("%d/%m/%Y"))
 4. Realizar el programa u algoritmo que genere la F y calcule el promedio de las
posiciones múltiplo de tres
x−2 x −1 x0 x1 x2
F= + + + + … .Solicitando los valores de
( 1 y−1 ) ! ( 1 y ) ! ( 2 y +2 ) ! ( 3 y +4 ) ! ( 5 y +7 ) !
"x", "y","n" donde n es el numero de fracciones

import math

def calcular_factorial(n):

if n == 0:

return 1

else:

return n * calcular_factorial(n-1)

def calcular_F(x, y, n):

F=0

count = 0

for i in range(n):

denominador = (i * 2 + 1) * y + (i * 2 + 1) + 1

factorial = calcular_factorial(i)

termino = (x ** i) / factorial * (x ** -i) / denominador

F += termino

if i % 3 == 0:

count += 1

promedio = F / count

return F, promedio

# Solicitar valores de x, y y n al usuario

x = float(input("Ingrese el valor de x: "))

y = float(input("Ingrese el valor de y: "))

n = int(input("Ingrese el número de fracciones (n): "))

resultado, promedio = calcular_F(x, y, n)

print("El valor de F es:", resultado)

print("El promedio de las posiciones múltiplo de tres es:", promedio)