/*-----------------------------------------------------*/
/*Ecriture sur la sortie standard, redirection UNIX etc*/
/*------------ Laure Gonnord, novembre 2004 -----------*/
/*-----------------------------------------------------*/

#include <stdio.h>
#define N 1000
#define VRAI 1
#define FAUX 0

/*pour une ligne*/
void mange_ligne_et_reecrit(void)
{
  char c;
  c = getchar();

  while (c != '\n')
    {
      putchar(c);
      c=getchar();
    }
  putchar('\n');
}

/*lecture/ecriture jusqu'a fin de fichier*/
void mange_et_reecrit(void)
{
  char c;
  c = getchar();
  while ( c != EOF ) 
    {
      putchar(c);
      c = getchar();
    }
}


/*compte le nombre de passages a la ligne*/
int compte_sauts_ligne(void)
{
  char c;
  int cpt = 0;
  c = getchar();
  while ( c != EOF ) 
    {
      if (c == '\n') { cpt++;};
      c = getchar();
    }
  return cpt;
}


/*avance et mange jusqu'au premier blanc rencontré*/
/*retourne le premier blanc ou EOF*/
char manger_mot(void)
{
  char c = getchar();
  while ((c != ' ') && (c != '\t') && (c != '\n') && (c!= EOF))
    {
      c = getchar();
    }
  return c;
}


/*avance et mange tous les blancs, retourne le premier caractère non blanc*/
char manger_blancs(void)
{
  char c = getchar();
  while ((c == ' ') || (c == '\t') || (c == '\n'))
    {
      c = getchar();
    }
  return c;
}


/*compte le nb de mots*/
/*attention, ce n'est pas le nb de caractères egaux à ' '*/
int compte_mots(void)
{
  char c; 
  int cpt = 0;

  c = manger_blancs();

  while (c != EOF)
    {
      c = manger_mot();
      cpt++ ; /*on est certain qu'il y a eu un mot*/
      if (c!= EOF) 
	/*dans le cas où l'on n'a pas atteint eof, on mange les blancs*/
	{
	  c = manger_blancs();
	}
    }
  return cpt;
}

/*écrit à l'envers (tito --> otit*/
/*on enregistre les caracteres dans un tableau, */
  /* et ensuite on imprime a l'envers*/
void retourne(void)
{
  char t[N];
  int j;
  int i=0; /*compte le nb de caracteres lus*/
  char c = getchar();

  while (c != EOF)
    {
      t[i] = c;
      c = getchar();
      i++;
    }
  /*a ce stade on a rempli avec les caracteres du texte*/

  for (j=i-1 ; j>=0 ; j--)
    { 
      putchar(t[j]);
    }  
}


/*mange un mot de taille <N et le stocke dans la i-eme ligne du tableau
  passé en parametre*/
/*on passe le premier caractere du mot en parametre, car on l'a eu avant...*/
char stocker_mot(char cc, char t[N][N], int i)
{
  int j=0;
  char c = cc;
  while ((c != ' ') && (c != '\t') && (c != '\n') && (c!= EOF))
    {
      t[i][j] = c;
      c = getchar();
      j++;
    }
  t[i][j] = '\0';
  return c;
}

/*imprime le ieme mot*/
void imprimer_mot(char t[N][N], int i)
{
  char c = t[i][0];
  int j=0;
  while (c != '\0')
    {
      putchar(c);
      j++;
      c = t[i][j];
    }
}

/*initialisation d'un tableau de chaines*/
void initialiser(char t[N][N])
{
  int i;
  for (i=0;i<N;i++)
    {
      t[i][0] = '\0';
    }
}


/*ecrit les mots du texte dans l'ordre inverse*/
/* on se fiche des blancs*/
void mots_za_lenvers(void)
{
  char t[N][N];
  int i = 0; /*compteur du nb de mots*/
  int j; /*var de boucle decroissante*/
  char c;
  int continuer = VRAI;

  initialiser(t);
  /*on stocke tous les mots dans le tableau t*/
  /*ligne par ligne*/
  c = manger_blancs();
  if (c != EOF) /* si le fichier n'est pas vide*/
    {
      while(continuer)
	{
	  c = stocker_mot(c,t,i);
	  i = i+1;
	  if (c != EOF)
	    {
	      c = manger_blancs();
	      if (c == EOF)
		{
		  continuer = FAUX;
		} 
	    }
	  else 
	    {
	      continuer = FAUX;
	    }
	}
    }
  /*on fait l'impression mot par mot*/

  for (j=i;j>=0;j--)
    {
      imprimer_mot(t,j);
      printf(" "); /*un unique espace entre chaque mot*/
    }
}

/*on suppose que le fichier ne contient que des caractères a --> z*/
/*on utilise un tableau dejaVu dont le but est d'avoir 1 si la lettre*/
/*est apparue. Ensuite on parcourt ledit tableau*/
void liste_et_imprime_non_apparues(void)
{
  int i;
  char c; int dejaVu[26];
  /*initialisation de dejaVu*/
  for (i=0;i<26;i++)
    {
      dejaVu[i]=0;
    }
  /*parcours du texte*/
  c=getchar();
  while (c !=EOF)
    {
      dejaVu[c-97] = 1;
      c = getchar();
    }

  /*impression des resultats*/
  for (i=0;i<26;i++)
    {
      if (dejaVu[i] == 0)
	{
	  printf("%c, ",i+97); 
	  /*il y aura une virgule de trop à la fin*/
	  /*comment faire pour que cela n'arrive pas ?*/
	}
    }
  printf("\n");
}

/*dans un premier temps, on stocke les caractères du fichier*/
/*ensuite, on teste si le tableau obtenu est un palindrome*/
int est_palindrome(void)
{
  char stock[N];
  int i=0;
  int j,k;
  char c;

  /*je stocke les caracteres utiles du texte*/
  c = getchar();
  while (c != EOF)
    {
      if ((c>=97) && (c<=122)) /*caractere entre a et z */
	{
	  stock[i] = c;
	  i = i+1;
	}
      c = getchar();
    }

  j=i-1; /*indice du dernier caractere valide dans stock*/
  /*parcours du tableau stock*/

  for (k=0;k<j/2;k++)
    {
      if (stock[k] != stock[j-k])
	{
	  return FAUX;
	}
    }
  /*si je suis ici, cela signifie que c'est un palindrome*/
  return VRAI;
}

/*anagrammes*/
int sont_anagrammes(char mot1[N], char mot2[N])
{
  int res = VRAI;
  int i;
  
  /*A FAIRE*/

  return res;
}


/*renvoie VRAi si identiques, FAUX sinon*/
int compare_mots(char mot1[N], char mot2[N])
{
  int i=0;
  int res = FAUX;
  int continuer = VRAI;
  while ((i<N) && continuer)
    {
      if (mot1[i] == '\0' && mot2[i] == '\0')
	{
	  res = VRAI ; continuer = FAUX;
	}
      else
	{
	  if (mot1[i] != mot2[i])
	    {
	      res = FAUX ; continuer = FAUX;
	    }
	  else
	    {
	      i = i+1;
	    }
	}
    }
  return res;
}

/*recherche d'un motif. On va stocker les mots un par un, et au fur et à 
  mesure regarder si le mot est celui cherché*/
int cherche_motif(char motif[N])
{
  char c;   int i;
  char mot_courant[N]; /*mot du texte en cours d'analyse*/
  int continuer = VRAI; /*si on a trouvé le motif ou EOF, on s'arrête*/
  int res;
  int j;

  while (continuer)
    {
      i=0;
      /* je mange les blancs, c recupere le 1er non blanc*/
      c = manger_blancs(); 

      /*je mets à jour le mot courant*/
      while ( (c !=' ') && (c !='\t') && (c !='\n') && (c!= EOF))
      {
	mot_courant[i] = c;
	i++;
	c = getchar();
      }
      mot_courant[i] = '\0';


      /*si on a trouvé le motif*/
      if (compare_mots(mot_courant,motif))
	{
	  continuer = FAUX; res = VRAI; /*stop, et res VRAI*/
	}
      else
	{
	  if (c== EOF) 
	    /*je n'ai pas trouve le motif et je suis à la fin du fichier*/
	    {
	      continuer = FAUX; res = FAUX;
	    }
	}
    }
  return res;
}


/*codage de césar*/
void codage_cesar(void)
{
  char c;char d;
  c = getchar();
  while ( c != EOF ) 
    {
      if ((c>=97) && (c<=109))
	{
	  putchar(c+13);
	}
      else 
	{
	  if ((c>=110) && (c<=122))
	    {
	      putchar(c-13);
	    }
	  else
	    {
	    putchar(c);
	    }
	}
      c = getchar();
    }
}

/*parentheses*/
/* on prend un compteur qui diminue avec une fermante, augmente avec une */
/* ouvrante. Si on passe dans les négatifs, c'est perdu. Si à la fin cpt  */
/* est 0, c'est gagné  */
int est_bien_parenthese(void)
{
  int cpt=0;
  char c;
  
  c = getchar();
  while ( (c != EOF) && (cpt>=0)) 
    {
      if (c =='(') {cpt++;}
      else
	{
	  if (c == ')') {cpt--;}
	}
      c = getchar();
    }
  if (cpt ==0)
    {
      return VRAI;
    }
  else
    {
      return FAUX;
    }
}



/* Pour les mots interdits, la flemme me gagne, disons que l'on stockerait les */
/* mots interdits dans un tableau de charactères 2d (chaque ligne représente un */
/* mot. Ensuite, il faut modifier très peu le programme de recherche de motif */
/* (au lieu de s'arrêter si on a trouvé, il faut écrire des étoiles ; dans les  */
/* cas ou le mot lu n'est pas un mot cherché, il faut recopier le mot tel quel) */

int main(void)
{
  int nb;
  char mot[N];
  
  mange_et_reecrit();
  
  nb = compte_sauts_ligne();
  nb = compte_mots();
  printf("%d\n",nb);
  
  retourne();
  mots_za_lenvers();
  
  liste_et_imprime_non_apparues();
  
  if (est_palindrome()) {printf("oui\n");} else {printf("non\n");};

  if (sont_anagrammes("marine","irmane")) {printf("oui\n");} else {printf("non\n");}
  
  mot[0]='p';
  mot[1]='l';
  mot[2]='o';
  mot[3]='u';
  mot[4]='f';
  mot[5]='\0';
  if (cherche_motif(mot)) {printf("oui\n");} else {printf("non\n");}
  
  
  codage_cesar();

  if (est_bien_parenthese()) {printf("oui\n");} else {printf("non\n");};
  
  return 0;
}