Comment vérifier si un nombre est un carré parfait en Java

Introduction

Dans ce laboratoire, vous apprendrez à déterminer si un entier donné est un carré parfait en Java. Nous explorerons l'utilisation de la méthode Math.sqrt() pour calculer la racine carrée d'un nombre, puis vérifierons si le résultat est un nombre entier.

Grâce à des exercices pratiques de codage, vous allez implémenter un programme Java qui prend en compte les entrées de l'utilisateur, calcule la racine carrée et détermine si le nombre original est un carré parfait. Nous testerons également le programme avec diverses entrées, y compris des nombres négatifs et des nombres qui ne sont pas des carrés parfaits, pour garantir sa robustesse.

Calculer la racine carrée et vérifier si c'est un entier

Dans cette étape, nous allons écrire un programme Java pour calculer la racine carrée d'un nombre et déterminer si le nombre original est un carré parfait. Un carré parfait est un entier qui est le carré d'un autre entier ; en d'autres termes, c'est le produit d'un entier par lui-même. Par exemple, 9 est un carré parfait car c'est égal à 3 * 3.

Nous allons utiliser la méthode Math.sqrt() fournie par Java pour calculer la racine carrée. Cette méthode renvoie une valeur de type double, qui peut avoir des décimales. Pour vérifier si le nombre original est un carré parfait, nous devons vérifier si sa racine carrée est un nombre entier.

Tout d'abord, créons un nouveau fichier Java nommé SquareRootChecker.java dans votre répertoire ~/project. Vous pouvez le faire en cliquant avec le bouton droit dans l'explorateur de fichiers à gauche et en sélectionnant "Nouveau fichier", puis en tapant SquareRootChecker.java.
Ouvrez le fichier SquareRootChecker.java dans l'éditeur et collez le code suivant :
```
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();
    }
}
```
Examinons les nouvelles parties de ce code :
- import java.util.Scanner; : Nous importons à nouveau la classe Scanner pour lire les entrées de l'utilisateur.
- System.out.print("Enter an integer: "); : Cela invite l'utilisateur à entrer un nombre.
- int number = scanner.nextInt(); : Cela lit l'entier saisi par l'utilisateur et le stocke dans la variable number.
- if (number < 0) : C'est une instruction if qui vérifie si le nombre saisi est négatif. Si c'est le cas, nous affichons un message d'erreur.
- double squareRoot = Math.sqrt(number); : Cette ligne utilise la méthode Math.sqrt() pour calculer la racine carrée du number et stocke le résultat dans une variable de type double appelée squareRoot.
- if (squareRoot == Math.floor(squareRoot)) : C'est la logique principale pour vérifier si la racine carrée est un entier. Math.floor(squareRoot) renvoie le plus grand entier inférieur ou égal à squareRoot. Si squareRoot est un nombre entier, squareRoot et Math.floor(squareRoot) seront égaux.
- System.out.println(...) : Ces lignes affichent le résultat en fonction de si le nombre est un carré parfait ou non.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, compilez le programme dans le terminal :
```
javac SquareRootChecker.java
```
S'il n'y a pas d'erreurs, un fichier SquareRootChecker.class sera créé.
Exécutez le programme compilé :
```
java SquareRootChecker
```
Le programme vous invitera à entrer un entier. Entrez un nombre comme 9 puis appuyez sur Entrée. Vous devriez voir un message indiquant que 9 est un carré parfait. Exécutez le programme à nouveau et entrez un nombre comme 10. Vous devriez voir un message indiquant que 10 n'est pas un carré parfait.
```
Enter an integer: 9
9 is a perfect square.
```
```
Enter an integer: 10
10 is not a perfect square.
```

Vous avez réussi à écrire un programme Java qui calcule la racine carrée et vérifie si un nombre est un carré parfait !

Utiliser Math.sqrt() pour vérifier un carré parfait

Dans cette étape, nous allons nous concentrer sur la compréhension du fonctionnement de Math.sqrt() et sur la manière dont nous l'avons utilisé dans l'étape précédente pour déterminer si un nombre est un carré parfait.

La méthode Math.sqrt() fait partie de la classe Math intégrée à Java, qui propose de nombreuses fonctions mathématiques. Math.sqrt(double a) prend une valeur de type double a en entrée et renvoie sa racine carrée sous forme de double.

Par exemple :

Math.sqrt(9.0) renvoie 3.0
Math.sqrt(10.0) renvoie approximativement 3.1622776601683795
Math.sqrt(0.0) renvoie 0.0
Math.sqrt(-9.0) renvoie NaN (Not a Number - Pas un nombre)

Dans notre programme SquareRootChecker.java, nous lisons un entier saisi par l'utilisateur, mais Math.sqrt() attend un double. Java convertit automatiquement l'entier number en double lorsque nous le passons à Math.sqrt().

La clé pour vérifier si un nombre est un carré parfait réside dans la comparaison de la racine carrée calculée (double squareRoot) avec sa valeur arrondie à l'entier inférieur (Math.floor(squareRoot)).

Si squareRoot est un nombre entier (comme 3.0), alors Math.floor(squareRoot) sera également égal à 3.0, et la condition squareRoot == Math.floor(squareRoot) sera vraie.
Si squareRoot a une partie décimale (comme 3.16...), alors Math.floor(squareRoot) sera égal à 3.0, et la condition squareRoot == Math.floor(squareRoot) sera fausse.

Cette simple comparaison nous permet de vérifier efficacement si l'entier original était un carré parfait.

Réexécutons le programme quelques fois pour observer la sortie pour différentes entrées et consolider votre compréhension.

Assurez-vous d'être dans le répertoire ~/project dans le terminal.
Exécutez à nouveau le programme compilé :
```
java SquareRootChecker
```
Entrez le nombre 25 puis appuyez sur Entrée. Observez la sortie.
```
Enter an integer: 25
25 is a perfect square.
```
Exécutez le programme à nouveau :
```
java SquareRootChecker
```
Entrez le nombre 15 puis appuyez sur Entrée. Observez la sortie.
```
Enter an integer: 15
15 is not a perfect square.
```

En exécutant le programme avec différentes entrées, vous pouvez voir comment la comparaison entre Math.sqrt() et Math.floor() identifie correctement les carrés parfaits.

Tester les entrées négatives et non entières

Dans cette étape, nous allons tester notre programme SquareRootChecker.java avec des nombres négatifs et examiner ce qui se passe si l'utilisateur entre quelque chose qui n'est pas un entier.

Dans le code que nous avons écrit, nous avons inclus une vérification pour les nombres négatifs :

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

Cette instruction if gère le cas où l'utilisateur entre un entier négatif. Testons cette partie du code.

Assurez-vous d'être dans le répertoire ~/project dans le terminal.
Exécutez le programme compilé :
```
java SquareRootChecker
```
Lorsque vous êtes invité, entrez un nombre négatif, par exemple, -4, puis appuyez sur Entrée.
```
Enter an integer: -4
Cannot calculate the square root of a negative number.
```
Comme prévu, le programme identifie correctement qu'il ne peut pas calculer la racine carrée d'un nombre négatif et affiche le message approprié.

Maintenant, examinons ce qui se passe si l'utilisateur entre une entrée qui n'est pas un entier, comme du texte ou un nombre décimal. Notre programme utilise scanner.nextInt() pour lire l'entrée. Cette méthode est conçue pour lire uniquement des valeurs entières. Si l'utilisateur entre quelque chose qui ne peut pas être interprété comme un entier, une InputMismatchException se produira et le programme plantera.

Gérer ces erreurs de manière élégante est une partie importante de l'écriture de programmes robustes. Pour ce laboratoire introductif, nous n'implémenterons pas une gestion complète des erreurs pour les entrées non entières, mais il est important de savoir que cela peut arriver. Dans les futurs laboratoires, vous apprendrez des techniques telles que les blocs try-catch pour gérer les exceptions et rendre vos programmes plus résistants aux entrées inattendues de l'utilisateur.

Pour l'instant, observons simplement ce qui se passe lorsque vous entrez une entrée non entière.

Exécutez à nouveau le programme compilé :
```
java SquareRootChecker
```

Lorsque vous êtes invité, entrez du texte, par exemple, hello, puis appuyez sur Entrée.

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)

Vous verrez un message d'erreur indiquant une InputMismatchException. Cela est dû au fait que scanner.nextInt() attendait un entier mais a reçu "hello".

Cette étape souligne l'importance de prendre en compte différents types d'entrées utilisateur et de savoir comment votre programme les gérera. Bien que notre programme actuel soit simple, comprendre ces problèmes potentiels est crucial pour le développement d'applications plus complexes.

Résumé

Dans ce laboratoire, nous avons appris à déterminer si un entier donné est un carré parfait en Java. Nous avons utilisé la méthode Math.sqrt() pour calculer la racine carrée du nombre d'entrée.

La logique principale consistait à vérifier si la racine carrée calculée est un nombre entier en la comparant à sa valeur arrondie à l'entier inférieur en utilisant Math.floor(). Nous avons également géré le cas des nombres d'entrée négatifs, car leurs racines carrées ne sont pas des nombres réels. Ce processus nous a permis d'identifier efficacement les carrés parfaits.