Comment vérifier si un nombre est moche en Java ?

Si les facteurs premiers d'un nombre ne comprennent que 2, 3 et 5, alors on l'appelle nombre laid.

Peut-être que certains nombres ont des facteurs premiers avec seulement un ou deux facteurs, mais ces facteurs doivent être l'un des 2, 3 et 5.

Dans cet article, nous verrons comment vérifier si un nombre est un Nombre laid ou non en utilisant le langage de programmation Java.

Pour vous montrer quelques instances

Instance-1

Le numéro d'entrée est 20.

Vérifions cela en utilisant la logique des nombres laids.

Prime factors of 20 = 2, 2, 5

Ainsi, comme vous le remarquez ici, tous les facteurs premiers incluent un seul parmi 2, 3 et 5.

Par conséquent, 20 est un chiffre moche.

Instance-2

Le numéro d'entrée est 30.

Vérifions cela en utilisant la logique des nombres laids.

Prime factors of 30 = 2, 3, 5

Ainsi, comme vous le remarquez ici, tous les facteurs premiers incluent un seul parmi 2, 3 et 5.

Par conséquent, 30 est un chiffre moche.

Instance-3

Le numéro d'entrée est 14.

Vérifions cela en utilisant la logique des nombres laids.

Prime factors of 14 = 2, 7

Donc, comme vous le remarquez ici, 7 est présent à l'un des facteurs premiers ci-dessus.

Par conséquent, 14 n’est pas un vilain nombre.

Algorithme

• Étape 1 − Nous définissons d'abord une fonction pour vérifier si le nombre saisi est un nombre premier ou non.

• Étape 2 - Collectez les entrées de l'utilisateur via une méthode statique ou une méthode définie par l'utilisateur.

• Étape 3 - Initialisez la boucle pour trouver tous les facteurs premiers du nombre d'entrée.

• Étape 4 - Après avoir trouvé les facteurs premiers, nous exécutons une condition pour vérifier si les facteurs ne contiennent que 2, 3 et 5.

• Étape 5 - Si la condition est vraie, alors nous imprimons le numéro d'entrée est un nombre laid, sinon le numéro d'entrée n'est pas un nombre laid.

Approches multiples

Nous proposons des solutions de différentes manières.

• En utilisant des valeurs d'entrée statiques

• En utilisant la méthode définie par l'utilisateur

Regardons le programme Java et sa sortie un par un.

Approche 1 : en utilisant la valeur d'entrée statique

Dans cette approche, une valeur entière positive non−zéro sera initialisée dans le programme, puis en utilisant l'algorithme, nous pourrons vérifier si un nombre est un nombre laid ou non.

Exemple

import java.util.Scanner;
public class Main {
   public static void main(String args[]) {

      //declare a variable with a static value
      int inputNumber = 25;

      //declare a variable with boolean value
      boolean check = true;

      //initialise the loop for the checking of ugly number
      for(int i = 2; i<=inputNumber; i++) {

      // checks whether numbers only include 2,3 and 5
         if(i!=2&&i!=3&&i!=5) {

         // Checks if there are some other prime factors
            if(inputNumber%i==0&&checkPrime(i)) {

            // Sets the flag to false if there are some other prime factors
               check = false;
               break;
            }

         }
      }
      if(check) {
         System.out.println(inputNumber+" is an ugly number");
      } else {
         System.out.println(inputNumber+" is Not an ugly number");
      }
   }

   // Function that checks for prime
   static boolean checkPrime(int number) {
      boolean flag = true;
      for(int i = 2; i<=number/2; i++) {
         if(number%i==0) {
            flag = false;
            break;
         }
      }
      return flag;
   }
}

Sortie

25 is an ugly number

Approche-2 : en utilisant la méthode définie par l'utilisateur

Dans cette approche, une valeur entière positive non−zéro sera initialisée dans le programme, puis nous appellerons une méthode définie par l'utilisateur en passant ce numéro d'entrée en paramètre.

Dans cette méthode, nous utiliserons un algorithme pour vérifier si un nombre est un nombre laid.

Exemple

import java.util.Scanner;
public class Main {
   //initialise main method
   public static void main(String[] args) {

      //declare a variable with a static value
      int inp = 56;

      //check whether our condition is true or not in user defined method
      //if true number is ugly otherwise not
      if(checkUgly(inp)) {
         System.out.println(inp+" is an ugly number");
      } else {
         System.out.println(inp+" is Not an ugly number");
      }

   }
   // Function that checks for prime
   static boolean checkPrime(int number) {
      boolean flag = true;
      for(int i = 2; i<=number/2; i++) {
         if(number%i==0) {
            flag = false;
            break;
         }
      }
      return flag;
   }

   //define the user defined method
   //checking for ugly number
   public static boolean checkUgly(int inputNumber) {

      //declare a variable with boolean value
      boolean check = true;

      //initialise the loop for the checking of Ugly number
      for(int i = 2; i<=inputNumber; i++) {

         // checks whether numbers only include 2,3 and 5
         if(i!=2&&i!=3&&i!=5) {

            // Checks if there are some other prime factors
            if(inputNumber%i==0&&checkPrime(i)) {

               // Sets the flag to false if there are some other prime factors
               return false;
            }

         }
      }
      return true;
   }
}

Sortie

56 is Not an ugly number

Dans cet article, nous avons exploré comment vérifier un nombre s'il s'agit d'un nombre laid ou non en Java en utilisant différentes approches.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!