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)

[PRomu@ld]

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

[souviron34]

Comme tu l'auras remarqué, nous sommes ici dans le forum algorithmes et non pas dans le forum C . 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

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

[PRomu@ld]

Dans le langage C

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

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

[coyotte507]

Edit: Nouvelle solution en julien.

[PRomu@ld]

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.

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.

[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