Algoritmos y Estructuras de Datos

LABORATORIO N° 02

Recursividad y Backtraking

CODIGO DEL CURSO:

Alumno(s) Nota

MAMANI.MAMANI.renzo.junior

Grupo E
Ciclo III
Fecha de entrega

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 1 de 6

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
 Laboratorio de Algoritmos y Estructuras de Datos
Página 2 de 6

TIEMPO DE EJECUCION
0.0045

0.004

0.0035

0.003
SEGUNDOS

0.0025

0.002

0.0015

0.001

0.0005

0
1 2 4 8 16 32 64 128 256 512 1024
VALORES

b.- Implementar el diagrama de flujo

c.- Indicar sus apreciaciones

se puede observar que este código transforma un numero decimal en entero y si es entero lo
deja tal como esta redondeando el numero para que cumpla la condicion
d.- Evaluar si es posible aumentar el tamaño del stack.
Si es posible lo que necesitamos es aumentar la máxima profundidad de recursividad, en la
cual usaremos la función setrecursionlimit() para poder establecer el límite de recursividad, a
continuación mostraré los pasos a seguir:
1. Primero importamos sys
2. Si mostramos el límite de recursividad con “sys.getrecursionlimit()” podemos ver que
por defecto tiene 1000.
3. Luego usamos la función para establecer un nuevo límite de 3000 (opcional)
“sys.setrecursionlimit(3000)”
 Laboratorio de Algoritmos y Estructuras de Datos
Página 3 de 6

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 objetivo de este algoritmo consiste en tres torres con anillos ordenados de mayor a menor
tamaño, se deben pasar los anillos de la primera a la tercera torre y quedar en el mismo
orden. Los anillos siempre se deben ubicar de mayor a menor teniendo como base de la torre
el mayor anillo.
Designamos 3 parámetros:
- Número de discos (numberOfDisks)
- Origen (src), destino (dest)
- Una variable auxiliar (tmp).
Luego creamos un flujo “if” donde “numberOfDisks” es evaluado como True luego hace las
modificaciones en la función aplicada dentro de la misma función: numberOfDisks - 1, src =
src, dest = tmp, tmp = dest.
 Laboratorio de Algoritmos y Estructuras de Datos
Página 4 de 6

Después la función aplicada dentro de la misma función vuelve a tomar otros valores:
numberOfDisks - 1, src = tmp, dest = dest, tmp = src
Finalmente el flujo llegará en un momento en el cual “numberOfDisks” tome 0, por lo tanto ya
no se ejecuta el flujo, para así obtener la mínima cantidad de movimientos posibles para cierto
número de discos.

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

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

if n == 0: return [] Si en caso que no sea 0 se creará una lista.

if n == 1: return ["0", "1"] En caso que salga 1 nos retorna valores a una lista devolviendo
verdadero de una función, y si devuelve 0 en la función principal significa que el programa se
ejecutó correctamente
return [digit + bitstring for digit in bitStrings(1) for bitstring in bitStrings(n - 1)] haciéndolo
más simple y fácil de entender:
digit=x
bitstring =y
print([x + y for x in bitStrings(1) for y in bitStrings(n - 1)])
 Laboratorio de Algoritmos y Estructuras de Datos
Página 5 de 6

___________________________________________________________________________
________
print([x + y for x in [“0”,”1”]for yin [“0”,”1”]])
el resultado sería:

Este resultado nos da ya que sencillamente es un for de for.

en la manera tradicional sería:

para que se asemeja al resultado de queremos faltaria agregarle lista:

resultado:

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

if __name__ == "__main__":
Llama a la función asignando un número de acuerdo #a cada valor
print(bitStrings)
c.- Indiques sus apreciaciones
Con este código podemos ver cómo se crea una secuencia de combinaciones utilizando los
dos dígitos brindados “1 y 0” con un “n” número de cifras ingresadas por teclado.
1.

2.

3.

4.
 Laboratorio de Algoritmos y Estructuras de Datos
Página 6 de 6

CONCLUSIONES:
1. Se concluyo que el backtracking nos sirve para enumerar las
alternativas que existen para dar con la solución de un problema y dar
marcha atrás por si no se llega a esa solución para intentar otra alternativa
2. Se concluyó que la recursividad, es hacer que una función se llame a sí
misma repetidas veces hasta cumplir una cierta condición para evitar el
uso de bucles.
3. Se concluyó que el uso de backtracking y la recursividad, es esencial en
la programación para ahorrar recursos, espacio y tiempo al momento de
que se ejecute el programa.
4.se concluyo que en algunos ejercicios se pudo observar que pudimos
mejorar el código para que pueda ejecutar mas valores en menor tiempo
dándonos así mas posibilidades de hacer códigos mejores
5.se concluyo la que al aplicar estas funciones como seria recursividad y
backtracking se puede mantener un orden y ejecución más simple y rápida
y para ser un tema trabajado las primeras semanas me parece muy bueno
para aprender y así tener mas opciones para nuestros proyectos a futuro