Discussion :

[coyotte507]

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 :

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

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 :

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
 
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 :

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
 
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
}

[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 :

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

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.

[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.

[PRomu@ld]

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 )

[coyotte507]

note: je viens d'éditer le premier post.

[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)