Partage

[zConjug] Exercice pour débutants

Venez nombreux !

1 2 >>

7 mars 2011 à 22:03:03

Bonjour !

J'ouvre ce topic pour répondre à l'exercice proposé du mois de mars.

Mois : Mars
Sujet : Manipulation de chaînes de caractères

zConjug

L'exercice de ce mois-ci nous permettra de revoir un peu la conjugaison française.

Dans un premier temps, serez amenés à conjuguer un verbe du premier ou du deuxième groupe sans prendre en compte les exceptions. Par la suite, nous essayerons de gérer quelques exceptions (oui... il y en a tellement).
Tous les temps dans lesquels seront conjugués nos verbes seront à l'indicatif.

Les verbes du premier groupe

Dans un premier temps, la conjugaison de verbes du premier groupe !
Pour ce programme, l'utilisateur entrera un verbe et le programme devra vérifier s'il se fini bien par -er, si oui, le conjuguer au présent. On supposera que l'utilisateur est intelligent (s'il rentre un verbe du genre aerzasdqdfzer, notre programme le conjuguera).
Voici les terminaisons du présent :

Je         -e
Tu         -es
Il/Elle/on -e
Nous       -ons
Vous       -ez
Ils/Elles  -ent

La langue française ne se limite pas à un seul temps, c'est pourquoi vous améliorerez votre programme pour qu'il conjugue aussi votre verbe à l'imparfait, au futur simple (je ne mets pas le passé simple à cause des accents). Encore une fois, nous ne prendrons pas en compte les exceptions (manger, appeler, etc.).
Voici les terminaisons :

Imparfait    : -ais,  -ais,  -ait, -ions,  -iez,  -aient
Futur simple : -erai, -eras, -era, -erons, -erez, -eront

Les verbes du second groupe

Ici, rien de difficile si vous avez fait la première partie. Vous vérifiez si le verbe appartient au second groupe (se finir par -ir) et vous le conjuguez. Pour les verbes du 2ème groupe, il n'y a pas d'exceptions ; si le participe présent du verbe ne se finit pas par -issant, c'est un verbe du 3ème groupe (on ne fera pas de distinctions, si l'utilisateur entre un verbe du 3ème groupe (pouvoir, fuir) on le conjuguera comme un verbe du 2ème groupe).
Voilà les terminaisons :

Présent      : -is,     -is,     -it,     -issons,  -issez,  -issent
Imparfait    : -issais, -issais, -issait, -issions, -issiez, -issaient
Futur simple : -irai,   -iras,   -ira,    -irons,   -irez,   -iront

Gestion des exceptions des verbes du premier groupe

Comme vous l'aurez constatés, certains verbes ont quelques particularités... c'est pourquoi vous ferez un programme qui gère toutes ces exceptions. Vous pourrez les retrouver sur ce lien.
Prenez bien en compte que le verbe 'aller' est du 3ème groupe.

Vous pourrez modifier le 'je' devant les verbes ; si le verbe commence par une voyelle, on met j' et non je (j'appelle, je chante).
S'il y en a qui se sentent d'attaque, vous pouvez essayer de conjuguer certains verbes du 3ème groupes (-oir, etc.).

Bon courage !

Pouet_forever m'a considérablement aidé et conseillé pour la réalisation cet exo, je le remercie beaucoup.

candide

9 mars 2011 à 2:37:09

C'est bien triste, il fut un temps où ce topic aurait déjà reçu 3 pages de réponses.

Pourtant ton exo est intéressant (classique certes).

Tu devrais essayer de préciser de quels éléments du cours les zéros ont besoin pour le résoudre, en te référant à des liens précis du cours officiel. C'est un exo que j'ai donné en examen TP de programmation C pour des L1 maths-info et les réponses obtenues n'éatient vraiment pas brillantes (je les ai encore). Exemple de solution possible (mais incomplète par rapport à toutes les questions que tu poses), attention, je n'ai pas relu ça depuis deux ans donc il y a peut-être des maladresses :

#include <stdio.h>
#include <string.h>

void afficher_radical(char *verbe)
{
  int lg = strlen(verbe);
  int i;

  for (i = 0; i < lg - 2; i++)
    printf("%c", verbe[i]);

}


void conjuguer(char *verbe)
{
  char *pronoms[6] = { "je ", "tu ", "il ", "nous ", "vous ", "ils " };
  char *terminaisons[6] = { "e", "es", "e", "ons", "ez", "ent" };
  int i;

  for (i = 0; i < 6; i++)
    {
      printf("%s", pronoms[i]);
      afficher_radical(verbe);
      printf("%s", terminaisons[i]);
      printf("\n");
    }
}


int main(void)
{
 conjuguer("coder");

  return 0;
}

je code
tu codes
il code
nous codons
vous codez
ils codent

Lebrian

9 mars 2011 à 9:40:20

Salut,

je me lance

Je dois dire que j'ai jamais participé à un zExo (exercices pour Zér0s) étant nouveau. Mais aussi, j'ai jamais présenté quoi que ce soit à une tierce personne pour analyse ce qui fait que je ne sais pas vraiment si je m'y prends bien. Bref, voici mon code pour l'exercice. N'hésitez pas à apporter toutes vos remarques pour que je corrige mes éventuels défauts qui sont encore cachés :-°

J'ai fait la première et la deuxième question.

main.c

#include <stdio.h>
#include <stdlib.h>
#include "zconjug.h"

int main(void)
{
    char verbe[20] = "";
    int analyse = 0;

    printf("Entrez un verbe :");
    scanf("%s", verbe);
    while(getchar() != '\n');

    analyse = analyser(verbe);

    switch(analyse){
        case 1:
            firstGroup(verbe);
            break;

        case 2:
            secondGroup(verbe);
            break;

        default:
            printf("A bientot\n");
            break;
    }

    return EXIT_SUCCESS;
}

zconjug.h

#ifndef DEF_ZCONJUG
#define DEF_ZCONJUG

void zconjug(char *verbe, char (*)[10]);
int analyser(char*);
void supprimerTerm(char*);
void firstGroup(char*);
void secondGroup(char*);

#endif

zconjug.c

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include "zconjug.h"

void zconjug(char* verbe, char term[][10]){
    char verbeConjugue[7][50] = {""};
    char pronom[7][10] = {"Je ", "Tu ", "Il ", "Nous ", "Vous ", "Ils "};

    int i;

    for(i = 0; i < 6; i++){
        strcpy(verbeConjugue[i], pronom[i]);
        strcat(verbeConjugue[i], verbe);
        strcat(verbeConjugue[i], term[i]);
    }

    for(i = 0; i < 6; i++)
        printf("%s\n", verbeConjugue[i]);

    printf("\n");
}

int analyser(char* verbe){
    int i = strlen(verbe);

    if(verbe[i - 1] == 'r' && verbe[i - 2] == 'e'){
        printf("\nVerbe du premier groupe\n");
        return 1;
    }

    else if(verbe[i - 1] == 'r' && verbe[i - 2] == 'i'){
        printf("\nVerbe du deuxieme groupe\n");
        return 2;
    }
    else{
        printf("Nous ne pouvons pas encore gerer votre cas\n");
        return 0;
    }
}

void supprimerTerm(char* verbe){
    int i = strlen(verbe);

    verbe[i - 2] = '\0';
}

void firstGroup(char* verbe){
    char terminaison[4][7][10] = {{"e", "es", "e", "ons", "ez", "ent"},
                                  {"ais", "ais", "ait", "ions", "iez", "aient"},
                                  {"erai", "eras", "era", "erons", "erez", "eront"}};

    int i = 0;

    supprimerTerm(verbe);

    for(i = 0; i < 3; i++)
        zconjug(verbe, terminaison[i]);
}

void secondGroup(char* verbe){
    char terminaison[4][7][10] = {{"is", "is", "it", "issons", "issez", "issent"},
                                  {"issais", "issais", "issait", "issions", "issiez", "issaient"},
                                  {"irai", "iras", "ira", "irons", "irez", "iront"}};
    int i = 0;

    supprimerTerm(verbe);

    for(i = 0; i < 3; i++)
        zconjug(verbe, terminaison[i]);
}

Je vous remercie

candide

9 mars 2011 à 10:18:16

Citation : LeBri@n

N'hésitez pas à apporter toutes vos remarques pour que je corrige mes éventuels défauts

J'ai pas le temps de faire une analyse, même superficielle de ton code. Ton code compile, avec un warning toutefois (main.c:22: warning: implicit declaration of function ‘secondGroup’).

J'ai fait plusieurs essais de verbes du premier groupe, ça fonctionne bien. Petit détail, parfois il faut remplacer Je par J' . T'as de la chance, t'as pas posté hier (journée internationale des femmes) mais que fais-tu des cas Elle, Elles ? Attention, ton code ne devrait pas accepter un verbe (imaginaire) comme er (un radical ne peut-être vide).

Je n'aurais pas placé l'espace après les pronoms personnels. Tu utilises trop de constantes magiques. Tes triples tableaux sont lourds, il vaut mieux utiliser des chaînes statiques (donc des tableaux de pointeurs). Ton codage n'est pas générique :
-- une seule fonction devrait pouvoir traiter tous les groupes puisque la méthode est la même ;
-- l'analyse pourrait être plus générale (imagine que tu doives traiter de nouveaux groupes).

Attention, le verbe à conjuguer est modifié par ton code, ça limite la souplesse de ton code puisque ton code ne peut admettre de verbe qualifié const.

Ton code est très bien pour une première approche après on peut faire des choses bien bien plus sophistiquées, tout dépend de tes objectifs, de ta motivation, de ta disponibilité et de ton expérience.

Marc Mongenet

9 mars 2011 à 10:35:00

Salut,

Citation : LeBri@n

Bref, voici mon code pour l'exercice. N'hésitez pas à apporter toutes vos remarques pour que je corrige mes éventuels défauts qui sont encore cachés

Le mélange de langue dans les identificateurs est à éviter (analyseret firstGroup).
Un nom de fonction comme analyser n'est pas assez spécifique pour qu'on comprenne ce qu'elle fait.
Tu peux écrire switch (analyser(verbe)), ça supprime une ligne et une variable (un état de moins à retenir pour le relecteur).
Pour ce genre de programme en console, il vaut la peine d'utiliser les arguments de main plutôt que de forcer l'interactivité avec un scanf.
Il est amusant que tu as utilisé les deux types de déclaration compatibles pour le pointeur de tableau de zconjug:char (*)[10] et char term[][10]. Je te conseille vivement la première, l'autre est trompeuse, obsolète, illogique, limitée.
Je n'aurais pas fait d'affichage dans analyser.

Lebrian

9 mars 2011 à 11:31:37

Depuis près d'une heure, j'essaie de répondre sur le sujet mais je n'y parviens pas.

Merci à vous pour vos conseils

@Candide

Je crois que le warning viens du fait que j'ai oublié de mettre le prototype dans le *.h (je crois)

Pour le er je dois dire que j'y avais même pas pensé

(vu qu'on supposait l'utilisateur intelligent). Idem pour Elle/Elles ça dénonce mon sexe :-°

Je crois que j'ai encore du pain sur la planche

Citation : candide

[...]tout dépend de tes objectifs, de ta motivation, de ta disponibilité et de ton expérience.

C'est surtout l'expérience qui fait défaut. je crois que ça viens avec le temps et en pratiquant un peu plus. Voilà pourquoi j'ai décidé de faire cet exercice et je vois qu'il y a encore beaucoup à faire.

@Marc

C'est vrai que mélanger les langues comme ça ne sonne pas bien (ça fait aussi mal au yeux

), mais c'était pour éviter que le nom soit trop long. C'est vrai aussi que ça ne pose pas de problème si c'est long. Je vais changer ça...

Pour le char (*)[] et char term[][], je vais revoir ça. Je dois, là encore, avouer que j'ai pas vraiment travaillé avec les tableaux à plusieurs dimensions. Mais bon...

Je vous remercie et j'espère pouvoir apporter ces changements.

A++

candide

9 mars 2011 à 12:34:28

Citation : LeBri@n

@Marc

Le conseil que Marc t'a donné de ne pas faire d'affichage dans la fonction analyser me paraît hautement pertinent. C'est un principe fondamental de design (separation of concerns) : une fonction = une unique tâche.

nemesis15

11 mars 2011 à 3:04:34

Moi, je suis comme LeBri@n
Voici ma solution(très incomplet)
Tout les commentaires sont les bienvenue

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static void purge (char *str);
void conjuger (char *verbe);
void setRadical (char *verbe, char *radical);
void backup (char *verbe, char *radical);

char const * const premier[6] = {
        "e", "es", "e", "ons", "ez", "ent" /* présent */
};

int main(void)
{
    char verbe[100];

    fgets (verbe, 100, stdin);
    purge (verbe);

    conjuger (verbe);

    return 0;
}

static void purge (char *str)
{
    char *p = NULL;
    int c;

    p = strchr(str, '\n');
    if (p != NULL)
        *p = '\0';
    else
        while ((c = getchar()) != '\n' && c != EOF);
}

void conjuger (char *verbe)
{
    size_t i;
    char *pronon[6] = {"Je", "Tu", "Il", "Nous", "Vous", "Ils"};
    char radical[100];

    setRadical (verbe, radical);

    for (i = 0; i < 6; ++i)
        {
            backup (verbe, radical);
            strcat(verbe, premier[i]);
            printf ("%s %s\n", pronon[i], verbe);
        }
}

void setRadical (char *verbe, char *radical)
{
    size_t i;
    size_t size = strlen (verbe);

    for ( i = 0; i < size-2; ++i)
        radical[i] = verbe[i];
}

void backup (char *verbe, char *radical)
{
    size_t i;

    for (i = 0; i < 100; ++i)
        verbe[i] = radical[i];
}

macmist

12 mars 2011 à 0:52:30

Voici ma solution, mon code se répète pas mal je sais, et j'ai honteusement piqué 2 fonctions au tuto de m@théo (lire et viderbuffer, je voulais éviter les erreurs et je fais pas mieux que ça en fait )

Le code gère groupes 1 et 2, présent, imparfait et futur simple, de l'indicatif bien sûr, mais pas les exceptions.
C'est un programme super intéressant à coder, je pense l'améliorer par la suite

le code :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int lire( char *chaine , int longueur ) ;

int rechercheGroupe ( char chaine[] , int taille ) ;
void conjuguerG1prst ( char chaine[] ) ;
void conjuguerG1impft ( char chaine[] ) ;
void conjuguerG1ftr ( char chaine[] ) ;
void conjuguerG2prst (char chaine[] ) ;
void conjuguerG2impft (char chaine[] ) ;
void conjuguerG2ftr (char chaine [] ) ;
void viderBuffer();






int main(int argc , char* argv[])
{
    char verbe[100] = {0} ;

    int groupe = 0 ;
    int taille = 0 , choix = 0 ;

    printf( "Bienvenue dans ZConjug, le programme de conjugaison pour les Zeros.\n" ) ;
    printf( "Pour l'instant, seul les verbes du premier et deuxieme groupe le présent et l'imparfait de l'indicatif sont traites\n" ) ;
    printf( "Il vous suffit d'entrer un verbe a conjuguer , puis de suivre les instructions a l'ecran.\n\n" ) ;
    printf( "Entrez le verbe a conjuguer : ") ;
    lire( verbe , 100 ) ;
    printf( "\n\n" ) ;
    printf( "Choisissez le temps auquel conjuguer :\n") ;
    printf( "1.Present\n2.Imparfait\n3.futur\n4.A tous les temps possible") ;
    while ( choix <= 0 || choix > 4)
    {
        scanf ( "%d" , &choix ) ;
        if (  ( choix <= 0 || choix > 4 ) )
        {
            printf( "Veuillez entrer 1 ,  2 , 3 ou 4\n");
        }

    }
    taille = strlen ( verbe ) ;
    groupe = rechercheGroupe (  verbe , taille ) ;
    verbe [ taille - 2 ] = '\0';
    if (groupe == 1)
    {
        if ( choix == 1) conjuguerG1prst( verbe ) ;
        else if ( choix == 2) conjuguerG1impft( verbe ) ;
        else if ( choix == 3) conjuguerG1ftr (verbe) ;
        else if (choix == 4)
        {
            conjuguerG1prst( verbe ) ;
            conjuguerG1impft( verbe ) ;
            conjuguerG1ftr (verbe) ;
        }
    }

    else if (groupe == 2)
    {
        if ( choix == 1) conjuguerG2prst( verbe ) ;
        else if ( choix == 2) conjuguerG2impft( verbe ) ;
        else if ( choix == 3) conjuguerG2ftr ( verbe ) ;
        else if (choix == 4)
        {
            conjuguerG2prst( verbe ) ;
            conjuguerG2impft( verbe ) ;
            conjuguerG2ftr (verbe) ;

        }
    }

    return 0;
}

void conjuguerG1prst ( char chaine[] )
{
    char *termPrst [6] = { "e" , "es" , "e" , "ons" , "ez" , "ent"};
    char *pronoms[6] = { "Je" , "Tu" , "Il / Elle" , "Nous" , "Vous" , "Ils / Elles"};
    int nombre = 6 ;
    int i = 0;

    printf( "\n\nLe verbe %ser au present : \n", chaine ) ;

    while ( i < nombre)
    {

        printf( "%s %s%s\n", pronoms[i] , chaine , termPrst[i] );
        i++;
    }

}

void conjuguerG1impft ( char chaine[] )
{
    char *termPrst [6] = { "ais" , "ais" , "ait" , "ions" , "iez" , "aient"};
    char *pronoms[6] = { "Je" , "Tu" , "Il / Elle" , "Nous" , "Vous" , "Ils / Elles"};
    int nombre = 6 ;
    int i = 0;

    printf( "\n\nLe verbe %ser a l'imparfait : \n", chaine ) ;

    while ( i < nombre)
    {

        printf( "%s %s%s\n", pronoms[i] , chaine , termPrst[i] );
        i++;
    }

}

void conjuguerG1ftr ( char chaine[] )
{
    char *termPrst [6] = { "ai" , "as" , "a" , "ons" , "ez" , "ont"};
    char *pronoms[6] = { "Je" , "Tu" , "Il / Elle" , "Nous" , "Vous" , "Ils / Elles"};
    int nombre = 6 ;
    int i = 0;

    printf( "\n\nLe verbe %ser au futur : \n", chaine ) ;

    while ( i < nombre)
    {

        printf( "%s %ser%s\n", pronoms[i] , chaine , termPrst[i] );
        i++;
    }

}

void conjuguerG2prst ( char chaine[] )
{
    char *termPrst [6] = { "is" , "is" , "it" , "issons" , "issez" , "issent"};
    char *pronoms[6] = { "Je" , "Tu" , "Il / Elle" , "Nous" , "Vous" , "Ils / Elles"};
    int nombre = 6 ;
    int i = 0;

    printf( "\n\nLe verbe %sir au present : \n", chaine ) ;

    while ( i < nombre)
    {

        printf( "%s %s%s\n", pronoms[i] , chaine , termPrst[i] );
        i++;
    }

}

void conjuguerG2impft ( char chaine[] )
{
    char *termPrst [6] = { "issais" , "issais" , "issait" , "issions" , "issiez" , "issaient"};
    char *pronoms[6] = { "Je" , "Tu" , "Il / Elle" , "Nous" , "Vous" , "Ils / Elles"};
    int nombre = 6 ;
    int i = 0;

    printf( "\n\nLe verbe %sir a l'imparfait : \n", chaine ) ;

    while ( i < nombre)
    {

        printf( "%s %s%s\n", pronoms[i] , chaine , termPrst[i] );
        i++;
    }
}

void conjuguerG2ftr ( char chaine[] )
{
    char *termPrst [6] = { "ai" , "as" , "a" , "ons" , "ez" , "ont"};
    char *pronoms[6] = { "Je" , "Tu" , "Il / Elle" , "Nous" , "Vous" , "Ils / Elles"};
    int nombre = 6 ;
    int i = 0;

    printf( "\n\nLe verbe %sir au futur : \n", chaine ) ;

    while ( i < nombre)
    {

        printf( "%s %sir%s\n", pronoms[i] , chaine , termPrst[i] );
        i++;
    }

}

int rechercheGroupe ( char chaine[] , int taille )
{
    int i = taille - 2 , j = 0 ;
    char copie [3] = {0} ;

    while (i < taille)
    {
        copie[j] = chaine [i] ;
        i++ ;
        j++ ;
    }

    if ( strcmp ( "er" , copie ) == 0 )
        return 1 ;

    else if (strcmp ( "ir" , copie ) == 0 )
        return 2;

    else return 0;
}


void viderBuffer()
{
    int c = 0;
    while (c != '\n' && c != EOF)
    {
        c = getchar();
    }
}


int lire(char *chaine, int longueur)
{
    char *positionEntree = NULL;

    if (fgets(chaine, longueur, stdin) != NULL)
    {
        positionEntree = strchr(chaine, '\n');
        if (positionEntree != NULL)
        {
            *positionEntree = '\0';
        }
        else
        {
            viderBuffer();
        }
        return 1;
    }
    else
    {
        viderBuffer();
        return 0;
    }
}

Voilà si vous avez des critiques, conseils, n'hésitez pas !

candide

12 mars 2011 à 1:45:45

Citation : macmist

Voici ma solution, mon code se répète pas mal je sais, et j'ai honteusement piqué 2 fonctions au tuto de m@théo (lire et viderbuffer, je voulais éviter les erreurs et je fais pas mieux que ça en fait )

-- aucun warning (TB)
-- l'essentiel est acquis : les verbes sont conjugués comme il faut.

Quelques remarques :
-- excessive redondance de code (comme tu l'as remarqué toi-même) ->à reprendre.
-- une fonction fait une tâche et une seule : conjuguer et afficher sont deux tâches différentes

.
-- Attention aux constantes magiques !
-- Pourquoi utiliser strcmp et ignorer strcat (pour copier) ?
-- La gestion des entrées est assez incomplète (mais pour moi, ce n'est pas du tout l'essentiel).

nemesis15

12 mars 2011 à 21:12:59

voici mon code complet

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void conjuger (char *verbe, int groupe);
void setRadical (char *verbe, char *radical);
void setVerbe (char *verbe, char *radical, int groupe, int temps);
int setGroupe (char *verbe);
void afficher(char *verbe, char *pronon, int c);
int voyelle (char *str);

char const * const premier[18] = {
    "e", "es", "e", "ons", "ez", "ent",
    "ais", "ais", "ait", "ions", "iez", "aient",
    "erai", "eras", "era", "erons", "erez", "eront"
};

char const * const deuxieme[18] = {
    "is", "is", "it", "issons", "issez", "issent",
    "issais", "issais", "issait", "issions", "issiez", "issaient",
    "irai", "iras", "ira", "irons", "irez", "iront"
};

int main(int argc, char **argv)
{
    int n_groupe;

    if (argc < 2)
        {
            printf ("Usage : zConjug verbe\n");
            exit(0);
        }

    n_groupe = setGroupe(argv[1]);
    if (n_groupe == -1)
        {
            printf ("Impossible de conjuger le verbe\n");
            exit(0);
        }

    conjuger (argv[1], n_groupe);

    return 0;
}

void afficher (char *verbe, char *pronon, int c)
{
    if (c)
        printf ("%s%s  \t\t", pronon, verbe);
    else
        printf ("%s %s \t\t", pronon, verbe);
}

void conjuger (char *verbe, int groupe)
{
    size_t i;
    char *pronon[6] = {"Je", "Tu", "Il", "Nous", "Vous", "Ils"};
    char radical[100];
    int c = 0;

    setRadical (verbe, radical);
    if (voyelle(radical)) {
        pronon[0] = "J'";
        c = 1;
    }

    for (i = 0; i < 6; ++i)
        {
            /* Present */
            setVerbe (verbe, radical, groupe, i);
            afficher (verbe, pronon[i], c);

            /* Imparfait */
            setVerbe (verbe, radical, groupe, i+6);
            afficher (verbe, pronon[i], c);

            /* Future */
            setVerbe (verbe, radical, groupe, i+12);
            afficher (verbe, pronon[i], c);
            puts("");

            c = 0;
        }
}

int voyelle (char *str)
{
    if (*str == 'a' || *str == 'e' || *str == 'i' || *str == 'o' || *str == 'u')
        return 1;
    else
        return 0;
}

int setGroupe (char *verbe)
{
    if (strstr (verbe, "er") != NULL)
        return 1;
    else if (strstr (verbe, "ir") != NULL)
        return 2;
    else
        return -1;
}

void setRadical (char *verbe, char *radical)
{
    size_t i;
    size_t size = strlen (verbe);

    for ( i = 0; i < size-2; ++i)
        radical[i] = verbe[i];
    radical[i] = '\0';

}

void setVerbe (char *verbe, char *radical, int groupe, int temps)
{
    size_t i;
    size_t size = strlen(verbe);

    for (i = 0; i < size; ++i)
        verbe[i] = radical[i];

    if (groupe == 1)
        strcat(verbe, premier[temps]);
    else
        strcat(verbe, deuxieme[temps]);
}

n'hésitez pas à faire des commentaire sur mon code.

Marc Mongenet

13 mars 2011 à 0:05:06

Citation : nemesis15

n'hésitez pas à faire des commentaire sur mon code.

La fonction setGroupe (en franglais) est mal conçue, elle classe "vernir" en verbe du 1er groupe.

candide

13 mars 2011 à 0:51:06

Citation : nemesis15

n'hésitez pas à faire des commentaire sur mon code.

Quelques essais (juste du premier groupe) semblent donner des résultats satisfaisants, avec un rendu plutôt propre.

Quelques remarques :

-- (détail) si on entre le verbe (imaginaire er) on obtient un affichage décalé bizarre
-- (très ennuyeux) la présence de la fonction setVerbe conduit à des absurdités puisque chaque fois que tu lances une conjugaison, tu vas recopier dans verbe caractère par caractère le radical qui lui même avait été recopié caractère par caractère depuis le verbe et en plus tu vas faire ça à toutes les personnes et à tous les temps, bref, ton code ne respecte pas le protocole de Kyoto

-- (ennuyeux) comme observé par Marc, ton identification de groupe est très naïve et grossièrement fausse.
-- (dommage) pas de fonction qui se charge de conjuguer complètement un verbe à toutes les personnes
-- (détail) Il n'y a pas que les voyelles qui entraînent la modification de Je en J' .
-- (détail) pourquoi les terminaisons de conjugaison sont en const et pas les pronoms ?
-- (peu maintenable) pourquoi regrouper toutes les terminaisons de tous les temps en un même tableau au lieu de faire un tableau par temps ?
-- (pour les courageux) et les accents (le C gère assez bien l'utf-8 ou tout simplement latin-1) ?
-- (micro-détail) tu as écrit ta fonction conjuger au lieu de conjuguer
-- (à reprendre) Si tu dois exporter ton code, ta fonction publique, c'est bien conjuger. Je ne trouve pas sa signature bien choisie, elle ne devrait prendre en paramètre que le verbe puisque le radical se déduit du verbe.
-- (à reprendre) Éviter les constantes magiques !

Pouet_forever

13 mars 2011 à 2:00:00

Citation : candide

-- (détail) Il n'y a pas que les voyelles qui entraînent la modification de Je en J' .

Tu peux citer des exemples stp ?

A part les verbes commençant par une voyelle, je vois pas. :s

Marc Mongenet

13 mars 2011 à 2:11:48

Citation : Pouet_forever

Tu peux citer des exemples stp ?

J'hésite.

Adroneus

13 mars 2011 à 2:27:40

J'habite

Arf, ouned by Marc, classe en plus

ca m'apprendra a glandouiller devant l'ecran

nemesis15

13 mars 2011 à 4:13:37

Citation : candide

-- (détail) si on entre le verbe (imaginaire er) on obtient un affichage décalé bizarre

J'avais remarquer ce problème, ça le fait pas juste avec les verbes imaginaire
comme finir.Mais j'ai aucune idée comment le régler.

Citation : candide

-- (détail) pourquoi les terminaisons de conjugaison sont en const et pas les pronoms ?

Parce que des fois le programme doit modifier le "Je" en "J'".

Citation : candide

-- (très ennuyeux) la présence de la fonction setVerbe conduit à des absurdités puisque chaque fois que tu lances une conjugaison, tu vas recopier dans verbe caractère par caractère le radical qui lui même avait été recopié caractère par caractère depuis le verbe et en plus tu vas faire ça à toutes les personnes et à tous les temps, bref, ton code ne respecte pas le protocole de Kyoto

Est ce que ça serait mieux d'utilisé strcopy ?

Merci pour tout tes commentaire.

Drakalex92

13 mars 2011 à 9:58:32

@candide : un peu en retard, j'ai essayé ton premier code, essaye de conjuguer "aller"

candide

13 mars 2011 à 10:11:41

Citation : nemesis15

Citation : candide

-- (détail) pourquoi les terminaisons de conjugaison sont en const et pas les pronoms ?

Parce que des fois le programme doit modifier le "Je" en "J'"

OK mais il te suffit d'adapter, le plus simple : mettre un indice de plus à la fin du tableau sinon faire un tableau 2D (tu as ignoré les cas Elle, Elles)

Citation : nemesis15

Est ce que ça serait mieux d'utilisé strcopy ?

Fondamentalement ça ne change rien même si en pratique c'est quand même préférable. Ce qui me gêne c'est que ton code se contente d'afficher la conjugaison donc inutile de faire les nombreuses copies et recopies.

Citation : Drakalex92

@candide : un peu en retard, j'ai essayé ton premier code, essaye de conjuguer "aller"

Ce code n'est pas du tout une solution à zConjug mais juste la solution à un exercice particulier que j'avais donné en TP (sur les chaînes) à des débutant en C (et où il était hors de question de s'attarder sur ce genre de détail).

nemesis15

13 mars 2011 à 16:15:35

voici mon nouveau code.
j'ai pris en considération la plupart des commentaires

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void conjuguer (char *verbe, int groupe);
void setRadical (char *verbe, char *radical);
void affiche_verbe (char *radical, int groupe, int temps);
void affiche_pronom (int j);
int setGroupe (char *verbe);
int voyelle (char *str, int indice);

#define N_MAX 100
#define N_PERSONNE 6
#define N_TEMPS 18

char const * const premier[N_TEMPS] = {
    "e", "es", "e", "ons", "ez", "ent",
    "ais", "ais", "ait", "ions", "iez", "aient",
    "erai", "eras", "era", "erons", "erez", "eront"
};

char const * const deuxieme[N_TEMPS] = {
    "is", "is", "it", "issons", "issez", "issent",
    "issais", "issais", "issait", "issions", "issiez", "issaient",
    "irai", "iras", "ira", "irons", "irez", "iront"
};

char const * const pronom[N_PERSONNE+1] = {"Je", "Tu", "Il", "Nous", "Vous", "Ils", "J'"};

int main(int argc, char **argv)
{
    int n_groupe;

    if (argc < 2)
        {
            printf ("Usage : zConjug verbe\n");
            exit(0);
        }

    n_groupe = setGroupe(argv[1]);
    if (n_groupe == -1)
        {
            printf ("Impossible de conjuguer le verbe\n");
            exit(0);
        }

    conjuguer (argv[1], n_groupe);

    return 0;
}

void conjuguer (char *verbe, int groupe)
{
    size_t i, j = 0;
    char radical[N_MAX];

    setRadical (verbe, radical);
    if (voyelle(radical, 0) || (radical[0] == 'h' && voyelle(radical, 1)))
        j = 6;

    for (i = 0; i < N_PERSONNE; ++i, ++j)
        {
            /* Present */
            affiche_pronom (j);
            affiche_verbe (radical, groupe, i);

            /* Imparfait */
            affiche_pronom (j);
            affiche_verbe (radical, groupe, i+6);

            /* Future */
            affiche_pronom (j);
            affiche_verbe (radical, groupe, i+12);
            puts("");

            if (j == 6)
                j = 0;
        }
}

int voyelle (char *str, int indice)
{
    if (str[indice] == 'a' || str[indice] == 'e' ||
        str[indice] == 'i' || str[indice] == 'o' || str[indice] == 'u')
        return 1;
    else
        return 0;
}

int setGroupe (char *verbe)
{
    size_t size = strlen(verbe);

    if (verbe[size-2] == 'e' && verbe[size-1] == 'r')
        return 1;
    else if (verbe[size-2] == 'i' && verbe[size-1] == 'r')
        return 2;
    else
        return -1;
}

void setRadical (char *verbe, char *radical)
{
    size_t i;
    size_t size = strlen (verbe);

    for ( i = 0; i < size-2; ++i)
        radical[i] = verbe[i];
    radical[i] = '\0';

}

void affiche_pronom (int j)
{
    if (j == 6)
        printf ("%s", pronom[j]);
    else
        printf ("%s ", pronom[j]);
}

void affiche_verbe (char *radical, int groupe, int temps)
{
    printf ("%s", radical);
    if (groupe == 1)
        printf ("%s  \t\t", premier[temps]);
    else
        printf ("%s\t\t", deuxieme[temps]);
}

n'hésitez pas à faire des commentaire sur mon code.

Drakalex92

13 mars 2011 à 17:26:19

A quoi ça sert:

if (argc < 2)
        {
            printf ("Usage : zConjug verbe\n");
            exit(0);
        }

??

Moi il me met tout le temps :

Usage : zConjug verbe

...

Je comprends pas, tu peut me dire stp ?

Lebrian

13 mars 2011 à 17:36:39

Je ne sais pas utiliser les paramètres de la fonction main

il est temps de lire le tuto présent sur le site

Je ne poste pas les modifications apportées à mon code (suite aux conseils de Marc et candide) puisque j'ai pas vraiment fais grand chose :euh:

-Conseils de Marc --> fait sauf paramètres du main.
-Conseils de candide --> j'essaie toujours de comprendre :-°

. Mais la gestion des exceptions comme dans le sujet de l'exercice n'est pas maintenant

A++

nemesis15

13 mars 2011 à 17:56:08

Citation : Drakalex92

A quoi ça sert:

if (argc < 2)
        {
            printf ("Usage : zConjug verbe\n");
            exit(0);
        }

Ça sert à empêcher l'utilisateur d’exécuter le programme
sans paramètre.

exemple d’exécution :

./zConjug aimer

macmist

13 mars 2011 à 18:05:53

Salut !
Suite à vos commentaires, voici une (légère ) amélioration du code : les fonctions ne font plus qu'une chose à la fois (en tout cas je l'espère ) . Cette partie à été plus dure que je ne le pensais , c'est pourquoi j'ai mis autant de temps !
De plus j'ai regroupé les 6 fonctions de conjugaison en 2 (une pour chaque groupe ) et j'ai rajouté quelques accents, mais pas leur gestion complète .

@candide : Que voulais tu dire par :

Citation : candide

-- Attention aux constantes magiques !

et que pourrais - je améliorer quand tu dis :

Citation : candide

-- La gestion des entrées est assez incomplète (mais pour moi, ce n'est pas du tout l'essentiel).

?

Pour le cas de strcmp , c'était juste que je voulais l'utiliser au moins une fois et pas tout le temps strcat, et je trouve que comparer au lieu de copier est plus censé dans ce cas là (enfin avis personnel

)

Le code corrigé :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int lire( char *chaine , int longueur ) ;

int rechercheGroupe ( char chaine[] , int taille ) ;
char* conjuguerG1 ( const char chaine[] , int temps , int taille , int sujet ) ;
char* conjuguerG2 ( const char chaine[] , int temps , int taille , int sujet ) ;

void afficherVerbeConjug ( const char *verbe  , const char *sujet) ;
void viderBuffer() ;






int main(int argc , char* argv[])
{
    char verbe[100] = {0} ;
    char *nouveauVerbe   = " " ;
    char *pronoms[6] = { "Je" , "Tu" , "Il / Elle" , "Nous" , "Vous" , "Ils / Elles" } ;
    int groupe = 0 ;
    int taille = 0 , choix = 0 , i = 0 ;

    printf( "Bienvenue dans ZConjug, le programme de conjugaison pour les Z%cros.\n" , 130 ) ;
    printf( "Pour l'instant, seul les verbes du premier et deuxi%cme groupe le pr%csent et l'imparfait de l'indicatif sont trait%cs\n" , 138 , 130 , 130 ) ;
    printf( "Il vous suffit d'entrer un verbe %c conjuguer , puis de suivre les instructions %c l'%ccran.\n\n" , 133 , 133 , 130 ) ;
    printf( "Entrez le verbe %c conjuguer : " , 133 ) ;
    lire( verbe , 100 ) ;
    printf( "\n\n" ) ;
    printf( "Choisissez le temps auquel conjuguer :\n") ;
    printf( "1.Pr%csent\n2.Imparfait\n3.Futur\n4.A tous les temps possible" , 130 ) ;
    while ( choix <= 0 || choix > 4)
    {
        scanf ( "%d" , &choix ) ;
        if (  ( choix <= 0 || choix > 4 ) )
        {
            printf( "Veuillez entrer 1 ,  2 , 3 ou 4\n");
        }

    }
    taille = strlen ( verbe ) ;
    groupe = rechercheGroupe (  verbe , taille ) ;
    verbe [ taille - 2 ] = '\0' ;

    if (groupe == 1)
    {
        if (choix == 4)
        {
            printf( "Le verbe %s au pr%csent:\n\n" , verbe , 130) ;
            choix = 1 ;
            while ( i < 6 )
                {
                    nouveauVerbe = conjuguerG1 ( verbe  , choix , taille , i ) ;
                    afficherVerbeConjug( nouveauVerbe , pronoms [i] ) ;
                    i++ ;
                }

            i = 0 ;

            printf( "\n\nA l'imparfait: \n ") ;
            choix = 2 ;
            while ( i< 6)
            {
                nouveauVerbe = conjuguerG1 ( verbe  , choix , taille , i ) ;
                    afficherVerbeConjug( nouveauVerbe , pronoms [i] ) ;
                    i ++ ;
            }
            i = 0 ;

            printf( "\n\nAu futur: \n") ;
            choix = 3 ;
            while ( i < 6)
                {
                    nouveauVerbe = conjuguerG1 ( verbe  , choix , taille , i ) ;
                    afficherVerbeConjug( nouveauVerbe , pronoms [i] ) ;
                    i++ ;
                }
        }


        else if ( choix == 1 || choix == 2 || choix == 3 )
        {
            if ( choix == 1 ) printf ( "Le verbe %s au pr%csent" , verbe , 130) ;
            if ( choix == 2 ) printf ( "Le verbe %s %c l'imparfait" , verbe , 133 ) ;
            if ( choix == 3 ) printf ( "Le verbe %s au futur" , verbe ) ;
            while ( i < 6 )
            {

                nouveauVerbe = conjuguerG1 ( verbe  , choix , taille , i ) ;
                printf ( "%s %s \n" , pronoms[i] , nouveauVerbe  ) ;
                i++ ;
            }
        }
    }

    if (groupe == 2)
    {
        if (choix == 4)
        {
            printf( "Le verbe %s au pr%csent:\n\n" , verbe , 130) ;
            choix = 1 ;
            while ( i < 6 )
                {
                    nouveauVerbe = conjuguerG2 ( verbe  , choix , taille , i ) ;
                    afficherVerbeConjug( nouveauVerbe , pronoms [i] ) ;
                    i++ ;
                }

            i = 0 ;

            printf( "\n\nA l'imparfait: \n ") ;
            choix = 2 ;
            while ( i< 6)
            {
                nouveauVerbe = conjuguerG2 ( verbe  , choix , taille , i ) ;
                afficherVerbeConjug( nouveauVerbe , pronoms [i] ) ;
                i ++ ;
            }
            i = 0 ;

            printf( "\n\nAu futur: \n") ;
            choix = 3 ;
            while ( i < 6)
                {
                    nouveauVerbe = conjuguerG2 ( verbe  , choix , taille , i ) ;
                    afficherVerbeConjug( nouveauVerbe , pronoms [i] ) ;
                    i++ ;
                }
        }


        else if ( choix == 1 || choix == 2 || choix == 3 )
        {
            if ( choix == 1 ) printf ( "Le verbe %s au pr%csent" , verbe , 130 ) ;
            if ( choix == 2 ) printf ( "Le verbe %s %c l'imparfait" , verbe , 133 ) ;
            if ( choix == 3 ) printf ( "Le verbe %s au futur" , verbe ) ;
            while ( i < 6 )
            {

                nouveauVerbe = conjuguerG2 ( verbe  , choix , taille , i ) ;
                printf ( "%s %s \n" , pronoms[i] , nouveauVerbe  ) ;
                i++ ;
            }
        }
    }

    return 0;
}




char* conjuguerG1 ( const char chaine []  , int temps  , int taille , int sujet)
{
    char *termPrst [6] = { "e" , "es" , "e" , "ons" , "ez" , "ent"} ;
    char *termImpft [6] = { "eais" , "eais" , "eait" , "ions" , "iez" , "aient"} ;
    char *termFtr [6] = { "erai" , "eras" , "era" , "erons" , "erez" , "eront"} ;
    char *pronoms[6] = { "Je" , "Tu" , "Il / Elle" , "Nous" , "Vous" , "Ils / Elles"} ;
    char verbeConjugue[100]  = {""};

    int nombre = 6 , i = 0;

    strcat ( verbeConjugue  , chaine  ) ;

    if ( temps == 1 ) strcat ( verbeConjugue , termPrst[sujet] ) ;
    if ( temps == 2 ) strcat ( verbeConjugue , termImpft[sujet] ) ;
    if ( temps == 3 ) strcat ( verbeConjugue , termFtr[sujet] ) ;


    return verbeConjugue ;
}


char* conjuguerG2 ( const char chaine []  , int temps  , int taille , int sujet)
{
    char *termPrst [6] = { "is" , "is" , "it" , "issons" , "issez" , "issent"};
    char *termImpft [6] = { "issais" , "issais" , "issait" , "issions" , "issiez" , "issaient"};
    char *termFtr [6] = { "irai" , "iras" , "ira" , "irons" , "irez" , "iront"};
    char *pronoms[6] = { "Je" , "Tu" , "Il / Elle" , "Nous" , "Vous" , "Ils / Elles"} ;
    char verbeConjugue[100]  = {""};

    int nombre = 6 , i = 0;

    strcat ( verbeConjugue  , chaine  ) ;

    if ( temps == 1 ) strcat ( verbeConjugue , termPrst[sujet] ) ;
    if ( temps == 2 ) strcat ( verbeConjugue , termImpft[sujet] ) ;
    if ( temps == 3 ) strcat ( verbeConjugue , termFtr[sujet] ) ;


    return verbeConjugue ;

}


int rechercheGroupe ( char chaine[] , int taille )
{
    int i = taille - 2 , j = 0 ;
    char copie [3] = {0} ;

    while (i < taille)
    {
        copie[j] = chaine [i] ;
        i++ ;
        j++ ;
    }

    if ( strcmp ( "er" , copie ) == 0 )
        return 1 ;

    else if (strcmp ( "ir" , copie ) == 0 )
        return 2;

    else return 0;
}


void viderBuffer()
{
    int c = 0;
    while (c != '\n' && c != EOF)
    {
        c = getchar();
    }
}


int lire(char *chaine, int longueur)
{
    char *positionEntree = NULL;

    if (fgets(chaine, longueur, stdin) != NULL)
    {
        positionEntree = strchr(chaine, '\n');
        if (positionEntree != NULL)
        {
            *positionEntree = '\0';
        }
        else
        {
            viderBuffer();
        }
        return 1;
    }
    else
    {
        viderBuffer();
        return 0;
    }
}

void afficherVerbeConjug ( const char *verbe  , const char *sujet)
{

    printf( "%s %s \n" , sujet , verbe ) ;
}

Pouet_forever

13 mars 2011 à 18:58:15

Ah ouais, bien vu. Mais indirectement, les verbes qui commencent pas H sont quand même soumis aux voyelles pour le J'.

candide

13 mars 2011 à 22:33:48

Citation : macmist

@candide : Que voulais tu dire par :
Citation : candide

-- Attention aux constantes magiques !

et que pourrais - je améliorer quand tu dis :
Citation : candide

-- La gestion des entrées est assez incomplète (mais pour moi, ce n'est pas du tout l'essentiel).

J'ai pas testé ton code car il me sort :

sdz.c: In function ‘main’:
sdz.c:17: warning: unused parameter ‘argc’
sdz.c:17: warning: unused parameter ‘argv’
sdz.c: In function ‘conjuguerG1’:
sdz.c:171: warning: function returns address of local variable
sdz.c:162: warning: unused variable ‘i’
sdz.c:162: warning: unused variable ‘nombre’
sdz.c:159: warning: unused variable ‘pronoms’
sdz.c:154: warning: unused parameter ‘taille’
sdz.c: In function ‘conjuguerG2’:
sdz.c:192: warning: function returns address of local variable
sdz.c:183: warning: unused variable ‘i’
sdz.c:183: warning: unused variable ‘nombre’
sdz.c:180: warning: unused variable ‘pronoms’
sdz.c:175: warning: unused parameter ‘taille’

et quand je vois ça j'ai pas confiance

et en plus j'ai pas trop de temps. Pour les entrées, faudrait que je puisse tester ton code.

Ta fonction main est carrément ATROCE, pour moi un paquet comme ça c'est une horreur.

Pour les constantes magiques, c'est des constantes numériques brutes qui apparaissent dans le code et dont on ne comprend pas la "sémantique" vu que c'est juste des constantes numériques. Je te donne un exemple dans ton code, tu écris while ( i < 6 ), typiquement 6 est une constante magique. Une bonne pratique est d'écrire une macro genre

#define NB_PERSONNES 6

(dans d'autre cas, on utilises une enum) et comme ça chaque qu'on rencontre NB_PERSONNES, on sait que tu te réfères au nombre de pronoms personnels je, tu, il, etc. Et puis imagine que le nombre de personnes change (ça été le cas pour un autre zéro dans ce fil), il te suffit juste de changer ta macro. Bon, enfin bref, disons que c'est la tradition, les us et coutumes (style Kernighan et Pike), on évite les constantes magiques même si je sais que parfois ça semble un peu too much.

Marc Mongenet

13 mars 2011 à 22:58:11

Citation : Pouet_forever

Ah ouais, bien vu. Mais indirectement, les verbes qui commencent pas H sont quand même soumis aux voyelles pour le J'.

Je ne hoche pas affirmativement de la tête à cette affirmation.

Pouet_forever

14 mars 2011 à 11:59:34

Je ne peux que m'incliner au vu de ces réponses qui ne me donnent pas raison.

macmist

14 mars 2011 à 18:58:59

Houlà je m'attendais pas à ça ><
Bon après vos commentaires j'ai encore une fois modifié mon code, j'ai fait d'autres fonctions pour réduire le main (mais c'est pas encore ça :/ ), j'ai modifié la façon dont le programme utilisait telle fonction en fonction du groupe, j'ai supprimé quelques "constantes magiques" , merci à candide de m'avoir donné ce conseil

supprimé les variables inutiles, et modifié le retour des fonctions conjuguerG1 et conjuguerG2, et j'ai rajouté une fonction pour changer le " Je " et " J' " si besoin.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NB_SUJETS 6
#define PRESENT 1
#define IMPARFAIT 2
#define FUTUR 3
#define TOUS 4
#define NB_CHJ 7

int lire( char *chaine , int longueur ) ;

int rechercheGroupe ( char chaine[] , int taille ) ;
char* conjuguerG1 ( const char chaine[] , char *chaineACopier , int temps  , int sujet ) ;
char* conjuguerG2 ( const char chaine[] , char *chaineACopier , int temps, int sujet ) ;
void boucleAffichage ( const char verbe [] , int groupe , int temps ) ;
void afficherVerbeConjug ( const char *verbe  , const char *sujet) ;
int changerJ ( const char verbe [] ) ;
void viderBuffer(void) ;
void afficheTexte ( void ) ;
int changerJ( const char verbe [] ) ;




int main( void )
{
    char verbe[100] = {0} ;
    int groupe = 0 ;
    int taille = 0 , choix = 0 ;

    afficheTexte () ;
    lire( verbe , 100 ) ;

    printf( "\n\n" ) ;
    printf( "Choisissez le temps auquel conjuguer :\n") ;
    printf( "1.Pr%csent\n2.Imparfait\n3.Futur\n4.A tous les temps possible\n" , 130 ) ;
    while ( choix < PRESENT || choix > TOUS )
    {
        scanf ( "%d" , &choix ) ;
        if (  ( choix < PRESENT || choix > TOUS ) )
        {
            printf( "Veuillez entrer 1 ,  2 , 3 ou 4\n");
        }

    }
    taille = strlen ( verbe ) ;
    groupe = rechercheGroupe (  verbe , taille ) ;
    if ( choix == PRESENT )
    {
        printf( "Le verbe %s au pr%csent\n" , verbe , 130 ) ;
        verbe [ taille - 2 ] = '\0' ;
        boucleAffichage( verbe , groupe , choix ) ;
    }
    else if ( choix == IMPARFAIT )
    {
        printf( "Le verbe %s %c l'imparfait\n" , verbe , 133) ;
        verbe [ taille - 2 ] = '\0' ;
        boucleAffichage( verbe , groupe , choix ) ;
    }
    else if ( choix == FUTUR )
    {
        printf( "Le verbe %s au futur\n" , verbe ) ;
        verbe [ taille - 2 ] = '\0' ;
        boucleAffichage( verbe , groupe , choix ) ;
    }

     else if ( choix == TOUS )
    {
        choix = 1 ;
        printf( "Le verbe %s au pr%csent\n" , verbe , 130 ) ;
        verbe [ taille - 2 ] = '\0' ;
        boucleAffichage( verbe , groupe , choix ) ;

        choix = 2 ;
        printf( "A l'imparfait\n" , verbe , 133) ;
        boucleAffichage( verbe , groupe , choix ) ;

        choix = 3 ;
        printf( "Au futur\n" , verbe ) ;
        boucleAffichage( verbe , groupe , choix ) ;
    }
    return 0;
}



char* conjuguerG1 ( const char chaine []  , char *chaineACopier , int temps  , int sujet )
{
    char *termPrst [6] = { "e" , "es" , "e" , "ons" , "ez" , "ent"} ;
    char *termImpft [6] = { "eais" , "eais" , "eait" , "ions" , "iez" , "aient"} ;
    char *termFtr [6] = { "erai" , "eras" , "era" , "erons" , "erez" , "eront"} ;
    char verbeConjugue [100]  = {" "} ;

    strcat ( verbeConjugue  , chaine  ) ;

    if ( temps == PRESENT ) strcat ( verbeConjugue , termPrst[sujet] ) ;
    if ( temps == IMPARFAIT ) strcat ( verbeConjugue , termImpft[sujet] ) ;
    if ( temps == FUTUR ) strcat ( verbeConjugue , termFtr[sujet] ) ;


    strcat ( chaineACopier , verbeConjugue ) ;

    return chaineACopier ;
}


char* conjuguerG2 ( const char chaine []  , char *chaineACopier , int temps , int sujet )
{
    char *termPrst [6] = { "is" , "is" , "it" , "issons" , "issez" , "issent"};
    char *termImpft [6] = { "issais" , "issais" , "issait" , "issions" , "issiez" , "issaient"};
    char *termFtr [6] = { "irai" , "iras" , "ira" , "irons" , "irez" , "iront"};
    char verbeConjugue[100]  = {" "} ;

    strcat ( verbeConjugue  , chaine  ) ;

    if ( temps == PRESENT ) strcat ( verbeConjugue , termPrst[sujet] ) ;
    if ( temps == IMPARFAIT ) strcat ( verbeConjugue , termImpft[sujet] ) ;
    if ( temps == FUTUR ) strcat ( verbeConjugue , termFtr[sujet] ) ;

    strcat ( chaineACopier , verbeConjugue ) ;

    return chaineACopier ;

}


int rechercheGroupe ( char chaine[] , int taille )
{
    int i = taille - 2 , j = 0 ;
    char copie [3] = {0} ;

    while (i < taille)
    {
        copie[j] = chaine [i] ;
        i++ ;
        j++ ;
    }

    if ( strcmp ( "er" , copie ) == 0 )
        return 1 ;

    else if (strcmp ( "ir" , copie ) == 0 )
        return 2;

    else return 0;
}


void viderBuffer(void)
{
    int c = 0;
    while (c != '\n' && c != EOF)
    {
        c = getchar();
    }
}


int lire(char *chaine, int longueur)
{
    char *positionEntree = NULL;

    if (fgets(chaine, longueur, stdin) != NULL)
    {
        positionEntree = strchr(chaine, '\n');
        if (positionEntree != NULL)
        {
            *positionEntree = '\0';
        }
        else
        {
            viderBuffer();
        }
        return 1;
    }
    else
    {
        viderBuffer();
        return 0;
    }
}

void boucleAffichage ( const char verbe[] , int groupe , int temps )
{
    char *pronoms[6] = { "Je" , "Tu" , "Il / Elle" , "Nous" , "Vous" , "Ils / Elles" } ;
    char *resultat = NULL ;
    char verbeAcopier [100] = {""} ;
    int i = 0 ;
    if ( groupe == 1 )
    {
        while ( i < NB_SUJETS )
        {
            resultat = conjuguerG1 ( verbe , verbeAcopier , temps , i ) ;
            afficherVerbeConjug( resultat, pronoms[i] ) ;
            verbeAcopier[0] = '\0' ;
            i++ ;
        }
    }

    if ( groupe == 2)
    {
        while ( i < NB_SUJETS)
        {
            resultat = conjuguerG2 ( verbe , verbeAcopier , temps , i ) ;
            afficherVerbeConjug( resultat , pronoms[i] ) ;
            verbeAcopier[0] = '\0' ;
            i ++ ;
        }
    }
}

void afficherVerbeConjug ( const char *verbe  , const char *sujet)
{
    if ( strcmp ( sujet , "Je" ) == 0 && changerJ ( verbe ) == 1)
    printf( "J'%s \n" ,  verbe ) ;
    else printf( "%s%s \n" , sujet , verbe ) ;
}

void afficheTexte ( void )
{
    printf( "Bienvenue dans ZConjug, le programme de conjugaison pour les Z%cros.\n" , 130 ) ;
    printf( "Pour l'instant, seul les verbes du premier et deuxi%cme groupe le pr%csent et l'imparfait de l'indicatif sont trait%cs\n" , 138 , 130 , 130 ) ;
    printf( "Il vous suffit d'entrer un verbe %c conjuguer , puis de suivre les instructions %c l'%ccran.\n\n" , 133 , 133 , 130 ) ;
    printf( "Entrez le verbe %c conjuguer : " , 133 ) ;
}

int changerJ( const char verbe [] )
{
    int i = 0 ;
    char lettres[7] = { 'a' , 'e' , 'i' , 'o' , 'u' , 'y' , 'h'} ;
    while ( i < NB_CHJ )
    {
        if ( verbe [1] == lettres [i] )
        {
            return 1 ;
        }
    }
    return 0 ;
}

Je sais ça fait beaucoup de fois que je poste, mais si vous pourriez une fois de plus me dire ce qui va et qui ne va pas dans ce code recorrigé, je vous en serait reconnaissant ! Le code est - il toujours aussi horrible ? J'ai essayé de changer mais à mes yeux tous paraît horrible donc je sais pas trop :/

Voilà merci d'avance

nemesis15

14 mars 2011 à 23:13:48

@macmist : utilise les arguments du main

1 2 >>