- Partage ce devoir avec tes amis !
Sujet du devoir
bonjour qui pourrais m'aider à programmer un algorithme sur algobox pour avoir le nombre d entiers deficients abondants et parfait entre 0 et 1000 s.v.p
Où j'en suis dans mon devoir
C'est très urgent s.v.p j'en ai vraiment besoin merci d'avance pour ceux qui m'aideront.
15 commentaires pour ce devoir
Ils ont besoin d'aide !
- Aucun devoir trouvé, poste ton devoir maintenant.
J'ai réussi à créer ton programme. Je suis donc à même de pouvoir t'aider.
Voilà toutes les variables que j'ai utilisées :
i EST_DU_TYPE NOMBRE -> variable de tour de boucle
j EST_DU_TYPE NOMBRE -> variable de tour de boucle
n EST_DU_TYPE NOMBRE -> l'utilisateur choisit le nombre de départ, ici 1000
s EST_DU_TYPE NOMBRE -> somme des diviseurs
def EST_DU_TYPE LISTE -> liste des nombres déficients
defr EST_DU_TYPE NOMBRE -> curseur de la liste def
par EST_DU_TYPE LISTE -> liste des nombres parfaits
parr EST_DU_TYPE NOMBRE -> curseur de la liste par
abo EST_DU_TYPE LISTE -> liste des nombres abondants
abor EST_DU_TYPE NOMBRE -> curseur de la liste abo
Je te rassure, je n'ai pas pensé à toutes ces variables dès le début. C'est en créant le programme qu'elles sont venues petit à petit.
Merci beaucoup le programme marche comme ça ? Ou il faut continuer ?
Il faut bien sûr continuer. Là, je ne t'ai fais qu'une liste de toutes les variables qu'il faut utiliser dans ton algorithme, avec le pourquoi je les ai utilisées. Mais je n'ai pas écrit le programme en lui-même.
Essaye de commencer à concevoir ton algorithme avec un papier et un crayon. Qu'est-ce que tu veux faire ? Comment procèderais-tu si tu n'avais pas de machine ?
Ah enfaite moi je comptais faire 3 algorithmes différents par exemple pour déterminer les nombres deficients j'ai ecrit
n EST DU TYPE NOMBRE
i EST DU TYPE NOMBRE
DEBUT_ALGORITHME
S PREND LA VALEUR 0
LIRE n
Pour i ALLANT DE 1 A N-1
DEBUT POUR
SI (n% i==0) ALORS
DEBUT SI
S PREND LA VALEUR S+I
FIN SI
FIN POUR
SI (n> S) ALORS
DEBUT SI
AFFICHER n
AFFICHER " est un nombre deficient "
FIN SI
SINON
DEBUT SINON
AFFICHER n
AFFIXHER " n'est pas un nombre deficient "
FIN SINON
FIN ALGORITHME
mais si je fais ca 3 fois c'est long vous voyez mais avec les 3 d'un coup en 1 algorithme j'y arriverais jamais c'est trop long non ? Mais il faut en faire 1 c'est ça le problème ; s
Ton algorithme permet de savoir si un nombre est déficient ou non.
Est-ce que tu peux le modifier pour afficher tous les nombres déficients de 1 à n ?
Après ça, je te donnerai l'algorithme entier pour avoir à la fois les nombres déficients, parfaits et abondants. Car je ne crois pas qu'en terminale on manipule des listes. Ce n'est pas indispensable, mais c'est ce qui est beaucoup plus pratique dans le cadre de ton exercice.
Je dois mettre pour i allant de 1 a 999 ? Et après mettre un retour à la ligne ?
Attention, la variable i, tu l'as déjà utilisée pour savoir si n était divisible par i. Il faut donc prendre un autre nom de variable.
Je te donne mon code sur Algobox. Je le commenterai dimanche soir voire lundi soir, je n'ai pas le temps maintenant.
VARIABLES
i EST_DU_TYPE NOMBRE
j EST_DU_TYPE NOMBRE
n EST_DU_TYPE NOMBRE
s EST_DU_TYPE NOMBRE
def EST_DU_TYPE LISTE
defr EST_DU_TYPE NOMBRE
parr EST_DU_TYPE NOMBRE
abor EST_DU_TYPE NOMBRE
par EST_DU_TYPE LISTE
abo EST_DU_TYPE LISTE
DEBUT_ALGORITHME
1) LIRE n
2) defr PREND_LA_VALEUR 0
3) parr PREND_LA_VALEUR 0
4) abor PREND_LA_VALEUR 0
5) POUR i ALLANT_DE 1 A n
DEBUT_POUR
6) s PREND_LA_VALEUR 0
7) POUR j ALLANT_DE 1 A i
DEBUT_POUR
8) SI (i%j==0) ALORS
DEBUT_SI
9) s PREND_LA_VALEUR s+j
FIN_SI
FIN_POUR
10) SI (s > 2*i) ALORS
DEBUT_SI
11) abor PREND_LA_VALEUR abor+1
12) abo[abor] PREND_LA_VALEUR i
FIN_SI
13) SINON
DEBUT_SINON
14) SI (s==2*i) ALORS
DEBUT_SI
15) parr PREND_LA_VALEUR parr+1
16) par[parr] PREND_LA_VALEUR i
FIN_SI
17) SINON
DEBUT_SINON
18) defr PREND_LA_VALEUR defr+1
19) def[defr] PREND_LA_VALEUR i
FIN_SINON
FIN_SINON
FIN_POUR
20) AFFICHER "Déficients : "
21) POUR i ALLANT_DE 1 A defr
DEBUT_POUR
22) AFFICHER def[i]
23) AFFICHER " "
FIN_POUR
24) AFFICHER " "
25) AFFICHER "Parfaits :"
26) POUR i ALLANT_DE 1 A parr
DEBUT_POUR
27) AFFICHER par[i]
28) AFFICHER " "
FIN_POUR
29) AFFICHER " "
30) AFFICHER "Abondants : "
31) POUR i ALLANT_DE 1 A abor
32) DEBUT_POUR
33) AFFICHER abo[i]
34) AFFICHER " "
FIN_POUR
FIN_ALGORITHME
D'accord merci beaucoup pour votre réponse.
Pouvez-vous le commentez s.v.p ??
Désolé pour le retard, mais mieux vaut tard que jamais. Voilà l'explication :
1) Tu choisis jusqu'à quel nombre tu veux savoir de quel type il est.
2) à 4) Être sûr que les variables à l'initialisation soient bien mis à 0.
5) Pour tous les nombres dont on veut savoir le type.
6) Remise à zéro de la somme.
7) à 9) On fait la somme de tous les diviseurs du nombre en cours.
10) Si le nombre en cours est abondant.
11) Le nombre de nombres abondants augmente de 1.
12) Sauvegarde de ce nombre dans les nombres abondants à la clé abor.
13) et 14) Si c'est un nombre parfait.
15) Le nombre de nombres parfaits augmente de 1.
16) Sauvegarde de ce nombre dans les nombres parfaits à la clé parr.
17) Si c'est un nombre déficient.
18) Le nombre de nombres déficients augmente de 1.
19) Sauvegarde de ce nombre dans les nombres parfaits à la clé defr.
20) On va afficher les nombres déficients.
21) Pour toutes les clés des nombres déficients.
22) Afficher le nombre déficient correspondant à la clé.
23) Une espace pour mieux voir les nombres.
24) Excuse de l'affichage d'une espace pour un retour à la ligne.
25) On va afficher les nombres parfaits.
26) Pour toutes les clés des nombres parfaits.
27) Afficher le nombre parfait correspondant à la clé.
28) Une espace pour mieux voir les nombres.
29) Excuse de l'affichage d'une espace pour un retour à la ligne.
30) On va afficher les nombres abondants.
31) Pour toutes les clés des nombres abondants.
32) Afficher le nombre abondant correspondant à la clé.
33) Une espace pour mieux voir les nombres.
34) Excuse de l'affichage d'une espace pour un retour à la ligne.
Un autre message va suivre pour mieux expliciter une variable de type liste.
Merci beaucoup à vous c'est très gentil de votre part.
C'est sûrement ce qui pose en réalité le plus de problème dans la compréhension de l'algorithme : le type "Liste". Un type que tu n'as sûrement pas encore vu en cours, mais pourtant qui est très pratique dans des algorithmes plus complexes. En fait, c'est une super-variable qui contient plusieurs variables. Pour savoir de quelle variable on veut piocher dans la super-variable, on utilise une clé. Cette clé est dans la plupart des cas un nombre.
Voici comment on peut représenter une variable de type liste :
http://www.pixenli.com/images/1414/1414615043073727900.png
Si on demande d'afficher seulement "tab", le compilateur ne va pas accepter car la liste (aussi appelé tableau) peut comporter plusieurs valeurs. En revanche, si tu demandes tab[2], il te sortira le booléen false. Si tu demandes tab[5], il te sortira le flottant 3,14. Si tu demandes tab[4] il te sortira le caractère r. Je ne sais pas si c'est très clair, car je n'en ai pas l'impression, alors n'hésite pas à me demander plus d'éclaircissements.
Merci beaucoup de m'expliquer. En effet c'est un peu compliqué à comprendre je vous l'avoue. ..
Par contre juste une question je voulais de 0 à 1000 et vous m'avez fait de 1 à 1000 non ?
??