Calcul rang d'un jour dans l'année

[PapouMAC]

Bonjour

Je vous montre d'abord ce que j'ai fait :

Code

                     //
                            //  main.m
                            //  Rang du jour dans l'_annee
                            //
                            //  Created by André Maleyran on 26/11/2014.
                            //  Copyright (c) 2014 André Maleyran. All rights reserved.
                            //
                            
                            #include<stdio.h>
                            
                            
                            int main()
                            
                            {
                                int jour, annee, N1, N2, K, RangduJour, menu, mois;
                                int c, a, m, j;
                                
                                char jours[7] [9] = {"dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"};
                                char lesMois [12] [10] = {"janvier", "février", "mars", "avril", "mai", "juin", "juillet", "août", "septembre", "octobre", "novembre", "décembre"};
                                
                                
                                do {
                                    printf("Entrer le jour :");
                                    scanf("%d", &jour);
                                    printf("Entrer le mois :");
                                    scanf("%d", &mois);
                                    printf ("Entrer l'année :");
                                    scanf("%d", &annee);
                                    
                    // Calcul pour rang du jour dans l'année
                  
                                    N1 = (int) ((mois * 275) / 9);
                                    N2 = (int) ((mois+9)/12);
                                    K = 1 + (int) ((annee-4*(int)(annee/4)+2)/3);
                                  
                                    RangduJour = N1  - N2 * K + jour - 30;
                            
                    // ICI LE TEST pour année non bissextile      
                    
                                 if ((float)annee/400 != annee/400 )
                                {
                                       RangduJour = RangduJour - 1;
                                }
                                
                   // Calcul pour jour de la semaine
            
                                    c = (int)((14-mois)/12);
                                    a = annee - c;
                                    m = mois + 12 * c -2;
                                
                                    j = jour + a + (int) a/4 - (int) a/100 + (int) a/400 + (int)((31*m)/12);
                                    j = j % 7;
                                    
                                    
                                    printf("\nLe %d/%s/%d est le %deme jour de l'année.", jour, lesMois[mois-1], annee, RangduJour);
                                    
                                    printf(" Et c'est (c'était ou sera) un ");
                                    
                                    printf("%s.\n", jours[j]);
                                    
                                    do {
                                        printf("\nVoulez-vous recommencer ? \n\n");
                                        printf("1 - Oui\n");
                                        printf("2 - Non\n\n");
                                        printf ("Votre choix ? : ");
                                        scanf("%d", &menu);
                                        printf("\n");
                                    } while (menu > 2 || menu < 1);
                                } while (menu == 1);
                                
                            }

Ce que je sais :

Pour qu'une année soit bissextile, il faut qu'elle soit divisible par 4, sauf pour les années séculaires qui elles doivent être divisible par 400.
Alors là où je bloque c'est au niveau du test. if ((float)annee/400 != annee/400)......
Quand je choisi par exemple 31/12/1900 cela correspond au 365e jour de l'année. Normal puisque 1900 n'est pas une année bissextile.
Mais lorsque je rentre 31/12/2012, là aussi le programme m'indique que c'est le 365e jour de l'année, alors que 2012 est une année bissextile, je devrais avoir comme réponse le 366e jour de l'année.

D'où ma question comment faire pour indiquer qu'il y a 366 jours dans une année bissextile, mais que 365 jours dans une année séculaire lorsque celle-ci n'est bissextile ? Merci.

PS : en fait je viens d' m'apercevoir que si je fait le test cela fonctionne pour les année séculaire, mais pas pour les autres années, j'ai un jour de moins à chaque fois.

Ce message a été modifié par PapouMAC - 29 Nov 2014, 12:27.

[schlum]

Tes calculs sont extrêmement bizarres ; savoir si une année est bissextile se fait avec :

Code

(a%400)==0||((a%4)==0&&(a%100)!=0)

[PapouMAC]

Tes calculs sont extrêmement bizarres ; savoir si une année est bissextile se fait avec :

Code

(a%400)==0||((a%4)==0&&(a%100)!=0)

Je te remercie, mais quels calculs, car ce sont ceux que j'ai glané sur internet ?
Ou tu ne parle que du test pour savoir si une année est bissextile ?

[schlum]

Je parle de l’entièreté du code, il y a des casts bizarres et à priori inutiles (un int divisé par un autre int donne déjà un int, c’est une division entière), des tests de congruence faits par comparaison entre un float et un int (ça n’est jamais fait comme ça).

Le test est faux effectivement, tester la congruence par 400 est insuffisant pour savoir si une année est bissextile.

Comme je l’ai dit ci-dessus, le test pour savoir si une année est bissextile est :

Code

(a%400)==0||((a%4)==0&&(a%100)!=0)

Et le test pour savoir si une année n’est pas bissextile est :

Code

(a%4)!=0||((a%100)==0&&(a%400)!=0)

[PapouMAC]

Je parle de l’entièreté du code, il y a des casts bizarres et à priori inutiles (un int divisé par un autre int donne déjà un int, c’est une division entière), des tests de congruence faits par comparaison entre un float et un int (ça n’est jamais fait comme ça).

Le test est faux effectivement, tester la congruence par 400 est insuffisante pour savoir si une année est bissextile.

Comme je l’ai dit ci-dessus, le test pour savoir si une année est bissextile est :

Code

(a%400)==0||((a%4)==0&&(a%100)!=0)

Et le test pour savoir si une année n’est pas bissextile est :

Code

(a%4)!=0||((a%100)==0&&(a%400)!=0)

Je te remercie, j'ai utilisé le test pour savoir si une année n'est pas bissextile.
Si je rentre le 31/12/1900, j'obtiens bien 365e jour, mais si je demande une autre date exemple 31/12/1700, là j'ai 366e jour.
Et si je rentre 31/12/2014, j'ai 364e jour. Pourquoi ?
Pour avoir un résultat correct, il faut que j'interrompe le programme et je le relance à nouveau ???

[Jaypee]

Je crois qu'il faut rester simple tout en étant rigoureux. Je propose le code suivant, ce n'est qu'un point de départ pour
l'inspiration

Code

/****************************************************
* rang.c
* Calcule le rang d'un jour dans l'année en cours
* Compilation: cc -o rang rang.c && chmod +x ./rang
* Usage : rang jour mois année
***************************************************/
#include <stdio.h>
#include <stdlib.h>
#define FEVRIER 2
#define BOOL int
#define BISSEXTILE(x)  (0 == (x) % 4) && !((0 == (x) % 100) && 0 != (x) % 400)
int nb_jours(int mois, int année) {
        int NB_JOURS[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        switch(mois) {
                case FEVRIER:
                        if (BISSEXTILE(année)) {
                                return 29;
                        } else {
                                return 28;
                        }
                        break;
                default:
                        return NB_JOURS[mois - 1];
        }
}
BOOL validation(int jj, int mm, int aaaa) {
        return (0 < mm) && (mm <= 12) && (0 < jj) && jj <= nb_jours(mm, aaaa);
}
int main(int argc, char *argv[] ) {
        if (argc < 4) {
                printf("Usage :  rang jj mm aaaa\n");
                exit(1);
        } else {
                int jj = atoi(argv[1]);
                int mm = atoi(argv[2]);
                int aaaa = atoi(argv[3]);
                if (validation(jj, mm, aaaa)) {
                        printf("Date saisie: %d/%d/%d\n", jj, mm, aaaa);
                        int rang = jj;
                        for (int m = 1; m < mm; m++) {
                                rang += nb_jours(m, aaaa);
                        }
                        printf("Le rang est: %d\n", rang);
                        exit(0);
                } else {
                        printf("Date invalide !\n");
                        exit(2);
                }
        }
}

Les questions et les saisies peuvent se faire en script shell, puis l' exécutable est appelé avec les bons arguments.
Le principe est qu'un programme en ligne de commande est une extension du système OS X.
Rigoureusement il faudrait écrire un programme de test, mais les tests suivants sont faciles à faire:

Code

./rang 1 1 2014 # On attend 1
./rang 31 12 2014 # On attend 365
./rang 31 12 2012 # On attend 366
./rang 31 12 2000 # On attend 366
./rang 31 12 1900 # On attend 365
./rang 29 02 2014 # On attend un message d'erreur (date invalide)
./rang 1 1 # On attend un message d'erreur

J-P

Ce message a été modifié par Jaypee - 12 Dec 2014, 09:58.

[schlum]

Tu as oublié la règle de congruence à 400 pour ta macro BISSEXTILE (du coup, le résultat pour 2000 est faux, car 2000 était bissextile, contrairement à 1900)

[Jaypee]

OK, je corrige au dessus.
Edit: C'est corrigé. Merci !
J-P

Ce message a été modifié par Jaypee - 29 Nov 2014, 14:46.

[PapouMAC]

Merci pour un pauvre débutant (1 mois seulement d'apprentissage du C).

Je vais essayer avec ce nouveau code.

PS : je viens d'essayer, mais ce code est trop complexe pour moi. Du moins pour le moment.
Je vais attendre d'avoir acquit une connaissance plus approfondie du C.
Mais encore merci à tous les deux.

Ce message a été modifié par PapouMAC - 29 Nov 2014, 16:18.

[Jaypee]

Dis-nous exactement où tu bloques, parce qu'il me semble que le code est réduit avec quelques petites sophistications, mais vraiment peu de choses et on t'aidera.
Là c'est juste pour l'inspiration, il est volontairement ni simpliste, ni trop compliqué.

J-P

[PapouMAC]

Là ou je bloque, c'est surtout lors du test pour savoir si les années sont bissextiles ou non. Séculaires comprises.
Par contre ton code est vraiment complexe pour moi, car il y a des parties que je n'ai pas encore vues.

exemple

Code

                 BOOL validation(int jj, int mm, int aaaa) {
                         return (0 < mm) && (mm <= 12) && (0 < jj) && jj <= nb_jours(mm, aaaa);
              
               où
          
               int main(int argc, char *argv[] ) {
                       if (argc < 4) {
                               printf("Usage :  rang jj mm aaaa\n");
                               exit(1);
                       } else {
                               int jj = atoi(argv[1]);
                               int mm = atoi(argv[2]);
                               int aaaa = atoi(argv[3]);
                               if (validation(jj, mm, aaaa)

Tu vois j'ai encore beaucoup de travail à faire pour arriver à maitriser le C. Si j'y arrive ?
Donc pour le moment je vais en rester là. Je reprendrais ce programme plus tard lorsque j'aurai avancer dans le C.
Je vais commencer petit, je crois qu'ici j'ai vu un peu trop grand (du moins pour moi). Encore merci pour la peine que vous prenez pour me répondre.

[Jaypee]

Il se peut que tu cumules les difficultés.

Indépendamment du code, il faut vraiment être à l'aise en logique de base, les lois de De Morgan sont essentielles, c'est-à-dire les enchaînements de ET et de OU et de NEGATION ne doivent pas t' arrêter.

La formule de l'année bissextile se lit:
année divisible par 4 et n'est pas un siècle non divisible par 400, c'est-à-dire divisible par 4 sans être un siècle ou être un siècle divisible par 400.

2012 => divisible par 4 et n'est pas un siècle => Bissextile
1900 => divisible par 4, est un siècle, n'est pas divisible par 400 => Non bissextile
2000 => divisible par 4, est un siècle, est divisible par 400 => Bissextile

Voilà comment comprendre la formule.

Il faut savoir d'une manière générale que la fonction main, peut être déclarée sans détails, mais si on utilise les détails, ils sont toujours les mêmes :
- main est invoquée automatiquement avec deux arguments: Le premier entier est le nombre d'arguments passés sur la ligne de commande, et le second un tableau de chaînes de caractères, les chaines passées à la suite du nom du programme. Traditionnellement, le nombre d'arguments est nommé argc "argument count", et le tableau d'arguments argv, v pour variable, puisque la taille du tableau est élastique.

Ici, le programme s'appelle rang et accepte 3 arguments jj, mm et aaaa qui sont lus comme du texte sur la ligne de commande. Par convention, le premier argument est le nom du programme lui-même donc
- argc = 4
- argv[0] = "rang"
- argv[1] = jj
- argv[2] = mm
- argv[3] = aaaa

Dans le main, il faut transformer la chaîne jj en entier jj, et cela se fait par la fonction de la bibliothèque standard (stdlib.h) atoi(text) = a-to-i = alpha to int = conversion texte vers entier
"31" devient le nombre 31.

Le gros problème suivant est de comprendre la gestion de mémoire. Mais tu peux parquer cette question pour le moment.

Par exemple, les chaînes de caractères en C, on pourrait les traiter comme des tableaux de caractères mais ce n'est pas ce qui se fait habituellement, on utilise généralement un pointeur sur un caractère, un char *.
La chose fondamentale à retenir c'est :

Un pointeur c'est toujours deux informations : une adresse en mémoire et un type. Essaie de te rappeler cela comme d'un proverbe de programmation.

Ici, une chaîne c'est donc une adresse, et un type char, sa taille est de 1 octet. C'est le cas le plus facile.
char *str = "abc";

Donc pour déclarer un tableau de chaînes, on fait un tableau de char * c'est-à-dire char *argv[] qui est un tableau d'adresse de chaînes, on ne trouve aucun caractère dedans.

Voilà, tu verras, c'est précis, technique, mais pas vraiment difficile à comprendre.

J-P

[PapouMAC]

Il se peut que tu cumules les difficultés.

Indépendamment du code, il faut vraiment être à l'aise en logique de base, les lois de De Morgan sont essentielles, c'est-à-dire les enchaînements de ET et de OU et de NEGATION ne doivent pas t' arrêter.

La formule de l'année bissextile se lit:
année divisible par 4 et n'est pas un siècle non divisible par 400, c'est-à-dire divisible par 4 sans être un siècle ou être un siècle divisible par 400.

2012 => divisible par 4 et n'est pas un siècle => Bissextile
1900 => divisible par 4, est un siècle, n'est pas divisible par 400 => Non bissextile
2000 => divisible par 4, est un siècle, est divisible par 400 => Bissextile

Ça j'ai bien intégré. Mais je n'en suis pas encore aux pointeurs. Donc pas tout compris. Mais ça vient.

[Akirami]

Rapidement, DMY traduit en ms, par ordre alpha sur une liste indent et relire l'Array, l'avantage de DMY est que c'est l'ordre alphabétique mais pas que..

Edit : le ms traduit le milli (tick) / sec, il s'agit de l'horloge du proco, alors si en plus ... ...
Edit 2 : Cette horloge est statique et est propre à tous les procos Intel ainsi qu'ARM..

Ce message a été modifié par Akirami - 30 Nov 2014, 00:26.

[Jaypee]

@PapouMac: Si ça peux t'aider, voici une analogie

D'après ton code original, tu avais une vision du tableau de chaînes, comme un casier à bouteille, un caractère, une place.

En fait donc, une chaîne, c'est une adresse en mémoire, comme une clé qui n'est pas la chose conservée, mais le moyen de l'atteindre. Donc ta vision devrait être changée vers celle d'un porte-clé: Il peut conduire aux choses conservées, mais aucune d'elle ne fait partie directement du porte-clé, seulement sa clé.

Soyons plus technique, maintenant qu'on sait qu'une chaîne est une adresse en mémoire, comment connaître sa longueur?

Elle est marquée par un marqueur de fin de chaîne, qui est le caractère ASCII zéro:

Sachant que le code ASCII de A, c'est 65, pour ranger la chaîne "ABC", le compilateur C alloue une place en mémoire, disons à l'adresse 1000, sur une longueur de 4 octets:

Un dump montrerait (je simplifie grossièrement) :
1000: 65 66 67 0 ...... A B C nul ....
A l'adresse 1004, il y a déjà autre chose... Terrain miné.

La fonction strlen("ABC") donne 3, c'est à dire la longueur de la chaîne.

Comme tu vois, la mémoire est complètement "goupillée", une fois allouée, on ne peut pas faire grand chose
Si tu voulais construire "ABC" + "DEF", il faudrait:
- Allouer de la mémoire : 3 x taille d'un char + 3 x taille d'un char + 1 x taille d'un char pour le marqueur de fin de chaîne: Le char est le plus facile, sa taille est de 1 octet. pour info ce serait: char *ptrChaîne = malloc(7);
- Copier vers ptrChaîne le contenu de "ABC" dans la destination: strcpy(ptrChaîne, "ABC"); /* Le nul derrière ABC est copié avec */
- Copier vers ptrChaîne + 3 la chaîne "DEF" : strcpy(ptrChaîne + 3, "DEF"); /* on "écrase" le nul déjà copié par le D, et le nouveau nul de "DEF" vient avec */

==> Fais-toi un exercice autour de la copie de chaînes, et tu verras, tu seras plus à l'aise après.

Règles à se rappeler #1
On garde toujours le résultat du malloc dans une variable, car une fois fini d'être utilisé, il faut faire un free(ptrChaîne); La mémoire allouée vous appartient, à vous de la libérer ou de la garder. Elle est prise sur une zone de mémoire libre appelée le "tas" ou "heap" en anglais.
Le bug facile c'est de faire un autre malloc pour le même pointeur en oubliant de garder l'ancienne valeur qui est perdue. Toujours s'assurer que le free est fait avant de réutiliser un pointeur ou que l'ancienne valeur est copiée dans un autre pointeur. Le problème arrive facilement dans une boucle.

Car sinon, la zone mémoire sera perdue pour le programme: c'est une "fuite" de mémoire à l'intérieur de l'environnement du programme exécuté. Elle sera récupérée lorsqu'on redémarre le programme avec un environnement d'exécution tout neuf.
- L'allocation se fait par unité égale à la taille du type.
C'est pour cela que le type est toujours associé au pointeur, il conditionne la granularité d'accès aux adresses de la mémoire: Avec des char, les adresses 1000 1001 1002 etc sont toutes accessibles parce que la taille du type est de 1 octet.

Si on avait un pointeur vers un entier de 64-bits = 8 octets à l'adresse disons 1500, les adresses 1501, 1502 etc ne sont pas accessibles, la prochaine accessible est 1508. S'il fallait à tout prix accéder aux mémoires intermédiaires, il faudrait "faire semblant" d'être un pointeur vers du char" pour le faire. Cette esbroufe s'appelle un "cast" :

- int *ptrInt = malloc(5 * sizeof(int)); /* supposons que c'est 1500, on veut ranger 5 entiers */
- char *ptrEspion = (char *)prtInt; /* on cast le int * en char * */

ptrEspion + 1 => adresse suivante = 1501, on pourrait l'utiliser pour examiner la représentation en mémoire d'un entier
ptrInt + 1 => adresse 1508, il saute d'adresse en adresse par pas égal à la taille d'un entier

Règle à se rappeler #2
Le + 1 d'un pointeur signifie + 1 x la taille du type pointé

Règle à se rappeler #3
int *ptrInt; /* on n'a alloué que la place pour le pointeur lui même, c'est à dire la place de la clé seulement, mais pas encore l'espace de rangement associé, il faut un malloc pour cela. Avant le malloc, ptrInt vaut n'importe quoi, ne pas supposer que c'est zéro */
char *ptrChaine = "ABC"; /* Là on laisse C faire le malloc, on ne fait pas le free, parce qu'on n'a pas fait le malloc soi-même */

Règle à se rappeler #4
Les variables à l'intérieur d'une fonction sont allouées par le compilateur sur la pile d' exécution. En revanche, la mémoire ainsi utilisée est automatiquement rendue au retour de la fonction.

int monCalcul() {
int tableau[100000]; /* On va très certainement exploser la pile ici */
....
return 42;
}


Voilà, c'est très dense, mais encore absorbable, prends ton temps.
JP

Ce message a été modifié par Jaypee - 30 Nov 2014, 10:57.

[Akirami]

Merci JP

[guerom00]

Apparemment, les années "fin de siècle" divisibles par 400 commencent toujours par un samedi
Marrant ça

[PapouMAC]

Merci Jaypee pour ces explications. Pour le moment pour moi c'est du chinois. J'en suis pas assez loin dans mon étude du C pour tout comprendre. Mais patience, chaque jour suffit sa peine.

Apparemment, les années "fin de siècle" divisibles par 400 commencent toujours par un samedi
Marrant ça

Oui, effectivement curieux, mais il doit y avoir une explication à ça.

[schlum]

Merci Jaypee pour ces explications. Pour le moment pour moi c'est du chinois. J'en suis pas assez loin dans mon étude du C pour tout comprendre. Mais patience, chaque jour suffit sa peine.

Apparemment, les années "fin de siècle" divisibles par 400 commencent toujours par un samedi
Marrant ça

Oui, effectivement curieux, mais il doit y avoir une explication à ça.

Pas si curieux ; en 400 ans, nous avons :
* 1 année bissextile divisible par 400 (366 jours)
* 3 années non bissextiles divisibles par 100 (3*365 jours)
* 96 années bissextiles divisibles par 4 (96*366 jours)
* 300 années non bissextiles non divisibles par 4 (300*365 jours)

Ce qui donne 366+3*365+96*366+300*365 = 146 097 jours qui est un multiple de 7 -> il y a exactement 20 871 semaines sur 400 ans

On repart donc sur le même jour tous les 400 ans

[PapouMAC]

Merci Jaypee pour ces explications. Pour le moment pour moi c'est du chinois. J'en suis pas assez loin dans mon étude du C pour tout comprendre. Mais patience, chaque jour suffit sa peine.

Apparemment, les années "fin de siècle" divisibles par 400 commencent toujours par un samedi
Marrant ça

Oui, effectivement curieux, mais il doit y avoir une explication à ça.

Pas si curieux ; en 400 ans, nous avons :
* 1 année bissextile divisible par 400 (366 jours)
* 3 années non bissextiles divisibles par 100 (3*365 jours)
* 96 années bissextiles divisibles par 4 (96*366 jours)
* 300 années non bissextiles non divisibles par 4 (300*365 jours)

Ce qui donne 366+3*365+96*366+300*365 = 146 097 jours qui est un multiple de 7 -> il y a exactement 20 871 semaines sur 400 ans

On repart donc sur le même jour tous les 400 ans

Et bien voilà il suffisait de demander. Merci.