Clase 15 de 31 • Curso de Introducción al Pensamiento Computacional con Python
Contenido del curso
Carlos Andrés Valderrama Pabón
Cristian Antonio García González
Valentina Bacherer
Carli Code
Andrés Beltràn
Luis Alejandro Vera Hernandez
Fernando Andres Muñoz Suazo
franklin andres rodriguez gonzalez
franklin andres rodriguez gonzalez
Miguel Ángel Arévalo Andrade
Miguel Andres Rendon Reyes
Andrés Soret Chacin
Harrinson Quintero
Héctor Soto Huamaní
Mauricio Gonzalez Falcon
Carmen Sánchez Salgado
Erika Itzel Hernández López
Carmen Sánchez Salgado
Harvi Calle
Daniel Serna
Abel Salas Leal
Marco Andres Patzi Crespo
Maria Alejandra Moreno Giraldo
Miguel Torres
Arredondo Escoto Jose Antonio
Jesus Esteban Cuentas Villanueva
David Pantoja Yescas
Marco Antonio Macedo Preciado
David Pantoja Yescas
Ibon Andrea Godoy Tovar
Kevin J. Zea Alvarado
René Sanchez
Yeison Tapasco
René Sanchez
Miguel Salinas
López Ary Dani
Walquiria Salinas
María José Ledesma
Alejandro Urrea Giraldo
Jose Antonio Rojas Ollarves
Marcos Monteverde
Sergio Andrés Pachón Dotor
Edilson Byron Laura Mercado
Jhonny Cubillos
Aquí está mi código, recibo sugerencias de cómo mejorarlo
def enumeracion_exhaustiva (objetivo): respuesta = 0 while respuesta**2 < objetivo: respuesta += 1 if respuesta**2 == objetivo: print(f'La raiz de {objetivo} es {respuesta}') else: print(f'{objetivo} no tiene raiz cuadrada exacta') def aproximacion (objetivo, epsilon): paso = epsilon**2 respuesta = 0.0 iteraciones = 0 while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo: respuesta += paso iteraciones += 1 if abs(respuesta**2 - objetivo) >= epsilon: print(f'No se encontro raiz cuadrada {objetivo}') else: print(f'La raiz cuadrada de {objetivo} es {respuesta}') def busqueda_binaria (objetivo, epsilon): bajo = 0.0 alto = max(1.0, objetivo) respuesta = (alto + bajo) / 2 # absoluto = abs(respuesta**2 - objetivo) # print(f'absoluto: {absoluto}') while abs(respuesta**2 - objetivo) >= epsilon: print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}') if respuesta**2 < objetivo: bajo = respuesta else: alto = respuesta respuesta = (alto + bajo) / 2 print(f'La raiz cuadrada de {objetivo} es {respuesta}') opcion = int(input(f'Elija el algoritmo de ordenamiento para buscar la raiz cuadrada de su numero \n 1. Enumeracion Exhaustiva \n 2. Aproximacion \n 3. Busqueda Binaria \n')) if opcion == 1: print('1. Enumeracion Exhaustiva') numero = int(input('* Digite un numero: ')) enumeracion_exhaustiva(numero) elif opcion == 2: print('2. Aproximacion') numero = int(input('* Digite un numero: ')) parametro_epsilon = float(input('* Digite un epsilon: ')) aproximacion(numero,parametro_epsilon) elif opcion == 3: print('3. Busqueda Binaria') numero = int(input('* Digite un numero: ')) parametro_epsilon = float(input('* Digite un epsilon: ')) busqueda_binaria(numero,parametro_epsilon) else: print('Opcion no valida') ```
Hola compañero creo que encontré un error en tu código y es en la tercera opción cuando estas usando el while y pones el operador lógico mayor o igual que, no debería ser menor o igual que para que se pueda ejecutar.
Bueno como decía no se si no ejecute bien tu código o no puse bien los datos ya que ponía (4 y 0.1) no funcionaba y cuando le cambie de "mayor o igual que" a "menor o igual que" ya me funcionaba.
No se si alguien mas le funciona el código cuando usan la tercera opción o estoy mal yo.
Tiene un pequeño error, el tablador print
print(f'La raiz cuadrada de {objetivo} es {respuesta}')
de la aproximacion binaria deberia estar a la altura del while, para que imprima solo una vez al final el resultado. Yo le quite tambien el
print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
colocandole un # por delante
#print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')
excelente respuesta, gracias!
Esta es mi solucion:
def opciones(): print(f'Opciones para hallar raiz cuadrada \n (1) Enumeracion exhaustiva \n (2) Aproximacion de soluciones \n (3) Busqueda binaria') opcion = int(input('Elija una opcion: ')) numero = int(input('Elija un numero: ')) if opcion==1: Enumeracion(numero) elif opcion==2: Aproximacion(numero) elif opcion==3: BusquedaBinaria(numero) else: print('Elija 1, 2 o 3') def Enumeracion(objetivo): respuesta = 0 while respuesta**2 < objetivo: print(respuesta) respuesta += 1 if respuesta**2 == objetivo: print(f'La raiz cuadrada de {objetivo} es {respuesta}') else: print(f'{objetivo} no tiene una raiz cuadrada exacta') def Aproximacion(objetivo): epsilon = 0.001 paso = epsilon**2 respuesta = 0.0 while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo: #print(abs(respuesta**2 - objetivo), respuesta) respuesta += paso if abs(respuesta**2 - objetivo) >= epsilon: print(f'No se encontro la raiz cuadrada {objetivo}') else: print(f'La raiz cudrada de {objetivo} es {respuesta}') def BusquedaBinaria(objetivo): epsilon = 0.001 bajo = 0.0 alto = max(1.0, objetivo) respuesta = (alto + bajo) / 2 while abs(respuesta**2 - objetivo) >= epsilon: print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}') if respuesta**2 < objetivo: bajo = respuesta else: alto = respuesta respuesta = (alto + bajo) / 2 print(f'La raiz cuadrada de {objetivo} es {respuesta}') opciones()
El resultado se ve así:
Opciones para hallar raiz cuadrada (1) Enumeracion exhaustiva (2) Aproximacion de soluciones (3) Busqueda binaria Elija una opcion: 2 Elija un numero: 4 La raiz cudrada de 4 es 1.999749999925672
Gracias, pase horas y solo viendo tu código encontré un error en el mio.
me faltaba cerrar el def inicial.
Hola, una pregunta, estaba usando tu codigo y todo perfecto si funciona, pero soy nuevo en esto y no entiendo una parte. Como el programa sabe cual es el objetivo? La palabra "objetivo" esta dentro de los parametros de las variables pero no entiendo como el programa se la asigna a "objetivo" si la entrada del numero que ingresa el usuario es en "numero" . Disculpen mi ignorancia companeros, espero haber sido claro en mi duda para que me puedan ayudar >.<
objetivo = int(input('Escoge un numero: ')) print('Porque metodo te gustaria encontrar la raiz cuadara?:') print('1. Enumeracion exhaustiva.') print('2. Aproximacion') print('3. Busqueda Binaria') opcion = int(input('Escribe el numero de la opcion que deseas: ')) def enumeracion_exhaustiva(objetivo): respuesta = 0 while respuesta**2 < objetivo: respuesta += 1 if respuesta**2 == objetivo: return print(f'La raiz cuadrada de {objetivo} es {respuesta}') else: return print(f'{objetivo} no tiene una raiz cuadrada exacta') def aproximacion(objetivo): epsilon = 0.01 paso = epsilon**2 respuesta = 0.0 while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo: respuesta += paso if abs(respuesta**2 - objetivo) >= epsilon: return print(f'No se encontro la raiz cuadrada de {objetivo}') else: return print(f'La raiz cuadrada de {objetivo} es {respuesta}') def busqueda_binaria(objetivo): epsilon = 0.001 bajo = 0.0 alto = max(1.0, objetivo) respuesta = (alto + bajo) / 2 while abs(respuesta**2 - objetivo) >= epsilon: if respuesta**2 < objetivo: bajo = respuesta else: alto = respuesta respuesta = (alto + bajo) / 2 return print(f'La raiz cuadrada de {objetivo} es {respuesta}') if opcion == 1: enumeracion_exhaustiva(objetivo) elif opcion == 2: aproximacion(objetivo) elif opcion == 3: busqueda_binaria(objetivo) else: print('Opcion no valida.')```
sorprendente bro, gracias por código voy analizarlo esta todo bien, increíble que tu código no tenga comentario.
No sabia que se podria colocar mas de un DEF
En programación, abstracción es realmente solo una forma de simplificar una idea o acción complicada. Veamos cuál es fácilmente la abstracción más común que todo programador sabe que son usos. ¿Qué es lo primero que aprendes como programador principiante? El Hello World... programa clásico donde imprime un texto en la consola. Pero, ¿alguna vez te has detenido y te has preguntado cómo funciona esto realmente bajo el capó? El estándar Hello World en la mayoría de los idiomas generalmente se ve así: print ("Hola, mundo") La mayoría de los programadores no saben cómo funciona esta única línea de código. Y tampoco tienen que hacerlo. Todo lo que necesita saber es qué entradas dar a la función print() para que funcione.
Entender cómo funciona un lenguaje y como son sus builts- in hace que tengamos un enorme poder entre nuestra manos. No es broma, solo es un hecho.
Woww, muchas gracias por el aporte, de verdad fue muy necesario 👍👍
Parte de la teoria:
. Habilidades importantes de los ingenieros del Software .
1.Abstracción: Significa que no necesitas entender la forma como opera algo internamente para poderlo utilizar. 2.Decomposición: Permite dividir el código en componentes que colaboran con un fin común (se puede pensar como mini programas dentro de un programa mayor). .
Sintaxis de una función en python:
def <nombre>(<parámetros>): <cuerpo> return <expresion> #Ejemplo: def suma (a, b): total = a + b return total suma(2, 3)
.
Argumentos de tipo Keyword y valores por defecto
def nombre_completo(nombre, apellido, inverso=False): if inverso: return f" {apellido} {nombre}" else: return f" {nombre} {apellido}" nombre_completo("Harrinson", "Quintero") nombre_completo("Harrinson", "Quintero", inverso=True) nombre_completo(apellido="Harrinson", nombre="Quintero")
Muchas gracias crack, lo necesitaba. :)
thanks!
Importante destacar que los argumentos de una función que tengas valores por default van al final de los demás argumentos, de otra forma se produce un error. SyntaxError: non-default argument follows default argument
def nombre_completo(inverso=False, nombre, apellido ): if inverso: return f'{apellido} {nombre}' else: return f'{nombre} {apellido}'
No estoy segura si te estoy entendiendo ¿a qué te refieres?
Me refiero al orden en se ponen los argumentos en la definición de la función. Es decir, el ejemplo que pongo marcara un error. Anexo imagen.
La ultima opción tiene una sintaxis correcta, así que: los argumentos con valor por default, va a la derecha (o al final) de todos los demás argumentos.
Happy coding!
En mi caso particular, utilicé dos archivos, el primero reto.py, en el cual definí la lectura y el llamado de las variables, así como la importación de las funciones:
from funciones import (bbinaria, aproximacion) import time start_time = time.perf_counter() objetivo = int(input('Escoge un numero: ')) epsilon = 0.1 bajo = 0.0 alto = max(1.0, objetivo) respuesta = (alto + bajo) / 2 seleccion = int(input('Ingresa una opción \n 1 para Busqueda binaria \n 2 para Aproximacion \n')) paso = epsilon**2 if seleccion == 1: bbinaria(objetivo, respuesta, bajo, alto, epsilon) else: aproximacion(objetivo, paso, bajo, alto, epsilon) print (time.perf_counter() - start_time, "seconds")
Adicionalmente, funciones.py (funciones en el archivo reto), donde definí los dos algoritmos usados:
#Algoritmo de Busqueda binaria def bbinaria (objetivo, respuesta, bajo, alto, epsilon): while abs(respuesta**2 - objetivo) >= epsilon: print(f'bajo = {bajo}, alto={alto}, respuesta={respuesta}') if respuesta**2 < objetivo: bajo = respuesta else: alto = respuesta respuesta = (alto + bajo) / 2 print(f'la raiz cuadrada de {objetivo} es {respuesta}') #Algoritmo de aproximación de soluciones def aproximacion (objetivo, paso, bajo, alto, epsilon): respuesta = 0.0 while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo: print(abs(respuesta**2 - objetivo), respuesta) respuesta += paso if abs(respuesta **2 - objetivo) >= epsilon: print(f'No se encontro la raiz cuadrada de {objetivo}') else: print(f'La raiz cuadrada de {objetivo} es {respuesta}')
Yo lo hice todo en el mismo archivo pero creo que así separado lo tienes mejor organizado
¿Cómo le hiciste para manejar tus códigos por separados?
Hola Marco. Gracias por tu programa, me sirvió mucho. Encontré que tienes un error al cerrar las funciones: no debes usar el nombre de la función al finalizar porque te arrojará error; debes reemplazarlo por return.
Aquí la solución con cada método para calcular la raíz cuadrada encapsulado y decompuesta en tres funciones que se mandan a llamar con una variable llamada method. :D
def enumeracion(objetivo): respuesta = 0 while respuesta**2 < objetivo: #Enumera todas las soluciones posibles print(respuesta) respuesta += 1 if respuesta**2 == objetivo: #Evalúa las soluciones de acuerdo a las restricciones del problema return respuesta else: print(f'{objetivo} no tiene raíz cuadrada exacta') def aproximacion(objetivo): epsilon = 0.01 paso = epsilon**2 respuesta = 0.0 while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo: print(abs(respuesta**2 - objetivo), respuesta) respuesta += paso if abs(respuesta**2 - objetivo) >= epsilon: print(f'No se encontro la raíz cuadrada de {objetivo}') else: return respuesta def busq_binaria(objetivo): epsilon = 0.001 bajo = 0.0 alto = max(1.0, objetivo) respuesta = (alto + bajo) / 2 while abs(respuesta**2 - objetivo) >= epsilon: print(f'bajo = {bajo}, alto = {alto}, respuesta = {respuesta}') if respuesta**2 < objetivo: bajo = respuesta else: alto = respuesta respuesta = (alto + bajo) / 2 return respuesta method = input('''Escoge el método para calcular la raíz cuadrada [E]numeración exhaustiva [A]proximación de soluciones [B]úsqueda binaria ''') objetivo = int(input('Escoge un número entero: ')) if method == 'e' or method == 'E': result = enumeracion(objetivo) # print(f'La raíz cuadrada de {objetivo} es {result}') elif method == 'a' or method == 'A': result = aproximacion(objetivo) # print(f'La raíz cuadrada de {objetivo} es {result}') elif method == 'b' or method == 'B': result = busq_binaria(objetivo) # print(f'La raíz cuadrada de {objetivo} es {result}') else: print('No escogiste un método') if result != None: print(f'La raíz cuadrada de {objetivo} es {result}')
también en python es común iniciar con una función principal que indique dónde inicia la ejecución del programa.
def main(): #tu código comienza aquí if __name__ == '__main__': main()
Abstracción: no necesitas saber cómo algo funciona internamente para poderlo utilizar.
Descomposición: Dividir el código en componentes que colaboran con un fín en común.
Se que mi código no es el mejor pero es un trabajo honesto y corre bien jaja
Hey, no estas encapsulando los diferentes metodos :D
cierto, ya lo corregí gracias
En la tercera linea cuando dice "if inverso:" quiere decir: cuando inverso sea True?
Correcto.
Al poner un if variable: se marca por default como si fuera if variable == true:.
❤
from datetime import datetime def aproximacion(): objetivo = int(input('Escoge un numero: ')) epsilon = 0.01 paso = epsilon ** 2 respuesta = 0.0 tiempoInicio = datetime.now() while abs(respuesta ** 2 - objetivo) >= epsilon and respuesta <= objetivo: respuesta += paso if abs(respuesta ** 2 - objetivo) >= epsilon: print(f'No se encontro la raiz cuadrada de {objetivo}') else: print(f'La raiz cuadrada de {objetivo} es {respuesta}') tiempoFinal = datetime.now() print(f'Comenzo a las {tiempoInicio} y termino a las {tiempoFinal}') Lista() def enumeracionExhaustiva(): objetivo = int(input('¿Escoge un entero: ')) respuesta = 0 while respuesta**2 < objetivo: respuesta += 1 if respuesta**2 == objetivo: print(f'La raiz cuadrada de {objetivo} es {respuesta}') else: print(f'{objetivo} no tiene una raiz cuadrada exacta') Lista() def busquedaBinaria(): objetivo = int(input('Escoge un numero: ')) # Precision epsilon = 0.001 # limite inferior bajo = 0.0 # limite superior alto = max(1.0, objetivo) respuesta = (alto + bajo) / 2 # Derecha => alto # izquierda => bajo # MIsion disminuir a la mitad la busqueda while abs(respuesta ** 2 - objetivo) >= epsilon: print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}') if respuesta ** 2 < objetivo: bajo = respuesta else: alto = respuesta # Divivir entre 2 el espacio de busqueda por ende solo la mitad respuesta = (alto + bajo) / 2 print(f'La raiz cuadrada de {objetivo} es {respuesta}') Lista() def eleccion(opcion): if opcion == 1: aproximacion() elif opcion == 2: enumeracionExhaustiva() elif opcion == 3: busquedaBinaria() elif opcion == 4: print('Muchas gracias por usar nuestros sistemas!!') else: print('Solo puedes seleccionar los algoritmos de la lista, te devolveremos al inicio') Lista() def Lista(): print(""" Cual algoritmo deseas usar para obtener la raiz cuadrada ? ====================Lista================== 1- Aproximacion 2- Enumeracion Exhaustiva 3- Busqueda Binaria 4- Salir """) opcion = int(input('Yo escogere: ')) eleccion(opcion) if __name__ == '__main__': Lista()```
Muchas gracias, no sabia como llamar el datetime en Python
Super! de nada 😊
Comparto mi codigo!
# DEFINICIÓN DE FUNCIONES(ALGORITMOS): # //////////////////////////// 1 ENUMERACION EXHAUSTIVA ////////////////////////////// def enumeracion_exhaustiva(objetivo,respuesta): #respuesta = float(input('puedes sugerir una solución aproximada y reducir el tiempo de calculo: ')) # valor inicial de busqueda. while respuesta**2 < objetivo: respuesta += 1 #print(f'respuesta = {respuesta}, error = {abs(respuesta**2 - objetivo)}') if respuesta**2 == objetivo: return respuesta #print(f'// La raiz cuadrada de {objetivo} es {respuesta}') else: respuesta = -1 return respuesta #print(f'{objetivo} no tiene raiz cuadrada exacta') # /////////////////////////// 2 APROXIMACION DE SOLUCIONES ////////////////////////////// def aprox_soluciones(objetivo, respuesta, epsilon): paso = epsilon**2 #es el salto o incremento que realiza al valor anterior. # while abs(respuesta**2-objetivo) >= epsilon: #print(respuesta, respuesta**2, objetivo) if respuesta**2 > objetivo: respuesta -= paso # se debe decrementar para encontrar la solución elif respuesta**2 < objetivo: respuesta += paso # se debe incrementar para encontrar la solución else: return respuesta #print(f'la respuesta es {respuesta}') # respuesta^2 = objetivo if abs(respuesta**2 - objetivo) >= epsilon: respuesta = -1 return respuesta #print('No se encontró solución') else: return respuesta #print(f'la raiz cuadrada de {objetivo} es {respuesta}') # /////////////////////////// 3 BUSQUEDA BINARIA ///////////////////////////////////////// def busqueda_binaria(objetivo, epsilon): #print('Metodo busqueda binaria o de la Bisección') bajo = 0.0 alto = max(1.0, objetivo) respuesta = (alto+bajo)/2 while abs(respuesta**2 - objetivo) >= epsilon: #print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}, error={respuesta**2 - objetivo}') if respuesta**2 < objetivo: bajo = respuesta else: alto = respuesta respuesta = (alto+bajo)/2 return respuesta # AQUI COMIENZA EL CODIGO: print('//////////// Este programa calcula la raiz de un numero //////////////') print('// Puedes elegir entre estos tres algoritmos de calculo: ') print('// Digite el numero correspondiente... ') algoritmo = int(input('// Enumeración exhaustiva (1), Aproximación de Soluciones (2) o Busqueda Binaria (3): ')) objetivo = int(input('// Escoge un entero y calcularé su Raíz: ')) import time start_time = time.time() if algoritmo == 1: respuesta = 0.0 respuesta = enumeracion_exhaustiva(objetivo,respuesta) if algoritmo == 2: epsilon = float(input('ingrese la precisión esperada epsilón: ')) # presición esperada. respuesta = float(input('puedes sugerir una solución aproximada y reducir el tiempo de calculo: ')) # valor inicial de busqueda. respuesta = aprox_soluciones(objetivo, respuesta, epsilon) if algoritmo == 3: epsilon = float(input('ingrese la precisión esperada epsilón: ')) # presición esperada. respuesta = busqueda_binaria(objetivo, epsilon) if respuesta == -1: print(f'{objetivo} no tiene raiz cuadrada exacta, o no tiene solución') else: print(f'// La raiz cuadrada de {objetivo} es {respuesta}') print(f'// Tiempo de ejecución del codigo fue: {time.time() - start_time} segundos') # Aqui finaliza el codigo principal.```
Estas en la sección de preguntas y no de aportes, saludos :D
Sigue siendo chino basico, para mi, es un poco desmoralizante realmente me cuesta mucho entender
¡Hola WalquiriaSalinas! Yo estaba igual que vos, pero volví a ver algunos videos e incluso consultando en el sistema de discusiones. Entre todos podemos ayudar con las dudas que tienes :)
¡Nunca pares de aprender! (Y practicar) ✨🦄
Hola WalquiriaSalinas
Aprender a programar (o bailar, cocinar, pintar, nadar, etc) puede ser difícil al principio, especialmente cuando es algo totalmente nuevo. Puede pasar que no se tienen los conocimientos de base, o que simplemente un montón de prejuicios nos impiden empezar a aprender
Primero, haga un diagnóstico para saber exactamente que es lo que se le dificulta: los conceptos matemáticos, lo lógica que se usa para resolver un problema, la velocidad a la que está aprendiendo, los términos o conceptos de programación que se usan en la clase, etc. Esto le ayudará a tener claro por donde empezar. Es posible que antes de tomar algún curso, deba tener claros algunos conceptos que le permitirán aprender otros un poco más avanzados. Intente probar primero cursos más básicos que le den bases sólidas. Luego, intente retomar los cursos que le parecían difíciles. Seguramente los entenderá mejor.
Además recuerde que el proceso de aprendizaje es diferente para cada estudiante. Todos tenemos un ritmo propio. Acabar un curso muy rápido o muy lento, no mide cuanto se ha aprendido, ni cuan inteligente es una persona. Intente poner las clases a una velocidad mas baja y repítalas cuantas veces sea necesario hasta entender.
Recuerde que en platzi existe una comunidad muy activa, dispuesta a ayudarle. No se desanime. Siga adelante!
Reto completado:
def enumeracion(): objetivo = int(input("Escoge un entero: ")) respuesta = 0 while respuesta**2 < objetivo : print(respuesta) respuesta +=1 if respuesta**2 == objetivo: print(f'La raiz cuadrada de {objetivo} es {respuesta}') else: print(f'{objetivo} no tiene raiz cuadrada exacta') def aproximacion(): objetivo = int(input('Escoge un numero: ')) epsilon = 0.01 paso = epsilon**2 respuesta = 0.0 while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo: print(abs(respuesta**2 - objetivo), respuesta) respuesta += paso if abs(respuesta**2 - objetivo) >= epsilon: print(f'No se encontro la raiz cuadrada {objetivo}') else: print(f'La raiz cudrada de {objetivo} es {respuesta}') def busqueda_binaria(): objetivo = int(input('Escoge un numero: ')) epsilon = 0.001 bajo = 0.0 alto = max(1.0, objetivo) respuesta = (alto + bajo) / 2 while abs(respuesta**2 - objetivo) >= epsilon: print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}') if respuesta**2 < objetivo: bajo = respuesta else: alto = respuesta respuesta = (alto + bajo) / 2 print(f'La raiz cuadrada de {objetivo} es {respuesta}') menu = """ 🙌Bienvenido Con este programa podras hacer busqueda de raices cuadradas con los siguientes 3 metodos🐱👓: 1 - Enumeracion 2 - Aproximacion 3 - Busqueda binaria Eligue una opcion: """ opcion = int(input(menu)) if opcion == 1: print("Haz eleguido el metodo Enumeracion exhaustiva") enumeracion() elif opcion == 2: print("Haz eleguido el numero aproximacion") aproximacion() elif opcion == 3: print("Haz eleguido el metodo busqueda binaria") busqueda_binaria() else: print("Elige una opcion correcta porfavor!")
Felicidades!
Aquí está mi solución, tiene la estructura del curso de aprender Python creando un CRUD (Recomendado)
#Aproximación def aproximacion (respuesta, objetivo, epsilon, paso): while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo: respuesta += paso if abs(respuesta**2 - objetivo) >= epsilon: print(f'Square root of {objetivo} not found') else: print(f'Square root of {objetivo} is {respuesta}') #Búsqueda Binaria def busqueda_bin (respuesta_bin, objetivo, epsilon, low, high): while abs (respuesta_bin**2 - objetivo) >= epsilon: #print(f'bajo={low}, alto={high}, respuesta={respuesta_bin}') if respuesta_bin**2 < objetivo: low = respuesta_bin else: high = respuesta_bin respuesta_bin = (high + low) / 2 print (f'Square root of {objetivo} is {respuesta_bin}') #Enumeración Exhaustiva def enumeracion (objetivo, respuesta_int): while respuesta_int**2 < objetivo: respuesta_int += 1 if respuesta_int**2 == objetivo: print(f"Square root of {objetivo} is {respuesta_int}") else: print(f"{objetivo} has no exact square root") #Bienvenida def welcome (): print(" ") print ("WELCOME TO THE SQUARE ROOT CALCULATOR!") print("_"*50) print("Wich algoridim are you going to choose today?") print(" ") print("[A]proximation") print("[B]inary Search") print("[E]xhaustive ennumeration") print("_"*50) print(" ") if __name__ == "__main__": #Da la bienvenida welcome () #Comando para escoger el algoritmo command = input("Wich algorithm do you want to choose?: ") command = command.upper() if command == "A": objetivo = int(input('Choose a number: ')) paso = epsilon**2 respuesta = 0.0 epsilon = 0.01 aproximacion = aproximacion (respuesta, objetivo,epsilon, paso) elif command == "B": objetivo = float(input('Choose a number: ')) low = 0.0 high = max(1.0, objetivo) epsilon = 0.01 respuesta_bin = (high + low) / 2 busqueda_bin(respuesta_bin, objetivo, epsilon, low, high) elif command == "E": objetivo = int(input('Choose a number: ')) respuesta_int = 0 enumeracion(objetivo, respuesta_int) else: print ("Invalid Command")```
def aprox_de_sol(objetivo): epsilon = 0.01 paso = epsilon**2 respuesta= 0.0 while abs(respuesta**2 - objetivo) >= epsilon and objetivo >= respuesta: print(abs(respuesta**2 - objetivo), respuesta) respuesta += paso if abs(respuesta**2 - objetivo) >= epsilon: print(f'No se encontró la raíz cuadrada del objetivo') else: print(f'La raiz cuadrada de {objetivo} es {respuesta}') def enum_exhaustiva(objetivo): answer = 0 while answer**2 < objetivo: print(answer) answer += 1 if answer**2 == objetivo: print(f'la raíz cuadrada del {objetivo} es {answer}') else: print(f'{objetivo} no tiene una raiz cuadrada exacta') def busq_bin(objetivo): epsilon = 0.001 bajo= 0.0 alto = max(1.0, objetivo) respuesta = (alto + bajo) / 2 while abs(respuesta**2 - objetivo) >= epsilon: print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}') if respuesta**2 < objetivo: bajo = respuesta else: alto = respuesta respuesta = (alto + bajo) / 2 print(f'La raiz cuadrada del {objetivo} es {respuesta}') option= int(input("Escoge el método para hallar la raíz cuadrada:\n 1.Enumeración exhaustiva. \n 2.Aproximación de soluciones. \n 3.Búsqueda Binaria \n")) objetivo = int(input('Escoge un número: ')) if option == 1: enum_exhaustiva(objetivo) elif option == 2: aprox_de_sol(objetivo) elif option == 3: busq_bin(objetivo) else: print("No es una opción válida")```
Mi aporte:
def BusquedaBinaria(): objetivo = int(input('Escoge un numero: ')) epsilon = 0.001 bajo = 0.0 alto = max(1.0, objetivo) respuesta = (alto + bajo) / 2 while abs(respuesta**2 - objetivo) >= epsilon: print(f'bajo={bajo}, alto={alto}, respuesta{respuesta}') if respuesta**2 < objetivo: bajo = respuesta else: alto = respuesta respuesta = (alto + bajo) / 2 print(f'La raiz cuadrada de {objetivo} es {respuesta}') def Aproximacion(): objetivo = int(input('Escoger un número: ')) epsilon = 0.01 paso = epsilon**2 respuesta = 0.0 while abs(respuesta**2 - objetivo) >= epsilon and respuesta <= objetivo: print(abs(respuesta**2-objetivo), respuesta) respuesta += paso if abs(respuesta**2 - objetivo) >= epsilon: print(f'No se encontró raíz cuadrada de {objetivo}') else: print(f'La raíz cuadrada aproximada de {objetivo} es {respuesta}') def EnumExahustiva(): objetivo = int(input('Ecribe un numero entero: ')) respuesta = 0 while respuesta**2 < objetivo: respuesta += 1 if respuesta**2 == objetivo: print(f'La raiz cuadrada de {objetivo} es {respuesta}') else: print(f'{objetivo} no tiene raiz cuadrada exacta') def main(): print('Escoge como buscar de la raiz cuadrada de un numero: ') print(''' 1. Por aproximacion 2. Por Enumeracion exahustiva 3. Por Busqueda biinaria 4. Salir ''') command = int(input('Que metodo vas a usar: ')) while True: if command == 1: Aproximacion() break elif command == 2: EnumExahustiva() break elif command == 3: BusquedaBinaria() break elif command == 4: False else: print('Opcion Invalida') break if __name__ == "__main__": main()```
