Enumeración exhaustiva

A punta de enumeración exhaustiva Dr Strange se puso a ver en que futuro los vengadores ganaban a Thanos

Diagrama de flujo:

Relaciono mi código y como veo que varios estamos interesados en medir el tiempo de ejecución, este script también imprime el tiempo que se demora ejecutando:

import time

tiempo_inicial = time.time()

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 una raiz exacta')

print(f'El programa demoró {time.time() - tiempo_inicial} segundos ')

Aquí el resultado:

En seguridad informática, existe un tipo de ataque llamado de “fuerza bruta”, en el que un atacante trata de ingresar a un sistema probando TODAS las contraseñas posibles hasta que logra ingresar al sistema. Prácticamente es un algoritmo de enumeración exhaustiva en todo su esplendor.
Por eso muchos sitios implementaron medidas de seguridad para cuando alguien trata muchas veces de logearse con un mismo usuario.

Para no tener que estar escribiendo lo mismo cada vez que compilemos en consola, les dejo los pasos para configurar Visual Studio y lo haga automático.

En este video lo explica a detalle: https://www.youtube.com/watch?v=9Hh6fqieReE

Este es el famoso metodo llamado “Fuerza Bruta”, es el peor algorithmo de todos, aunque el tiene razon al decir que las computadoras tienen un gran poder de computo, imagina si tienes que hacer esa consulta miles de veces en un minuto, ahi es donde en CS, se mira la manera de utilizar mejores algoritmos para mejorar los tiempos y recursos del sistema, basado en parametros de “Time Complexity” y “Space Complexity”

Enumeración exhaustiva
También llamado “adivina y verifica” donde simplemente generamos todas las posibilidades. Técnicamente este no es un algoritmo eficiente, sin embargo, dependiendo del universo de posibilidades puede ser que sea el mas adecuado, ya que las computadoras actuales son muy rapidas y por lo tanto la eficiencia de nuestro programa no es relevante, por lo tanto siempre ten en mente este tipo de algoritmo como uno de los primeros en implementar.

Vamos a crear un ejemplo de enumeración exhaustiva buscando la raíz cuadrada exacta de un numero.

objetivo = int(input('Escoge un entero: '))

# Inicializamos respuesta como 0
respuesta = 0

# Mientras respuesta^2 sea menor que nuestro numero objetivo.
while respuesta**2 < objetivo:
    respuesta += 1  # Respuesta aumentara en 1.

if respuesta**2 == objetivo:
    print(f'La raiz cuadrada de {objetivo} es {respuesta}')

else:
    print(f'{objetivo} no tinene una raiz cuadrada exacta')

While, hasta que la condicion deje de ser verdadera
For, hasta que la condicion sea falsa

Qué hermoso es todo esto!!! Aún sigo sin entenderlo jaja

Cuidado con la enumeración exhaustiva:

Aunque es cierto que las computadoras son bien rápidas, estas tienen un límite.

Prueben con este número: 134724234304. Verán que no lo hará en segundos, se tomará algunos minutos llegar a que es: 367048. ¿Por qué?

Porque el ordenador se hace más lento al calcular a partir de las 1010 iteraciones, volviéndose 1 segundo el tiempo de cálculo de 1011, 10 el de 10**12, y así sucesivamente.

Es un caso extremo pero que da la moraleja que cuando las cosas escalan exponencialmente, Sí es necesario optimizar.
Espero que les sirva para más adelante. Salu2

No comparto esta forma de ‘pensar computacionalmente’, decir que no importa que el algoritmo sea ineficiente porque las maquinas son cada vez mas rápidas es un error, imagina que esta aplicación corre en un servidor donde muchos usuarios están usando esos algoritmos; siempre debemos escribir programas eficientes. David no es un experto en el tema, simplemente realizó un curso antes de dictar esta otro curso.

Algoritmo de fuerza bruta 😎

El algoritmo es ineficiente pero las computadoras son muy rapidas.
es un algoritmo ineficiente pero EFICAZ.

Hallazgo de raiz cuadrada exacta por ennumeracion exhaustiva
Por favor digite un numero: 1000000000000
1000000 es la raiz cuadrada exacta de 1000000000000

hizo un millon de intentos y se demoro 1 segundo!!!

Me está gustando mucho el curso
.

A prueba de errores si introduces un valor de tipo float o string:

objetivo = int (input('Escoge un numero 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 una raiz cuadrada exacta ')

Esta chevere este python jejej no lo habia usado pero es muy intuitivo

objetivo = int(input('Ingrese un numero para verificar si tiene raiz='))

raiz = -1

for i in range(objetivo):
    if i*i== objetivo:
        raiz = i
        break
    elif i*i>objetivo:
        break
        


if raiz != -1:
    print(f'La raiz del numero {objetivo}, es {raiz}')
else:
    print(f'El numero {objetivo}, no tiene raiz')```

Les recomiendo este vídeo para entender sobre los algoritmos
https://www.youtube.com/watch?v=U3CGMyjzlvM

Exc introduccion a los algoritmos.

Gracias.

Les comparto un ejemplo de raíz cúbica, simplemente cambiamos el 2 por el 3 y modificamos la impresión de texto.

Buena clase profe, quería dejar clarada una cosa que me estuvo dando problemas a la hora de entender el código de esta clase. En el loop while, la condición dice que mientras la respuesta al cuadrado sea menor al objetivo, se le sumará 1 a la respuesta. Aquí la cuestión, por qué la respuesta llega a ser 4 si respuesta al cuadrado es IGUAL y no menor a objetivo. Pues cuando el bucle while evalua la condición cuando la respuesta es 3, en esa iteración se le suma 1 a la respuesta y esta queda en 4, por eso aunque cuando la respuesta el 4 y esta elevada al cuadrado no cumple la condición del while, la variable respuesta ya vale 4. Espero haberme explicado lo suficientemente bien 😃

Agregue algo de texto para comprende mejor la numeración exhaustiva.

objetivo = int(input('Escoge un entero: '))
respuesta = 0

while respuesta**2 < objetivo:
    print(f'{respuesta} al cuadrado es {respuesta**2}, que es menor a {objetivo}')
    respuesta +=1

if respuesta**2 == objetivo:
    print(f'La raíz cuadrada de {objetivo} es {respuesta}')
else:
    print(f'{objetivo} no cuenta con una raíz cuadrada exacta')

Note: Hasta lo que he podido ver el límite al momento de crear un programa de Python estará limitado por nuestro propio conocimiento de matemáticas en general.

Era escéptico frente a la eficiencia del algoritmo, pero después de una que otra prueba noté que sí es bastante eficiente.

p. ej. En mi código importé el modulo time para calcular el tiempo de ejecución, también random para obtener un número aleatorio realmente grande y math, únicamente con el propósito de densificar un poco el programa.

El número aleatorio está comprendido entre 3^(25) o 847.288.609.443 y 3^(30) o 205.891.132.094.649. Es decir, es un número realmente grande, pero sorprendentemente a la computadora no le va a tomar más de 3 s determinar si tiene o no una raíz cuadrada exacta. 🤯

Cree esto que por medio de la fuerza bruta, encuentra cualquier password que le ingreses, esta bassado en un codigo creado en el curso basico de python.

Si quieren hacer capturas de pantalla de su código en VS Code, pueden instalar CodeSnap para que se vean así:

El codigo utilizando la nomenclatura vista en el curso basico de python, anterior a este

Excelente explicación.

muchas gracias

Lo borre luego de verlo en la clase, para escribirlo por mi cuenta nuevamente y entenderlo. Acá se los dejo.
Creo que el Print(respuesta) fue lo que me ayudo a verlo desde una mejor perspectiva.

objetivo = int(input('Ingresa un numero 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 una raiz exacta')```

Acá mi ejercicio, añadí al aviso de cuando la raíz cuadrada no sea exacta el resultado:

import math
num = int (input(('Escriba un número: ')))
raiz = 0

while raiz**2 < num:
    raiz += 1
    #print(raiz)

if raiz**2 == num:
    print(f'{num} tiene Raíz cuadrada exacta, es = {raiz}')
else:
    print(f'{num} no tiene raíz cuadrada exacta, su raiz cuadrada es = {math.sqrt(num)}')```

response = True

while response == True:
    objetive = int(input('Escoge un entero: '))
    respuesta = 0
    
    while respuesta**2 < objetive:
        print(respuesta)
        respuesta += 1


    if respuesta**2 == objetive:
        print(f'La raiz cuadrada de {objetive} es {respuesta}')

    else:
        print(f'El {objetive} no tiene una raiz cuadrada exacta')

    
    print('         ¿Desea continuar?')
    print('             SI = 1')
    print('             NO = 2')
    option = int(input(': '))

    if option == 1:
        response = True

    else:
        response = False

Lo hice de esta forma

objetivo = int(input('Ingrese un numero entero'))
resultado = 1
while resultado <= objetivo:
    if resultado**2 == objetivo:
        print(f'la raiz cuadrada es: {resultado}')
    resultado+=1
    if resultado == objetivo:
        print('No se encontraron raices cuadradas')```

Dónde profundizo más sobre el tema

probar todo hasta que la encuentres, excelente frase

vscode es IDE?

Que increíble ejemplo, me encanto esta clase.

## Esta programa permita calcular la Raiz Cuadrada exacta de cualquier numero, y podemos visualizar el proceso##
objetivo = int(input('Escoge un entero: '))
resultado = 0
while resultado**2 < objetivo:
    print(resultado, 'X', resultado,'=',resultado**2)
    resultado += 1
if resultado**2 == objetivo:
    print(f'la raiz de  {objetivo} es {resultado}')
else:
 print(f'{objetivo} No tienes raiz Cuadrada Perfecta')```

Se me ocurrió colocar un numero súper grande, ya ha pasado 4 minutos y aun no da respuesta

Consejo!!
entender bien como funciona este algoritmo es escencial para entender las siguientes clases 😉

La numeración exhaustiva es lo más básico dentro de los algoritmos

Yo con mi MacBook 2015

Muy interesante este tema de enumeración exhaustiva y utilizar print para ver que esta haciendo la maquina muchas gracias por los tips.

Recuerdo que cuando estaba en la universidad utilice muchas veces un método similar para tomar medidas con sensores, donde se debían tomar cientos e incluso miles de medidas por segundo y analizarlas, y el pc lo hacia sin problema, es impresionante el poder y la velocidad que tienen los computadores hoy en día!

Otra forma:

import math


def main():
    number = int(input('write number: '))
    if(math.sqrt(number) % 1 == 0):
        print('square root')
    else:
        print('no square root')


if __name__ == "__main__":
    main()

tuve que sentarme a leer la lógica detenidamente preguntándome el porque de cada cosa cuando lo entendi fue como :

Este sería el tiempo en que se tardo en obtener la raíz cuadrada de 108638929:

Cabe mencionar que estoy trabajando con una raspberry pi4 de 8 GB de RAM. Puede variar dependiente de las características del equipo. Pero como lo menciona el profesor, las computadoras actuales son muy muy rápidas.

De esta manera lo entendí.
Ingreso: 5
CICLO
respuesta = 0
1x1= 1
2x2= 4
3x3= 9 (Me paso, me quedo con el anterior)
respuesta = 2

SI (2X2) ES IGUAL A 5
si
print(“respuesta”)
no
print(“No es exacta”)

Es como el algoritmo de “no sé nada, vamos a ver qué sale”. 😄

Excelente ejemplo y algoritmo!

12. Enumeración exhaustiva

• También llamado “adivina y verifica”.
• Las computadoras actuales son muy rápidas.
• Uno de los primeros algoritmos que debes tratar.

objetivo = int(input('Escoge un entero: '))
respuesta = 0

while respuesta**2 < objetivo:
    print(respuesta)
    respuesta += 1

if respuesta**2 == objetivo:
    print(f'La raíz cuadrada de {objetivo} es {respuesta}')
else:
    print(f'{objetivo} no tiene una raíz cuadrada exacta')

Para las personas que llegan hasta acá felicitaciones, no se rindan, ya que el profesor es uno de los mejores que he visto en Platzi hasta ahora, no te enseña solo código, sino que te enseña a pensar computacionalmente, según la lógica y eso es mucho más importante que el código, puesto que si desarrollas esa lógica, ese criterio propio lo puedes plasmar donde sea.

Excelente profesor.

Atajo para abrir la terminal en VSCode: ctrl + J

Este algoritmo en complejidad de tiempo si no estoy mal es O de N por el bucle que hace, pero la verdad no hay necesidad del bucle, simplemente es sacarle la raíz al numero, o sea, elevarlo a la 1/2 y con modulo comprobar si sobra parte decimal, si sobra parte decimal diferente de 0 no es raíz cuadrada exacta, si nos sobra 0 como parte decimal, es raíz cuadrada exacta. Así reducimos la complejidad en tiempo de este algoritmo.

Buenas! como estan? Si bien no es objeto de la clase, comparto otra solucion posible a la incognita de buscar la raiz cuadrada exacta sin realizar una enumeración exaustiva 🥴

Objetivo = int(input('Escoge un numero entero: '))
respuesta = (Objetivo ** (1/2))
if (respuesta)%1 == 0.0:
    print(f'la raiz cuadrada de {Objetivo} es {respuesta}')
else:
    print(f'{Objetivo} no tiene una raiz cuadrada exacta')

Un abrazo para todo la comunidad!

#Enumeración exhaustiva
objetivo = int(input('Escoge un entero: ')) #Encontrar la raiz cuadrada de un numero
respuesta = 0

while respuesta**2 < objetivo: #Mientras el cuadrado de un numero sea menor que el objetivo
    print(respuesta) #Di el numero actual
    respuesta += 1 #Agregale uno al numero actual

if respuesta**2 == objetivo: #Si se encuentra raiz cuadrada exacta
    print(f'La raiz cuadrada de {objetivo} es {respuesta}')  #Imprime la oracion siguiente con las variables objetivo y respuesta
else: #Si no tiene variable exacta
    print(f'{objetivo} no tiene una raiz cuadrada exacta') #Imprime lo anterior```

#variables en la memoria
objetivo = int(input('escoge un entero:'))
respuesta = 0

#mientras el valor de 'respuesta al cuadrado' es menor que 'objetivo', sumar 1 al valor 'respuesta
while respuesta**2 < objetivo:
    respuesta += 1

#si 'respuesta al cuadrado' es igual a objetiv, ejecutar print
if respuesta**2 == objetivo:
    print(f'la raiz cuadrada de {objetivo} es {respuesta}')

#de otra forma, ejecutar este print
else:
    print(f'{objetivo} no tiene raiz cuadrada')```

Ire realizando este ejercicio con cada script que escriba en adelante, me ayuda mucho a comprenderlo y si necesito revisarlo de nuevo se me hace mucho mas facil

Existen diferentes algoritmos para encontrar soluciones a problemas y uno de estos es la enumeración exhaustiva. Este se refiere a probar uno por uno todos los pasos para poder encontrar la respuesta correcta. Es una manera de poder encontrar la solución, pero una de las más ineficientes ya que estas probando uno por uno. Lo bueno es que las computadoras hoy en día son tan potentes que problemas súper complejos que requieran un montón de iteraciones se pueden realizar en cuestión de segundos. Una prueba es el siguiente código:

import time


objetivo = int(input("Escoge un entero: "))
respuesta = 0

tiempo_inicial = time.time()


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")

print(f"El programa demoró {time.time() - tiempo_inicial} segundos")```

Que buena explicación, como tip para los que vamos empezando es muy buena práctica imprimir los valores que va tomando la variable para entender como funciona el código 😃 es una de mis prácticas favoritas cuando trato de entender algún código nuevo

Ensayo y error!

muy bueno

este es mi aporte, lo hice multiplicando el mismo numero para quitar el ** 2

objetivo = int(input(f'escoge un entero: '))
respuesta = 0 

while respuesta * respuesta < objetivo:
    print(respuesta)
    respuesta += 1
if respuesta * respuesta == objetivo:
    print(f'la raiz cuadrada de objetivo {objetivo} es {respuesta}')
else:
    print(f'{objetivo} no tiene rai cuadrada exacta')

que buena clase, excelente persona.

Eso de f’{formato}’ no lo sabía, perfecto cada día se aprenden cosas nuevas!

Tengo python 3.4. Así es como lo escribí y aprendí a transformar mis enteros a strings para poder imprimir. Estoy considerando seriamente actualizar a 3.7 para poder usar print(f’’)

objetivo = int(input('Escoge un entero: '))
resultado = 0

while resultado**2 < objetivo:
    print(resultado)
    resultado += 1

if resultado**2 == objetivo:
    print('La raiz cuadrada de ' + str(objetivo) + ' es ' + str(resultado))
else:
    print(str(objetivo) + ' no tiene raiz cuadrada')

A partir de ahora PRINT STATEMENT para todo!

Es muy útil usar print() para verificar que pasa y solucionar errores lógicos

Cuando puso print(respuesta) comencé a entender el proceso. La verdad es que es genial cuando ya tenes resuelto el proceso en sí.

Para entender computacionalmente como funcionan los programas de software, es muy necesario aprender pseudocodigo con diagramas de flujo y realizar las pruebas de escritorio. Así se estimula el cerebro.

Tengo entendido que esto es parecido a la fuerza bruta o no?

El diagrama de flujo

Aqui presente mi reto, saludos

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 aproxima(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 raiz cuadrada {objetivo}')
    else:
        print(f'La raiz cudrada de {objetivo} es {respuesta}')
    
def binaria(objetivo):
    epsilon = 0.01
    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 run():
    margen('🟥')
    objetivo = int(input('Escoge un numero: '))
    margen('🟥')
    eleccion = int(input('Escoge un sistema para resolver la raiz cuadrada: 1 - Enumeración Exhaustiva | 2 - Aproximación | 3 - Búsqueda Binaria : '))
    
    if eleccion == 1:
        enumeracion(objetivo)
    elif eleccion == 2:
        aproxima(objetivo)
    elif eleccion == 3:
        binaria(objetivo)
    else:
        print(f'Escoge un número entero, {objetivo} no cumple con las indicaciones')

def margen(emoji): #Para no repetir tanto el margen
    print('')
    print('*' * 10, emoji, '*' * 10)
    print('')

margen('🏁')
print(f'Este programa es para calcular la raiz cuadra con diferentes métodos')
margen('🏁')
run()

Practica:

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 raiz cuadrada exacta')

<#Enumeracion exhaustiva

def calcular_raiz_cuadrada_exacta (objetivo)
respuesta = 0
while respuesta **2 < objetivo:
  print (respuesta)
  respuesta +=1

if respuesta**2 == objetivo:
  print ( "la raiz cuadrada de", objetivo, "es", respuesta)

else :
  print( objetivo,"no tiene una raiz cuadrada exacta")

valor_objetivo = int(input("Elige un entero: "))
resultado = calcular_raiz_cuadrada_exacta(valor_objetivo)
print(resultado)
  
#Aproximacion
epsilon = 0.001
paso = epsilon ** 2

def raiz_cuadrada(objetivo):
    respuesta = 0.0

    while abs(respuesta ** 2 - objetivo) >= epsilon and respuesta <= objetivo:
        respuesta += paso

    if abs(respuesta ** 2 - objetivo) >= epsilon:
        return f"No se encontró la raíz cuadrada de {objetivo}"
    else:
        return f"La raíz cuadrada de {objetivo} es {respuesta}"

# Ejemplo de uso
raiz_objetivo = int(input("Elige un entero: "))
resultado = raiz_cuadrada(raiz_objetivo)
print(resultado)
#Busqueda binaria

epsilon = 0.1
bajo = 0.0
alto = max(1.0, objetivo)

def raiz(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 respuesta

# Ejemplo de uso
objetivo = int(input("Elige un entero: "))
resultado = raiz(objetivo)
print('La raíz cuadrada de', objetivo, 'es', resultado)> 

Muy bueno con lo que dijo como conclusion me quedo más claro la Enumeración exhaustiva y solucionar un problema sino se tienen una mejor solución con todas las posibilidades y usar print cuando se tenga preguntas que está haciendo tal parte del código.

para poder entender que era lo que pasaba tuve que pensar en el programa como una función matematica xd

x= int(input("escoge un numero entero: ")) #y=raiz(x)
y=0
while y**2 < x:
    y+=1
if y**2 == x:
     print(f'la raiz cuadrada de {x} es {y}')
else :
     print(f'{x} no tiene raiz cuadrada exacta')

Aprendí sobre la enumeración exhaustiva en la clase y cómo se puede utilizar para resolver una amplia variedad de problemas. En la clase se vio la Enumeración Exhaustiva Este algoritmo consiste en probar todas las posibilidades hasta encontrar la respuesta correcta o determinar que no existe una respuesta exacta. Aunque puede parecer ineficiente, las computadoras actuales son lo suficientemente rápidas como para que en términos prácticos casi nunca importe. ¡Estoy emocionado de seguir aprendiendo sobre programación y algoritmos!

Enumeración exhaustiva

En términos generales, el algoritmo de enumeración exhaustiva implica la creación de un conjunto de posibles soluciones para el problema, y luego la evaluación de cada solución en busca de la mejor solución posible. En Python, esto se puede lograr mediante el uso de bucles para iterar a través de todas las posibles soluciones y compararlas entre sí.
.
Por ejemplo, si se quisiera encontrar el número más grande en una lista de números, se podría utilizar un algoritmo de enumeración exhaustiva para iterar a través de cada número en la lista y compararlo con el número anteriormente identificado como el más grande. Si se encuentra un número más grande, se reemplaza el número actual más grande con ese número.

-Ennumeración exhaustiva, ulalá señoir francés
-Entonces, cómo se dice?
-De tin marín de do pingué

<
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 exacta')
> 

Realice este ejercicio con node js:

console.log("Ingrese un numero entero: ")
const stdin = process.openStdin()
respuesta = 0

stdin.addListener("data", (data) => {
    while (respuesta**2 < Number(data)){
        console.log(respuesta)
        respuesta += 1
    }
    if( respuesta ** 2 == Number(data)){
        console.log(`La raiz cuadrada de ${Number(data)} es ${respuesta}`)
    }else{
        console.log(`${Number(data)} no tiene una raiz cuadrada exacta`)
    }
    process.exit();
})

Consiste en enumerar todas las posibilidades.
Y en cualquier caso es el primer algoritmo que debo descartar, si bien no es tan eficiente respecto a otros, es muy efectivo.
Se le puede llamar “adivina y verifica”.

entero = int(input('Por favor digita un número para calcular su raíz cuadrada exacta: '))
respuesta = 0

while respuesta **2 < entero:
		print(respuesta)
		respuesta +=1

if respuesta**2 == entero:
		print( f'La raíz cuadrada exacta de {entero} es {respuesta}')
else:
		print(f'La raíz cuadrada exacta de {entero} no existe')

Lo que estoy haciendo en el código anterior es que tome el número que le entregué y me lo eleve a la segunda potencia.

Dentro del iterador tengo un condicional que servirá para detener mi ejecución, empiezo a iterar desde 0 a n asignado a la variable respuesta, si mi respuesta tiene raíz exacta su potencia será igual al número entero que ingrese.
Es decir estoy preguntandole: ¿Qué número elevado a la 2 me devuelve mi número?

Si funciona y es muy sencillo

Como aportar una imagen en este recuadro?

Algo de teoria (libros) seria genial para profundizar al respecto

😄

😃

12-Enumeración exhaustiva

También llamado “adivina y verifica” donde enumeramos todas las posibilidades, puede ser ineficiente, pero ahora las computadoras actuales son muy rápidas. Este debe ser uno de los 1ros algoritmos en pensar a la hora de solucionar problemas.

# Calcular la raiz cuadrada
# usamos libreria time para ver el tiempo de ejecucion
import time
tiempo_inicial = time.time()

objetivo = int(input('Escoge un entero: '))
respuesta = 0
# mientras la respuesta al cuadrado sea menor que el objetivo
# aumentar la respuesta en +1
while respuesta**2 < objetivo:
    print(respuesta) # Para ver los Nros que esta probando
    respuesta += 1
# si la raiz cuadrada de objetivo -> imprimir respuesta
if respuesta**2 == objetivo:
    print(f'La raiz cuadrada de {objetivo} es {respuesta}')
else:
    print(f'{objetivo} no tiene una raiz exacta')

print(f'El programa demoró {time.time() - tiempo_inicial} mili segundos')

Holaa, hice una comparación entre la forma exhaustiva y una mejora y vean la diferencia de tiempo en segundos:

import time

def exhautivo(number):
    print("De forma exhaustiva")
    start = time.perf_counter()
    i = 0
    while i**2 < number:
        i +=1

    if i**2 == number:
        print(f"La raiz de {number} es {i}")
    else:
        print(f"El numero {number} no tiene raiz exacta")

    end = time.perf_counter()
    print(f"Tiempo: {end-start}")

def mejorado(number):
    print("\nDe forma mejorada")
    start = time.perf_counter()
    
    raiz = number**0.5

    if  raiz % 1 == 0:
        print(f"La raiz de {number} es {int(raiz)}")
    else:
        print(f"El numero {number} no tiene raiz exacta")

    end = time.perf_counter()
    print(f"Tiempo: {end-start}")


number = int(input("numero: "))
exhautivo(number)
mejorado(number)```

Les dejo este pequeño programa que calcula raíces de cualquier índice

print(’’)
print(‘Bienvenido a la calculadora de raices’)
print(’’)
cantidad_de_veces = int(input('Introduzca la cantidad de raices a calcular: '))

while (cantidad_de_veces > 0):
entero = int(input('Introduzca un numero entero: '))
raiz = int(input('Introduzca el indice de la raiz: '))
raiz = float(1/raiz)
resultado = entero ** raiz
print (resultado)
cantidad_de_veces -= 1

yo los reto a algo; yo hice este programa , el cual lo comparé con el del profe y me di cuenta que es realmente ineficiente (aunque haga lo mismo).

Mi reto es que se den cuenta por qué mi programa es ineficiente y el del profe no!!!
def is_cuadrado_exacto_v2(num:float):

aux = 0

while aux < num:
    
    if aux ** 2 == num:
        return aux
    
    aux += 1

return False

He aqui otra manera de realizar el reto…

numero = int(input("Escoge un numero entero: "))
respuesta = numero**0.5
i = 0

while i < respuesta:
    i += 1 
if i == respuesta:
    print("Tu numero tiene raiz cuadrada entera, es " + str(respuesta))
else:
    print("Tu numero no tiene raiz cuadrada entera")

Buscar hasta encontrar.

def run():
numero=int(input('Ingrese un numero '))
box={2,3,4,5,6}
if numero <=10:
print(‘su numero es menor o igual a 10’, 'Su numero es ',numero)
else:
print(‘su numero es mayor a 10’‘tu numero es’,numero)

for i in box:
    if i==numero:
        print('El numero esta en box')
    else:
         print('El numero no  esta en box')  

if name==“main”:
run()

objetivo = int(input('Escope un entero: '))
respuesta = 0

while respuesta**2 < objetivo:
    print(respuesta)
    respuesta += 1 

if respuesta**2 == objetivo:
    print(f'la rais cuadrada de {objetivo} es {respuesta}')
else:
    print(f'{objetivo} no tiene raiz cuadrada exacta')

#Enumeracion exhaustiva / adivina o verifca

objetivo = int(input("Escoje un entero: "))
respuesta = 0

while respuesta**2 < objetivo:
respuesta += 1

if respuesta**2 == objetivo:
print(‘la raiz cuadrada de ’ + str(objetivo) + str(respuesta))
else:
print(str(objetivo) + ’ no tiene raiz cuadrada exacta’)

Yo conozco la Enumeracion exhaustiva como ansiedad.

Personalmente me encanto esta clase, y la voz de locutor que tiene el profe ayuda mucho jajaja

Creo que ya entendí el propósito de este curso.