--------------------------------------------
Exercice 1
--------------------------------------------
Un exercice tres elementaire - on compte les
occurrences de v entre les cases de rang 0 et
n - 2 inclus. 

int occs_non_finales(int *t, int n, int v) {
  int i, k = 0;
  for (i = 0; i < n - 1; i++)
    if (t[i] == v) 
      k++;
  return k;
}

on alloue ensuite un tableau dont la taille
est donnee par la fonction precedente. On 
parcourt t, en copiant dans ce tableau les
valeurs qui succedent a chacune des occurrences 
de v dans t :

int *succ_occs(int *t, int n, int v) {
   int *u, i, j = 0;
   u = malloc(occ_non_finales(t, n, v) * sizeof(int));
   for (i = 0; i < n - 1; i++) {
      if (t[i] = v) {
         u[j] = t[i+1];
         j++;
      }
   }
   return u;
} 
	
--------------------------------------------
Exercice 2
--------------------------------------------
La premiere valeur cherchee est forcement
t[0]. A partir de la case 1, on compare les
valeurs a cette valeur de reference. A la
premiere valeur differente de t[0], on leve un 
drapeau (svt pour "valeur suivante trouvee")
et on memorise cette valeur (sv, "valeur 
suivante"). Une fois svt egal a 1, chaque 
nouvelle valeur lue doit etre egale a t[0] 
ou a sv.

int bivalue(int *t, int n) {
  int i, svt = 0, sv;
  if (n <= 1)
    return 0;
  for (i = 1; i < n; i++) {
    if (svt == 0 && t[i] != t[0]) {
      svt = 1;
      sv  = t[i];
    }
    else if (t[i] != t[0] && t[i] != sv) 
      return 0;
  }
  return svt == 1;
}
--------------------------------------------
Exercice 3
--------------------------------------------
Voici une solution en deux fonctions, comme
le suggerait l'enonce. La fonction suivante
verifie que s, de longeur ls, est periodique
de periode lp.

(1) si la chaine est vide, la periode doit
etre nulle. sinon, c'est-a-dire si la chaine
est non vide :
(2) la periode ne doit pas etre nulle, 
(3) et la longueur de la chaine doit etre
un multiple de lp.
(4) si la chaine est de longueur lp, elle
est periodique de periode lp.
(5) sinon, elle est de longueur au moins
2 * lp (a cause du test (3)). Les caracteres
de s[0 ... lp-1] et s[lp... lp + lp -1]...
(6) ... et la chaine commencant a la position
lp doit etre periodique de periode lp.

int periodique(char *s, int ls, int lp) {
  int i;
  if (ls == 0)        // (1)
    return lp == 0;
  if (lp <= 0)        // (2)
    return 0;
  if (ls % lp != 0)   // (3)
    return 0;
  if (ls == lp)       // (4) 
    return 1;
  for (i = 0; i < lp; i++)  // (5)
    if (s[i] != s[i + lp]) 
      return 0;  
  return periodique(s + lp, ls - lp, lp); // (6)
}

On teste ensuite simplement toutes les periodes 
possibles.

int periode(char *t) {
  int lt = strlen(t), lp;
  for (lp = 0; lp < lt; lp++) {
    if (periodique(t, lt, lp))
      return lp;
  }
  return lt;
}

--------------------------------------------
Exercice 4
--------------------------------------------
Un exercice nettement plus dur, et indique
comme tel.

(1) on calcule la longueur de la chaine - en
verifiant au passage qu'il n'y a pas de ligne
vide (mais cette precaution etait inutile avec
les hypotheses de l'enonce).
(2) on effectue le traitement principal - la
variable j est placee sur le marqueur de fin
a la fin de la boucle (1), la variable i est
placee au debut de la premiere ligne (en 0).
le traitement dure tant que i n'a pas depasse j.
(3) on recule j jusqu'a un debut de ligne.
(4) les caracteres en i et j doivent etre
egaux.
(5) on avance i jusqu'a un debut de ligne.

int acropal(char *s) {
  int i = 0, j;
  for (j = 0; s[j] != '\0'; j++) {      // (1)
    if (s[j] == '\n' && s[j + 1] == '\n')
      return 0;
  }
  if (j == 1)                    
    return 0;
  while(i < j) {                        // (2)
    do 
      j--;
    while (j > 0 && s[j - 1] != '\n');  // (3)
    if (s[i] != s[j])                   // (4)    
      return 0;
    do                                  // (5)
      i++;
    while (s[i - 1] != '\n');           
  }
  return 1;
}

--------------------------------------------
Exercice 5
--------------------------------------------
Un exercice tres facile - il suffit de creer
une nouvelle cellule de clef n, et de la 
cabler correctement.

struct cell *inserer_succ(struct cell *pc, int n) {
   struct cell *pcn;
   if (pc == NULL)
      return NULL;
   pcn = malloc(sizeof(struct cell));
   pcn -> clef = n
   pcn -> suiv = inserer_succ(pc -> suiv);
   pc  -> suiv = pcn;
} 



--------------------------------------------
Exercice 6
--------------------------------------------
Un exercice plutot facile. Si l'une des deux 
listes est vide, l'alternance est simplement 
formee de l'autre liste. Sinon, on recable la 
premiere cellule de pc1 a la premiere cellule 
de pc2, et l'on recable la premiere cellule 
de pc2 a l'alternance des deux listes privees 
de leurs premieres cellules.

struct cell *alternance(struct cell *pc1, 
                        struct cell *pc2) {
  if (pc1 == NULL)
    return pc2;
  if (pc2 == NULL)
    return pc1;
  pc2 -> suiv = alternance(pc1 -> suiv, 
                           pc2 -> suiv);
  pc1 -> suiv = pc2;
  return pc1;
}