Cómo comprobar si un número es un cuadrado perfecto en Java

Introducción

En este laboratorio, aprenderás cómo determinar si un entero dado es un cuadrado perfecto en Java. Exploraremos el uso del método Math.sqrt() para calcular la raíz cuadrada de un número y luego comprobar si el resultado es un número entero.

A través de ejercicios prácticos de codificación, implementarás un programa en Java que tome la entrada del usuario, calcule la raíz cuadrada y determine si el número original es un cuadrado perfecto. También probaremos el programa con diversas entradas, incluyendo números negativos y números que no son cuadrados perfectos, para garantizar su robustez.

Calcular la raíz cuadrada y comprobar si es un entero

En este paso, escribiremos un programa en Java para calcular la raíz cuadrada de un número y determinar si el número original es un cuadrado perfecto. Un cuadrado perfecto es un entero que es el cuadrado de otro entero; en otras palabras, es el producto de un entero por sí mismo. Por ejemplo, 9 es un cuadrado perfecto porque es 3 * 3.

Utilizaremos el método Math.sqrt() proporcionado por Java para calcular la raíz cuadrada. Este método devuelve un valor de tipo double, que puede tener decimales. Para comprobar si el número original es un cuadrado perfecto, necesitamos verificar si su raíz cuadrada es un número entero.

Primero, creemos un nuevo archivo Java llamado SquareRootChecker.java en el directorio ~/project. Puedes hacer esto haciendo clic derecho en el Explorador de archivos de la izquierda y seleccionando "Nuevo archivo", luego escribiendo SquareRootChecker.java.
Abre el archivo SquareRootChecker.java en el editor y pega el siguiente código:
```
import java.util.Scanner;

public class SquareRootChecker {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter an integer: ");
        int number = scanner.nextInt();

        if (number < 0) {
            System.out.println("Cannot calculate the square root of a negative number.");
        } else {
            double squareRoot = Math.sqrt(number);

            // Check if the square root is an integer
            if (squareRoot == Math.floor(squareRoot)) {
                System.out.println(number + " is a perfect square.");
            } else {
                System.out.println(number + " is not a perfect square.");
            }
        }

        scanner.close();
    }
}
```
Veamos las nuevas partes de este código:
- import java.util.Scanner;: Volvemos a importar la clase Scanner para leer la entrada del usuario.
- System.out.print("Enter an integer: ");: Esto solicita al usuario que ingrese un número.
- int number = scanner.nextInt();: Esto lee el entero ingresado por el usuario y lo almacena en la variable number.
- if (number < 0): Esta es una instrucción if que verifica si el número ingresado es negativo. Si lo es, imprimimos un mensaje de error.
- double squareRoot = Math.sqrt(number);: Esta línea utiliza el método Math.sqrt() para calcular la raíz cuadrada del number y almacena el resultado en una variable de tipo double llamada squareRoot.
- if (squareRoot == Math.floor(squareRoot)): Esta es la lógica central para comprobar si la raíz cuadrada es un entero. Math.floor(squareRoot) devuelve el mayor entero menor o igual que squareRoot. Si squareRoot es un número entero, squareRoot y Math.floor(squareRoot) serán iguales.
- System.out.println(...): Estas líneas imprimen el resultado según si el número es un cuadrado perfecto o no.
Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, compila el programa en la Terminal:
```
javac SquareRootChecker.java
```
Si no hay errores, se creará un archivo SquareRootChecker.class.
Ejecuta el programa compilado:
```
java SquareRootChecker
```
El programa te pedirá que ingreses un entero. Ingresa un número como 9 y presiona Enter. Deberías ver una salida que indique que 9 es un cuadrado perfecto. Ejecuta el programa de nuevo e ingresa un número como 10. Deberías ver una salida que indique que 10 no es un cuadrado perfecto.
```
Enter an integer: 9
9 is a perfect square.
```
```
Enter an integer: 10
10 is not a perfect square.
```

¡Has escrito con éxito un programa en Java que calcula la raíz cuadrada y comprueba si un número es un cuadrado perfecto!

Usar Math.sqrt() para determinar cuadrados perfectos

En este paso, nos centraremos en entender cómo funciona Math.sqrt() y cómo lo utilizamos en el paso anterior para determinar si un número es un cuadrado perfecto.

El método Math.sqrt() es parte de la clase Math incorporada en Java, que proporciona muchas funciones matemáticas. Math.sqrt(double a) toma un valor double a como entrada y devuelve su raíz cuadrada como un double.

Por ejemplo:

Math.sqrt(9.0) devuelve 3.0
Math.sqrt(10.0) devuelve aproximadamente 3.1622776601683795
Math.sqrt(0.0) devuelve 0.0
Math.sqrt(-9.0) devuelve NaN (No es un número)

En nuestro programa SquareRootChecker.java, leemos un entero del usuario, pero Math.sqrt() espera un double. Java convierte automáticamente el int number a un double cuando lo pasamos a Math.sqrt().

La clave para comprobar si un número es un cuadrado perfecto radica en comparar la raíz cuadrada calculada (double squareRoot) con su valor entero más cercano por debajo (Math.floor(squareRoot)).

Si squareRoot es un número entero (como 3.0), entonces Math.floor(squareRoot) también será 3.0, y la condición squareRoot == Math.floor(squareRoot) será verdadera.
Si squareRoot tiene una parte decimal (como 3.16...), entonces Math.floor(squareRoot) será 3.0, y la condición squareRoot == Math.floor(squareRoot) será falsa.

Esta simple comparación nos permite comprobar de manera efectiva si el entero original era un cuadrado perfecto.

Vamos a volver a ejecutar el programa un par de veces para observar la salida con diferentes entradas y consolidar tu comprensión.

Asegúrate de estar en el directorio ~/project en la Terminal.
Vuelve a ejecutar el programa compilado:
```
java SquareRootChecker
```
Ingresa el número 25 y presiona Enter. Observa la salida.
```
Enter an integer: 25
25 is a perfect square.
```
Vuelve a ejecutar el programa:
```
java SquareRootChecker
```
Ingresa el número 15 y presiona Enter. Observa la salida.
```
Enter an integer: 15
15 is not a perfect square.
```

Al ejecutar el programa con diferentes entradas, puedes ver cómo la comparación entre Math.sqrt() y Math.floor() identifica correctamente los cuadrados perfectos.

Probar entradas negativas y no enteras

En este paso, probaremos nuestro programa SquareRootChecker.java con números negativos y consideraremos qué sucede si el usuario ingresa algo que no es un entero.

En el código que escribimos, incluimos una comprobación para números negativos:

if (number < 0) {
    System.out.println("Cannot calculate the square root of a negative number.");
}

Esta instrucción if maneja el caso en el que el usuario ingresa un entero negativo. Vamos a probar esta parte del código.

Asegúrate de estar en el directorio ~/project en la Terminal.
Ejecuta el programa compilado:
```
java SquareRootChecker
```
Cuando se te solicite, ingresa un número negativo, por ejemplo, -4, y presiona Enter.
```
Enter an integer: -4
Cannot calculate the square root of a negative number.
```

Como se esperaba, el programa identifica correctamente que no puede calcular la raíz cuadrada de un número negativo e imprime el mensaje adecuado.

Ahora, consideremos qué sucede si el usuario ingresa una entrada que no es un entero, como texto o un número decimal. Nuestro programa utiliza scanner.nextInt() para leer la entrada. Este método está diseñado para leer solo valores enteros. Si el usuario ingresa algo que no se puede analizar como un entero, se producirá una InputMismatchException y el programa se detendrá.

Manejar estos errores de manera adecuada es una parte importante de escribir programas robustos. Para este laboratorio introductorio, no implementaremos un manejo completo de errores para entradas no enteras, pero es importante ser consciente de que esto puede suceder. En futuros laboratorios, aprenderás técnicas como los bloques try-catch para manejar excepciones y hacer que tus programas sean más resistentes a entradas inesperadas del usuario.

Por ahora, simplemente observemos qué sucede cuando se ingresa una entrada no entera.

Vuelve a ejecutar el programa compilado:
```
java SquareRootChecker
```

Cuando se te solicite, ingresa algún texto, por ejemplo, hello, y presiona Enter.

Enter an integer: hello
Exception in thread "main" java.util.InputMismatchException
    at java.base/java.util.Scanner.throwFor(Scanner.java:939)
    at java.base/java.util.Scanner.next(Scanner.java:1594)
    at java.base/java.util.Scanner.nextInt(Scanner.java:2258)
    at java.base/java.util.Scanner.nextInt(Scanner.java:2212)
    at SquareRootChecker.main(SquareRootChecker.java:9)

Verás un mensaje de error que indica una InputMismatchException. Esto se debe a que scanner.nextInt() esperaba un entero pero recibió "hello".

Este paso destaca la importancia de considerar diferentes tipos de entrada del usuario y cómo tu programa las manejará. Si bien nuestro programa actual es sencillo, comprender estos posibles problemas es crucial para desarrollar aplicaciones más complejas.

Resumen

En este laboratorio, aprendimos cómo determinar si un entero dado es un cuadrado perfecto en Java. Utilizamos el método Math.sqrt() para calcular la raíz cuadrada del número de entrada.

La lógica central consistió en comprobar si la raíz cuadrada calculada es un número entero comparándola con su valor entero más cercano por debajo utilizando Math.floor(). También manejamos el caso de números de entrada negativos, ya que sus raíces cuadradas no son números reales. Este proceso nos permitió identificar de manera efectiva los cuadrados perfectos.