Bonjour,

Qu'est-ce qu'un nombre parfait ?

Bonjour,
C'est un nombre qui n'admet comme diviseurs que lui-meme et 1

Non!
Cela c'est plus ou moins la définition d'un nombre premier!

bonjour, un nombre parfait est un nombre n tel que la somme de ses diviseurs = 2n.

Donc déjà, construit la logique globale de l'algorithme :

on va faire une boucle faisant varier N de 1 à 10000
puis il faut trouver les diviseurs de N ou plutôt leur somme. On initialise une variable à S, puis
seconde boucle faisant varier K de 1 à N (on va tester tous les nombres entre 0 et N et s'ils sont un diviseur on les ajoute à S)
Pour tester s'il sont un diviseur de N on regarde si le reste de la division de N par K est nul ou pas. Dans algobox ça se note N%K donc on va mettre un
SI N%K == 0 ALORS
S Prend la valeur S+K
Fin SI
on termine la seconde boucle, on a donc maintenant dans S la somme des diviseurs et on peut tester si N est parfait
SI 2*N == S ALORS
Afficher N
FinSI
et on termine la première boucle

Essaye de coder ça dans Algobox, pour progresser dans les algorithmes il faut essayer de les faire soi même et se battre un peu avec la syntaxe.

Bonjour Glapion,

La 2è boucle ne peut-elle pas être diminuée ,réduite de moitié ?

Ah oui en effet, je me suis trompée de définition..

J'essaie de rentrer ça dans algobox alors, merci beaucoup !

Oui on peut optimiser un peu tu as raison, et de rechercher des diviseurs que jusqu'à N/2 et en déduire les autres, mais je n'ai pas voulu compliquer pour un premier algorithme. Algobox est tellement performant que de 1 à 10000, il va faire ça très vite, même non optimisé.

On aurait pu optimiser en allant jusque la racine carrée du nombre à tester.
C'est ce que j'avais prévu.

oui N et pas N/2, tu as raison.

alors j'ai ça, mais ça me met "erreur ligne 15" apparemment j'ai dépassé la capacité d'algobox


VARIABLES
  S EST_DU_TYPE NOMBRE
  N EST_DU_TYPE NOMBRE
  i EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
  POUR N ALLANT_DE 1 A 10000
    DEBUT_POUR
    S PREND_LA_VALEUR 0
    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 (2*N==S) ALORS
      DEBUT_SI
      AFFICHER N
      FIN_SI
    FIN_POUR
FIN_ALGORITHME

Oui on dépasse une limite d'algobox sur les boucles imbriquées.
On va être obligé d'utiliser l'astuce que nous a donnée fontaine6140.

Mais d'abord, il faut que tu comprennes de quoi il s'agit. on ne va chercher les diviseurs que de 1 à N
car si on tombe sur un diviseur, on peut automatiquement en trouver un autre qui sera N/i

ça va donner :

VARIABLES
	S EST_DU_TYPE NOMBRE
	N EST_DU_TYPE NOMBRE
	i EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
	POUR N ALLANT_DE 2 A 10000
		DEBUT_POUR
		S PREND_LA_VALEUR 0
		POUR i ALLANT_DE 1 A sqrt(N)
			DEBUT_POUR
			SI (N%i==0) ALORS
				DEBUT_SI
				S PREND_LA_VALEUR S+i+N/i
				FIN_SI
			FIN_POUR
		SI (2*N==S) ALORS
			DEBUT_SI
			AFFICHER* N
			FIN_SI
		FIN_POUR
FIN_ALGORITHME

D'accord, mais pourquoi on va de 2 à 10 000 ?

je l'ai programmé sur algobox et ça marche, merci beaucoup !!

Oui fait partir N de 1 si tu veux (j'avais mis 2 car au début i allait de 1 jusqu'à N-1 et si N=1 ça faisait i allant de 1 à 0 et j'avais peur que ça crée une erreur), mais maintenant ça passe. De toute façon on sait que 1 n'est pas parfait.

ah d'accord, donc ça ne change rien, merci beaucoup pour ton aide !

Quand je le mets en langage courant, je met quoi dans l'initialisation ?

S prend la valeur 0
Entrer N  

?? Merci

ha non on entre pas N. (tu as vu l'instruction LIRE N quelque part ?)
tu ne sais même pas lire un programme algobox et le décrire en langage courant ? c'est pourtant plus facile que de faire l'inverse

Bah non justement, je n'ai pas vu Lire N.
C'est bien pour cela que je demande ce qu'il doit y avoir dans l'initialisation.
Je ne vais pas rien mettre si ?

ben non, on a besoin d'initialiser aucune variable.

Ah d'accord, même pas S à 0 ?

i est bien entier par contre ?

J'ai rien dit pour S, on lui affecte sa valeur après ! Désolé

Et il n'y a pas de sortie non plus ? Car N sort dans le traitement.

Les sorties ce sont les AFFICHER* N qui sont dans le traitement, oui

Pourquoi une étoile d'ailleurs ?

Ouais mais quand on l'écrit en langage courant il n'y a pas de rubrique "sortie" donc.

AFFICHER N met les nombres les uns à la suite des autres
AFFICHER* N permet d'aller à la ligne après chaque AFFICHER et donc de les avoir les uns en dessous des autres.
Si on ne met pas d'étoile, la sortie sera illisible (tu n'as qu'à essayer d'ailleurs).

Je me suis d'ailleurs demandé pourquoi ils étaient tous l'uns en dessous de l'autre, c'est donc grâce à l'étoile !
Merci beaucoup

[[b][b]b]Voici le programme du nombre parfais en langage C :[/b][/b][/b]


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

main()
{
int n, i, ds, somme;
printf("n = ");
scanf("%d", &n);
somme=0;
for(ds=1;ds<n;ds++){if((n%ds) == 0){ somme = somme + ds ;}}

if(n == somme && n!=1){printf("%d est parfait\n", n);}
else{printf("%d est imparfait", n);}

getch();
}

[b][b][b]Voici le programme du nombre parfais en langage C à l'aide d'une fonction :[/b][/b][/b]

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

int fct(int n)
{
int y, i, ds, somme;
somme=0;
for(ds=1;ds<n;ds++){if((n%ds) == 0){ somme = somme + ds ;}}
if(n == somme && n!=1){y=1;}
else{y=0;}
return(y);
}
main()

{ int nbr, y1;
    printf("nbr =");
    scanf("%d", &nbr);
    y1 = fct(nbr);
    printf("y1 = %d", y1);
    getch();
    
}


Executeeez !!!!

[b][b]Voici le programme de la détection des  nombres parfais de 1 à un nombre entier "p"  en langage C :[/b][/b]



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

main()
{
int n, ds, somme, p;
printf("p = ");
scanf("%d", &p);

for(n=1;n<=p;n++){somme=0; for(ds=1;ds<n;ds++){if((n%ds) == 0){ somme = somme + ds ;}}

if(n == somme && n!=1){printf("%d est parfait\n", n);}}


getch();
}



Exécuteeeez !!!  

3 ans après, ça va faire une belle jambe au posteur qui en plus s'est désinscris du site entre temps et qui de toutes façons voulait un programme algobox.

Bonjour,

écriture en C "de cochon"
il ne s'agit pas de faire des concours du plus petit nombre de lignes du programme (tu pouvais même réduire encore ...)
mais de faire des programmes qui soient lisibles


et puis "au gout du jour" c'est en Python maintenant ...

salut

lire n
s = 0
pour p = 1 à sqrt (n)
     q = n/p
     si q = ent (q) alors
          s = s + p + q
si s = 2n alors écrire n + "est parfait"

lire n
s = 0
p = 1
q = n
tant que q = ent (q) et p < q
     s = s + p + q
     p = p + 1
     q = n/p
si p = q alors s = s + p
si s = 2n alors écrire n + "est parfait"

attention à l'énoncé
on ne demande pas de dire si p est parfait, mais de donner la liste des nombres parfaits :
deux boucles imbriquées

Bon, il serait bon de ramener la vérité ici.
Déjà, un nombre parfait, c'est un nombre égal à la somme de ses diviseurs, aucun rapport avec des histoires de 2n, etc
Ainsi, 6 est parfait car 1+2+3 = 6
Ou encore 1+2+4+7+14=28, donc 28 est parfait

Ça marche aussi avec 496, etc.

ENSUITE

Un nombre N, contrairement à ce que vous dites, possède très souvent des diviseurs supérieurs à N.
Exemple avec 28 :
racine de 28 = à peu près 5,5.
Or 14 est un diviseur de 28, et 14>5,5
Donc un nombre peut avoir des diviseurs supérieurs à sa racine.
Donc votre algorithme est faux.

Si vous voulez optimiser votre programme, vous pouvez garder à l'esprit qu'aucun nombre N n'a de diviseur supérieur à N/2+1


Voici un programme en python qui mettra tout le monde d'accord :

def parfait(nombre) :
   sommeDiviseurs = 0
   for i in range(1, int(nombre/2+1)) :
      if nombre%i == 0 :
         sommeDiviseurs += i
   if sommeDiviseurs == nombre :
      return True
   else :
      return False

print("This is console module")
n = int(input("Combien de nombres ?"))
debut = int(input("À partir de combien ?"))
nombresRecontres = 0

while nombresRecontres < n:
   if parfait(debut) :
      print(debut)
      nombresRecontres += 1
   debut += 1
      
  
Si vous n'êtes toujours pas convaincus, voici un exemple de son exécution :

This is console module
Combien de nombres ?4
À partir de combien ?1
6
28
496
8128

#[QPython] Press enter to exit

Allez salut !

Bonjour et bonne année,

quelques rectifications,

un nombre est parfait ssi il est égal à la somme de ses diviseurs propres

par exemple 28 admet 28 comme diviseur, si si!
de sorte que la somme des diviseurs tout court de 28 est 1 + 2 + 4 + 7 + 14 + 28 = 56
les diviseurs propres sont avec 28 exclus 1 + 2 + 4 + 7 + 14 = 28