Nombre d'Armstrong En Python et/ou C(++)

[alfranz]

J'ai besoin d'imprimer tous les nombres armstrong entre 1 et 10000. Mon problème est que lorsque j'exécute mon programme et que j'atteins 150, il ne fait rien.

Code

(1^3) + ((5^3)-1) + (0^3)

au lieu de

Code

(1^3) + (5^3) + (0^3).

Est-ce un bug du compilateur ? Est-il nécessaire de réinstaller mon compilateur ? J'utilise actuellement des blocs de code.

Code

#include <iostream>
#include <math.h>

using namespace std;

int main()
{
    for(int i = 0;i <= 10000;++i)
    {
        int r = i;
        int dig = 0;
        while(r != 0)
        {
            dig++;
            r /= 10;
        }
        int n = i, sum = 0;
        while(n != 0)
        {
            int d = n % 10;
            sum += pow(d, dig);
            n /= 10;
        }
        if(sum == i)
            cout << i << ' ';
    }
    cout << "\n\n\n";
    return 0;
}

En conséquence, il n'imprime pas 153 (un nombre d'Armstrong), car la somme est de 152. Je ne sais pas si d'autres nombres effectuent la même chose. Mais j'ai vérifié jusqu'à 200 en utilisant cette source et il n'y a aucun problème avec les autres chiffres sauf ceux de la zone 150-160.

Ce message a été modifié par Phil J. Fry - 31 Mar 2023, 12:31.

Raison de l'édition : Titre

[hubeert]

bonjour;

Je ne connais pas le python mais le code suivant ' action script 3.0 est facilement adaptable je crois le "trace " d'action script correspond au "print" du python le reste ne sont que des boucles, j'ai priviliégié les boucles car la boucle while incluent des calculs supplémentaires ( à voir selon les langages)..
J'ai tenté aussi une approche par les nombres en base 2, sans succès. Ce code trouve les nombres Armstrong dit narcissique. Ce code a un défaut il compare la somme de cube ou de puissance dont le total est nettement supérieure à l'intervalle sur laquelle porte les recherches, par exemple 9999 des la première élévation à a la puissance 4, on a 9⁴= 6561 de toute évidence au deuxième 9 on va être au dessus de 10 000, je n'ai pas cherché a résoudre le problème car il induit des comparaisons qui risquent d'alourdir le code voire sa célérité.( à voir)

une question cette recherche des nombres Armstrong est pédagogique ou a un utilité particulière?

Code

var s:i,nt// somme
var i:int
var j:int
var k:int
var n:int;
var l:int;
var ex:int // exposant
var compteur:int=0
        
                for(i=0;i<=9;i++){ // quatre boucles pour tester les 10 000 nombres
                 for(j=0;j<=9;j++){
                  for(k=0;k<=9;k++){
                   for(l=0;l<=9;l++){
                       n=compteur++;  // la variablle compteur qui affiche ces nombres
            if( compteur< 1000) { ex=3 } // on teste les nombres en dessous de 1000; en effet ceux ci seront representés par  3 chifres  et ces trois chiffres seront elevés au cube
            if( compteur > 999){ ex=4;}    // on teste les nombres en dessus de 1000; en effet ceux ci seront representés par 4  chifres  et ces 4 chiffres seront elevés a la puissance 4    
            s=Math.pow(i,ex)+Math.pow(j,ex)+Math.pow(k,ex)+Math.pow(l,ex); // On élève les trois ou les quatre chiffre au cube ou à la puissance 4 selon les conditions
            if (s==n && n>=100) trace (s + " est un nombre armstrong") // On compare les nombres  donnés par le compteur aux nombres donné par le calcul de la somme des puissances, si ce nombre est similaire nous avons un armstrong
                
            }}}}

et la sortie les nombres Armstrong pour 10 000

153 est un nombre armstrong
370 est un nombre armstrong
371 est un nombre armstrong
407 est un nombre armstrong
1634 est un nombre armstrong
8208 est un nombre armstrong
9474 est un nombre armstrong

en langage C

Code

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main(int argc, const char * argv[]) {
    int s=0;// somme
    int i=0, j=0 ,k=0, n=0 , l=0,compteur=0;
    int ex=0; // exposant
  
            
                    for(i=0;i<=9;i++){ // quatre boucles pour tester les 10 000 nombres
                     for(j=0;j<=9;j++){
                      for(k=0;k<=9;k++){
                       for(l=0;l<=9;l++){
                           n=compteur++;  // la variablle compteur qui affiche ces nombres
                           if( compteur< 1000) { ex=3;} // on teste les nombres en dessous de 1000; en effet ceux ci seront representés par  3 chifres  et ces trois chiffres seront elevés au cube
                if( compteur > 999){ ex=4;}    // on teste les nombres en dessus de 1000; en effet ceux ci seront representés par 4  chifres  et ces 4 chiffres seront elevés a la puissance 4
                s =  pow(i,ex)+ pow(j,ex)+  pow(k,ex)+  pow(l,ex); // On élève les trois ou les quatre chiffre au cube ou à la puissance 4 selon les conditions
                           if (s==n && n>=100) printf ( " %d           est un nombre armstrong \n",s);// On compare les nombres  donnés par le compteur aux nombres donné par le calcul de la somme des puissances, si ce nombre est similaire nous avons un armstrong
                    
                }}}}
    return 0;
}

Ce message a été modifié par hubeert - 8 Apr 2023, 12:48.

[hubeert]

bonjour ; :

que veux tu dire par ta note : Note : Les nombres à 4 chiffres trouvés par le javascript ne sont pas des nombres d'Armstrong de quel javascript parles tu ?et de quel nombre ?

sinon 9474 = 9⁴+4⁴+ 7⁴+4⁴ . = 6561+ 256 + 2401 + 256 = 9474 ce qui correspond a la définition d'un Armstrong

un nombre égal à la somme de tous ses chiffres élevés à la puissance correspondante aux nombre de chiffre le composant ( ici 4)

Sinon ton code est sympa mais sans connaitre l'APL difficile de comprendre pour moi ; malgré les commentaires explicatif

Bonne journée a tout le monde.

Ce message a été modifié par hubeert - 10 Jul 2023, 06:24.