Numéros heureux en Java

Les nombres heureux sont des nombres entiers positifs non nuls. Si nous trouvons la somme des carrés de chaque chiffre, répétez ce processus jusqu'à ce que le nombre soit égal à 1 (un). Sinon, on l’appelle Numéro Malheureux ou Numéro Triste. Ainsi, dans cet article, nous discuterons en détail des nombres heureux en Java.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Des exemples de nombres heureux sont 1, 7, 10, 13, 19, 23, 28, 31, 32, etc.

Logique derrière les nombres heureux en Java :

Example: 23 is a Happy Number or Not.	Example: 11 is a Happy Number or Not.
Step1: 22 + 32 = 13	Step1: 12 + 12 = 2
Step2: 12 + 32 = 10	Step2: 22 = 4
Step3: 12 + 02 =1
Output: 1(one), So 23 is a Happy number.	Output: 4(four), So 11 is an Unhappy number.

Exemple :

23 est un nombre heureux ou non.

Exemple :

11 est un nombre heureux ou non.

Étape 1 :

2² + 3² = 13

Étape 1 : 1² + 1² = 2 Étape 2 : 1² + 3² = 10 Étape 2 :

2² = 4

Étape 3 : 1² + 0² =1 Sortie : 1(un), donc 23 est un nombre heureux. Sortie :

 4(quatre), donc 11 est un nombre malheureux.

Algorithme pour trouver des nombres heureux en Java Voici les différentes étapes pour trouver des nombres heureux en Java.

Étape 1 : Pour saisir un nombre positif non nul à partir du clavier et l'attribuer à la variable appelée nombre.

Étape 2 : Calculez le reste en divisant (%) le nombre donné par 10 (%).

Étape 3 : Calculez le carré de la valeur restante et ajoutez-le à une somme variable.

Étape 4 : Diviser (/) le nombre par 10.

Étape 5 : Répétez l'étape : 2 à l'étape : 4 jusqu'à ce que nous obtenions la somme du carré de tous les chiffres du nombre donné.

Étape 6 : La valeur d'addition finale est stockée dans la somme variable.

Étape 7 :

Définir une variable appelée résultat et l'initialiser avec la valeur d'un nombre.

• Étape 8 :
• Si la valeur du résultat n'est pas égale à 1 ou 4, nous appellerons simplement la méthode créée pour la répéter.

Étape 9 :

Si la valeur du résultat est définie sur 1, il imprime « C'est un nombre heureux » ; sinon, il affiche « Ce n'est pas un numéro heureux. »

Remarque :

Dans Happy Number, le nombre n'est pas affecté par l'insertion/suppression de zéros d'un côté ou de l'autre.

import java.util.*;
public class HappyNumber
{
public static int checkHappyNumber (int number)
{
int rem = 0, sum = 0;
// calculate the sum of squares of each digits
while(number > 0)
{
rem = number %10;
sum = sum+(rem*rem);
number = number/10;
}
return sum;
}
public static void main(String[] args)
{
// Take number from KeyBoard
Scanner sc = new Scanner (System.in);
System.out.print("Enter a non-zero Positive Number:");
int number = sc.nextInt( );
int result = number;
while (result != 1 && result != 4)
{
result = checkHappyNumber(result);
}
if (result ==1)
{
System.out.println ("It is a Happy Number");
}
else
{
System.out.println (" It is not a Happy Number");
}
}
}

Si un nombre est un nombre heureux, c'est-à-dire qu'une séquence d'un nombre est heureuse. Par exemple, 23 est un nombre heureux ; cela indique que la séquence de nombres comme 13,10,1 devrait être un nombre heureux.

Si finalement la somme des carrés de ses chiffres est égale à 4(quatre), c'est à dire qu'il est malheureux. Exemples

Voici les différents exemples de vérification des nombres heureux en Java.

Exemple n°1

Nous créons une méthode checkHappyNumber() pour vérifier si le numéro donné sera ou non un Happy Number.

Code :

import java.util. *;
public class Main
{
public static Boolean checkHappyNumber(int number)
{
Set<Integer> digits=new HashSet<Integer>();
while(digits.add(number))
{
int result = 0;
while(number > 0)
{
result += Math.pow(number % 10, 2);
number = number/10;
}
number = result;
}
return number == 1;
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.println ("Enter a non-zero integer number :");
int number = sc.nextInt();
System.out.println(checkHappyNumber(number)?"It is a Happy Number":"It is an Unhappy Number");
}
}

Sortie :

Exemple n°2

Nous créons une méthode checkHappyNumber() pour vérifier si le numéro donné sera ou non un Happy Number.

Code :

Sortie

import java.util.*;
public class HappyNumber
{
public static int checkHappyNumber(int number)
{
int rem = 0,sum = 0;
// calculate the sum of squares of digits
while(number >0)
{
rem = number%10;
sum = sum + (rem*rem);
number = number/10;
}
return sum;
}
public static void main(String[] args)
{
// Take starting and ending number from keyboard
Scanner sc = new Scanner(System.in);
System.out.print("Enter the Starting Number:");
int i=sc.nextInt();
System.out.print("Enter the Ending Number:");
int j=sc.nextInt();
System.out.println("The happy numbers between "+i+" and "+j+" are: ");
for (int x=i ; x <= j; x++)
{
int result = x;
//Happy number always ends with 1 and unhappy number ends with 4
while(result != 1 && result != 4)
{
result = checkHappyNumber(result);
}
if(result == 1)
System.out.print(x + ",");
}
}
}

 :
Exemple #3 Nous créons une méthode checkHappyNumber() pour vérifier que tous les nombres entre une plage de nombres sont des nombres heureux ou non et imprimons la liste des nombres heureux. Code :

Sortie

 : Conclusion Dans cet article, nous discuterons spécialement des Happy Numbers en Java. C'est un numéro fascinant. La somme des carrés de chaque chiffre et répétez le même processus pour obtenir 1 finalement. Après avoir compilé tous les processus, si le résultat n'est pas égal à 1 ou 4, on l'appelle Numéro Malheureux ou Numéro Triste. Comme les nombres heureux, tous les membres de sa séquence sont également mécontents si un nombre est malheureux. Nous proposons différents programmes Java pour vérifier les Happy Numbers en utilisant différentes méthodes Java.

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!