Bonjour a tous ,  
 
J'ai des exercices a faire pour Mardi et il y a 3 exercices qui me posent problèmes et sur lesquels je sèche :
 
1) Ecrire un programme qui lit une date (jour, mois, année) et qui vérifie qu'elle est valide dans le calendrier grégorien.(année comprise entre 1583 et 2483)
-Remarques:1)Il faut saisir la date au format(jj/mm/aaaa) en une fois.
                 2)L'année, le mois et le jour doivent être contrôlés(une 1ere fois ) à la saisie.
 
2) Entrez une phrase contenant des parenthèses droites '(' et gauches ')', l'entrée se terminera par un point. Le programme vérifiera si la phrase à une structure de parenthèses correcte, c'est à dire qu'à chaque parenthèse ouverte correspond une et une seule parenthèse fermée située à sa droite.Utiliser getchar() pour les entrées.
 
3) Ecrire un programme proposant le jeu suivant: l'ordinateur tire au hasard un nombre compris entre 40 et 75 l'affiche; le joueur 1 et le joueur 2 doivent alternativement soustraire de ce nombre un nombre compris entre 1 et 9; après chaque soustraction le total restant est affiché. La fin du jeu est atteinte quand un joueur atteint 0 et à de ce fais perdu; le programme indique quel à perdu. Les entrées doivent être contrôlées.
 
Voilà les énoncés, je remercie ceux qui prendront un peu de leurs temps pour m'aider et m'expliquer car je débute en progra je n'en ai donc jamais fais auparavant.  
PS: Je travail sous CodeBlocks Svn 4066.

Bonjour, pour le 1, je vous donne un code écrit avec Ada qui permet de manipuler des dates gregorienne.

La spec.
 
package Date_Gregorien is
 
   -- le type des numéro de jour dans le mois
   -- on utilise un sous-type d'Integer pour pour voir faire dessus
   -- des opérations comme +, put, etc...
   subtype T_Num_Jour is Integer range 1 .. 31;
 
   -- On utilise un type énuméré pour les mois
   type T_Mois is (Janvier, Fevrier, Mars, Avril, Mai, Juin,
                   Juillet, Aout, Septembre, Octobre, Novembre, Decembre);
 
   -- type du nom des jours dans la semaine
   type T_Jour is (Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche);
 
   -- les années sont des entiers entre 1601 et 5000
   subtype T_Annee is Integer range 1601 .. 5000;
 
   -- le type des dates
   type T_Date is private;
 
   -- lit une date sur l'entrée standard (clavier)
   procedure Get(D: out T_Date);
 
   -- écrit une date sur la sortie standard (écran)
   procedure Put(D: in T_Date);
 
   -- crée une date à partir de ses constituants
   -- en effectuant un contrôle de validité
   -- date n'est pas changé si les arguments ne sont pas valides
   -- date_ok indique la validité de la date
   procedure Cree_Date(Jour_Semaine : in T_Jour;
                       Jour_Mois : in T_Num_Jour;
                       Mois : in T_Mois;
                       Annee : in T_Annee;
                       Date: out T_Date);
 
   -- donne une date correspondant au lendemain de la date passée en argument
   function Lendemain(Date: T_Date) return T_Date;
 
   -- fonction qui dit combien de jours se sont écoulés depuis le
   -- premier janvier (inclus) jusqu'à la date pasée en paramètre.
   function Jour_Annee(D : T_Date) return Natural;
 
   -- fonction qui calcule le nom du jour correspondant
   -- à un numro de jour, un mois et une année
   function Nom_Jour(Jour : T_Num_Jour;
                     Mois : T_Mois;
                     Annee : T_Annee) return T_Jour;
 
   -- exception levée en cas d'erreur sur une date
   Date_Incorrecte : exception;
 
private
 
   -- Le type des dates
   type T_Date is record
      Num_Jour : T_Num_Jour;
      Nom_Du_Jour : T_Jour;
      Nom_Du_Mois : T_Mois;
      Annee : T_Annee;
   end record;
 
end Date_Gregorien;

 
L'implementation

with Ada.Text_Io;
with Ada.Integer_Text_Io;
-- exceptions levées lors des entrées sorties
with Ada.Io_Exceptions; use Ada.Io_Exceptions;
 
-- implantation du package Date_Gregorien
package body Date_Gregorien is
 
   --=========================================================================
   --=========================================================================
   -- Définitions auxiliaires
   --------------------------
   -- nombre de jours par mois
   -- années bissextiles
   -- fonction Date_Valide
   --=========================================================================
   --=========================================================================
 
   -- un type tableau de num_jour dont les indices sont les mois de l'année
   type T_Tab_Jours_Mois is array (T_Mois) of T_Num_Jour;
 
   -- le tableau NJ qui associe à chaque mois son nombre de jours
   N_J : T_Tab_Jours_Mois :=
     ( Janvier   => 31, Fevrier => 28, Mars     => 31, Avril    => 30,
       Mai       => 31, Juin    => 30, Juillet  => 31, Aout     => 31,
       Septembre => 30, Octobre => 31, Novembre => 30, Decembre => 31 );
 
   --=========================================================================
   -- fonction testant si une année est bissextile
   -- tous les 4 ans, sauf les centaines. Les années multpiples de 400 sont
   -- bissextiles
   function Est_Bissextile(A : T_Annee) return Boolean is
   begin
      return
        A mod 4 = 0
        and ( A mod 100 /= 0
              or A mod 400 = 0) ;
   end Est_Bissextile;
 
   --=========================================================================
   -- vérifie si une date est valide
   function Date_Valide(D: T_Date) return Boolean is
      Jour_Ok : Boolean;
   begin
      -- test pour savoir si cette année, il y a le 29 février
      if D.Nom_Du_Mois = Fevrier and Est_Bissextile(D.Annee) then
         Jour_Ok := D.Num_Jour <= N_J(Fevrier) + 1;
      else
         Jour_Ok := D.Num_Jour <= N_J(D.Nom_Du_Mois);
      end if;
 
      return Jour_Ok and
        ( Nom_Jour(D.Num_Jour,D.Nom_Du_Mois,D.Annee) = D.Nom_Du_Jour );
   end Date_Valide;
 
 
   --=========================================================================
   --=========================================================================
   -- Entrées sorties
   ------------------
   -- procedures Put et Get
   --=========================================================================
   --=========================================================================
 
   -- instanciation du package générique Ada.Text_Io.Enumeration_IO
   -- avec le type T_Mois pour faire des entrées/sorties sur les mois
   package Mois_Io is
      new Ada.Text_Io.Enumeration_IO(Enum => T_Mois);
 
   -- instanciation du package générique Ada.Text_Io.Enumeration_IO
   -- avec le type T_Mois pour faire des entrées/sorties sur les jours de
   -- la semaine
   package Jour_Io is
      new Ada.Text_Io.Enumeration_IO(Enum => T_Jour);
 
   --=========================================================================
   -- lit une date sur l'entrée standard (clavier)
   procedure Get(D: out T_Date) is
   begin
      Jour_Io.Get(D.Nom_Du_Jour);
      Ada.Integer_Text_Io.Get(D.Num_Jour);
      Mois_Io.Get(D.Nom_Du_Mois);
      Ada.Integer_Text_Io.Get(D.Annee);
      if not Date_Valide(D) then
         raise Date_Incorrecte;
      end if;
   exception
      when Data_Error
        |  Constraint_Error => raise Date_Incorrecte;
   end;
 
   --=========================================================================
   -- écrit une date sur la sortie standard (écran)
   procedure Put(D: in T_Date) is
   begin
      Jour_Io.Put( D.Nom_Du_Jour );
      Ada.Text_Io.Put( " " & T_Num_Jour'Image(D.Num_Jour) & " " );
      Mois_Io.Put( D.Nom_Du_Mois );
      Ada.Text_Io.Put( " " & T_Annee'Image(D.Annee) );
   end Put;
 
 
   --=========================================================================
   -- création de date
   -------------------
   -- procedure cree_date
   --=========================================================================
 
   -- crée une date à partir de ses constituants
   -- en effectuant un contrôle de validité
   -- date n'est pas changé si les arguments ne sont pas valides
   -- une exception est levée dans ce cas
   procedure Cree_Date(Jour_Semaine : in T_Jour;
                       Jour_Mois: in T_Num_Jour;
                       Mois : in T_Mois;
                       Annee : in T_Annee;
                       Date: out T_Date ) is
      D : T_Date ;
   begin
      D := ( Nom_Du_Jour => Jour_Semaine,
             Num_Jour => Jour_Mois,
             Nom_Du_Mois => Mois,
             Annee => Annee );
      if Date_Valide(D) then
         Date := D;
      else
         raise Date_Incorrecte;
      end if;
   end Cree_Date;
 
   --=========================================================================
   -- Calculs sur les dates
   ------------------------
   -- Calcul du lendemain
   -- calcul du jour dans l'année
   -- calcul du nom d'un jour
   --=========================================================================
 
   -- donne une date correspondant au lendemain de la date passée en argument
   -- l'exception date_incorrecte est levée si on est le 31 decembre de
   -- l'an 5000.
   function Lendemain(Date: T_Date) return T_Date is
      -- vrai si on est le dernier jour du mois
      Dernier_Jour_Mois : Boolean;
 
      -- la date à renvoyer
      -- on l'initialise en utilisant date, puis on la modifie
      -- pour qu'elle représente le lendemain
      Resultat : T_Date := Date;
   begin
      -- on calcule si on est au dernier jour du mois courant
      if Date.Nom_Du_Mois = Fevrier and Est_Bissextile(Date.Annee) then
         Dernier_Jour_Mois := ( Date.Num_Jour = N_J(Fevrier) + 1);
      else
         Dernier_Jour_Mois := ( Date.Num_Jour = N_J(Date.Nom_Du_Mois) );
      end if;
 
      if Dernier_Jour_Mois then
         -- le jour est le premier dans le mois
         Resultat.Num_Jour := 1;
         -- test pour le dernier mois de l'année
         if Date.Nom_Du_Mois = Decembre then
            -- on renvient en janvier
            Resultat.Nom_Du_Mois := Janvier;
            -- et on passe à l'année suivante
            Resultat.Annee := Date.Annee + 1;
         else
            -- on prend le mois suivant, l'année reste la même
            Resultat.Nom_Du_Mois := T_Mois'Succ(Date.Nom_Du_Mois);
         end if;
      else
         Resultat.Num_Jour := Date.Num_Jour + 1;
      end if;
 
      --traitement du jour de la semaine
      if Date.Nom_Du_Jour = Dimanche then
         Resultat.Nom_Du_Jour := Lundi;
      else
         Resultat.Nom_Du_Jour := T_Jour'Succ(Date.Nom_Du_Jour);
      end if;
 
      return Resultat;
   exception
      when Constraint_Error => raise Date_Incorrecte;
   end Lendemain;
 
   --=========================================================================
   -- fonction qui dit combien de jours se sont écoulés depuis le
   -- premier janvier (inclus) jusqu'à la date pasée en paramètre.
   function Jour_Annee(Jour : T_Num_Jour;
                       Mois : T_Mois;
                       Annee : T_Annee) return Natural is
      Resultat : Natural := 0;
      M : T_Mois := Janvier;
   begin
      -- on ajoute le nombre de jours correspondant au mois M
      -- tant que M n'est pas le mois de la date passée en argument
      while ( M < Mois ) loop
         Resultat := Resultat + N_J(M);
         M := T_Mois'Succ(M);
      end loop;
 
      Resultat := Resultat + Jour;
 
      -- traitement des années bissextiles, si le mois est après février
      if Est_Bissextile(Annee) and Mois > Fevrier then
         Resultat := Resultat + 1;
      end if;
 
      return Resultat;
   end Jour_Annee;
 
   -- la version qui prend une date en arguement
   function Jour_Annee(D : T_Date) return Natural is
   begin
      return Jour_Annee(D.Num_Jour, D.Nom_Du_Mois, D.Annee);
   end Jour_Annee;
 
   --=========================================================================
   -- nom du jour de la semaine correspondant au 1er janvier 1601
   -- comme 1600 est bissextile et commence un samedi
   Nom_1er_Janvier_1601 : T_Jour := lundi;
 
   -- fonction qui calcule le nom du jour correspondant
   -- à un numro de jour, un mois et une année
   function Nom_Jour(Jour : T_Num_Jour;
                     Mois : T_Mois;
                     Annee : T_Annee) return T_Jour is
      -- compteur d'années
      A : natural := 1601;
      -- décalage en nombre de jours modulo 7 à partir du premier jour
      -- de la semaine, à savoir lundi
      Decal_Jour : Natural :=
        T_Jour'Pos(Nom_1er_Janvier_1601) - T_Jour'Pos(lundi);
 
   begin
      -- calcul du décalage dues aux années précédentes
      while A < Annee loop
         if Est_Bissextile(A) then
            Decal_Jour := (Decal_Jour + 366) mod 7;
         else
            Decal_Jour := (Decal_Jour + 365) mod 7;
         end if;
         A := A + 1;
      end loop;
 
      -- calcul du décalage dû aux jours de cette année
      -- on regarde la différence avec le premier jour, donc on retire 1
      Decal_Jour := (Decal_Jour + Jour_Annee(Jour,Mois,Annee) - 1) mod 7;
 
      return T_Jour'Val( T_Jour'Pos(lundi) + Decal_Jour );
   end Nom_Jour;
 
end Date_Gregorien;

 
 
Le deux et le trois sont trop facile.
 
Si t'as jamais programmé, t'as du suivre des cours qui te permettent de le faire.
Je travaille avec Emacs.

Merci pour la solution mais je n'ai jamais utiliser Ada pour programmer ...  
Comme je l'ai préciser je travail exclusivement avec CodeBlocks .Sinon j'ai suivis des cours mais ce genre d'exercices (le 2 et 3 surtout) on n'en n'a pas fais en cours de ce style.

Comme toujours dans ces cas-là, présentez-nous votre avancement sur chacun des exercices, pour que nous puissions vous donner des indications vous permettant d'aller plus loin, le but n'étant pas que nous fassions les exercices à votre place
 
Par exemple, bloquez-vous sur l'algorithme ou sur l'implémentation en C ? En fonction de vos réponses, nous pourrons vous aider à avancer
 
Bon courage !

Bonsoir,  
Ben pour le 1er après avoir déclaré les 3 variables quand je rentre dans le If j'ai du mal a voir qu'elle condition je dois posé en premier.
 
Est-ce celle-la ? If(année>=1583 && année<=2483)

Par exemple, c'est un bon début !
 
De fait, l'ordre est assez peu important ! L'important est de n'oublier aucun test de validité, de bien penser à toutes les conditions à vérifier pour qu'une date soit valide.
 
Une fois tous vos tests imaginés "sur papier", vous pourrez passer à la phase suivante, qui consiste à coder l'algorithme que vous avez défini.

 
 
L'ordre n'est pas important dans ce cas précis, mais il y a quand même une différence. Si le test échoue dans la partie gauche du "&&" , la partie droite ne sera même pas évaluée. Cela permet de faire des optimisations ou bien des choses de ce genre :
 

Je ne parle pour l'instant que d'algorithme, les détails d'implémentation seront vus plus tard !

Bonsoir,  
Finallement je suis arrivé un résultat pas mauvais je trouve    
 
#include <stdio.h>
#include <stdlib.h>
 
 
main()
{
    int jours, mois, annee,jmax;
    printf("\n entrez une date (jj/mm/aaaa)" );
    scanf("%d/%d/%d/", &jours, &mois, &annee);
 
    if(annee<1583||annee>2483)
    {
         printf("\n annee non valide" );
    }
    if(mois<1|| mois>12)
    {
        printf("\n mois non valide" );
    }
 
    switch(mois)
    {
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
            jmax=31;
            break;
        case 4:
        case 6:
        case 9:
        case 11:
            jmax=30;
            break;
        case 2:
            if((annee%4==0)&&(annee%100!=0)||(annee%400==0))
            {
                jmax=29;
                printf("\n annee bissextile" );
            }
            else
            {
                jmax=28;
                printf("\n annee non bissextile" );
            }
            break;
    }
 
    return 0;
}
 
Mais j'ai toujours un problème car quand je rentre une date il ne m'affiche pas si l'année est bissextile si je rentre par exemple le 28/10/2010 il ne m'affiche rien tandis que si je rentre le 28/02/2012 la il m'affiche bien annee bissextile ?

L'affichage "annee bissextile" / "annee non bissextile" n'est effectué que si le mois saisi est février. Dans le premier exemple que vous avez donné, il est donc normal que rien ne soit affiché.
 
En revanche, vous ne faites pas le test pour vérifier que le jour saisi est correct (vous ne faites que positionner jmax sans l'utiliser )
 
Edit : Vous devriez aussi tester le retour de la fonction "scanf".

Voila pour tester le jour :
if(jours>jmax)
    {
        printf("\n Date non valide" );
    }
    else
    {
        printf("\n Date valide" );
 
C'est bon la il me semble car quand je le compile et l’exécute et que je rentre une date il m'affiche bien date valide ?

Salut :  
Voilà ma solution, elle fonctionne.
Tu es de l'inpress?
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    int jour,mois,annee;
    char slash1, slash2;
 printf("\n Saisir un jour, un mois et une annee sous le format JJ/MM/AAAA : " );
 scanf("%d%c%d%c%d",&jour,&slash1,&mois,&slash2,&annee); /* L'instruction acceptera les données après le / */
 
 if (annee <1583 && annee >2483)
 printf ("La date saisie est invalide" ); /* Si la condition n'est pas valide, indique date saisie invalide */
 if (mois <1 && mois >12)
 printf ("La date saisie est invalide" ); /* Si la condition n'est pas valide, indique date saisie invalide */
 if (jour <1 && jour >31)
 printf ("La date saisie est invalide" ); /* Si la condition n'est pas valide, indique date saisie invalide */
         switch (mois)
                {
            case 02: if (annee %400 ==0 || (annee%100!=0 && annee%4==0)) /* Voici les conditions a respecté pour le mois de février */
            printf (" Ce mois contient 29 jours", mois); /* D'après les calculs, affiche si le mois contient 29 jours */
            else /* sinon */
            printf (" Ce mois contient 28 jours", mois); /* D'après les calculs, affiche si le mois contient 28 jours */
            break;
 
            case 4:
            case 6:
            case 9:
            case 11: printf(" Ce mois contient 30 jours \n", mois); /* D'après les calculs, affiche si le mois contient 30 jours */
            break;
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
            printf(" Ce mois contient 31 jours \n", mois); /* D'après les calculs, affiche si le mois contient 31jours */
            break;
            default : printf("\n La date saisie est invalide" ); /* Sinon, indique date invalide */
                }
 
    return 0;
}

Vous devriez aussi tester que "jours" est supérieur à zéro, sinon, cela paraît correct, en effet.  

J'ai indique jour <1 && >31 Donc, le jour doit est au dessus de 1 et en dessous de 31.
 
Quelqu'un aurait une idée pour les exercices 2 et 3?

Ce n'est pas à vous que je m'adressais

Désolé.
Mais est-ce que vous sauriez m'aidez pour les 2 autres exercices?
Je suis très novice

Comme indiqué plus haut, montrez-nous ce que vous avez déjà fait ou sur quel point précis vous bloquez et nous pourrons vous donner des indices pour avancer dans la résolution des problèmes.

Pour le trois, je partirais de la fin de la chaîne si je trouve une parenthèse ouvrante avant une parenthèse fermante, je lève une erreur.

Pour le Deux : #include <stdio.h>
#include <stdlib.h>
 
int main()
{
    int ph, Fin, Ouvertes, Fermes;
 printf("Saisir une phrase entre parenthese et finir la phrase par un point: " );
 
fflush (stdin);
 
while(ph != '.' && ph != 1)
{
Fin = '.';
if (getchar() ==40)
{
Ouvertes=Ouvertes+1;
}
else
{
Fermes=Fermes+1;
 
}
}
Fin ='.';
fflush (stdin);
 return 0;
}
 
 
Il ne tourne pas

Plusieurs remarques ...
 
 * Vous ne comparez le  caractère lu (retour de "getchar()" ) qu'au code 40, pas aux autres caractères intéressants (parenthèse fermante et point). Par ailleurs, autant tester "if (x == '(')" au lieu de "if (x == 40)", c'est beaucoup plus lisible.
 
 * La variable "ph" que vous utilisez pour rester dans le "while" n'est pas initialisée, il y a donc de grandes chances que vous n'entriez jamais dans ce while.
 
 * Vous ne faites que compter le nombre de parenthèses ouvrantes et de fermantes, mais l'égalité de ces deux nombres n'est pas suffisante pour valider le fait que la phrase saisie soit "correcte" de ce point de vue-là.
 
Je vous propose d'organiser le programme d'une autre façon (aux erreurs de syntaxe près, je n'ai pas de compilateur sous la main pour tester ) :  
 

 
Il ne vous reste plus qu'à remplir les trois parties contenant les traitements

Bonsoir.
Merci pour votre rapidité et votre efficacité.
Je vais le compiler et remplir les autres traitements nécessaire.
 
Grand Merci.
 
Par contre, pour le dernier exercices, je ne vois pas par ou commence.

Tout simplement en créant le squelette du programme :  
 
 * tirer un nombre au hasard
 * faire une boucle qui demande alternativement à chacun des joueurs de saisir un chiffre et décrémenter le nombre initial de la valeur saisie jusqu'à ce que l'on atteigne 0
 
L'important est de bien vérifier les valeurs saisies et de gérer l'alternance des joueurs, puis d'afficher le nom du gagnant.

J'essaie de changer les traitements pour l'exercices et m'attaquent 'enfin' a l'exercice 3.
Merci Farian

Bon courage !
 
Je lirai vos éventuels progrès après une bonne nuit de sommeil (mon patron ne me paye pas pour passer la nuit sur HFR à aider les gens )

Malheureusement, ça m'aurait bien aidé.
Grand merci à toi et je m'arrangerai pour l'exercice 3.
Je dois le rendre demain matin..
 
Bonne nuit et bonne soirée

Rien de nouveau pendant la nuit ?

Voilà, j'ai rendu mon exercice a mon prof.
 
voilà ce que j'ai trouve pendant la nuit. (Elle à porte conseil)
 
EX : 1
 
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    int jour,mois,annee;
 
    do{
    system("cls" );
 printf("\n Saisir un jour, un mois et une annee sous le format JJ/MM/AAAA : " );
 scanf("%d/%d/%d",&jour,&mois,&annee); /* L'instruction acceptera les données après le / */
    }while(annee<1583 || annee>2483 || mois<1 || mois>12 || jour<1 || jour>31);
 
 // Autre possibilité" //
 //if (annee <1583 || annee >2483)
 //printf ("La date saisie est invalide" ); /* Si la condition n'est pas valide, indique date saisie invalide */
 //if (mois <1 || mois >12)
 //printf ("La date saisie est invalide" ); /* Si la condition n'est pas valide, indique date saisie invalide */
 //if (jour <1 || jour >31)
 //printf ("La date saisie est invalide" ); /* Si la condition n'est pas valide, indique date saisie invalide */
 
         switch (mois)
                {
            case 02: if (annee %400 ==0 || (annee%100!=0 && annee%4==0)) /* Voici les conditions a respecté pour le mois de février */
            printf (" Ce mois contient 29 jours", mois); /* D'après les calculs, affiche si le mois contient 29 jours */
            else /* sinon */
            printf (" Ce mois contient 28 jours", mois); /* D'après les calculs, affiche si le mois contient 28 jours */
            break;
 
            case 4:
            case 6:
            case 9:
            case 11: printf(" Ce mois contient 30 jours \n", mois); /* D'après les calculs, affiche si le mois contient 30 jours */
            break;
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
            printf(" Ce mois contient 31 jours \n", mois); /* D'après les calculs, affiche si le mois contient 31jours */
            break;
            default : printf("\n La date saisie est invalide" ); /* Sinon, indique date invalide */
                }
 
    return 0;
}
 
 
 

EX 2 :
 
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    int saisie,D,G,A,total; //D => Parenthèses D, G => Parenthèses G, A=> Autres polices. //
    D=0, G=0, A<=1; // Les compteurs sont à 0 pour G et D. Mais inférieur ou égale à 1 pour A (Caractère) //
    printf("Saisir une phrase entre parenthese et finir la phrase par un point: \n" );
    fflush (stdin); //Vider le buffer//
 
    do
    {
        saisie = getchar();
        switch (saisie)
        {
        case '(':D++; //Compteur D//
 
        break;
        case ')':G++; //Compteur G//
 
        break;
        default:A++; //Police//
        break;
        }
        } while (saisie != '.'); //Si la phrase est finie par un . Sortir du programme//
 
        total=D-G; //Ma phrase (total) est correct si il y a une parenthèse ( et une parenthèses ) avec un .
        if(total!=0 || A<=1)
        {
            printf("\n La phrase est incorrecte" );
        }
        else
        {
        printf("\n Bravo, la phrase est correcte" );
        }
 return 0;
}
 
 
EX 3 :
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int main()
{
    /* Déclaration des variables */
    int Nombre, SubNombre, a, b, Joueur;
 
 
    fflush(stdin);
 
    /* mettre les valeurs des variables */
    a = 40;
    b = 76;
    Joueur = 1; // 1 = premier joueur, 2 = second joueur */
 
    /* Générer un nombre aléatoire */
    srand(time(NULL));
    Nombre = rand() % (b - a) + a; // entre 40 et 75 //
 
    /* Les règles et le nombre aléatoire choisi : */
    printf("\nLe nombre est %d", Nombre);
    printf("\n\nIl faut soustraire un nombre compris entre 1 et 9.\nLe premier joueur a atteindre 0 a perdu." );
    printf("\n\n-------------------------------------------------------------------------------" );
 
    /* Que le jeu commence */
    while(Nombre > 0)
    {
        if(Joueur == 1)
        {
            /* Demander au joueur 1 */
            printf("\n\n\n- C'est au tour du joueur 1.\n\n   Entrer votre nombre a soustraire : " );
            scanf("%d", &SubNombre);
 
            Joueur = 2;
        }
        else
        {
            /* Demander au joueur 2 */
            printf("\n\n\n- C'est au tour du joueur 2.\n\n   Entrer votre nombre a soustraire : " );
            scanf("%d", &SubNombre);
 
            Joueur = 1;
        }
 
        if(SubNombre >=1 && SubNombre <= 9)
        {
            /* Soustraire le nombre choisi */
            Nombre = Nombre - SubNombre;
 
 
            if(Nombre > 0)
            {
                printf("\n>>> Reste : %d", Nombre);
            }
            else
            {
                printf("\n>>> Reste : 0" );
            }
        }
        else
        {
            /* Dire qu'il y a une erreur si le nombre est plus petit que 1 et plus grand que 9 */
            printf("\n       /!\\ Entrez un nombre compris entre 1 ET 9 !!" );
 
            /* Demander au meme joueur de rejouer */
            if(Joueur == 2)
            {
                Joueur = 1;
            }
            else
            {
                Joueur = 2;
            }
        }
    }
 
    /* Dire qui a perdu */
 
    if(Joueur == 2)
    {
        printf("\n\n\n>>>>> Dommage, Joueur 1, vous avez perdu !!\n\n\n\n" );
    }
    else
    {
        printf("\n\n\n>>>>> Dommage, Joueur 2, vous avez perdu !!\n\n\n\n" );
    }
 
    return 0;
}
 

Y a moyen d'avoir une info sur l'algo adapté à la résolution automatique de ce jeu, je suis intéressé.

Pour l'algo, aucune idée.
Désole.
 
Mais tous les programmes ci-dessus fonctionnent

Tout d'abord, bravo !
 
Le code aurait pu être plus simple (notamment en évitant de dupliquer le code de demande du nombre et en ne changeant de joueur actif qu'une fois un nombre valide saisi ).
 
Jovalise, pouvez-vous préciser votre question ? Cherchez-vous une stratégie gagnante ?

 
Oui, voir le % de partie gagné par joueur 1 et joueur 2 en fonction du tirage. Je comprend à peine le jeu, elle est compliquée votre question.

Arf, non, c'est pas ça que je cherche, je veux que le jeu joue contre lui même.
Je me retrouve... Merci.

Bonsoir Farian,  
voila pour le 1er j'ai un problème car il ne m'affiche pas toujours date invalide exemple si je met 32/10/2010 ?
Si tu sais prendre un peu de ton temps pour m'aider Merci  
 
#include <stdio.h>
#include <stdlib.h>
 
 
main()
{
    int jour, mois, annee, jmax;
    printf("\n entrez une date (jj/mm/aaaa): " );
    scanf("%d/%d/%d/", &jour, &mois, &annee);
 
    if(annee<1583 && annee>2483)
    {
         printf("\n annee non valide" );
    }
    if(mois<1 && mois>12)
    {
        printf("\n date non valide" );
    }
    if(jour<1 && jour>31)
    {
        printf("\n date non valide" );
    }
    if(jour>jmax)
    {
        printf("\n date non valide" );
    }
    else
    {
        printf("\n date valide" );
    }
 
    switch(mois)
    {
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
            jmax=31;
            break;
        case 4:
        case 6:
        case 9:
        case 11:
            jmax=30;
            break;
        case 2:
            if((annee%4==0)&&(annee%100!=0)||(annee%400==0))
            {
                jmax=29;
            }
            else
            {
                jmax=28;
            }
            break;
            default: printf("\n la date n'est pas valide" );
    }
 
    return 0;
}

Bonsoir !
 
2 fautes, à première vue :  
 
 * Les tests de validité sont mal faits : if(annee<1583 && annee>2483) vaut toujours faux, car l'année ne peut pas être à la fois inférieure à 1583 et supérieure à 2483 Il faut remplacer les && par des || !  (idem pour le mois et le jour)
 
 * Vous ne testez pas à la fin que jours <= jmax ! Vous le faites avant d'avoir positionné la valeur de jmax, il faut le faire APRES le switch.
 

Merci au fait les tests de validité j'ai remarqué l'erreur assez bête    
Et pour tester que jours<= jmax je le place donc quand je sort du switch ?
Edit:  
main()
{
    int jour, mois, annee, jmax;
    printf("\n entrez une date (jj/mm/aaaa): " );
    scanf("%d/%d/%d/", &jour, &mois, &annee);
 
    if(annee<1583 || annee>2483)
    {
         printf("\n annee non valide" );
    }
    if(mois<1 || mois>12)
    {
        printf("\n date non valide" );
    }
    if(jour<1 || jour>31)
    {
        printf("\n date non valide" );
    }
 
    switch(mois)
    {
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
            jmax=31;
            break;
        case 4:
        case 6:
        case 9:
        case 11:
            jmax=30;
            break;
        case 2:
            if((annee%4==0)&&(annee%100!=0)||(annee%400==0))
            {
                jmax=29;
            }
            else
            {
                jmax=28;
            }
            break;
 
    }
if(jour>jmax)
    {
        printf("\n date non valide" );
    }
    else
    {
        printf("\n date valide" );
    }
    return 0;
}
La il ne me semble pas mauvais qu'en pensez-vous ? (Il me reste que cette exercice un peu casse tete a cause de ce probleme d'affichage)

Plutôt que de passer par un case compliqué, faire d'entrée un tableau des jmax, et n'y modifier que l'entrée de février quand l'année n'est pas bissextile me semble plus simple comme approche.

 
A+,

Je n'avais pas fait gaffe tout à l'heure, mais il y a une erreur dans le code de l'exercice 2, comme je vous le suggérais hier :  
 

Vous ne faites que compter les parenthèses ouvrantes et fermantes, et vérifier à la fin qu'il y en a autant de chaque type, ce qui a pour effet que la "phrase" suivante sera vue comme correcte :  
 

 
Il n'est pas suffisant de vérifier à la fin que G = D, il faut aussi s'assurer à tout instant que G >= D (on pourrait aussi s'assurer qu'il y a toujours au moins un caractère "autre" entre une parenthèse ouvrante et une parenthèse fermante, mais je pense que c'est en dehors de la complexité de l'exercice, on ne va pas non plus écrire une grammaire !!!! )
 
(je pense que c'est un des pièges dans lequel votre examinateur attend que vous tombiez )

Bref un truc dans ce goût:

Je n'ai pas trop compris ce comptage des caractères autres que les parenthèses, il n'est pas demandé dans l'exercice. A priori, rien dans l'énoncé ne me semble exclure la vérification comme correcte de (()).
A+,

Tout à fait d'accord, c'était juste une remarque sur le fait que "()" n'apporte rien dans une "phrase" et pourrait être supprimé sans rien changer. Mais je vous accorde qu'il s'agit là de pinaillage sans rapport direct avec l'énoncé de l'exercice (je vais mettre ça sur le compte d'un petit moment de faiblesse de ma part ).

Bonjour.
Merci a tous pour vos réponses rapide efficace.
J'ai fais ce genre de solution () pour vérifie si j'indique (coucou(())). Était correct.
La phrase )(coucou. Est "correcte car les parenthèses sont ouvertes et fermes. Pas dans le sens traditionnel ().
Ayant déjà rendu mon travail, j'avais mal compris l'exercice et pensait que si je pouvais faire )( . Était correct car le . Mettais fin au programme et me disait si oui ou non la phrase était ok.
 
Encore grand merci, je vous tiens au courant et j'espère que ce devoir suffira.
Aanthoo dit Anthony