salut, j´ai un probleme avec un algorithme: j´ai une variable E , et je cherche a la diviser par 7 puis a extraire la partie située apres la virgule de maniere a obtenir un nombre en dessous de zero. Seulement voila, si je me sers de "/" ça me donne un nombre entier (le nombre de fois que 7 est contenu dans E). Exactement l´inverse de ce que je cherche. Comment faire siouplait?

utilise des variables de type float ou double, et non pas des variables de type int ou long.

d´accord, je vais essayer. Merci!

Il n´y a pas de fonction modulo

le but, apres, pour récupérer la partie décimale, c´est justement de se servir de la division entiere

Exemple :

double partiedecimale(double in)
{
return in - (int)in;
}

Mea Culpa !

J´ai dis une bêtise (je ne suis plus à ça prêt ) !

La fonction modulo renvoie le reste de la division, pas la partie décimale !

c´est quoi le mot clé "return"? tu peut m´expliquer ton code, Jeanyvesyves?

Return c´est ce que renvoi sa fonction partiedecimale!
La valeur qu´elle renvoi quoi.
Ta compris?

tu en est où de ton apprentissage du C ?

ça avance tout doucement... La comme j´ai pas d´idée (ni de competence) de programmes, je tente de refaire sur ordi les programmes de ma calculatrice graph 35 (plus de 100!) Et le but de ce programme est de fournir le jour correspondant a une date: par ex 14/07/1789 c´est un dimanche. Je l´ai vu grace a ce programme.

Assez gadget mais assez marrant aussi.

Le principe: definir une Constante, c´est a dire un jour que vous connaissez. Dans le cas de mon programme, c´est le mercredi 5 octobre 2005 (date ou j´ai fait mon prog sur calculatrice).

Et le but est de voir combien de jour il y a apres ce mercredi et donc d´en deduire le jour correspondant, par exemple, il y a 37jours de plus que ce mercredi, on divise par 7 (puisque les jour se repetent 7 jour apres dans la semaine = dimanche, 7 jour apres c´est toujours dimanche) et on obtient 5.2857 et des poussieres: 5 semaines et quelques jour de plus. on isole 0.2857, et on multiplie par 7 pour obtenir 2: 2 jours de plus que mercredi, on est un vendredi (verifiez!)

mais maintenant que je regarde mes calculs, et que mon cerveau commence doucement a reflechir et soudain s´eclate contre ma boite cranienne devant la complexité inutile de mon raisonnement, et devant la solution qui est LA, je me rend compte qu´une simple division avec reste suffit (modulo!)... Y a des fois, comme ça... mais oui! 37%7 = 2, le chiffre que je cherche!! 2 jours de plus que mercredi!! vendredi!! j´y suis arrivé, enfin!! j´ai trouvé ce foutu algorithme!! yeeepeeee les gars, j´ai quasiment finit ce programme!! apres y me restera plus qu´a le deboguer, mais c´est pas un probleme. Bonne journée!!

"14/07/1789 c´est un dimanche"

en fait , selon des sites trouves sur google , le 14 juillet 1789 etait un mardi ...

ptete un probleme d´années bissextiles ? ;p

quoi t´es sur? naan, les années bissextiles je les prend en compte dans mon programme. Je pense plutot que comme c´etait un truc que j´ai regardé y a quelques mois, ça s´est brouillé... Mais en tout cas, le Jeudi noir de 1929 est bien un jeudi. Ca j´en suis sur, je l´ai verifié vendredi dernier (qui est bien un vendredi soi dit en passant )

nickel! il marche a merveille maintenant, mon probleme venait du fait que j´ecrivais "if (e=3)" eu lieu de "if (e==3)"... voila mon programme, cadeau!

1. include <iostream.h>
2. include <stdlib.h>
3. include <math.h>

int main()
{

double jour;
double mois;
long annee;
double quantite;
cout << "Entrez les jours (jj)";
cin >> jour;
cout << "Entrez les mois (mm)";
cin >> mois;
cout << "Entrez les annees (aaaa)";
cin >> annee;
quantite= (annee*365)+jour;

if (mois==2){
quantite = quantite+31;

};
if (mois==3){
quantite = quantite+59;
};
if (mois==4){
quantite = quantite+90;
};
if (mois==5){
quantite = quantite+120;
};
if (mois==6){
quantite = quantite+151;
};
if (mois==7){
quantite = quantite+181;
};
if (mois==8){
quantite = quantite+212;
};
if (mois==9){
quantite = quantite+243;
};
if (mois==10){
quantite = quantite+273;
};
if (mois==11){
quantite = quantite+304;
};
if (mois==12){
quantite = quantite+334;
};
quantite =quantite +(annee/4);
quantite=quantite-732604;
int e;
e=quantite;
e=(e%7);

if (e<=0){
e=e+7;
}

if (e==0){
cout <<"mercredi!\n";
}
if (e==1){
cout <<"jeudi!\n";
};
if (e==2){
cout <<"vendredi!\n";
};
if (e==3){
cout <<"samedi!\n";
};
if (e==4){
cout <<"dimanche!\n";
}
if (e==5){
cout <<"lundi!\n";
}
if (e==6){
cout <<"mardi!\n";
}

system("PAUSE");
return 0;
}

amusez vous bien!

quelques petits commentaires :

-pourquoi utilise tu la variable quantite de type double, alros que la variable e de type int ferait largement affaire. (lorsque du calcul flottant n´est pas nécessaire, c´est bien déviter les double ou float).
-Cela n´a pas grande importance, mais un switch serait parfait à la place des if finaux.
-Le plus problématique : la ligne
quantite =quantite +(annee/4);
devrait être remplacé par :
quantite =quantite +(annee/4)-(annee/100)+(annee/400);
car les années multiple de 100 ne sont pas bisextiles (alors qu´elles sont multiple de 4) mais celles multiple de 400 le sont quand même.
Mais il faudra adapter ta constante (qui pourrait être entre 0 et 6 et ça irait largement).

tiens, pour les années multiples de 100 je savais pas! mais explique moi le truc de la constante? C´est censé etre un jour qu´on connait et qui sert de point de repere au programme... Faut que je la change un peu, je le reconnais (le probleme des années multiples de 100) mais sinon, c´est censé etre le nombre de jours ecoulés depuis la naissance de jicé...

oui, c´est cencé être ce nombre je jour, mais ce n´est pas nécesaire : après avoir soustrait la constante, tout ce que tu fait, c´est le modulo pour avoir le résultat final.
Donc soustraire 732604 ou 732604%7 c´est à dire 5 (ou même ajouter 2) donnera le même résultat après le modulo. et ça te traine une constante moins emmerdante que tu peut juste qualifier de "constante corrective".

ah.

Bon en fait, maintenant que ce programme marche, je vais passer a un autre... Vous avez pas une idée? j´arrive pas a installer de librairies SDL pour faire des trucs en 2D, alors, je peut pas faire la majorité de mes programmes de calculatrice (comme "foret", un programme qui genere une foret composée de 3 types d´arbres, disposés "au hasard" a partir d´un nombre qu´on entre dans le programme. Ce programme a la particularité que si on refait le programme en mettant le meme nombre, on obtient la meme foret... C´est, je crois, un peu la technique qu´a utilisé le pere Braben dans la serie des elite, pour generer des univers entiers.)

J´ai travaillé sur un genre de prog comme le tiens sur les dates, et je me souviens que pour les années bisextiles, la règle était :
- sont des années bisextiles celles divisibles par 4.
- ne le sont pas celles divisibles par 100, exception faites de celles divisibles par 1000.

en gros :
si ((annee mod 4 = 0) et (annee mod 100 != 0)) ou (annee mod 1000 = 0)

Pas 1000, mais 400 pour l´exception de l´exception.

Ca pourrait jouer assez peu, mais comme 2000 était dans ce cas là, on est en plein là où il faut le prendre en compte.