########################################################################################
# SUJET 1
########################################################################################
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef enum {false = 0, true = 1} tbool;
typedef unsigned char uchar;
typedef unsigned long long ullong;


void AfficherTab(uchar T[], uchar n){
  printf("T=[ ");
  for (size_t i = 0; i < n; i++)
    printf("%u ",T[i]);
  printf("]\n");
}

// RAS
uchar Incrementer(uchar T[], uchar n, uchar b){
  uchar i = 0;
  // ON REMET A ZERO SI PLUS GRAND CHIFFRE DE LA BASE  
  while ((i < n) && (T[i] == b - 1))
    T[i++] = 0;
  // ON INCREMENTE LE DERNIER CHIFFRE
  if (i < n)
    T[i]++;
  return i + 1;
}

// IL SUFFIT D'INCREMENTER LE TABLEAU
// [0,...,0] JUSQU'A ATTEINDRE [b-1,b-1,...,b-1]
// ATTENTION! POUR CETTE DERNIERE INSTANCE
// ON COMPTE LA RETENUE DONC n + 1 MODIFS
ullong Totaliser(uchar n, uchar b, ullong *card) {
  uchar *T = calloc(n, sizeof(T[0]));
  ullong total = 0;
  tbool continuer = true;  
  *card = 0;
  
  while (continuer) {
    (*card)++;
    uchar i = 0;
    while ((i < n) && (T[i] == (b - 1)))
      T[i++] = 0;
    if (i < n)
      T[i]++;
    else 
      continuer = false;
    total += (i + 1);    
  }  
  free(T);
  return total;
}

// RAS
int main(int argc, char *argv[]) {
  if (argc < 3) {
    printf("Syntaxe: %s <taille> <base>\n", argv[0]);
    return 1;
  }
  
  char *endptr;
  uchar n = (uchar) strtoul(argv[1],&endptr,10);    
  if (*endptr != '\0') {
    printf("Entrée %s invalide\n", argv[1]);
    return 1;
  }
  
  uchar b = (uchar) strtoul(argv[2],&endptr,10);    
  if (*endptr != '\0') {
    printf("Entrée %s invalide\n", argv[2]);
    return 1;
  }
  printf("Taille = %u, Base = %u\n",n,b);
  
  
  uchar *T = calloc(n,sizeof(T[0]));
  AfficherTab(T,n);
  uchar nbc = Incrementer(T,n,b);
  AfficherTab(T,n);
  for (uchar i = 0; i < n; i++)
    T[i] = b - 1;
  AfficherTab(T,n);
  nbc = Incrementer(T,n,b);
  AfficherTab(T,n);  
  free(T);    
  printf("Nb de cellules modifiées = %u\n",nbc);
  ullong card = 0;
  ullong nbmodifs = Totaliser(n,b,&card);
  printf("\n\nNb cellules modifiés = %llu  (n = %u => card = %llu)\n",nbmodifs, n, card);

  // Calcul de la moyenne théorique et pratique
  long double ratiop = (long double) nbmodifs/ (long double) card;
  long double ratiot = ((long double)b / ((long double)b-1)) - (1 / (powl(b,n)*(b-1)));
  printf("Nb théorique moyen de cellules modifiées = %Lf\n", ratiot);
  printf("Nb pratique moyen de cellules modifiées  = %Lf\n", ratiop);    
  return 0;
}

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

typedef enum {false = 0, true = 1} tbool;
typedef char * tmot;

// ON AVANCE TANT QUE SYMBOLES IDENTIQUES
tbool EstPrefixe(tmot pre, tmot mot){
  size_t i = 0;
  while ((i < strlen(pre)) && (i < strlen(mot)) && pre[i] == mot[i])
    i++;
  return (i >= strlen(pre));
}

// RAS
int main(int argc, char *argv[]) {
  if (argc < 3) {
    printf("Syntaxe: %s <mot1> <mot2>\n", argv[0]);
    return 1;
  }

  char *pre = argv[1];
  char *mot= argv[2];
  if (EstPrefixe(pre, mot))
    printf("%s est un préfixe de %s\n",pre,mot);
  else
    printf("%s n'est pas un préfixe de %s\n",pre,mot);
  return 0;
}

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

typedef enum {false = 0, true = 1} tbool;
typedef char *tmot;

// ON AVANCE TANT QUE LES CARACTERES SONT IDENTIQUES
tbool EstBienParenthesee(tmot expression){
  unsigned int n = strlen(expression);
  int RPS = 0;
  size_t i =0;
  
  while ((i < n) && !(RPS < 0)){
    if (expression[i] == '(')
      RPS++;
    else if (expression[i] == ')')
      RPS--;
    i++;
  }
  return (RPS == 0);
}


// RAS
int main(int argc, char *argv[]) {
  if (argc < 2) {
    printf("Syntaxe: %s <\"expression\">\n", argv[0]);
    return 1;
  }
  
  char *expression = argv[1];
  
  if (EstBienParenthesee(expression))
    printf("\"%s\" est bien parenthésée\n",expression);
  else
    printf("\"%s\" n'est pas bien parenthésée\n",expression);
  return 0;
}