########################################################################################
# SUJET 1
########################################################################################

/*
[Algorithmique]
Moderne: on fait plutôt appel à #include <stdbool.h>
qui définit le type bool.
*/
typedef enum { false = 0, true = 1 } tbool;


########################################################################################
# SUJET 2
########################################################################################

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

typedef unsigned int uint;
typedef unsigned char uchar;
typedef enum { false = 0, true = 1 } tbool;


/*
[Algorithmique]
Test de palindrome par comparaison symétrique.
On suppose que la chaîne est déjà "nettoyée"
(ici : concaténation des mots sans espaces).
*/
tbool EstPalindrome(char *phrase) {

    uint n = strlen(phrase);
    uint i = 0;

    while ( (i < n / 2) &&
            (tolower((uchar)phrase[i]) ==
             tolower((uchar)phrase[n - 1 - i])) ) {
        i++;
    }

    return (i >= (n / 2));
}


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

    if (argc < 2) {
        printf("Syntaxe: %s <une phrase>\n", argv[0]);
        return 1;
    }

    /*
    [Algorithmique]
    Les mots sont donnés séparément dans argv.
    On construit la chaîne en les concaténant sans espaces :
    cela revient à ignorer les séparateurs pour le test de palindrome.
    */
    size_t n = 0;
    for (int i = 1; i < argc; i++) 
        n += strlen(argv[i]);

    char *phrase = malloc(n + 1);

    /*
    [Ingénierie logicielle]
    Vérification standard (hors cœur algorithmique).
    */
    if (phrase == NULL)
        return 1;

    phrase[0] = '\0';

    for (int i = 1; i < argc; i++)
        strcat(phrase, argv[i]);

    if (EstPalindrome(phrase)) {
        printf("\"%s\" est un palindrome.\n", phrase);
    } else {
        printf("\"%s\" n'est pas un palindrome.\n", phrase);
    }

    free(phrase);
    return 0;
}



########################################################################################
# SUJET 3
########################################################################################

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

typedef unsigned int uint;
typedef enum { false = 0, true = 1 } tbool;


/*
[Algorithmique]
Fonction de Syracuse.
NB. voir opérateur ternaire z = test ? x : y
*/
uint Syracuse(uint n) {
    return ( (n % 2) != 0 ) ? (3 * n + 1) : (n >> 1);
}


/*
[Algorithmique]
Calcule :
- temps de vol
- plafond (valeur maximale atteinte)
*/
void Vol(uint u, uint *temps, uint *plafond, tbool afficher) {
    *temps = 0;
    *plafond = u;

    while (u != 1) {
        if (afficher) 
            printf("%u %u\n", *temps, u);
        u = Syracuse(u);
        if (u > *plafond)
            *plafond = u;
        (*temps)++;   // parenthèses importantes (priorité des opérateurs)
    }
    if (afficher) 
        printf("%u %u\n", *temps, u);
}


/*
[Algorithmique]
Génération de données pour tracés.
*/
void GenererGraphes(uint n, const char *datat, const char *datap) {
    FILE *ft = NULL; 
    FILE *fp = NULL; 
    
    if ((ft = fopen(datat, "w")) == NULL) {
        fprintf(stderr, "Problème ouverture fichier %s\n", datat);
        exit(1);
    }

    if ((fp = fopen(datap, "w")) == NULL) {
        fprintf(stderr, "Problème ouverture fichier %s\n", datap);
        fclose(ft);
        exit(1);
    }

    for (uint u = 1; u < n; u++) {
        uint temps, plafond;
        Vol(u, &temps, &plafond, false);
        fprintf(ft, "%u %u\n", u, temps);
        fprintf(fp, "%u %u\n", u, plafond);
    }

    fclose(ft);
    fclose(fp);
}


int main(int argc, char *argv[]) {

    if (argc < 2){
        printf("Syntaxe: %s <entier>\n", argv[0]);
        return 1;
    }

    char *endptr;
    uint u = strtoul(argv[1], &endptr, 10);

    /*
    [Ingénierie logicielle]
    Validation minimale de l’entrée.
    */
    if (*endptr != '\0') {
        printf("Entrée %s invalide\n", argv[1]);
        return 1;
    }

    uint plafond = 0;
    uint temps = 0;  

    Vol(u, &temps, &plafond, true);

    printf("Temps et plafond du vol u = %u : %u | %u\n",
           u, temps, plafond);

    GenererGraphes(u, "datat.txt", "datap.txt"); 

    return 0;
}