Es fascinante saber que con los conocimientos básicos que ya posees, eres capaz de escribir cualquier tipo de programa imaginable. Desde simples aplicaciones hasta sofisticados sistemas operativos, el concepto de "Turing Completo" se refiere a la capacidad de una máquina de Turing de ejecutar cualquier cálculo computacional, siempre y cuando existan los recursos necesarios. Utilizando primitivos como enteros, flotantes, buleanos, estructuras para iterar y tomar decisiones, podemos recrear una máquina de Turing completa. Sin embargo, escribir programas de esta forma sería un verdadero desastre, ya que resultaría en un código inmenso y complicado de gestionar.
¿Por qué son esenciales las abstracciones en programación?
¿Qué es una abstracción?
Abstraer en programación es poder utilizar herramientas o funciones sin necesidad de entender cómo funcionan internamente. Un ejemplo cotidiano es una calculadora: no necesitas conocer la electrónica interna para utilizarla; simplemente debes saber operar sus botones. Este mismo principio se aplica en la programación: usar bibliotecas creadas por otros sin desentrañar su implementación interna.
¿Cuál es la importancia de la composición?
La composición permite dividir el código en unidades lógicas, como si fueran pequeños programas que colaboran para lograr un resultado. Igual que en electrónica, donde se utilizan diferentes componentes para armar un circuito, en programación se encapsula la implementación y se define una interfaz pública.
¿Cómo se define una función en Python?
Crear funciones es esencial para modularizar y organizar el código. En Python, las funciones se definen con la palabra clave def, seguida del nombre de la función, parámetros, dos puntos, e indenta el cuerpo de la función. Es común incluir un return para devolver un valor, aunque si no se especifica, se devuelve None por defecto.
defsumar(a, b): total = a + b
return total
¿Qué son los argumentos por defecto y cómo se utilizan?
Las funciones en Python pueden tener argumentos predeterminados, permitiendo flexibilidad al llamarlas. Si un argumento tiene un valor por defecto, este puede omitirse al invocar la función.
defnombre_completo(nombre, apellido, inverso=False):if inverso:returnf"{apellido}{nombre}"returnf"{nombre}{apellido}"# Ejemplo de llamadas a la funciónprint(nombre_completo("David","Hernández"))print(nombre_completo("David","Hernández",True))
¿Cómo aplicar estos conceptos a tus proyectos?
Desarrollar funciones claras y bien organizadas no solo facilita el mantenimiento sino que hace que tu código sea reutilizable y colaborativo. Como nuevo reto, encapsula los algoritmos aprendidos previamente en funciones y crea un programa que permita al usuario elegir cuál utilizar. Comparte tus hallazgos y soluciones con la comunidad para seguir aprendiendo juntos.
Recuerda que la práctica constante y la colaboración en la comunidad son claves para mejorar tus habilidades en programación. ¡Adelante, sigue explorando!
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}')
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 =0while respuesta**2< objetivo: respuesta +=1if respuesta**2== objetivo:returnprint(f'La raiz cuadrada de {objetivo} es {respuesta}')else:returnprint(f'{objetivo} no tiene una raiz cuadrada exacta')def aproximacion(objetivo): epsilon =0.01 paso = epsilon**2 respuesta =0.0whileabs(respuesta**2- objetivo)>= epsilon and respuesta <= objetivo: respuesta += paso
ifabs(respuesta**2- objetivo)>= epsilon:returnprint(f'No se encontro la raiz cuadrada de {objetivo}')else:returnprint(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)/2whileabs(respuesta**2- objetivo)>= epsilon:if respuesta**2< objetivo: bajo = respuesta
else: alto = respuesta
respuesta =(alto + bajo)/2returnprint(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.')```
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.
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
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.
¡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 :)
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!
Aquí está mi código, recibo sugerencias de cómo mejorarlo
def enumeracion_exhaustiva(objetivo): respuesta =0while respuesta**2< objetivo: respuesta +=1if 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 =0whileabs(respuesta**2- objetivo)>= epsilon and respuesta <= objetivo: respuesta += paso
iteraciones +=1ifabs(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}')whileabs(respuesta**2- objetivo)>= epsilon:print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')if respuesta**2< objetivo: bajo = respuesta
else: alto = respuesta
respuesta =(alto + bajo)/2print(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')```
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 =0while respuesta**2< objetivo:print(respuesta) respuesta +=1if 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.0whileabs(respuesta**2- objetivo)>= epsilon and respuesta <= objetivo:#print(abs(respuesta**2- objetivo), respuesta) respuesta += paso
ifabs(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)/2whileabs(respuesta**2- objetivo)>= epsilon:print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')if respuesta**2< objetivo: bajo = respuesta
else: alto = respuesta
respuesta =(alto + bajo)/2print(f'La raiz cuadrada de {objetivo} es {respuesta}')opciones()
El resultado se ve así:
Opciones para hallar raiz cuadrada(1)Enumeracionexhaustiva(2)Aproximacion de soluciones(3)Busqueda binaria
Elija una opcion:2Elija un numero:4La raiz cudrada de 4 es 1.999749999925672
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)
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.1bajo =0.0alto =max(1.0, objetivo)respuesta =(alto + bajo)/2seleccion =int(input('Ingresa una opción \n 1 para Busqueda binaria \n 2 para Aproximacion \n'))paso = epsilon**2if 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):whileabs(respuesta**2- objetivo)>= epsilon:print(f'bajo = {bajo}, alto={alto}, respuesta={respuesta}')if respuesta**2< objetivo: bajo = respuesta
else: alto = respuesta
respuesta =(alto + bajo)/2print(f'la raiz cuadrada de {objetivo} es {respuesta}')#Algoritmo de aproximación de soluciones
def aproximacion(objetivo, paso, bajo, alto, epsilon): respuesta =0.0whileabs(respuesta**2- objetivo)>= epsilon and respuesta <= objetivo:print(abs(respuesta**2- objetivo), respuesta) respuesta += paso
ifabs(respuesta **2- objetivo)>= epsilon:print(f'No se encontro la raiz cuadrada de {objetivo}')else:print(f'La raiz cuadrada de {objetivo} es {respuesta}')
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 =0while respuesta**2< objetivo: #Enumera todas las soluciones posibles
print(respuesta) respuesta +=1if 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.0whileabs(respuesta**2- objetivo)>= epsilon and respuesta <= objetivo:print(abs(respuesta**2- objetivo), respuesta) respuesta += paso
ifabs(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)/2whileabs(respuesta**2- objetivo)>= epsilon:print(f'bajo = {bajo}, alto = {alto}, respuesta = {respuesta}')if respuesta**2< objetivo: bajo = respuesta
else: alto = respuesta
respuesta =(alto + bajo)/2return 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}')
❤
from datetime import datetime
def aproximacion(): objetivo =int(input('Escoge un numero: ')) epsilon =0.01 paso = epsilon **2 respuesta =0.0 tiempoInicio = datetime.now()whileabs(respuesta **2- objetivo)>= epsilon and respuesta <= objetivo: respuesta += paso
ifabs(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 =0while respuesta**2< objetivo: respuesta +=1if 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
whileabs(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)/2print(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-Aproximacion2-EnumeracionExhaustiva3-BusquedaBinaria4-Salir""") opcion =int(input('Yo escogere: '))eleccion(opcion)if __name__ =='__main__':Lista()```
Comparto mi codigo!
# DEFINICIÓNDEFUNCIONES(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 =-1return 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. #
whileabs(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
ifabs(respuesta**2- objetivo)>= epsilon: respuesta =-1return 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)/2whileabs(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)/2return respuesta
# AQUICOMIENZAELCODIGO: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.```
Reto completado:
def enumeracion(): objetivo =int(input("Escoge un entero: ")) respuesta =0while respuesta**2< objetivo :print(respuesta) respuesta +=1if 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.0whileabs(respuesta**2- objetivo)>= epsilon and respuesta <= objetivo:print(abs(respuesta**2- objetivo), respuesta) respuesta += paso
ifabs(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)/2whileabs(respuesta**2- objetivo)>= epsilon:print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')if respuesta**2< objetivo: bajo = respuesta
else: alto = respuesta
respuesta =(alto + bajo)/2print(f'La raiz cuadrada de {objetivo} es {respuesta}')menu ="""
🙌Bienvenido Con este programa podras hacer busqueda de raices cuadradas con los siguientes 3metodos🐱👓:1-Enumeracion2-Aproximacion3-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!")
Aquí está mi solución, tiene la estructura del curso de aprender Python creando un CRUD (Recomendado)
#Aproximacióndef aproximacion(respuesta, objetivo, epsilon, paso):whileabs(respuesta**2- objetivo)>= epsilon and respuesta <= objetivo: respuesta += paso
ifabs(respuesta**2- objetivo)>= epsilon:print(f'Square root of {objetivo} not found')else:print(f'Square root of {objetivo} is {respuesta}')#Búsqueda Binariadef busqueda_bin(respuesta_bin, objetivo, epsilon, low, high):whileabs(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)/2print(f'Square root of {objetivo} is {respuesta_bin}')#EnumeraciónExhaustivadef enumeracion(objetivo, respuesta_int):while respuesta_int**2< objetivo: respuesta_int +=1if respuesta_int**2== objetivo:print(f"Square root of {objetivo} is {respuesta_int}")else:print(f"{objetivo} has no exact square root")#Bienvenidadef 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)/2busqueda_bin(respuesta_bin, objetivo, epsilon, low, high) elif command =="E": objetivo =int(input('Choose a number: ')) respuesta_int =0enumeracion(objetivo, respuesta_int)else:print("Invalid Command")```
def aprox_de_sol(objetivo): epsilon =0.01 paso = epsilon**2 respuesta=0.0whileabs(respuesta**2- objetivo)>= epsilon and objetivo >= respuesta:print(abs(respuesta**2- objetivo), respuesta) respuesta += paso
ifabs(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 =0while answer**2< objetivo:print(answer) answer +=1if 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)/2whileabs(respuesta**2- objetivo)>= epsilon:print(f'bajo={bajo}, alto={alto}, respuesta={respuesta}')if respuesta**2< objetivo: bajo = respuesta
else: alto = respuesta
respuesta =(alto + bajo)/2print(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)/2whileabs(respuesta**2- objetivo)>= epsilon:print(f'bajo={bajo}, alto={alto}, respuesta{respuesta}')if respuesta**2< objetivo: bajo = respuesta
else: alto = respuesta
respuesta =(alto + bajo)/2print(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.0whileabs(respuesta**2- objetivo)>= epsilon and respuesta <= objetivo:print(abs(respuesta**2-objetivo), respuesta) respuesta += paso
ifabs(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 =0while respuesta**2< objetivo: respuesta +=1if 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.PorEnumeracion exahustiva
3.PorBusqueda biinaria
4.Salir''') command =int(input('Que metodo vas a usar: '))whileTrue:if command ==1:Aproximacion()break elif command ==2:EnumExahustiva()break elif command ==3:BusquedaBinaria()break elif command ==4:Falseelse:print('Opcion Invalida')breakif __name__ =="__main__":main()```
