Universidad autónoma de México

Facultad de ciencias

Núñez Xospa Karim

320170458

Tarea 2B
1)

2)

def par(q):

if q & 1 == 0:

return "Verdadero"

else:

return "Falso"

3)

def maxmin(lista):

if len(lista) == 0:

return None

max_num = lista[0]

min_num = lista[0]

for num in lista:

if num > max_num:

max_num = num

if num < min_num:

min_num = num

return max_num, min_num

4)

def suma_impares(n):

suma = 0

for i in range(1, n, 2):

suma += i
 return suma

5)

def invertir_lista(lista):

return lista[::-1]

-Ejemplo:

numeros = [1, 2, 3, 4, 5]

inverted_nums = invertir_lista(numeros)

print("Lista original:", numeros)

print("Lista invertida:", inverted_nums)

6)

def son_distintos(lista):

if len(lista) == 0:

return False

elementos_unicos = set(lista)

return len(elementos_unicos) == len(lista)

Ejemplo:

numeros = [1, 2, 3, 4, 5]

resultado = son_distintos(numeros)

print("Los números de la lista son distintos entre sí:", resultado)

7)

def contar_vocales(cadena):

vocales = "aeiouAEIOU"

contador = 0

for caracter in cadena:

if caracter in vocales:

contador += 1
 return contador

cadena = input("Ingrese una cadena de caracteres: ")

num_vocales = contar_vocales(cadena)

print("El número de vocales en la cadena es:", num_vocales)

8)

def tasa_de_cambio(dolares):

tasa = 20.0 # Tasa de cambio dólar a peso mexicano

pesos = dolares * tasa

denominaciones = [1000, 500, 200, 100, 50, 20, 10, 5, 2, 1]

print("Cantidad de pesos mexicanos a recibir: ", pesos)

print("Desglose de billetes y monedas:")

for denominacion in denominaciones:

cantidad = int(pesos // denominacion)

if cantidad > 0:

print("{}: {}".format(denominacion, cantidad))

pesos -= cantidad * denominacion

dolares = float(input("Ingrese la cantidad de dólares a cambiar: "))

tasa_de_cambio(dolares)

9)

def numeros_mas_grandes(lista):

if len(lista) <= 10:

 return sorted(lista, reverse=True)

else:

return sorted(lista, reverse=True)[:10]

lista_numeros = [4, 7, 2, 9, 1, 5, 8, 3, 6, 10, 15, 12, 11, 13, 14]

numeros_mas_grandes = numeros_mas_grandes(lista_numeros)

print("Los 10 números más grandes son:", numeros_mas_grandes)

11)

def entero_mas_repetido(L):

frecuencias = {}

for num in L:

if num in frecuencias:

frecuencias[num] += 1

else:

frecuencias[num] = 1

entero_max_rep = None

repeticiones_max = 0

for num, repeticiones in frecuencias.items():

if repeticiones > repeticiones_max:

entero_max_rep = num

repeticiones_max = repeticiones

return entero_max_rep, repeticiones_max

-Ejemplo:

lista = [1, 2, 3, 2, 4, 2, 1, 3, 2, 4, 4, 1, 2]

entero, repeticiones = entero_mas_repetido(lista)

print("El entero que más se repite es:", entero)

print("Se repite", repeticiones, "veces")

12)

def numeros_distintos(R):

numeros_distintos = list(set(R))

return numeros_distintos

-Ejemplo:

lista = [1.5, 2.5, 3.5, 2.5, 4.5, 2.5, 1.5, 3.5, 2.5, 4.5, 4.5, 1.5, 2.5]

numeros = numeros_distintos(lista)

print("Números distintos:", numeros)

16)

def calcular_suma(valores):

suma = 0

for valor in valores:

suma += valor

return suma

valores1 = [321, 32540, 5782907]

valores2 = [321, 32540, 5782907]

suma_valores1 = calcular_suma(valores1)
suma_valores2 = calcular_suma(valores2)

print("La suma de los elementos de valores1 es:", suma_valores1)

print("La suma de los elementos de valores2 es:", suma_valores2)

17)

def generar_suma(valores):

suma = 0

for valor in valores:

suma += valor

yield suma

valores1 = [321, 32540, 5782907]

valores2 = [321, 32540, 5782907]

generador_valores1 = generar_suma(valores1)

generador_valores2 = generar_suma(valores2)

# Obtener el resultado de la suma para n = 5782907

resultado = None

for suma in generador_valores2:

resultado = suma

print("La suma de los elementos de valores2 es:", resultado)

18)

def evaluar_polinomio(coeficientes, x):

grado = len(coeficientes) - 1

resultado = 0

for i, coeficiente in enumerate(coeficientes):

resultado += coeficiente * (x ** (grado - i))

 return resultado

coeficientes = [128, 1344, 6048, 15120, 22680, 20412, 10206, 2187]

x = 2 # Valor de x para evaluar el polinomio

resultado = evaluar_polinomio(coeficientes, x)

print("El resultado de evaluar el polinomio en x =", x, "es:", resultado)

19)

import time

def evaluar_polinomio(coeficientes, x):

grado = len(coeficientes) - 1

resultado = 0

for i, coeficiente in enumerate(coeficientes):

resultado += coeficiente * (x ** (grado - i))

return resultado

coeficientes = [128, 1344, 6048, 15120, 22680, 20412, 10206, 2187]

n = 650

inicio = 1

fin = 20

tiempo_inicio = time.time()

for x in range(inicio, fin + 1):

resultado = evaluar_polinomio(coeficientes, x)

tiempo_fin = time.time()
tiempo_total = tiempo_fin - tiempo_inicio

print("Tiempo de ejecución:", tiempo_total, "segundos")

20)

def encontrar_maximo_recursivo(L, n):

if n == 1:

return L[0]

else:

maximo_restante = encontrar_maximo_recursivo(L, n - 1)

if L[n - 1] > maximo_restante:

return L[n - 1]

else:

return maximo_restante

-Ejemplo:

lista = [4, 9, 2, 7, 5]

tamaño = len(lista)

maximo = encontrar_maximo_recursivo(lista, tamaño)

print("El elemento más grande de la lista es:", maximo)

22)

Solución Iterativa:

def hanoi_iterativo(n, origen, auxiliar, destino):

# Determinar el número total de movimientos necesarios

total_movimientos = 2**n - 1

# Si el número de discos es par, intercambiar torres auxiliar y destino

if n % 2 == 0:

auxiliar, destino = destino, auxiliar

 for movimiento in range(1, total_movimientos + 1):

# Movimientos impares

if movimiento % 2 != 0:

mover_disco(origen, destino)

# Movimientos pares

else:

mover_disco(origen, auxiliar)

mover_disco(origen, destino)

mover_disco(auxiliar, destino)

def mover_disco(torre_origen, torre_destino):

print("Mover disco de", torre_origen, "a", torre_destino)

-Ejemplo:

n = 3 # Número de discos

hanoi_iterativo(n, 'A', 'B', 'C')

Solución Recursiva:

def hanoi_recursivo(n, origen, auxiliar, destino):

if n == 1:

mover_disco(origen, destino)

else:

hanoi_recursivo(n-1, origen, destino, auxiliar)

mover_disco(origen, destino)

hanoi_recursivo(n-1, auxiliar, origen, destino)

def mover_disco(torre_origen, torre_destino):

print("Mover disco de", torre_origen, "a", torre_destino)

-Emplo:

n = 3 # Número de discos

hanoi_recursivo(n, 'A', 'B', 'C')

23)

def obtener_numero_mas_grande(lista):

maximo = max(lista)

posicion = lista.index(maximo)

return maximo, posicion

def obtener_numero_mas_pequeno(lista):

minimo = min(lista)

posicion = lista.index(minimo)

return minimo, posicion

def obtener_suma(lista):

suma = sum(lista)

return suma

def obtener_promedio(lista):

suma = obtener_suma(lista)

promedio = suma / len(lista)

return promedio

def obtener_dato_mas_repetido(lista):

contador = {}

for dato in lista:

if dato in contador:
 contador[dato] += 1

else:

contador[dato] = 1

dato_mas_repetido = max(contador, key=contador.get)

return dato_mas_repetido

def obtener_lista_ordenada(lista):

lista_ordenada = sorted(lista)

return lista_ordenada

def verificar_dato_en_lista(lista, dato):

return dato in lista

def verificar_datos_repetidos(lista):

return len(lista) != len(set(lista))

def eliminar_ultimo_elemento(lista):

lista.pop()

def obtener_suma_datos_pares(lista):

suma_pares = sum(dato for dato in lista if dato % 2 == 0)

return suma_pares

24)

import math

# Calcula la norma p de un vector

def calcular_norma(vector, p):

suma = sum(abs(dato)**p for dato in vector)

norma = suma**(1/p)
 return norma

# Multiplica un escalar por un vector

def multiplicar_escalar(vector, escalar):

resultado = [escalar * dato for dato in vector]

return resultado

# Suma dos vectores

def sumar_vectores(vector1, vector2):

resultado = [dato1 + dato2 for dato1, dato2 in zip(vector1, vector2)]

return resultado

# Calcula el producto punto de dos vectores

def calcular_producto_punto(vector1, vector2):

resultado = sum(dato1 * dato2 for dato1, dato2 in zip(vector1, vector2))

return resultado

# Multiplica dos vectores componente a componente

def multiplicar_vectores(vector1, vector2):

resultado = [dato1 * dato2 for dato1, dato2 in zip(vector1, vector2)]

return resultado