Partage

[zConjug] Exercice pour débutants

Venez nombreux !

<< 1 2

Demon_of_Apocalyps

27 mars 2011 à 13:52:42

J'èspere ne pas être en retard, j'ai vu le sujet qu'hier :lol:

Alors voici mon code, tout dans le main.c :diable:

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

#define GR1 1
#define GR2 2
#define GR3 3 
#define GR_INVALID 4


void viderBuffer();
char* strcat2(char* chaine1, const char* chaine2);
bool strcmp2(const char* chaine1, const char* chaine2);
bool getverbe(char* verbe);
int nombreDeCarac(char mot[]);
void tronqueTerm(char *v, char* vb);
void conjuguerVerbe(char *vb, int _groupe, int _t);

void viderBuffer()
{
    int c = 0;
    while (c != '\n' && c != EOF)
    {
        c = getchar();
    }
}
char* strcat2(char* chaine1, const char* chaine2)
{
	bool starcop = false;

	int compt = 0,
		compt2 = 0;
	

	do
	{
				if(chaine1[compt] == '\0') starcop = true;
				if(starcop)
				{
					chaine1[compt] = chaine2[compt2];
					compt2++;
				}

				compt++;

	} while(chaine2[compt2] != '\0');
	chaine1[compt] = '\0';

	return chaine1;
}

bool strcmp2(const char* chaine1, const char* chaine2)
{
	int compt = 0;
	bool result = true;
	bool stop = false;
	while(!stop)
	{
		if(chaine1[compt] != chaine2[compt])
		{	
			stop = true;
			return result = false;
		}
		if(chaine1[compt] == chaine2[compt] && chaine1[compt] == '\0') return result = true;
		compt++;
	}
	return result;
}

int nombreDeCarac(char mot[])
{
	int nombre = 0, i = 0;
	while(mot[i] != '\0')
	{
		nombre++;
		i++;
	}
	return nombre;
}
bool getverbe(char* verbe)
{
	int i = 0;
	printf("Verbe : ");
	fgets(verbe, 28, stdin);
	
	do
	{
		switch(verbe[i])
		{
			case ' ': case '0': case'1': case '2': case'3': case'4': case'5': case'6': case '7': case '8': case '9':
					printf("\n\t*ERREUR: Entrez un verbe avec une forme valide, sans espace ni de caractere numerique\n\n");
					return false;


			default:
					i++;
		}
		
	} while (verbe[i] != '\n');		

	verbe[i] = '\0';
	
	return true;
}	

int checkGR(char* v)
{
	int _n = nombreDeCarac(v);
	
	char _term[3];
	_term[0] = v[_n-2];
	_term[1] = v[_n-1];
	_term[2] = '\0';

	if(strcmp2(_term, "er")){
		if(strcmp2(v, "aller")) return GR3; 
		else return GR1;}
	
	else if(strcmp2(_term, "ir"))
		if(strcmp2(v, "venir") || strcmp2(v, "tenir") || strcmp2(v, "pouvoir") || strcmp2(v, "avoir")) return GR3;
		else return GR2;

	else if(strcmp2(_term, "re")) return GR3;

	else return GR_INVALID;

	//printf("\n1:%c 2:%c     tt: %s \n", v[_n-1], v[_n], _term);
	//return 1;
}
void tronqueTerm(char *v, char *vb)
{
	int i = 0;
	int _n = nombreDeCarac(vb);
	for(i; i<_n-2; i++)
		v[i] = vb[i];
	v[i] = '\0';
}

void conjuguerVerbe(char *vb, int _groupe, int t)
{
	char pronom[6][28] = { "Je", "Tu", "Il/Elle", "Nous", "Vous", "Ils/Elles" };
	
	char terminaison_GR1[3][7][28] =
	{
		{ "ais", "ais", "ait", "ions", "iez", "aient"}, // Passée 
		{ "e", "es", "e", "ons", "ez", "ent"}, // Present
		{ "erai", "eras", "era", "erons", "erez", "eront"} // Futur
	};

	char terminaison_GR2[3][7][28] =
	{
		{ "issais", "issais", "issait", "issions", "issiez", "issaient"}, // Passée 
		{ "is",     "is",     "it",  "issons",  "issez",  "issent"}, // Present
		{ "irai",   "iras",   "ira",    "irons",  "irez",   "iront"} // Futur
	};

	int i=0, j=0;
	char verbe_tr[28];
	
	tronqueTerm(verbe_tr, vb);

	if ( _groupe == GR1 )
	{
			for(j; j<6; j++)
			{
					if (j == 0 &&  verbe_tr[0] == 'a' || verbe_tr[0] == 'e' || verbe_tr[0] == 'i' || verbe_tr[0] == 'o' || verbe_tr[0] == 'u' )
					{
								printf(" J'%s \n", strcat2(verbe_tr, terminaison_GR1[t][j]));
								tronqueTerm(verbe_tr, vb);
					}

					else	
					{
							printf(" %s %s \n", pronom[j], strcat2(verbe_tr, terminaison_GR1[t][j]));
							tronqueTerm(verbe_tr, vb);
					}
			}
	}

	else if ( _groupe == GR2 )
	{
			for(j; j<6; j++)
			{
					if (j == 0 &&  verbe_tr[0] == 'a' || verbe_tr[0] == 'e' || verbe_tr[0] == 'i' || verbe_tr[0] == 'o' || verbe_tr[0] == 'u' )
					{
								printf(" J'%s \n", strcat2(verbe_tr, terminaison_GR2[t][j]));
								tronqueTerm(verbe_tr, vb);
					}

					else	
					{
							printf(" %s %s \n", pronom[j], strcat2(verbe_tr, terminaison_GR2[t][j]));
							tronqueTerm(verbe_tr, vb);
					}
			}
	}
	viderBuffer();

};	

int main()
{
	bool _c = false;
	do
	{

	printf("\t************* SUPER-CONJUGUEUR *************\n\n");
	printf("\t*Entrez votre verbe pour que le superbe conjugueur le conjugue !\n\n");
	char verbe[28];
	
	bool _r;
	int _g;
	do
	{
			_r = getverbe(verbe);
				if( !_r ) continue;

			_g = checkGR(verbe);
				if( _g == GR_INVALID) printf( " *Ce verbe appartient a un groupe non-valide ! Reessayer !\n\n");
				else if( _g == GR3 ) printf(" *Le programme ne gère pas les verbes du 3eme Groupe ! Ressayer !\n\n");
	}
			while( !_r || _g == GR_INVALID || _g == GR3);
	
	printf("\t*Entrez le temps de la conjugaison s'il vous plait\n\t*Au choix:\n\t 1. Passe 2. Present 3.Futur\n");
	int _t = -1;
	do 
			scanf("%i", &_t);
		while ( _t != 1 && _t != 2 && _t != 3 );
	_t--;
	
	char _e;

		conjuguerVerbe(verbe, _g, _t);
		printf("Voila ! Tappez Y si vous souhaitez recommencez avec un nouveau verbe !\n\n");
		scanf("%c", &_e);
			if( _e == 'Y' || _e == 'y')
				_c = true;
			else printf("Merci d'avoir choisi le super conjugueur !\n\n");

		viderBuffer();
	}
		while(_c);
		


	system("pause");
	return 0;
}

Soyez indulgent au niveau des verbes, j'ai pas gérez les exception et les verbes du 3ème groupe désolée y en a tellement !
J'attend vos remarques/critiques

Lebrian

31 mars 2011 à 22:35:52

main.c

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

#include "zconjug.h"

int main(int argc, char *argv[])
{
    if(argc <= 1){
        printf("Aucun argument recu\n");
        exit(EXIT_SUCCESS);
    }

    else{
        switch(analyser(argv[1])){
            case 1:
                printf("Verbe du premier groupe.\n\n");
                premierGroupe(argv[1]);
                break;

            case 2:
                printf("Verbe du deuxieme groupe.\n");
                secondGroupe(argv[1]);
                break;

            default:
                printf("Nous ne pouvons pas traiter votre cas.\n");
                break;
        }
    }
    
    return EXIT_SUCCESS;
}

zconjug.h

#ifndef DEF_ZCONJUG
#define DEF_ZCONJUG

#define TERM 2


void zconjug(char*, char (*)[], char (*)[], char (*)[]);
int analyser(char*);
void supprimerTerm(char*);
void premierGroupe(char*);
void secondGroupe(char*);
void afficher(char*, char (*)[]);
int menu(void);
int test(int c);

#endif

zconjug.c

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

#include "zconjug.h"

void afficher(char* verbe, char (*temps)[10]){
    char *pronom[] = {"Je", "Tu", "Il/Elle", "Nous", "Vous", "Ils/Elles"};
    int i;
    
    putchar('\n');
    
    if(test(verbe[0])) pronom[0] = "J'";
/*    
    if(verbe[strlen(verbe) - 1] == 'g'){
        if(strcmp(temps[3], "ons") == 0) 
            strcpy(temps[3], "eons");
        else{
	    for(i = 0; i < 2; i++){
		if(strcmp(temps[i], "ais") == 0){
		    strcpy(temps[i], "eais");
            	    strcpy(temps[2], "eait");
	    	}
	    }
        }
    }
*/
    for(i = 0; i < 6; i++)
        printf("%s %s%s\n", pronom[i], verbe, temps[i]);
}

void zconjug(char* verbe, char (*present)[], char (*futur)[], char (*imparfait)[]){

    switch(menu()){
        case 1:
            afficher(verbe, present);
            break;
        case 2:
            afficher(verbe, futur);
            break;
        case 3:
            afficher(verbe, imparfait);
            break;
        case 4:
            afficher(verbe, present);
	        afficher(verbe, futur);
	        afficher(verbe, imparfait);
	        break;
        default:
            printf("Merci, a bientot\n");
            break;
    }
}

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

    if(verbe[i - TERM + 1] == 'r' && verbe[i - TERM] == 'e' && i > TERM)
        return 1;

    else if(verbe[i - TERM + 1] == 'r' && verbe[i - TERM] == 'i' && i > TERM)
        return 2;

    else return 0;
}

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

    if(i > TERM)
        verbe[i - TERM] = '\0';
    else
        exit(EXIT_FAILURE);
}

void premierGroupe(char* verbe){
    char present[][10] = {"e", "es", "e", "ons", "ez", "ent"};
    char futur[][10] = {"erai", "era", "era", "erons", "erez", "eront"};
    char imparfait[][10] = {"ais", "ais", "ait", "ions", "iez", "aient"};

    supprimerTerm(verbe);
    zconjug(verbe, present, futur, imparfait);
}

void secondGroupe(char* verbe){
    char present[][10] = {"is", "is", "it", "issons", "issez", "issent"};
    char futur[][10] = {"irai", "iras", "ira", "irons", "irez", "iront"};
    char imparfait[][10] = {"issais", "issais", "issait", "issions", "issiez", "issaient"};

    supprimerTerm(verbe);
    zconjug(verbe, present, futur, imparfait);
}

int menu(void){
    int choix = 0;

    printf("\nConjuguer:\n\n1. Au present");
    printf("\n2. Au futur\n3. A l'imparfait\n");
    printf("4. Les trois temps\n\n");
    printf("Choix: ");
    scanf("%d", &choix);

    if(choix >= 1 && choix <= 4)
        return choix;
    else
        return 0;
}

int test(int c){
    char voyelle[] = {'a', 'e', 'i', 'o', 'u'};
    int i;

    for(i = 0; i < strlen(voyelle); i++)
        if(c == voyelle[i])
            return 1;

    return 0;
}

Bonsoir,
je reviens avec quelques modifications/ajouts par rapport à ma première proposition.
J'ai juste géré quelques exceptions :euh:

-verbes commençant par une voyelle;
-verbes qui se terminent par "ger" (exemple manger): La partie du code qui gère cette exception est mise en commentaire dans la fonction afficher car je veux trouver un moyen de déléguer ce travail à une fonction.
-(rien d'autres

)

Candide et Marc m'ont donné des conseils pour mon premier code, j'espère en tout cas les avoir suivi (je l'espère :-°

)

Je vois dis merci et n'hésitez pas pour vos conseils.(pour moi pauvre débutant :euh:

)

P.S: Il se peut que des erreurs se soient introduites lors de la saisie du message (dans le code).

paraze

20 mai 2011 à 23:48:50

Merci vous tous de vos participations !

Voici la correction qui arrive avec un peu d'avance : http://www.siteduzero.com/forum-83-504 [...] html#r6242778 .

Lebrian

21 mai 2011 à 12:11:26

Salut paraze,

je viens de faire des tests avec ton programme mais il y a comme des erreurs. Par exemple pour le verbe finir au présent, ça donne:

Je finisirai
Tu finisiras
Il/Elle finitira
Nous finissonsirons
Vous finissezirons
Ils/Elles finissentiront

C'est certainement une erreur qui s'est glissée

Je poste ici pour ne pas polluer le topic des exercices.

paraze

21 mai 2011 à 12:24:17

Merci LeBri@n, j'ai corrigé. En fait, le code fonctionnait très bien mais juste avant de poster, j'ai modifier un else if() en else pour simplifier le code; bien vu !

djasy3

21 mai 2011 à 16:14:59

bonjour,je suis aussi entrain de concevoir ce petit programme de conjugaison, mais je n'ai pas encore mis tous les temps, il y a juste le présent,l'imparfait et le passé simple. mais la suite est en cours!
bon voici mon code et n'hésitez pas à me faire des remarques, elles seront les bienvenues:

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

void present(char* verbe);
void imparfait(char* verbe);
void passe_simple(char* verbe);

int main()
{
   char vrb[]={};
   char *racine = NULL;
   int choix = 0;

//on extrait la racine du verbe en utilisant la fonction string lenght(strlen)
   racine = vrb + strlen(vrb) - 2;

/* on utilise la boucle tant que pour vérifier si le verbe se termine en er
 en utilisant string compare(strcmp) */

   while(strcmp(racine,"er")!= 0)
   {
       printf("veuillez entrer un verbe du 1er groupe\n");
       gets(vrb);

       racine = vrb + strlen(vrb) - 2;
   }
 // l'utilisateur fait son choix de temps qu'il veut que le programme conjugue

   printf("\t a quel temps voulez-vous conjuger?\n\n");
   printf("\t 1.indicatif present\n\n");
   printf("\t 2.indicatif imparfait\n\n");
   printf("\t 3.indicatif passe simple\n\n");
   printf("\t 4.tous les temps\n\n");

   printf(" veuillez choisir le temps svp en appuyant sur un chiffre de votre choix!\n");
   scanf("%d",&choix);

   while(choix > 4)
   {
       printf("recommencer svp\n");
       scanf("%d",&choix);
   }
   switch(choix)
   {
       case 1:
                present(vrb);

       break;

       case 2:
                imparfait(vrb);

       break;

       case 3:
                passe_simple(vrb);
       break;

       case 4:
                present(vrb);imparfait(vrb);passe_simple(vrb);
       break;

   }
   return 0;
}

void present(char* verbe)
{
     char vrb[]={};
     char *racine = NULL;
     char *term_prst[6]={"e","es","e","ons","ez","ent"};//on determine les terminaison pour chaque temps ainsi que les exceptions
     char *term_prst_g[6]={"e","es","e","eons","ez","ent"};
     char *pronom_v[6]={"J'","Tu","Il","Nous","Vous","Ils"};
     char *pronom[6]={"Je","Tu","Il","Nous","Vous","Ils"};
     int i;
     //on extrait la racine du verbe en utilisant la fonction string lenght(strlen)

     strcpy(vrb,verbe);
     printf("\t\t\t verbe %s a l'indicatif present\n",vrb);
     printf("\t\t\t ----------------------------------\n\n");
   racine = vrb + strlen (vrb) - 2;

                    for(i=0; i<6; i++)
                    {
                        if ((vrb[0] =='a'||vrb[0] =='e'||vrb[0] =='i'||vrb[0] =='o'||vrb[0] =='u') && racine[-1]=='g')
                        {
                             strcpy(racine,term_prst_g[i]);/* ici on converti la racine en chaine de caractère en utilisant
                                                            la boucle string copy(strcpy) et on colle en même temps les terminaisons
                                                            à la racine puis on les affiche via un printf! */
                             printf("\t%s\t%s\n",pronom_v[i],vrb);

                        }

                        else if(racine[-1]=='g')
                        {
                             strcpy(racine,term_prst_g[i]);
                             printf("\t%s\t%s\n",pronom[i],vrb);
                        }

                        else if(vrb[0] =='a'||vrb[0] =='e'||vrb[0] =='i'||vrb[0] =='o'||vrb[0] =='u')
                        {
                             strcpy(racine,term_prst[i]);
                             printf("\t%s\t%s\n",pronom_v[i],vrb);
                        }

                        else
                         {
                             strcpy(racine,term_prst[i]);
                             printf("\t%s\t%s\n",pronom[i],vrb);

                         }

                    }
}

void imparfait(char* verbe)
{
    char vrb[]={};
   char *racine = NULL;
   char *pronom[6]={"Je","Tu","Il","Nous","Vous","Ils"};
   char *pronom_v[6]={"J'","Tu","Il","Nous","Vous","Ils"};
   char *term_impft[6]={"ais","ais","ait","ions","iez","aient"};
   int i = 0;

     strcpy(vrb,verbe);
     printf("\t\t\t verbe %s a l'indicatif imparfait\n",vrb);
     printf("\t\t\t -------------------------------------\n\n");

     racine = vrb + strlen (vrb) - 2;
     for(i=0; i<6; i++)
                    {
                        if ((vrb[0] =='a'||vrb[0] =='e'||vrb[0] =='i'||vrb[0] =='o'||vrb[0] =='u'))
                        {
                             strcpy(racine,term_impft[i]);/* ici on converti la racine en chaine de caractère en utilisant
                                                            la boucle string copy(strcpy) et on colle en même temps les terminaisons
                                                            à la racine puis on les affiche via un printf! */
                             printf("\t%s\t%s\n",pronom_v[i],vrb);

                        }

                        else
                         {
                             strcpy(racine,term_impft[i]);
                             printf("\t%s\t%s\n",pronom[i],vrb);

                         }

                    }

}


void passe_simple(char* verbe)
{
   char vrb[]={};
   char *racine = NULL;
   char *pronom[6]={"Je","Tu","Il","Nous","Vous","Ils"};
   char *pronom_v[6]={"J'","Tu","Il","Nous","Vous","Ils"};
   char *term_ps[6]={"a","as","a","ames","ates","erent"};
   int i = 0;

     strcpy(vrb,verbe);
     printf("\t\t\t verbe %s a l'indicatif passe simple\n",vrb);
     printf("\t\t\t ---------------------------------------\n\n");

     racine = vrb + strlen (vrb) - 2;
     for(i=0; i<6; i++)
                    {
                        if ((vrb[0] =='a'||vrb[0] =='e'||vrb[0] =='i'||vrb[0] =='o'||vrb[0] =='u'))
                        {
                             strcpy(racine,term_ps[i]);/* ici on converti la racine en chaine de caractère en utilisant
                                                            la boucle string copy(strcpy) et on colle en même temps les terminaisons
                                                            à la racine puis on les affiche via un printf! */
                             printf("\t%s\t%s\n",pronom_v[i],vrb);

                        }

                        else
                         {
                             strcpy(racine,term_ps[i]);
                             printf("\t%s\t%s\n",pronom[i],vrb);

                         }

                    }

}

merci bien

Programmer n'est pas connaître les instructions d'un langage de programmation, mais plutôt trouver un algorithme pour résoudre un problème...

nemesis15

21 mai 2011 à 21:31:22

@djasy

J'ai survole ton code et je vois que tu utilses la fonction
gets qui est clairement deconseille par le manuel.

Citation : manuel

Never use gets(). Because it is impossible to tell without knowing the data in advance how many characters gets() will read, and because gets() will continue to store characters past the end of the buffer, it is extremely dangerous to use. It has been used to break computer security. Use fgets() instead.

ps: desole pour les accents, je suis en US.

djasy3

28 mai 2011 à 1:10:13

@nemesis15:thanks pour la remarque i'm going to change right now!

Programmer n'est pas connaître les instructions d'un langage de programmation, mais plutôt trouver un algorithme pour résoudre un problème...

Erwan-Overseas

28 mai 2011 à 10:42:33

@oaraze15: prend en compte les conseils donnes sur l'exercice,
la reponse que tu donnes... est moins bonne selon moi, que d'autres versions postees ici, qui ont gagne grace aux remarques pertinentes des intervenants, ceci dit, tout cela peut etre encore ammeliore.

Anonyme

28 mai 2011 à 11:35:37

Salut,

Je poste une petite solution un peu vieille, mais que j'ai adaptée pour l'exercice proposé. Hélas, elle ne prend en compte que le présent des verbes du premier groupe, du deuxième et d'aller :

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

void extraire_radical(char* verbe);
void prem_group(char* verbe);
int analyser_terminaison(char* verbe);
void deux_group(char* verbe);
void conjug_aller(char* verbe);

char *pronom[6] = {"je", "tu", "il / elle / on", "nous", "vous", "ils / elles"};

int main(void)
{
    /* Initialisation de la chaine */
    char mon_verbe[] = "";

    /* On demande à l'utilisateur d'entrer un verbe */
    printf("Entrez un verbe : ");
    scanf("%s", mon_verbe);
    while(getchar() != '\n');

    if(analyser_terminaison(mon_verbe) == 1)
        prem_group(mon_verbe);
    else if(analyser_terminaison(mon_verbe) == 2)
        deux_group(mon_verbe);
    else if(analyser_terminaison(mon_verbe) == 3)
        conjug_aller(mon_verbe);
    return 0;
}

void extraire_radical(char* verbe) {
    /*
        Cette fonction extrait le radical du verbe.
    */
    int ltr = strlen(verbe) - 2, i; // On "mesure" le verbe pour arriver à la 1 lettre de sa terminaison

    for(i=0 ; i<ltr; i++) {
        printf("%c", verbe[i]); // On affiche le radical
    }
}

int analyser_terminaison(char* verbe) {
    /*
        Cette fonction analyse la terminaison des verbes. Elle retourne 1, si c'est un verbe du premier groupe. 
        Elle retourne 2, si c'est un verbe du deuxième.
        Elle retourne 3, si le verbe est "aller".
    */
    int i = strlen(verbe);

    if(strcmp(verbe, "aller") == 0) { // si le verbe == aller, on lui donne un traitement spécial
        return 3;
    }
    if(verbe[i-2] == 'e' && verbe[i-1] == 'r')
        return 1;
    else if(verbe[i-2] == 'i' && verbe[i-1] == 'r')
        return 2;

    return 0;

}

void prem_group(char* verbe) {
    /*
        Cette fonction conjugue les verbes du premier groupe.
    */
    char *term[6] = {"e", "es", "e", "ons", "ez", "ent"};
    int i;

    for (i=0; i < 6; i++) {
        /* Si la première lettre du verbe est une voyelle ou un h, on élide le je */
        if(i==0 && (verbe[i] == 'a' || verbe[i] == 'e' || verbe[i] == 'i' || verbe[i] == 'o' || verbe[i] == 'u' || verbe[i] == 'h'))
            printf("J'");
        else
            printf("%s ", pronom[i]);
        extraire_radical(verbe);
        printf("%s\n", term[i]);
    }
}

void deux_group(char* verbe) {
    /*
        Cette fonction conjugue les verbes du deuxième groupe.
    */
    char *term[6] = {"is", "is", "it", "issons", "issez", "issent"};
    int i;

    for (i=0; i < 6; i++) {
        if(i==0 && (verbe[i] == 'a' || verbe[i] == 'e' || verbe[i] == 'i' || verbe[i] == 'o' || verbe[i] == 'u' || verbe[i] == 'h'))
            printf("J'");
        else
            printf("%s ", pronom[i]);

        extraire_radical(verbe);
        printf("%s\n", term[i]);
    }
}

void conjug_aller(char* verbe) {
    /*
        Cette fonction conjugue le verbe aller, irrégulier. 
    */
    char *term[6] = {"vais", "vas", "va", "allons", "allez", "vont"};
    int i;

    for(i = 0; i<6; i++) {
        printf("%s ", pronom[i]);
        printf("%s\n", term[i]);
    }
}

Voilà pour moi. Bonne journée.

Erwan-Overseas

28 mai 2011 à 12:04:09

un conteneur pour les groupes
--un conteneur pour les temps
---un conteneur pour les terminaisons
(ca peut marcher dans un ordre d'inclusion different temps>groupes>teminaisons...).

(edit: ------ un espace ne peut pas en cacher un autre).

comme deja dit, cela evite la dupplication (une fonction prenant des parametres (temps, et groupe, ou deduisant le groupe depuis l'argument passe (ce qui est mieu)).

une liste des verbes irregulier peut etre utile.
une liste des verbes regulier aussi... (un syteme du genre: "tiens je ne connais pas ce verbe, me garantissez vous qu'il existe?" et ajoute dans une base de donnee le verbe... ou suggere un autre verbe proche, ou alors grep bescherelle :-) )

ucéph

4 juin 2011 à 20:08:12

Salut, je viens proposer ma solution pour l'exercice.
J'ai fait la conjugaison des verbes 1er et 2eme (sans les exceptions).

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAX 100

int typeVerbe(char verbe[]) // Fonction qui definit le type du verbe
{
	int i = strlen(verbe);
	if ((verbe[i-1] == 'r') && (verbe[i - 2] == 'e')) return 1;// 1er groupe
	if (verbe[i-1] == 'r' && verbe[i - 2] == 'i') return 2;// ou 2eme groupe
    return EXIT_FAILURE;

}

void remakeVerbe(char verbe[], int type) // Fonction qui remet le verbe en etat (pour d'autres conjugaisons !)
{
	int i = strlen(verbe);
	switch(type)
	{
		case 1: verbe[i] = 'e'; verbe[i + 1] = 'r'; verbe[i + 2] = '\0'; break;
		case 2: verbe[i] = 'i'; verbe[i + 1] = 'r'; verbe[i + 2] = '\0'; break;
		default :break;
	}
}

void present(char verbe[]) // Fonction qui conjugue le "verbe" au Present
{
	char pronoms[6][MAX]={ "Je", "Tu", "Il/Elle/On", "Nous", "Vous", "Ils/Elles" }; // les pronoms
	int type = typeVerbe(verbe);

	if (type == 1)
	{
		char terminaisons[6][6] = { "e", "es", "e", "ons", "ez", "ent"}; // les terminaisons 1er groupe
		int i;
		verbe[strlen(verbe)-2]='\0'; // on se debarasse de la terminaison pour former le radical
		for (i = 0; i < 6; i++)
		{
			printf("%s", pronoms[i]);
			printf("\t:");
			verbe = strcat(verbe, terminaisons[i]); // auquel on colle une a une les terminaisons
			printf("%s", verbe);
			int longueur = strlen(verbe); // et puis on prepare l'arrivée de la suivante
			switch (i) // en ne retenant que le radical
			{
				case 0 : verbe[longueur - 1] = '\0'; break;
				case 1 : verbe[longueur - 2] = '\0'; break;
				case 2 : verbe[longueur - 1] = '\0'; break;
				case 3 : verbe[longueur - 3] = '\0'; break;
				case 4 : verbe[longueur - 2] = '\0'; break;
				case 5 : verbe[longueur - 3] = '\0'; break;
				default : break;
			}
			printf("\n");
		}
	}

	if (type == 2)
	{
		char terminaisons[6][7] = { "is", "is", "it", "issons", "issez", "issent"}; // les terminaisons 2eme groupe
		int i;
		verbe[strlen(verbe)-2]='\0';
		for (i = 0; i < 6; i++)
		{
			printf("%s", pronoms[i]); // on se debarasse de la terminaison pour former le radical
			printf("\t:");
			verbe = strcat(verbe, terminaisons[i]); // auquel on colle une a une les terminaisons
			printf("%s", verbe);
			int longueur = strlen(verbe); // et puis on prepare l'arrivée de la suivante
			switch (i) // en ne retenant que le radical
			{
				case 0 : verbe[longueur - 2] = '\0'; break;
				case 1 : verbe[longueur - 2] = '\0'; break;
				case 2 : verbe[longueur - 2] = '\0'; break;
				case 3 : verbe[longueur - 6] = '\0'; break;
				case 4 : verbe[longueur - 5] = '\0'; break;
				case 5 : verbe[longueur - 6] = '\0'; break;
				default : break;
			}
			printf("\n");
		}
	}

	remakeVerbe(verbe, type); // pour enfin rendre a notre radical sa vieille terminaison
}


void imparfait(char verbe[]) // Fonction qui conjugue le "verbe" à l'Imparfait
{
	char pronoms[6][MAX]={ "Je", "Tu", "Il/Elle/On", "Nous", "Vous", "Ils/Elles" }; // les pronoms
	int type = typeVerbe(verbe);


	if (type == 1)
	{
		char terminaisons[6][6] = { "ais", "ais", "ait", "ions", "iez", "aient"}; // les terminaisons 1er groupe
		int i;
		verbe[strlen(verbe)-2]='\0'; // on se debarasse de la terminaison pour former le radical
		for (i = 0; i < 6; i++)
		{
			printf("%s", pronoms[i]);
			printf("\t:");
			verbe = strcat(verbe, terminaisons[i]); // auquel on colle une a une les terminaisons
			printf("%s", verbe);
			int longueur = strlen(verbe); // et puis on prepare l'arrivée de la suivante
			switch (i) // en ne retenant que le radical
			{
				case 0 : verbe[longueur - 3] = '\0'; break;
				case 1 : verbe[longueur - 3] = '\0'; break;
				case 2 : verbe[longueur - 3] = '\0'; break;
				case 3 : verbe[longueur - 4] = '\0'; break;
				case 4 : verbe[longueur - 3] = '\0'; break;
				case 5 : verbe[longueur - 5] = '\0'; break;
				default : break;
			}
			printf("\n");
		}
	}

	if (type == 2)
	{
		char terminaisons[6][9] = { "issais", "issais", "issait", "issions", "issiez", "issaient"}; // les terminaisons 2eme groupe
		int i;
		verbe[strlen(verbe)-2]='\0'; // on se debarasse de la terminaison pour former le radical
		for (i = 0; i < 6; i++)
		{
			printf("%s", pronoms[i]);
			printf("\t:");
			verbe = strcat(verbe, terminaisons[i]); // auquel on colle une a une les terminaisons
			printf("%s", verbe);
			int longueur = strlen(verbe); // et puis on prepare l'arrivée de la suivante
			switch (i) // en ne retenant que le radical
			{
				case 0 : verbe[longueur - 6] = '\0'; break;
				case 1 : verbe[longueur - 6] = '\0'; break;
				case 2 : verbe[longueur - 6] = '\0'; break;
				case 3 : verbe[longueur - 7] = '\0'; break;
				case 4 : verbe[longueur - 6] = '\0'; break;
				case 5 : verbe[longueur - 8] = '\0'; break;
				default : break;
			}
			printf("\n");
		}
	}

	remakeVerbe(verbe, type); // pour enfin rendre a notre radical sa vieille terminaison

}


void futurSimple(char verbe[]) // Fonction qui conjugue le "verbe" au Futur Simple
{
	char pronoms[6][MAX]={ "Je", "Tu", "Il/Elle/On", "Nous", "Vous", "Ils/Elles" }; // les pronoms
	int type = typeVerbe(verbe);


	if (type == 1)
	{
		char terminaisons[6][6] = { "erai", "eras", "era", "erons", "erez", "eront"};	// les terminaisons 1er groupe
		int i;
		verbe[strlen(verbe)-2]='\0'; // on se debarasse de la terminaison pour former le radical
		for (i = 0; i < 6; i++)
		{
			printf("%s", pronoms[i]);
			printf("\t:");
			verbe = strcat(verbe, terminaisons[i]); // auquel on colle une a une les terminaisons
			printf("%s", verbe);
			int longueur = strlen(verbe); // et puis on prepare l'arrivée de la suivante
			switch (i) // en ne retenant que le radical
			{
				case 0 : verbe[longueur - 4] = '\0'; break;
				case 1 : verbe[longueur - 4] = '\0'; break;
				case 2 : verbe[longueur - 3] = '\0'; break;
				case 3 : verbe[longueur - 5] = '\0'; break;
				case 4 : verbe[longueur - 4] = '\0'; break;
				case 5 : verbe[longueur - 5] = '\0'; break;
				default : break;
			}
			printf("\n");
		}
	}

	if (type == 2)
	{
		char terminaisons[6][6] = { "irai", "iras", "ira", "irons", "irez", "iront"}; // les terminaisons 2eme groupe
		int i;
		verbe[strlen(verbe)-2]='\0'; // on se debarasse de la terminaison pour former le radical
		for (i = 0; i < 6; i++)
		{
			printf("%s", pronoms[i]);
			printf("\t:");
			verbe = strcat(verbe, terminaisons[i]); // auquel on colle une a une les terminaisons
			printf("%s", verbe);
			int longueur = strlen(verbe); // et puis on prepare l'arrivée de la suivante
			switch (i) // en ne retenant que le radical
			{
				case 0 : verbe[longueur - 4] = '\0'; break;
				case 1 : verbe[longueur - 4] = '\0'; break;
				case 2 : verbe[longueur - 3] = '\0'; break;
				case 3 : verbe[longueur - 5] = '\0'; break;
				case 4 : verbe[longueur - 4] = '\0'; break;
				case 5 : verbe[longueur - 5] = '\0'; break;
				default : break;
			}
			printf("\n");
		}
	}

	remakeVerbe(verbe, type); // pour enfin rendre a notre radical sa vieille terminaison
}

int main()
{
	char verbe[MAX]="finir";
	present(verbe);
	printf("\n");
	imparfait(verbe);
	printf("\n");
	futurSimple(verbe);
	return EXIT_SUCCESS;
}

dans l'attente de vos remarques, sincères salutations les amis

<< 1 2