Algoritmos y Estructuras de Datos

LABORATORIO N° 02

Recursividad y Backtraking

DESARROLLO DE SOFTWARE Ing. Jaime Farfán

PROGRAMA DE FORMACIÓN REGULAR jfarfan@tecsup.edu.pe
 Laboratorio de Algoritmos y Estructuras de Datos
Página 2 de 4

CODIGO DEL CURSO:

Alumno(s) Nota

Alvarez Ccompi Diego Armando

Grupo B
Ciclo III
Fecha de entrega
 Laboratorio de Algoritmos y Estructuras de Datos
Página 1 de 4

I.- OBJETIVOS:
 Definir las reglas básicas a seguir para la construcción y la correcta interpretación de los Diagramas de
Flujo, resaltando las situaciones en que pueden, o deben, ser utilizados.
 Elaborar y Diseñar algoritmos con arreglos de una sola dimensión(unidimensional) denominada vectores

II.- SEGURIDAD:
Advertencia:
En este laboratorio está prohibida la manipulación del
hardware, conexiones eléctricas o de red; así como la
ingestión de alimentos o bebidas.

III.- FUNDAMENTO TEÓRICO:

 Revisar el texto guía que está en el campus Virtual.

IV.- NORMAS EMPLEADAS:

 No aplica

V.- RECURSOS:
 En este laboratorio cada alumno trabajará con un equipo con Windows 10.

VI.- METODOLOGÍA PARA EL DESARROLLO DE LA TAREA:

 El desarrollo del laboratorio es individual.

VII.- PROCEDIMIENTO:

EJERCICIO DE APLICACIÓN

1. Recursividad : Factorial

# Factorial function
def factorial(n):
if n == 0:
return 1
else:
return n*factorial(n-1)

# Using
if __name__ == "__main__":
print(factorial(3))

a.- Graficar el tiempo que demora en ejecutarse una función factorial para los valores de:
1,2,4,8,16,32,64,128,256,512,1024

b.- Implementar el diagrama de flujo

 Laboratorio de Algoritmos y Estructuras de Datos
Página 2 de 4

c.- Indicar sus apreciaciones

función llamada factorial que calcula el factorial de un número utilizando recursión. La función
verifica si el número es igual a cero; en ese caso, devuelve 1, de lo contrario, multiplica el
número por el factorial del número anterior. Además, en el bloque principal, imprime la
factorial de 3
d.- Evaluar si es posible aumentar el tamaño del stack.
Es posible aumentar el tamaño del stack en Python, pero esto puede variar dependiendo del
sistema operativo y del entorno en el que estés trabajando. En general, el tamaño del stack se
puede ajustar mediante configuraciones específicas del sistema operativo o del intérprete de
Python,

2. Recursividad : Torre de Hanoi

# Hanoi Function
def towersOfHanoi(numberOfDisks, src=1,
dest=3, tmp=2):
if numberOfDisks:
towersOfHanoi(numberOfDisks-1, src = src,
dest = tmp, tmp = dest)
#print("Move disk %d from peg %d to peg %d"
# % (numberOfDisks, src, dest))
towersOfHanoi(numberOfDisks-1, src = tmp,
dest = dest, tmp = src)

if __name__ == "__main__":
# Execute
towersOfHanoi(numberOfDisks=6)

a.-Expllicar como funciona el algoritmo

El algoritmo de la Torre de Hanoi resuelve el problema de mover una pila de discos de
tamaño decreciente de una varilla de origen a una varilla de destino, utilizando una varilla
temporal. La función towersOfHanoi implementa este algoritmo utilizando recursión. En cada
llamada recursiva, se mueven los discos más pequeños de la varilla de origen a la varilla
 Laboratorio de Algoritmos y Estructuras de Datos
Página 3 de 4

temporal, luego se mueve el disco más grande a la varilla de destino y finalmente se mueven
los discos más pequeños de la varilla temporal a la varilla de destino, utilizando la varilla de
origen como varilla temporal. Este proceso se repite hasta que todos los discos se han movido
a la varilla de destino.
b.-Grafique el tiempo que demora en resolverse una torre de Hanoi de :
1,2,3,4,5,6,7,8,9,10,11,12,13,14

c.- Indiques sus apreciaciones

El algoritmo de la Torre de Hanoi es un excelente ejemplo de cómo la recursividad puede utilizarse para resolver
problemas complejos de manera eficiente y elegante. A medida que aumenta el número de discos, el número de
movimientos requeridos sigue un patrón exponencial, lo que ilustra la eficiencia del algoritmo. Sin embargo, es
importante comprender que, aunque la recursión es poderosa, también puede tener limitaciones en términos de
uso excesivo de la memoria o tiempo de ejecución en problemas muy grandes.

3. Backtracking

# bitStrings Function
def bitStrings(n):
if n == 0: return []
if n == 1: return ["0", "1"]
return [ digit + bitstring
for digit in bitStrings(1)
for bitstring in bitStrings(n-1)]

if __name__ == "__main__":
# Excuting
print(bitStrings(3))

a.- Como funciona el algortimo

El algoritmo de bitStrings genera todas las posibles cadenas binarias de longitud n. Funciona
de manera recursiva, dividiendo el problema en casos base (cuando n es 0 o 1) y luego
combinando las cadenas binarias de longitud n-1 con cada dígito binario (0 y 1) para formar
todas las cadenas binarias de longitud n. Es un ejemplo claro de cómo la recursividad puede
utilizarse para resolver problemas de manera eficiente y elegante, generando todas las
combinaciones posibles de forma sistemática.
 Laboratorio de Algoritmos y Estructuras de Datos
Página 4 de 4

b.- Calcule el valor de biStrings para : 3,4,5,6

print(bitStrings(3))

print(bitStrings(4))

print(bitStrings(5))
['00000', '00001', '00010', '00011', '00100', '00101', '00110', '00111', '01000', '01001', '01010',
'01011', '01100', '01101', '01110', '01111', '10000', '10001', '10010', '10011', '10100', '10101',
'10110', '10111', '11000', '11001', '11010', '11011', '11100', '11101', '11110', '11111']
print(bitStrings(6))
['000000', '000001', '000010', '000011', '000100', '000101', '000110', '000111', '001000',
'001001', '001010', '001011', '001100', '001101', '001110', '001111', '010000', '010001',
'010010', '010011', '010100', '010101', '010110', '010111', '011000', '011001', '011010',
'011011', '011100', '011101', '011110', '011111', '100000', '100001', '100010', '100011',
'100100', '100101', '100110', '100111', '101000', '101001', '101010', '101011', '101100',
'101101', '101110', '101111', '110000', '110001', '110010', '110011', '110100', '110101',
'110110', '110111', '111000', '111001', '111010', '111011', '111100', '111101', '111110',
'111111']

c.- Indiques sus apreciaciones

El algoritmo bitStrings proporciona una forma eficiente de generar todas las posibles cadenas binarias de
longitud n, utilizando recursión para dividir el problema en subproblemas más simples. Al observar los resultados
para n = 3, 4, 5, 6, queda claro cómo el número de cadenas binarias crece exponencialmente con el aumento de
n, lo que demuestra la eficiencia del algoritmo. Esta función es un buen ejemplo de cómo la recursión puede ser
útil para generar combinaciones o permutaciones de manera sistemática.

CONCLUSIONES:
1. La recursividad es una técnica poderosa en la resolución de problemas algorítmicos. A
través de ejercicios prácticos como el cálculo factorial, la Torre de Hanoi y la generación de
cadenas binarias, podemos apreciar su eficacia para abordar problemas complejos de manera
estructurada y comprensible.
2. Al trabajar con recursividad, es fundamental comprender los principios subyacentes y
aplicarlos de manera apropiada en el diseño de algoritmos. Estos ejercicios nos permiten
fortalecer nuestra comprensión teórica y adquirir habilidades prácticas en la implementación
de algoritmos recursivos.
3. Sin embargo, es importante tener en cuenta las limitaciones y consideraciones prácticas al
utilizar la recursión. Debemos ser conscientes del consumo de recursos de memoria y el
tiempo de ejecución, y optimizar nuestros algoritmos en consecuencia para evitar problemas
de rendimiento en situaciones de grandes conjuntos de datos o problemas mal diseñados.