Opérations sur les dates

Version imprimable

Edit:
Nouvelle solution plus rapide.

aaaa : entier pour l'année
mm : entier pour le mois
jj : entier pour le jour

année bissextile:

Code:

1
2
3
4
 
  si (mm =2) et (((aaaa mod 4=0) et (aaaa mod 100!=0)) ou aaaa mod 400=0)
    dire "L'année est bissextile"
  finsi

Maintenant, le code pour connaitre la date un nombre X de jours après (X peut être négatif).

Code:

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
 
fonction calcul_date(entier aaaa, entier mm, entier jj, entier X)
{
  //aaaa : ans
  //mm : mois
  //jj : jours
  //X : nombres d'itérations
 
  //On convertit la date donnée en nb de jours depuis le jour 0 de l'an 0
 
  entier tabmois[] <- {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
  si (aaaa mod 4=0 et aaaa mod 100!=0) ou aaaa mod 400=0
    tabmois[1] = 29
  finsi
 
  entier jourDeb <- 0
 
  //Somme des ans et jours
  jourDeb <- entier(aaaa/400) * 146097 + entier((aaaa mod 400)/100) *  36524 + entier((aaaa mod 100) / 4) * 1461 + (aaaa mod 4) * 365 + jj
 
  //Somme des mois: peut se résumer en une ligne en formule math. avec signe somme 
  pour i = 0, tant que i < mm, faire i++
    jourDeb <- jourDeb + tab
  finpour
 
  //On ajoute le nombre de jour, positif ou négatif
  jourDeb <- jourDeb + X
 
  //On convertit en calendrier standard
  //Nombre d'années
  aaaa <- entier(jourDeb/146097) * 400 + entier((jourDeb mod 146097)/36524) * 100 + entier(((jourDeb mod 146097) mod 36524)/ 1461) * 4 + entier((((jourDeb mod 146097) mod 36524) mod 1461) mod 365)
 
  //nombre de jour dans mm et jj
  jj <- entier((((jourDeb mod 146097) mod 36524) mod 1461) mod 365)
 
  //On acheve jj et mm. On vérifie d'abord la bissextilité
  si (aaaa mod 4=0 et aaaa mod 100!=0) ou aaaa mod 400=0
    tabmois[1] = 29
  sinon
    tabmois[1] = 28
  finsi
 
  pour i = 0, tant que jj > tabMois[i], faire i++
    mm++
    jj <- jj - tabmois[i]
  finpour
}

Fonctionnement:
Convertit la date en nombre de jours depuis le Jour 0, ajoute ou retrait le nombre de jours voulu, convertit le nombre de jours en date (d'après l'idée de souviron34).

Sans commentaires:

Code:

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
 
fonction calcul_date(entier aaaa, entier mm, entier jj, entier X)
{
  entier tabmois[] <- {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
  si (aaaa mod 4=0 et aaaa mod 100!=0) ou aaaa mod 400=0
       tabmois[1] = 29
 
  entier jourDeb <- 0
 
  jourDeb <- entier(aaaa/400) * 146097 + entier((aaaa mod 400)/100) *  36524 + entier((aaaa mod 100) / 4) * 1461 + (aaaa mod 4) * 365 + jj
 
  pour i = 0, tant que i < mm, faire i++
        jourDeb <- jourDeb + tab
 
  jourDeb <- jourDeb + X
 
  aaaa <- entier(jourDeb/146097) * 400 + entier((jourDeb mod 146097)/36524) * 100 + entier(((jourDeb mod 146097) mod 36524)/ 1461) * 4 + entier((((jourDeb mod 146097) mod 36524) mod 1461) mod 365)
 
  jj <- entier((((jourDeb mod 146097) mod 36524) mod 1461) mod 365)
 
  si (aaaa mod 4=0 et aaaa mod 100!=0) ou aaaa mod 400=0
       tabmois[1] = 29
  sinon
       tabmois[1] = 28
 
  pour i = 0, tant que jj > tabMois[i], faire i++
    mm++
    jj <- jj - tabmois[i]
  finpour
}

09/01/2007, 11h24
PRomu@ld
Pour ce qui est du premier algo, on ne peut pas dire que ça soit un algo. Vérifier une date est extremement simple, et ne consiste qu'en des tests.

Pour les deux autres, la méthode est un peu "bourrine", au lieu de passer par une boucle, il y a surement moyen d'arriver à un résultat quasi-direct plutôt que par une boucle.

Aussi, ceci :
Code:

1 2 3 4 5 si ((aaaa mod 4=0) et (aaaa mod 100!=0)) ou aaaa mod 400=0 alors tabMois[1] <- 28; sinon tabMois[1] <- 29; finsi
La branche sinon ne sert à rien, tabMois[1] vaut déjà 29.

L'idée en fait que je veux avancer, c'est qu'il serait bon d'avoir des algo avec une complexité optimale.

J'aimerai avoir l'avis d'autres utilisateurs pour voir ce qu'on fait des algos.

Merci de ta participation.
09/01/2007, 13h10
coyotte507

si en fait elle sert à qqchose

car si l'année de départ est bissextile alors ce sera 28 qu'il faudra changer en 29

Sinon tu as raison, pour les calculs, on peut aller direct au début/à la fin du mois, puis de mois en mois et d'années en années. Je changerais quand j'aurais le temps.
09/01/2007, 23h14
PRomu@ld

Citation:

si en fait elle sert à qqchose

car si l'année de départ est bissextile alors ce sera 28 qu'il faudra changer en 29

Oui, c'est parce que le calcul est fait séquentiellement, j'ai lu trop vite. Mais une solution directe serait la bienvenue. (si je veux calculer le milionniène jour d'après j'aimerai l'avoir directement ;) )
10/01/2007, 19h19
coyotte507

note: je viens d'éditer le premier post.
11/02/2007, 16h53
souviron34

pourquoi réinventer la roue ?

En C , il y a des fonctions toutes prêtes et avec un algo mini on fait ça :

la fonction time() donne le nombre de seconde depuis 01/01/1970
la fonction gmtime() prend un nombre de secondes et le décompose en années/mois/jour

donc :

pseudo-algo :

secs-depart = time(date-de-départ)
secs-fin = secs-depart +/- 86400 * nb de jours
date-fin = gmtime(secs-fin)
11/02/2007, 17h00
PRomu@ld

Citation:

pourquoi réinventer la roue ?

En C , il y a des fonctions toutes prêtes et avec un algo mini on fait ça :

Comme tu l'auras remarqué, nous sommes ici dans le forum algorithmes et non pas dans le forum C :aie: . Réinventer la roue comme tu le dis est utile dans les langages ne disposant pas de telles fonctions. De plus, il peut être intéressant de voir comment produire de tels algos.
11/02/2007, 17h43
souviron34

Citation:

Envoyé par PRomu@ld

Comme tu l'auras remarqué, nous sommes ici dans le forum algorithmes et non pas dans le forum C :aie: . Réinventer la roue comme tu le dis est utile dans les langages ne disposant pas de telles fonctions. De plus, il peut être intéressant de voir comment produire de tels algos.

OK.

Mais le principe est quand même applicable...

Et sinon il suffit de se placer en calendrier Julien, tous les jours se suivent depuis .... 2000 ans je crois non (puisque c'est ça qui sert en astronomie, comme ça pas à s'embêter avec ce genre de problème) ?

pseudo-algo :

convertir date en jour julien (date depart julien)
date fin julien = date - nombre jours
convertir jour julien en date
25/02/2007, 17h42
coyotte507

Edit: Le julien est une bonne idée, je vais essayer d'en faire un algo

Dans le langage C, on a une fonction qui donne le temps de 1970 à 203* (je me rappelle plus exactement)

Or dans cet intervalle de temps, tous les quatre ans l'année est bissextile (ce n'est pas le cas des années 1900, 2100, 2200...). C'est pour ca que leur opération est si facile (on peut calculer directement la date à ce moment).

Ici l'algo donne la date pour n'importe quel jour de l'espace temps. Cependant on peut faire une modif: En effet, l'intervalle de 400 ans comporte toujours le même nombre de jours.
25/02/2007, 20h05
PRomu@ld

Citation:

Dans le langage C

:evilred: Puis je vous rappeler que nous sommes dans le forum algorithme... (ici, pas de fonction qui existent déjà).

Citation:

Ici l'algo donne la date pour n'importe quel jour de l'espace temps. Cependant on peut faire une modif: En effet, l'intervalle de 400 ans comporte toujours le même nombre de jours.

Oui, ça mérite approfondissement. (je suis pas convaincu que l'amélioration que tu va trouver va diminuer significativement les calculs).
26/02/2007, 13h18
coyotte507

Edit: Nouvelle solution en julien.
07/03/2007, 07h07
PRomu@ld

Citation:

Lignes de codes:
21

Attention, ceci n'est absolument pas un gage d'efficacité (et quelque fois, c'est le contraire), je ne vois pas l'intérêt de le mettre.

Citation:

Edit: Nouvelle solution en julien.

As tu des traces de l'ancien algorithme ? Juste pour des raisons pédagogiques, on peut peut-être les garder.
07/03/2007, 13h32
coyotte507

Ok j'ai viré les lignes de codes ^^.

Non je n'ai pas gardé les anciens (par contre il y a un topic du même nom, opérations sur les dates, de la partie générale ou il doit en rester un).

Résumé des deux algos d'avant: (si ca peut aider)

*Boucle jour par jour

*jusqu'au mois complet, à l'année, d'années en années, de mois en mois et jusqu'au jour