Numéro Armstrong dans le programme JAVA utilisant la boucle For

⚡ Résumé intelligent

Les nombres d'Armstrong sont égaux à la somme de leurs chiffres élevés à la puissance du nombre de chiffres, et les deux Java Les programmes ci-dessous vérifient une seule valeur et listent tous les nombres d'Armstrong inférieurs à mille.

  • (I.e. Définition: Pour un nombre à n chiffres, chaque chiffre est élevé à la puissance n et les résultats sont additionnés.
  • ☑️ Exemple concret : 370 est admissible car 3³ plus 7³ plus 0³ donnent exactement 370.
  • ✅ DigitExtraction: L'opérateur modulo supprime le dernier chiffre et la division entière raccourcit le nombre à chaque itération.
  • 🧪 Deux programmes : L'un teste une valeur codée en dur de 153, l'autre parcourt tous les nombres de 0 à 999.
  • ️ Limite connue : Mettre chaque chiffre au cube ne fonctionne que pour les valeurs à trois chiffres, donc les plages plus larges nécessitent la puissance de n.
  • (I.e. Complexité: Les deux programmes s'exécutent en temps O(d) par nombre et utilisent O(1) de mémoire supplémentaire.

numéro d'Armstrong Java programme utilisant une boucle for

Qu’est-ce que le nombre d’Armstrong ?

Dans un nombre Armstrong, la somme des puissances des chiffres individuels est égale au nombre lui-même.

En d’autres termes, l’équation suivante sera vraie

xy..z = xn + yn+.....+ zn

n est le nombre de chiffres du nombre

Par exemple, il s'agit d'un numéro Armstrong à 3 chiffres.

370 = 33 + 73 + 03
 = 27 + 343 + 0
 = 370

Exemples d'Armstrong Numbers

0, 1, 4, 5, 9, 153, 371, 407, 8208, etc.

Tout chiffre de 0 à 9 satisfait trivialement cette règle, car un nombre à un chiffre élevé à la puissance un se répète. L'ensemble complet des nombres d'Armstrong à trois chiffres comprend 153, 370, 371 et 407, tandis que 1634, 8208 et 9474 sont les nombres à quatre chiffres. Les mathématiciens qualifient également ces nombres de nombres narcissiques, car chacun se reproduit à partir de ses propres chiffres.

Écrivons ceci dans un programme :

Fonctionnement de l'algorithme du nombre d'Armstrong

Avant de lire le code, il est utile de comprendre les opérations arithmétiques répétées par les deux programmes. La vérification ne nécessite que trois opérations : supprimer le dernier chiffre, l’élever à la puissance requise et raccourcir le nombre d’une position.

  1. Copiez les données d'entrée dans un fichier de travail. variable La valeur initiale est donc conservée pour la comparaison finale.
  2. Prenez le dernier chiffre avec l'opérateur modulo, digit = tempNumber % 10.
  3. Élevez ce chiffre à la puissance du nombre de chiffres et ajoutez-le au total cumulé.
  4. Supprimez le dernier chiffre par division entière, tempNumber /= 10.
  5. Répétez l'opération jusqu'à ce que la variable de travail atteigne 0, puis comparez le total cumulé au nombre initial.

L'exécution de ces étapes sur 153 produit le trace ci-dessous. Chaque valeur du tableau est affichée par le premier programme, ce qui permet de comparer la sortie ligne par ligne lors de l'apprentissage de la boucle.

Passé numéro temporaire chiffre somme du cube numérique
1 153 3 27
2 15 5 152
3 1 1 153
Sortie 0 - 153 est égal à 153, donc 153 est un nombre d'Armstrong.

Une limitation importante. Les deux programmes multiplient le chiffre par lui-même trois fois, ce qui correspond à la puissance correcte uniquement lorsque l'entrée comporte exactement trois chiffres. La règle générale consiste à élever chaque chiffre à la puissance n, où n est le nombre de chiffres. Ainsi, une valeur à quatre chiffres comme 8208 nécessite une puissance quatrième et ne serait pas prise en compte par un code basé sur le cube. Compter les chiffres au préalable et élever chacun d'eux à la puissance correspondante transforme la routine en un test général.

Une fois les calculs effectués, le premier programme les applique à une seule valeur codée en dur.

Java Programme pour vérifier si un numéro est un numéro Armstrong

La classe ci-dessous stocke le candidat dans inputArmstrongNumber et affiche les variables de travail à chaque passage, ce qui rend Java Boucle facile à suivre dans une console.

//ChecktempNumber is Armstrong or not using while loop
package com.guru99;
 
public class ArmstrongNumber {
	public static void main(String[] args) {
		 int inputArmstrongNumber = 153; //Input number to check armstrong  
		 int tempNumber, digit, digitCubeSum = 0;
	       tempNumber = inputArmstrongNumber;
	        while (tempNumber != 0)
	        {
	        	/* On each iteration, remainder is powered by thetempNumber of digits n
	        	 */
	            System.out.println("Current Number is "+tempNumber);
	            digit =tempNumber % 10;
				System.out.println("Current Digit is "+digit);
	            //sum of cubes of each digits is equal to thetempNumber itself
	            digitCubeSum = digitCubeSum + digit*digit*digit;
				System.out.println("Current digitCubeSum is "+digitCubeSum);
	            tempNumber /= 10;
	        }
	        //check giventempNumber and digitCubeSum is equal to or not 
	        if(digitCubeSum == inputArmstrongNumber)
	            System.out.println(inputArmstrongNumber + " is an Armstrong Number");
	        else
	            System.out.println(inputArmstrongNumber + " is not an Armstrong Number");
	}
}

Compilez et exécutez la classe depuis la racine du projet. Car le fichier déclare package com.guru99il doit être placé dans un endroit assorti com/guru99 Le dossier, ou l'environnement d'exécution signale une erreur de classe introuvable. Modifier la valeur sur le inputArmstrongNumber Une simple ligne suffit pour tester un autre candidat.

Sortie

Current Number is 153
Current Digit is 3
Current digitCubeSum is 27
Current Number is 15
Current Digit is 5
Current digitCubeSum is 152
Current Number is 1
Current Digit is 1
Current digitCubeSum is 153
153 is an Armstrong Number

Vérifier une valeur à la fois est utile pour tracmais la même logique s'étend à toute une gamme par enroulementping il se trouve dans une boucle externe.

Java Programme pour imprimer les nombres Armstrong de 0 à 999

La deuxième version conserve la même structure interne. while boucle et ajoute un for boucle qui parcourt le champ de tir. Notez que digitCubeSum La valeur est réinitialisée à 0 au début de chaque passe, un détail que la plupart des débutants oublient.

//ChecktempNumber is Armstrong or not using while loop
package com.guru99;
public class ArmstrongNumber {
    public static void main(String[] args) {
        int tempNumber, digit, digitCubeSum;
        for (int inputArmstrongNumber = 0; inputArmstrongNumber < 1000; inputArmstrongNumber++) {
            tempNumber = inputArmstrongNumber;
            digitCubeSum = 0;
            while (tempNumber != 0) {
                /* On each iteration, remainder is powered by thetempNumber of digits n
                 */
                digit = tempNumber % 10;
                //sum of cubes of each digits is equal to thetempNumber itself
                digitCubeSum = digitCubeSum + digit * digit * digit;
                tempNumber /= 10;
            }
            //check giventempNumber and digitCubeSum is equal to or not 
            if (digitCubeSum == inputArmstrongNumber)
                System.out.println(inputArmstrongNumber + " is an Armstrong Number");
        }
    }
}

Sortie

0 is an Armstrong Number
1 is an Armstrong Number
153 is an Armstrong Number
370 is an Armstrong Number
371 is an Armstrong Number
407 is an Armstrong Number

La liste s'arrête à 1 au lieu de continuer jusqu'à 9 car le cube d'un seul chiffre ne correspond qu'au chiffre lui-même pour 0 et 1. Élever chaque chiffre à la puissance de son nombre permettrait plutôt de renvoyer les dix valeurs à un seul chiffre, ce qui correspond à la même généralisation décrite précédemment.

Les deux listes sont suffisamment courtes pour servir de référence, il est donc pertinent d'indiquer explicitement le coût de cette approche.

Complexité temporelle et spatiale du programme numérique d'Armstrong

La boucle interne divise la variable de travail par 10 à chaque itération, ce qui signifie qu'elle s'exécute une fois par chiffre plutôt qu'une fois par unité du nombre. Ainsi, la vérification d'une valeur unique est extrêmement rapide, et elle le reste même lorsque la valeur d'entrée augmente.

Programme Complexité temporelle Complexité spatiale
Cochez un numéro O(d), où d est le nombre de chiffres O (1)
Analyser une plage de N nombres O(N × d) O (1)

Parce que d est égal au logarithme10(Nombre) arrondi à l'entier supérieur, la vérification unique est effectivement logarithmique par rapport à la valeur testée. Seulement trois int Les variables ne sont jamais allouées et aucun tableau ni collection n'est créé, c'est pourquoi le coût en espace reste constant quelle que soit la taille de la plage.

Deux remarques pratiques découlent de ceci. Premièrement, le balayage de la plage est dominé par N, donc imprimer les nombres d'Armstrong jusqu'à un million coûte environ mille fois plus cher que de les imprimer jusqu'à mille. Deuxièmement, un int Les valeurs dépassent 2 147 483 647, une recherche sur de très grandes plages nécessite donc… long pour le candidat et le total cumulé. Le même chiffre-extracCe schéma de connexion apparaît dans de nombreux exercices pour débutants, notamment dans le vérification des nombres premiers, le Série Fibonacci exercices de programmation et de tableaux tels que tri à bulles et tri par insertion.

FAQ

Oui. En élevant chaque chiffre au cube, on obtient 27 + 343 + 1, soit 371 ; la valeur se reproduit donc d'elle-même. Le programme de calcul de plage ci-dessus l'affiche avec 153, 370 et 407.

Le nom reflète la propriété elle-même : le nombre est entièrement composé de ses propres chiffres, il semble donc admirer son propre reflet. Les deux termes décrivent la même règle, et la somme des puissances des chiffres est parfois appelée invariant numérique plus-que-parfait.

Il y en a trois : 1634, 8208 et 9474. Chaque chiffre est élevé à la puissance quatre car la valeur comporte quatre chiffres. Le codage cubique ne peut pas les détecter, c’est pourquoi l’exposant doit suivre le nombre de chiffres.

Un nombre parfait est égal à la somme de ses diviseurs propres ; ainsi, 6 est un nombre parfait car 1 + 2 + 3. Un nombre d'Armstrong est égal à la somme des puissances de ses chiffres. Ces deux définitions n'ont aucune arithmétique commune et se recoupent rarement.

La fonction Math.pow() renvoie un nombre décimal (double), ce qui nécessite une conversion en entier (int) et peut entraîner des erreurs d'arrondi. Pour un cube donné, la méthode chiffre*chiffre*chiffre est plus rapide et plus précise. Math.pow() n'est utile que lorsque l'exposant varie en fonction du nombre de chiffres.

Oui. Une méthode auxiliaire peut prendre la valeur de travail, ajouter le dernier chiffre à la puissance à un accumulateur et s'appeler elle-même avec le nombre divisé par 10. C'est lisible, bien que la version avec boucle évite les cadres de pile supplémentaires.

Les assistants modernes peuvent effectuer un passage en mode contournement trace) Reformulez la boucle en langage clair et suggérez des cas limites tels que 0 ou une entrée négative. Vérifiez le trace par rapport à la sortie console réelle, car les guides générés sautent parfois une itération.

Copilote GitHub La boucle se termine généralement à partir du seul nom de la méthode, mais le cube est souvent codé en dur. Indiquez le nombre de chiffres souhaité dans l'invite de commande, puis compilez et testez la suggestion avant de vous y fier.

Résumez cet article avec :