// =====================================================================
//  TP1 S5 2026 — CC1
// =====================================================================
//  Template à compléter.
//
//  Pour tester l'exercice N, compilez puis exécutez :
//      g++ tp1_s5_2026.cpp -DEXO<N> -o exo<N> && ./exo<N>
//
//  Exemple pour l'exercice 1 :
//      g++ tp1_s5_2026.cpp -DEXO1 -o exo1 && ./exo1
//
//  Ne modifiez PAS les fonctions main() de test : elles servent à la
//  correction. Complétez uniquement le corps des fonctions demandées.
// =====================================================================

#include <iostream>
#include <cassert>
#include <cstring>
using namespace std;

// =====================================================================
//  EXO 1 — multiply
// =====================================================================
#ifdef EXO1
int multiply(int a, int b) {
    // TODO: compléter
    return 0;
}

int main() {
    assert(multiply(3, 4) == 12);
    assert(multiply(-2, 5) == -10);
    assert(multiply(0, 100) == 0);
    cout << "EXO1 OK" << endl;
    return 0;
}
#endif

// =====================================================================
//  EXO 2 — tab_product
// =====================================================================
#ifdef EXO2
int tab_product(int n, int *tab) {
    // TODO: compléter
    return 0;
}

int main() {
    int tab[5] = {1, 2, 3, 4, 5};
    assert(tab_product(5, tab) == 120);
    int tab2[3] = {2, 3, 4};
    assert(tab_product(3, tab2) == 24);
    cout << "EXO2 OK" << endl;
    return 0;
}
#endif

// =====================================================================
//  EXO 3 — tab_min
// =====================================================================
#ifdef EXO3
int tab_min(int n, int *tab) {
    // TODO: compléter
    return 0;
}

int main() {
    int tab[5] = {3, 1, 4, 1, 5};
    assert(tab_min(5, tab) == 1);
    int tab2[3] = {7, 2, 9};
    assert(tab_min(3, tab2) == 2);
    cout << "EXO3 OK" << endl;
    return 0;
}
#endif

// =====================================================================
//  EXO 4 — tab_min avec indice
// =====================================================================
#ifdef EXO4
int tab_min(int n, int *tab, int &i) {
    // TODO: compléter
    return 0;
}

int main() {
    int tab[5] = {3, 5, 1, 4, 2};
    int i;
    int min = tab_min(5, tab, i);
    assert(min == 1);
    assert(i == 2);
    cout << "EXO4 OK" << endl;
    return 0;
}
#endif

// =====================================================================
//  EXO 5 — tab_min avec tous les indices
// =====================================================================
#ifdef EXO5
int tab_min(int n, int *tab, int &size_idmin, int *idmin) {
    // TODO: compléter
    return 0;
}

int main() {
    int tab[5] = {3, 1, 5, 1, 2};
    int idmin[5];
    int size_idmin;
    int min = tab_min(5, tab, size_idmin, idmin);
    assert(min == 1);
    assert(size_idmin == 2);
    assert(idmin[0] == 1);
    assert(idmin[1] == 3);
    cout << "EXO5 OK" << endl;
    return 0;
}
#endif

// =====================================================================
//  EXO 6 — gestion de tableau
// =====================================================================
#ifdef EXO6
const int SIZE = 10;

void zero_tab(int *tab) {
    // TODO: compléter
}

void put_tab(int *tab, int i, int v) {
    // TODO: compléter
}

int get_length(int *tab) {
    // TODO: compléter
    return 0;
}

void remove_zeros(int *tab) {
    // TODO: compléter
}

void display_tab(int *tab) {
    // TODO: compléter
}

int main() {
    int tab[SIZE];

    zero_tab(tab);
    assert(tab[0] == 0);
    assert(tab[SIZE - 1] == 0);

    put_tab(tab, 0, 2);
    put_tab(tab, 2, 4);
    put_tab(tab, 4, 6);
    put_tab(tab, 8, 8);

    assert(get_length(tab) == 9);

    remove_zeros(tab);
    assert(tab[0] == 2);
    assert(tab[1] == 4);
    assert(tab[2] == 6);
    assert(tab[3] == 8);
    assert(tab[4] == 0);

    display_tab(tab);
    cout << "EXO6 OK" << endl;
    return 0;
}
#endif

// =====================================================================
//  EXO 7 — fibonacci
// =====================================================================
#ifdef EXO7
// (a) fibonacci récursive
int fibonacci(int n) {
    // TODO: compléter (récursif)
    return 0;
}

// (b) remplit tab[0..n-1] avec les n premiers nombres de Fibonacci
//     (utiliser la fonction fibonacci de la question (a))
void tabfibonacci(int n, int *tab) {
    // TODO: compléter
}

int main() {
    assert(fibonacci(0) == 0);
    assert(fibonacci(1) == 1);
    assert(fibonacci(7) == 13);

    int tab[8];
    tabfibonacci(8, tab);
    assert(tab[0] == 0);
    assert(tab[1] == 1);
    assert(tab[7] == 13);
    cout << "EXO7 OK" << endl;
    return 0;
}
#endif

// =====================================================================
//  EXO 8 — factorielles
// =====================================================================
#ifdef EXO8
int factorielle(int n) {
    // TODO: compléter
    return 0;
}

// res[i] doit contenir la factorielle de i : res[0] = 0! = 1, res[1] = 1! = 1, ...
int *factorielles(int n) {
    // TODO: compléter
    return nullptr;
}

int main() {
    int n = 6;
    int *fact = factorielles(n);
    assert(fact[0] == 1);
    assert(fact[1] == 1);
    assert(fact[2] == 2);
    assert(fact[3] == 6);
    assert(fact[4] == 24);
    assert(fact[5] == 120);
    delete[] fact;
    cout << "EXO8 OK" << endl;
    return 0;
}
#endif

// =====================================================================
//  EXO 9 — fast_fibonacci
// =====================================================================
#ifdef EXO9
int *fast_fibonacci(int n) {
    // TODO: compléter
    return nullptr;
}

int main() {
    int n = 10;
    int *fib = fast_fibonacci(n);
    assert(fib[0] == 0);
    assert(fib[1] == 1);
    assert(fib[5] == 5);
    assert(fib[9] == 34);
    delete[] fib;
    cout << "EXO9 OK" << endl;
    return 0;
}
#endif

// =====================================================================
//  EXO 10 — chiffre de César
// =====================================================================
#ifdef EXO10
// Rappel : un char est un entier ; 'b' == 'a' + 1 ; position d'une lettre : s[i] - 'a'
char *cesar(char *s, int shift) {
    // TODO: compléter
    return nullptr;
}

int main() {
    char s[] = "vive le chiffre de cesar";
    char *t = cesar(s, 3);
    assert(strcmp(t, "ylyh oh fkliiuh gh fhvdu") == 0);
    delete[] t;
    cout << "EXO10 OK" << endl;
    return 0;
}
#endif

// =====================================================================
//  TP à la maison — rapport (voir sujet, section « TP à la maison »)
// =====================================================================
//  Si le TP est fait à la maison, complétez le rapport ci-dessous,
//  écrit en markdown dans ce commentaire. Si le TP a été fait en
//  salle, laissez cette section telle quelle.
// =====================================================================
/*
# Rapport — TP à la maison

## 1. Usage de l'IA

J'ai utilisé une IA : **oui / non** (préciser laquelle : ChatGPT, Copilot, ...).

Prompts employés :

- « ... »
- « ... »

Ce que l'IA a apporté / ce que j'ai fait moi-même : ...

## 2. Installation du système de programmation C++

- Système d'exploitation : ...
- Éditeur de texte utilisé : ...
- Installation du compilateur `g++` (commandes utilisées) : ...
- Sortie de la commande `g++ --version` :

```
(coller ici la sortie de la commande)
```

## 3. Tests des programmes

- Commande de compilation utilisée : ...
- Résultats des tests (sorties des programmes `exo1`, `exo2`, ...) : ...
- Difficultés rencontrées : ...
*/