Langage C
bonjour,
j'ai un exo à faire sur les boucles le voilà:
écrire un programme qui calcule la somme des N premiers termes positifs pairs non multiple de trois.
voilà ce que j'ai fait:
#include<stdio.h>
#include<stdlib.h>
int main()
{
int n,s,i;
printf("donner une valeur de n");
scanf("%d",&n);
s=0
for(i=0;i<=n
{
if(i%2=0 && i%3=0)
{
s=s+i
}
}
system("pause");
return 0;
}
BonjourEnvoyé par fati_zfz
Pense à la balise code pour que ton message soit plus lisible :
Il y a plusieurs problèmes, d'abord un au niveau de la syntaxe : une boucle for est toujours de la forme for(<initialisation> ; <test> ; <incrémentation>) et tu as oublié la partie incrémentation.Code:#include<stdlib.h> int main() { int n,s,i; printf("donner une valeur de n"); scanf("%d",&n); s=0 for(i=0;i<=n;) { if(i%2=0 && i%3=0) { s=s+i } } system("pause"); return 0; }
Un autre problème se situe au niveau de la sélection du «nombre pair non multiple de 3», un tel nombre est donc un multiple de 2 (donc son modulo 2 doit être nul) et n'est pas un multiple de 3 (donc son modulo 3 ne doit pas être nul).
Le dernier problème est au niveau de la compréhension du problème : ce que tu essayes de faire est la somme des nombres pairs non multiples de 3 entre 0 et n (inclus), mais ce qui est demandé est de calculer la somme des n premiers nombres pairs non multiples de 3, tu vois la différence ?
Désolée mais j'ai pas compris :/ qu'est ce que je dois faire?
Bonjour,
On va aux bases, c'est à dire papier et crayon.
Tu cherches comment tu ferais à la main.
ET revoir les points signalés par kwariz, l'un est un problème de syntaxe, l'autre de logique qui ne respecte pas la question posée.
Comme te le conseille Whoami : il faut toujours commencer ce genre d'exercice en ne programmant pas mais en décrivant comment toi même tu fais. Ça s'appelle trouver un algorithme. Ensuite la partie programmation est triviale.
Voilà par exemple comment je fais pour résoudre le problème à la main :
D'abord en français :
Je dois parcourir les multiples de deux et si j'en trouve un qui n'est pas un multiple de 3 alors je l'ajoute à ma somme et je recommence tant que je n'ai pas ajouté n entier à ma somme.
Ensuite je formalise un peu en dégageant des étapes simples :
On va transformer ça en algorithme. D'abord on remarque que tout ce qu'il y a entre 2et 3 est répété tant que nombre d'entiers trouvés est plus petit que n -> on peut utiliser une boucle while par exemple. On remarque aussi qu'on a besoin de plusieurs variables, une qui est l'entier à tester (on va l'appeler candidat), une autre qui est le nombre d'entiers ajoutés à la somme (on va l'appeler accepté), et une pour garder la somme (appelons la somme). Le test contient un n qui nous sera donné : c'est un paramètre.Code:1. entier à tester = 0 (on va commencer par tester avec le premier entier pair) 2. si entier à tester n'est pas un multiple de 3 alors 2.1. ajouter entier à tester à somme (somme va devoir être une variable en plus) 2.2. j'ajoute 1 à nombre d'entiers trouvés (encore une variable) 3. si nombre d'entiers trouvés est plus petit que n alors je recommence en 2 avec entier à tester incrémenté de 2
Un algorithme pourra donc être :
Une fois que tu as l'algo, tu testes rapidement quelques cas à la main. On peut par exemple tester ce que ça donne avec n=3 puis n=10 pour s'assurer que le bon résultat est renvoyé qu'on a pas oublié une initialisation, qu'on ne s'est pas planté en mettant un < à la place d'un <=, etc ... On doit aussi tester avec des valeurs limites ... est-ce que ça fonctionne toujours avec n=0 ? n=-1 ?Code:fonction somme_pair_non_triple( n : entier ) : entier début candidat = 0 // on commence par 0 acceptes = 0 // on en a pas encore trouvé somme = 0 tant que acceptes<n faire si somme modulo 3 <> 0 alors // on vient de trouver un nombre qui convient acceptes = acceptes + 1 somme = somme + candidat fin si // on fait ce qu'il faut pour le tour suivant candidat = candidat + 2 fin tant que retourner somme fin
Idéalement on devrait prouver notre algorithme.
Une fois que tu as un algo fonctionnel tu peux le programmer en te disant que tu n'auras pas d'erreurs graves (mauvaise compréhension, algo invalide, ...). Comme tu as un jeu de test des étapes précédentes, tu n'as plus qu'à tester et emballé c'est pesé.
Il me semble de plus que le problème suivant n'a pas été cité:
Erreur fréquente qui consiste à confondre l'opérateur d'affectation = avec celui de comparaison ==Code:if(i%2=0 && i%3=0)
A+
Bonjour,
C'est vrai, c'est une des erreurs les plus fréquentes.
