Lab 02 - Recursividad-1 MAMANI - MAMANI.renzo - junior-3C24E

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
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)”
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.
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)])
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.
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

Lab 02 - Recursividad-1 MAMANI - MAMANI.renzo - junior-3C24E

Cargado por

Copyright:

Formatos disponibles

Lab 02 - Recursividad-1 MAMANI - MAMANI.renzo - junior-3C24E

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Lab 02 - Recursividad-1 MAMANI - MAMANI.renzo - junior-3C24E

Cargado por

Copyright:

Formatos disponibles

Algoritmos y Estructuras de Datos

CODIGO DEL CURSO:

DESARROLLO DE SOFTWARE Ing. Jaime Farfán

III.- FUNDAMENTO TEÓRICO:

IV.- NORMAS EMPLEADAS:

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

b.- Implementar el diagrama de flujo

c.- Indicar sus apreciaciones

2. Recursividad : Torre de Hanoi

a.-Expllicar como funciona el algoritmo

b.-Grafique el tiempo que demora en resolverse una torre de Hanoi de :

c.- Indiques sus apreciaciones

a.- Como funciona el algortimo

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

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

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

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

También podría gustarte

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.