ALGORITHME DE MAURICE KRAITCHIK (1882�1957)

Commentaire de ghuysmans99 le 30/04/2010 18:23:20

Fonctionne nickel mais on peut faire plus court (21 lignes contre 45 dans ta version) :


#include <stdio.h>

int main()
{
    int q; // quantième du mois
    int m; // mois où janvier=13 et février=14
    int a; // année
    int j; // jour de la semaine en partant de samedi
    char* jours[] = {"samedi","dimanche","lundi","mardi","mercredi","jeudi","vendredi"};

    printf("Entrez une date sous la forme JJ MM AAAA : ");
    scanf("%d %d %d",&q,&m,&a);

    if (m == 1) {a--;m=13;}
    if (m == 2) {a--;m=14;}
    j = (q + 2*m + ((3*(m + 1))/5) + a + (a/4) - (a/100) + (a/400) + 2) % 7;

    printf("\nLe jour de la semaine correspondant au %02d/%02d/%02d est %s.",q,m,a,jours[j]);

    return 0;
}

Commentaire de Menuki le 03/05/2010 09:19:32

Tu pourrais expliquer en quoi l'utilisation d'un tableau augmente l'espace mémoire occupé?
Parce que tes chaînes dans les différents printf, on doit bien les trouver également dans les données du programme, non?

Commentaire de LeFauve42 le 04/05/2010 10:42:44

Ca peut etre pratique comme algo.
Mais pour quelles dates est-il valide ?
Je pencherai pour 15/10/1582 => pas de limites mais j'ai du mal a trouver confirmation.

Puisqu'on est dans les optimisations, on peut aussi gagner quelques octets en remplacant
    if (m == 1) {a--;m=13;}
    if (m == 2) {a--;m=14;}
par :
    if (m <= 2) {a--;m+=12;}

La seule difference de taille memoire entre la version originale et celle de ghuysmans99 est le tableau de pointeurs alloue sur la pile (les constantes chaine de caracteres vont etre alouees dans le segment TEXT du code (ou la partie DATA associee selon l'OS) dans les 2 cas).

Ca peut donc avoir quelques repercussions dans quelques cas tres particuliers (code tres recursif), mais honetement j'aurai aussi utilise un tableau (a moins d'etre dans un de ces cas tres particulier).

Le plus efficace serait sans doute de declarer le tableau comme global, afin de ne pas avoir a le recreer sur la pile a chaque appel de la fonction, mais les variables globales, c'est pas trop top pour la maintenance non plus...

A moins qu'en declarant le tableau comme "const" le compilateur se charge d'optimiser ?
Mes cours de compilation commencent un peu a dater :o) mais si quelqu'un a la reponse, je serais curieux de la connaitre.

Commentaire de LeFauve42 le 04/05/2010 13:56:04

Argh... J'ai completement pas pense a "static"... Bien vu Menuki

Mais ta declaration est celle d'un tableau sur objets constants, pas sur un tableau constant :o) (1)
Vu qu'on a un tableau constant d'objets constants, on pourrait avoir:
static const char *const s_jours[]...

Mais ma question premiere se pose toujours (un peu changee) :
Est-ce que le static est necessaire, puisque le tableau et son contenu sont constants, il est probable que le compilateur le traitera comme un "local static" (il n'a aucun interet a ne pas le faire (sauf si j'ai loupe un truc)).

Eric

(1) Vu que je suis completement dyslexique(2), c'est peut-etre le contraire (desole)
(2) Oui, j'ai du googler pour retrouver la bonne orthographe de ce mot :o)

Commentaire de LeFauve42 le 04/05/2010 15:55:21

>Mais je pense que dans la majorité des cas, il ne faut pas trop s'appuyer sur les
>fonctionnalités spécifiques d'un compilateur en particulier. Rien que pour l'aspect
>portabilité par exemple.

Vaste debat :o)

Je me souviens de mots cles tombes en desuetude, comme "register"(1) par exemple.
L'idee generale est "Le compilateur sait mieux que toi si cette variable doit etre mise dans un registre ou pas".

Apres ca depend ce qu'on entends par "compilateur" :
N'importe qui peut ecrire un compilateur C(2), ca se fait en quelques heures de TP et ca fonctionne pas trop mal pour des programmes simples.
Mais dans la vraie vie, il doit exister environ une demi-douzaine de compilateurs "serieux" et on peut sans problemes esperer qu'ils font bien leur boulot (gcc, visual studio, ...).

Et puis ce genre de comportements (allocation memoire des "variables constantes"(3)) est probablement documente precisement, et pas sujet a interpretation.
Pour dire ca autrement, je suis en faveur de la portabilite mais pas au point de mettre des parentheses partout au cas ou un compilateur exotique ne respecterait pas la precedence des operateurs generalement admise en C.

Bref, c'est bien de ne pas utiliser les specificites non standard d'un compilateur particulier, mais si certains comportements sont documentes dans les specificites du language, pourquoi s'en priver.

J'ai du mal a croire que j'ai ecrit autant sur un bout de code aussi simple (ok, on est un peu parti en "hors topic" vers la fin).

Toutes mes excuses aux lecteurs qui se sont perdu ici et qui ne demandaient qu'un bout de code pour connaitre le jour de la semaine :o)

Je dois commencer a radotter un peu (ca me fait ca quand on parle du bon vieux temps ;o) ).

En tous cas, merci a LeBroyeur pour nous avoir fait partager cet algo tres instructif.

Eric

(1) Et puisque le compilateur se charge d'optimiser tout seul comme un grand, on a ajoute de nouveaux qualifiers comme "volatile"... mais c'est un autre probleme
(2) J'ai bien dit "C", pas "C++". Prevoir un peu plus de temps pour ce dernier language :o)
(3) Oui, je sais, ca n'a pas de sens...

Commentaire de ghuysmans99 le 04/05/2010 18:54:35

Mouais, pas faux pour le static const char* jours[];
Je n'y avais même pas pensé.

Il faudrait aussi penser à valider la date. Là l'utilisateur peut enter 17/343/2010 et le programme ne dira rien :D

Commentaire de thebroyeur le 05/05/2010 19:22:56

dsl je continu ma phrase : .... de fonction comme celle-ci et qu'elle sont appelé un grand nombre de fois cela risque de ralentir ton programme.Bien sur dans ce cas, la différence est casi inexistante.

Commentaire de thebroyeur le 08/05/2010 11:30:29

Oui c'est vrai. Je modifie le code tout de suite

Commentaire de Menuki le 26/05/2010 16:12:27

Je préfère la deuze mais avec la modif' de M. LeFauve42 :

if (m <= 2) {a--;m+=12;}

Par contre, il n'y a toujours pas de vérification des entrées...

Commentaire de ADELSTYLE le 29/05/2010 11:44:24

Oui mais c logique.
Merci à tous ceux qui ont fourni des idées

================= Exemple :) ====================

#include <stdio.h>
#include <stdlib.h>

int main()
{
int j,m,M,a,jour;

static const char * s_jours[]={"Samedi","Dimanche","Lundi","Mardi","Mercredi","Jeudi","Vendredi"};
static const char * s_Mois[]={"Janvier","Février","Mars","Avril","Mai","Juin","Juillet","Aout","Septembre","Octobre","Novembre","Décembre"};

printf("La date sous la forme JJ / MM / AAAA :\n\n");
printf("Entrez le jour (JJ): ");
scanf("%d",&j);
printf("Entrez le mois (MM): ");
scanf("%d",&m);
printf("Entrez l'année (AAAA): ");
scanf("%d",&a);
M=m;

if((M==2 && j>28) && !(a % 4 == 0 && a % 100 != 0 || a %400 == 0)){
printf("\n\nle mois de février [1-28] jour\n\n");}
else{
        if(m == 2){a--;m=14;
        jour=(j + 2*m + ((3*(m + 1))/5) + a + (a/4) - (a/100) + (a/400) + 2) % 7; a++;}
        else if(m == 1) {a--;m=13;
        jour=(j + 2*m + ((3*(m + 1))/5) + a + (a/4) - (a/100) + (a/400) + 2) % 7; a++;}
        else jour=(j + 2*m + ((3*(m + 1))/5) + a + (a/4) - (a/100) + (a/400) + 2) % 7;

        if(j == 0 || m == 0 || a == 0){
        printf("\nErreur JJ/MM/AAA <> 0\n\n");}
        else if(j > 31){
        printf("\nErreur -> Jour [1-31]\n\n");}
        else if(M > 12){
        printf("\nErreur -> Mois [1-12]\n\n");}
        else if(M == 4 & j >30){
        printf("\nErreur -> Mois = 30 jour\n\n");}
        else if(M == 6 & j >30){
        printf("\nErreur -> Mois = 30 jour\n\n");}
        else if(M == 9 & j >30){
        printf("\nErreur -> Mois = 30 jour\n\n");}
        else if(M == 11 & j >30){
        printf("\nErreur -> Mois = 30 jour\n\n");}
        else if(M == 2 & j > 29){
        printf("\nErreur -> Mois = 29 jour\n\n");}
        else {printf("\n%s %02d %s %04d\n\n",s_jours[jour],j,s_Mois[M-1],a);}
    }
system("pause");
return 0;
    
}

Commentaire de ghuysmans99 le 30/05/2010 18:57:00

Update majeure du code comprenant la validation de la date :
---

/*
# Programme permettant la détermination du jour de la semaine
# d'aprés l'Algorithme de Maurice Kraitchik.

Code original de TheBroyeur - 30/04/2010.
Modifications apportées par :
- Menuki
- LeFauve42
- ghuysmans99

*/

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

// @ghuysmans99 : ajout
void entreDate(int* jour, int* mois, int* annee)
{
int dateOk;
do
{
printf("Date (JJ MM AAAA) : ");
scanf("%d %d %d",jour,mois,annee);

dateOk = 1;
if (*jour > 31 || *jour < 1) goto nok;
//pas de jours négatifs ou > 31
if (*mois > 12 || *mois < 1) goto nok;
//pas de mois négatifs ou > 12
if (*jour > 29 && *mois == 2) goto nok;
//pas plus de 29 jours en février
if (!((*annee % 4 == 0 && *annee % 100 > 0) || (*annee % 400 == 0)) && (*jour > 28)) goto nok;
//pas plus de 28 jours en février pour les années bisextiles
if ((*annee < 1582) || ((*annee == 1582) && (*mois < 10)) || ((*annee == 1582) && (*mois == 10) && (*jour < 15))) goto nok;
//jours en dessous du 15/10/1582 (date de la réforme grégorienne) invalides car calendrier différent avant cette date
goto ok;

nok:
dateOk = 0;
printf("Date invalide.\n");
ok:
;
} while (dateOk == 0);
}

int main()
{
int a;  // l'année
int m;  // le mois (mais janvier et février sont 13ème et 14ème mois de l'année suivante)
int q ; // le quantième du mois
int j;  // le rang du jour de la semaine où 0=samedi, 1=dimanche, etc., 6=vendredi
// @Menuki : ajout
static const char* s_jours[] = {"samedi","dimanche","lundi","mardi","mercredi","jeudi","vendredi"};

// @ghuysmans99 : modif
entreDate(&q,&m,&a);

// @LeFauve42 : modif
if (m <= 2)
{
a--;
m+=12;
}

j = (q+2*m+((3*(m + 1))/5)+a+(a/4)-(a/100)+(a/400)+2)%7;

// @ghuysmans99 : modif
printf("Ce jour etait un %s.\n", s_jours[j]);

/*printf("\n");
system("pause");*/
return 0;
}

Commentaire de Menuki le 31/05/2010 10:00:16

Bien! Mais je n'aime pas trop les goto.

Même si dans certains cas, c'est bien pratique, quand j'ai une autre solution, je préfère les éviter (ne transformons pas ce sujet en guerre pro-contre goto ;-) ).
Dans mes pérégrinations, j'ai découvert une pratique dans des exemples de Microsoft : la "dummy loop".

Donc voici ce que je propose pour la vérification :

void entreDate(int* jour, int* mois, int* annee)
{
for (;;)
{
printf("Date (JJ MM AAAA) : ");
scanf("%d %d %d",jour,mois,annee);

// dummy loop
do
{
if (*jour > 31 || *jour < 1)
{
break;
}
//pas de jours négatifs ou > 31
if (*mois > 12 || *mois < 1)
{
break;
}
//pas de mois négatifs ou > 12
if (*jour > 29 && *mois == 2)
{
break;
}
//pas plus de 29 jours en février
if (!((*annee % 4 == 0 && *annee % 100 > 0) || (*annee % 400 == 0)) && (*jour > 28))
{
break;
}
//pas plus de 28 jours en février pour les années bisextiles
if ((*annee < 1582) || ((*annee == 1582) && (*mois < 10)) || ((*annee == 1582) && (*mois == 10) && (*jour < 15)))
{
break;
}
//jours en dessous du 15/10/1582 (date de la réforme grégorienne) invalides car calendrier différent avant cette date

// si on arrive ici, c'est qu'on a réussi tous les tests, donc la date est OK
return;
}while (false); // fin de la dummy loop

printf("Date invalide.\n");
}
}

Voilà, juste une proposition...

Commentaire de Menuki le 01/06/2010 14:48:50

Le break fait pareil (juste un jmp).
C'est pas pour une question de performance, c'est pour une question d'hygiène de vie!
C'est écrit partout sur les paquets de biscuit :
"Pour votre santé, éviter de manger sucré, salé et les goto"  ;-)

Trève de plaisanterie, comme je l'ai précisé, je n'ai pas envie de rentrer dans la sempiternel gueguerre pro/anti goto. Sans les absoudre totalement, j'estime que, quand je peux faire autrement, je les évite. Et voici un moyen de les éviter (sans perte de performance en plus)...

Commentaire de ghuysmans99 le 01/06/2010 19:03:24

Nouvelle proposition de code : http://pastebin.com/AP1AADHU
Menuki aura probablement moins envie de me taper dessus en le voyant (enfin j'espère).

Commentaire de ghuysmans99 le 02/06/2010 19:14:52

Sorry j'avais pas présenté la 2ème alternative :
# if (*mois > 12 || *mois < 1)
#   break;
Beaucoup plus lisible du coup. Mais quand c'est comme ici une série de if avec toujours la même chose dedans, tu peux bien comprendre que ça ne serve à rien dans ce cas-ci.

Commentaire de ghuysmans99 le 03/06/2010 21:05:36

Oui, pas faux. Mais quand on modifie un programme en C, il n'est pas interdit de réfléchir à ce qu'on fait. Un oubli pareil ne peut passer inaperçu si l'on teste ses fonctions une fois qu'on les a modifiées. Perso je fais ça à chaque fois et je n'ai pas de problèmes (en même temps je n'ai jamais travaillé sur de gros projets en C). Cela doit néanmoins devenir un réflexe de procéder comme ça (énorme gain de temps au debugging).