Discussion :

[snake264]

Bonsoir tout le monde
Voila je fais appel à vous car j'ai un soucis avec mon code, qui est censé me donné tout les nombres amis qui ne sont pas des nombres parfaits inférieur ou égale à une valeur choisi par l'utilisateur (ex: si je choisi jusqu'à 500 il ne devrait m'afficher que 284 et 220). Je ne comprend pas pourquoi quand j'execute mon code il ne me renvoit rien du tout. Le voici:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
#include<stdio.h>
int sommediv(int n)
{
	int i, somme = 0;
	for (i=1;i<n;i++)
	{
		if (n%i==0)
		{
			somme += i;
		}
	}
	return somme;
}
 
int amis(int a, int b)
{
	return ((sommediv(a)==b) && (sommediv(b)==a));
}
 
int parfait(int nombre)
{
	int i, result, sdiv = 0;
	for (i=(nombre-1);i>0;i--)
	{
		if (nombre % i == 0)
		{
			sdiv += i;
		}
			if (nombre == sdiv)
		    {
				result = nombre;
			}
	}
	return result;
}
 
int main()
{
	int i, j, n;
	printf("Jusqu'à quel valeur voulez-vous afficher les nombres amis ?: ");
	scanf("%d", &n);
	for(i=1;i<=n;i++)
	{
		for (j=1;j<=i;j++)
		{
			if ((amis(i,j)==1) && (!parfait(i)))
			{
				printf("Les nombres %d et %d sont amis\n", i, j);
			}
		}
	}
	return 0;
}

Merci d'avance de votre aide .

[romanegr]

Salut
il y a un problème dans ta fonction parfait je crois qu'il m'enque un x2 quelque part.

Nombre parfait


J'ai pas testé mais bon.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
#include<stdio.h>
int sommediv(int n)
{
	int i, somme = 0;
	for (i=1;i<n;i++)
	{
		if (n%i==0)
		{
			somme += i;
		}
	}
	return somme;
}
 
int amis(int a, int b)
{
	return ((sommediv(a)==b) && (sommediv(b)==a));
}
 
int main()
{
	int i, j, n;
	printf("Jusqu'à quel valeur voulez-vous afficher les nombres amis ?: ");
	scanf("%d", &n);
	for(i=1;i<=n;i++)
	{
		for (j=1;j<=i;j++)
		{
			if ((amis(i,j)==1) && (sommediv(i) != i*2))
			{
				printf("Les nombres %d et %d sont amis\n", i, j);
			}
		}
	}
	return 0;
}

Je sais même pas si sa compile Tu me dira sa.

[Skyounet]

C'est un problème d'algorithme et non de C, le C n'est que la traduction de ton algo, donc si l'algo est faux, bah le résultat aussi.

Je déplace.

[snake264]

Si c'est une faute dan l'algo de la fonction parfait() je ne vois pas ou est le problème car je l'ai testée à part et elle marche, elle me renvoie bien si un nombre est parfait ou non.

[Skyounet]

Si c'est une faute dan l'algo de la fonction parfait() je ne vois pas ou est le problème car je l'ai testée à part et elle marche, elle me renvoie bien si un nombre est parfait ou non.

Je n'ai jamais dit une faute dans l'algo de parfait() j'ai dit une faut d'algo tout court.

Ton problème est typique d'un problème d'algorithme, c'est pas un problème de code (segfault, pointeur invalide ou que sais-je d'autre), donc tu es sur le bon forum.

[snake264]

Je n'ai jamais dit une faute dans l'algo de parfait() j'ai dit une faut d'algo tout court.

Non désolé c'était à romanegr que je répondait, me disait que il y avait une erreur dans ma fonction parfait(), c'est de ma faute j'aurais du citer Et bien pourtant ce que tu me propose romanegr je ne vois pas ce que cela change enfin je n'ai pas testé tu me dira lol et oui le prog que j'ai fait compile bien mais lorsque je l'execute il ne me renvoi rien.

[Skyounet]

Non désolé c'était à romanegr que je répondait, me disait que il y avait une erreur dans ma fonction parfait(), c'est de ma faute j'aurais du citer Et bien pourtant ce que tu me propose romanegr je ne vois pas ce que cela change enfin je n'ai pas testé tu me dira lol et oui le prog que j'ai fait compile bien mais lorsque je l'execute il ne me renvoi rien.

Désolé au temps pour moi.

[fremen167]

D'un point de vue efficacité déjà, tu pourrais éviter de calculer la somme des diviseurs à plusieurs endroits.

Par ailleurs, un nombre n est parfait si n = sommediv (n), et non pas 2 * car sommediv calcule la somme des diviseurs de n inférieurs strictement à n.

Ta boucle dans la fonction parfait ne fait pas ça car le deuxième if devrait être en dehors de la boucle for.

Si le nombre est parfait, ça marche, mais par contre, si la somme des diviseurs est supérieure au nombre, tu peux sortir de la boucle prématurement.

A noter également que tu peux supposer arbitrairement que i < j.

[snake264]

Fremen 167, c'est vrai je n'avait pas vu cette faute de mon if qui devait être en dehors de la boucle mais pourtant je ne vois pas pourquoi la fonction parfait() ne test pas toutes les valeurs car quand je l'execute seule elle marche très bien pour me dir si un nombre est parfait ou non, je pense sinon qu'il doit y avoir un souci dans la condition de mon dernier if dans la fonction main().

[fremen167]

Fremen 167, c'est vrai je n'avait pas vu cette faute de mon if qui devait être en dehors de la boucle mais pourtant je ne vois pas pourquoi la fonction parfait() ne test pas toutes les valeurs car quand je l'execute seule elle marche très bien pour me dir si un nombre est parfait ou non, je pense sinon qu'il doit y avoir un souci dans la condition de mon dernier if dans la fonction main().

Non, elle ne marche pas très bien.

Suppose que sommediv (N) = N + 3 et que N est pair.

Alors quand i sera égal au plus petit diviseur > 2, on aura sdiv = N, et on sortira en fin de boucle avec parfait vrai.

Le test dans le main ne pose aucun problème à mon avis (si ce n'est que le == 1 ne sert à rien).

[romanegr]

Désoler, je me suis planté pour le x2 j'ai confondu la somme des diviseurs propres et la somme des diviseurs

[Zavonen]

Pour trouver un nombre parfait, ou plus précisément pour calculer sommediv (la somme des 'aliquotes'), le mieux est de sommer les diviseurs 2 par 2 et de s'arrêter à la racine du nombre.
En effet, si i est diviseur n/i l'est aussi au lieu de faire
s=s+i il est donc préférable de faire s=s+i+n/i
Cependant la sorte de boucle est un peu délicate, surtout dans le cas d'un carré parfait, car alors i = n/i et il ne faut ajouter qu'un seul des deux.
Cela reste malgré tout facile très facile à écrire.
Les couples d'amis se trouve en résolvant:
x=sommediv(sommediv(x))
avec la contrainte x<= sommediv(x) pour éviter les répétitions.

[snake264]

Oula Zanoven je suis complètement embrouiller avec ton explication, j'ai du mal à comprendre car si je met comme tu dis s=s+i+n/i sa me renverra tout le temps que mon nombre n'est pas parfait même si il l'est, à moins que que j'ai mal interpréter ce que tu me dit dans quel cas je m'en excuse.

Merci pour ton exemple Fremen je comprend mieux pourquoi maintenant l'intéret de sortir mon test de la boucle.

[Zavonen]

Mais non, je suggère simplement de modifier ta boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
	int i, somme = 0;
	for (i=1;i<n;i++)
	{
		if (n%i==0)
		{
			somme += i;
		}
	}

en remplaçant la condition d'arrêt i<n par i*i<n
et en remplaçant somme+=i; par somme += (i+n/i);
En sortie de boucle tu testes si n est un carré parfait i*i=n
Si oui, tu rajoutes une seule fois i à somme, et basta
Ainsi si n=1000000 tu fais une boucle de longueur 1000 au lieu de 1000000

[snake264]

Aaaa ok d'accord oui comme sa je comprend mieux désolé je suis un peu long à la détente.
Comme je n'ai pas de quoi modifier ici je te dirai ce que donne ce changement, mais pourtant si j'analyse bien tes modifications cette fois-ci mon code ne me retourne plus aucun nombre car mon code sans la fonction parfait() me renvoi quand je lui demande de m'afficher tout les nombres amis jusqu'à 500 :
6 et 6 sont amis
28 et 28 sont amis
284 et 220 sont amis
496 et 496 sont amis
Et les nombre 6, 28 et 496 sont parfaits or je ne veux pas les afficher, et si j'applique ta modification je pense que mon code ne me renverra rien du tout.

[Jedai]

Ce ne serait pas un problème du Projet Euler par hasard ?

En tout cas, pour chercher tous les nombres amicaux jusqu'à un certain rang (et pourvu que celui-ci ne soit pas trop grand, disons en dessous de 500_000_000), il est préférable de constituer un tableau des sommes de diviseurs, ça peut être fait beaucoup plus efficacement :

Code Haskell :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
mSumPropDivs :: Int -> UArray Int Int
mSumPropDivs n = accumArray (+) 1 (0,n) 
                 $ (0,-1):[(k,factor)| factor<-[2..n `div` 2]
                          , let f2 = factor * 2
                          , k<-[f2,f2+factor..n]
                          ]

En gros ce code crée un tableau rempli de 1 puis parcours les diviseurs propres possibles pour les nombres en dessous de n, et ensuite rajoute ce diviseur à tout ses multiples inférieurs ou égaux à n.

Ca ne devrait pas être trop difficile à traduire en C.

--
Jedaï

[snake264]

Je ne sais pas Jedai si c'est un problème du projet Euler ou non car je ne sais pas ce que c'est lol. Sinon pour trouver les nombres amicaux sa il n'y a pas de soucis ce que j'ai fais marche très bien, c'est une fois que je veu trier le résultat que je n'y arrive pas en y retirant tout les nombres parfait. Sinon j'ai bien une idée qui est de rajouter dans le test de fin dans la fonction main()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if ((amis(i,j)) && i != j)

mais sa serait jouer de facilité et je n'apprecie pas vraiment.

[fremen167]

Sinon j'ai bien une idée qui est de rajouter dans le test de fin dans la fonction main()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if ((amis(i,j)) && i != j)

mais sa serait jouer de facilité et je n'apprecie pas vraiment.

Comme je l'ai écrit plus haut, tu devrais imposer que i < j, et ça irait plus vite ! Quel est l'intérêt d'afficher (i,j) puis (j,i) ?

[snake264]

C'est vrai tu as raison Fremen c'est plus rapide de faire comme tu dis, bref c'est bon je suis arrivé à ce que je voulais je vous remercie beaucoup de votre aide et de la rapidité aussi