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.

[Jaypee]

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.

Au temps pour moi, je n'avais vu que les exemples ne dépassant la puissance 3.

La meilleure façon de se faire une idée d'APL est le portail Try APL

Il y a des règles simples : on le lit strictement de droite à gauche, les opération arithmétiques sont celles sur le clavier des calculettes : + - x ÷
2 x 3 + 1, un plus trois égale 4, fois deux, égale 8.

En revanche, (2 x 3) + 1 égale 7 avec les parenthèses.

APL est un langage d'IBM, dont le premier portable le 5100, antérieur à l'Apple II et au PC, se programmait en APL, une version BASIC a été créée par la suite.

Bonne journée à toi également,
JP
PS: Pour te donner ( un peu ) raison, une version vraiment illisible mais qui fait le job jusqu'à 1 000 000 (testable sur Try APL)

Code

      {({⍵ = +/v*⍴v←10⊥⍣¯1⊢⍵} ¨ ⍳⍵)/⍳⍵} 1000000
1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 54748 92727 93084 548834

v est une variable locale qui est le vecteur des chiffres, dont la dimension, le nombre de chiffres est noté rho de v, et le vecteur est monté à la puissance rho de v : v*⍴v puis réduit par l'addition +/v*⍴v et comparé à l'argument ⍵:
⍵ = +/v*⍴v qui produit un résultat 0 ou 1 pour faux ou vrai.
Comment obtient-on v ? Iil existe une syntaxe très simple pour encoder un nombre à partir de ses chiffres: 10⊥chiffres, avec chiffres = (c1, c2, c3...), c'est sa réciproque notée ⍣¯1, un peu comme dans ƒ^-1, qui est utilisée pour obtenir v : v←10⊥⍣¯1⊢, expression qu'on applique à l'argument initial ⍵ : v←10⊥⍣¯1⊢⍵. Au lieu d'être noté "chiffres", l'argument de cette expression est noté ⊢

Code

      10⊥1 2 3
123
      (10⊥⍣¯1⊢) 456
4 5 6

Ce message a été modifié par Jaypee - 15 Jul 2023, 08:37.