Práctica 10 - Estrategias para la

construcción de algoritmos I.
Las estrategias para la construcción de algoritmos I" se refiere a un área de estudio
dentro de la informática y la ciencia de la computación que se centra en enseñar
métodos y técnicas para diseñar algoritmos eficientes y efectivos

Divide y vencerás: Esta estrategia implica dividir un problema grande en subproblemas

más pequeños, resolver cada subproblema por separado y luego combinar las
soluciones para obtener la solución completa.
Programación dinámica: En lugar de resolver un problema desde el principio, la
programación dinámica resuelve subproblemas y almacena las soluciones para evitar
recalcularlas.
Greedy: Los algoritmos voraces toman decisiones localmente óptimas en cada etapa
con la esperanza de llegar a una solución global óptima.
Backtracking: Este enfoque se utiliza para resolver problemas de búsqueda y
optimización.
Algoritmos de fuerza bruta: Esta estrategia implica probar todas las posibles soluciones
a un problema y seleccionar la mejor.

import itertools

def generar_combinaciones():

letras = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

numeros = '0123456789'
 combinaciones = []

for combo in itertools.product(letras, repeat=3):

for numero in itertools.product(numeros, repeat=3):

placa = ''.join(combo) + '-' + ''.join(numero)

combinaciones.append(placa)

return combinaciones

combinaciones_de_placas = generar_combinaciones()

print(combinaciones_de_placas[:10])
import random

def bubble_sort(arr):

n = len(arr)

for i in range(n):

for j in range(0, n-i-1):

if arr[j] > arr[j+1]:

arr[j], arr[j+1] = arr[j+1], arr[j]

arreglo = [random.randint(1, 100000) for _ in range(100000)]

print("Arreglo antes de ordenar:")

print(arreglo[:10])

bubble_sort(arreglo)
print("\nArreglo después de ordenar:")

print(arreglo[:10])

import random

def quicksort(arr):

if len(arr) <= 1:

return arr

else:
 pivot = arr[0]

lesser = [x for x in arr[1:] if x <= pivot]

greater = [x for x in arr[1:] if x > pivot]

return quicksort(lesser) + [pivot] + quicksort(greater)

arreglo = [random.randint(1, 100000) for _ in range(100000)]

print("Arreglo antes de ordenar:")

print(arreglo[:10])

arreglo_ordenado = quicksort(arreglo)

print("\nArreglo después de ordenar:")

print(arreglo_ordenado[:10])
import random

import time

import matplotlib.pyplot as plt

def bubble_sort(arr):

n = len(arr)

for i in range(n):

for j in range(0, n-i-1):

if arr[j] > arr[j+1]:

arr[j], arr[j+1] = arr[j+1], arr[j]

def quicksort(arr):

if len(arr) <= 1:

return arr

else:

pivot = arr[0]

lesser = [x for x in arr[1:] if x <= pivot]

 greater = [x for x in arr[1:] if x > pivot]

return quicksort(lesser) + [pivot] + quicksort(greater)

def medir_tiempo_ejecucion(algoritmo, arreglo):

inicio = time.time()

algoritmo(arreglo)

fin = time.time()

return fin - inicio

tamaños = list(range(5000, 100001, 5000))

tiempos_bubble = []

tiempos_quicksort = []

for tamaño in tamaños:

arreglo_random = [random.randint(1, 100000) for _ in range(tamaño)]

tiempo_bubble = medir_tiempo_ejecucion(bubble_sort, arreglo_random.copy())

tiempos_bubble.append(tiempo_bubble)

tiempo_quicksort = medir_tiempo_ejecucion(quicksort, arreglo_random.copy())

tiempos_quicksort.append(tiempo_quicksort)

plt.plot(tamaños, tiempos_bubble, label='Bubble Sort')

plt.plot(tamaños, tiempos_quicksort, label='Quicksort')

plt.xlabel('Tamaño del arreglo')

plt.ylabel('Tiempo de ejecución (segundos)')

plt.title('Comparación de Tiempos de Ejecución')

plt.legend()

plt.show()
Las estrategias son herramientas fundamentales para alguien dedicado a la
computación o un ingeniero de software. Los programas se pudieron lograr, pero
debido al tamaño de los arreglos estos tardaron mucho, no fue posible presentar la
grafica debido a la falta de software.