C — Tableaux et chaînes de caractères

Idée : on retient un « champion » provisoire, initialisé à la première case, puis on le remplace dès qu'on voit plus grand.

int maximum(int t[], int n) {
    int m = t[0];                  // champion = 1re case
    for (int i = 1; i < n; i++) {  // on commence à 1 : t[0] est déjà pris
        if (t[i] > m) {
            m = t[i];              // nouveau champion
        }
    }
    return m;
}

Pourquoi partir de t[0] et de i = 1 ? Initialiser à 0 serait faux si toutes les valeurs étaient négatives. On prend donc un élément qui existe vraiment. Comme t[0] est déjà le champion de départ, la boucle commence à l'indice 1.

Déroulé sur {4, 9, 2, 7} : m = 4. i=1 : 9 > 4 → m = 9. i=2 : 2 > 9 ? non. i=3 : 7 > 9 ? non. Résultat : 9. Coût : un seul parcours, $O(n)$.

On parcourt la chaîne jusqu'au caractère nul en incrémentant un compteur à chaque case égale à c.

int compte(char s[], char c) {
    int n = 0;
    for (int i = 0; s[i] != '\0'; i++) {  // arrêt sur le caractère nul
        if (s[i] == c) {
            n = n + 1;
        }
    }
    return n;
}

La condition d'arrêt est s[i] != '\0', pas un i < n : pour une chaîne, on ne connaît pas la taille d'avance, c'est la sentinelle qui borne le parcours. Comparer des char avec == est correct (un char est un petit entier).

Résultats. "banane" = b a n a n e : le 'a' apparaît aux indices 1 et 3, donc compte("banane", 'a') vaut 2. Le mot a 6 lettres ; avec le caractère nul il occupe 7 cases.

Idée : échanger la première case avec la dernière, la deuxième avec l'avant-dernière, etc. On avance avec un indice i et sa case symétrique n - 1 - i.

void inverse(int t[], int n) {
    for (int i = 0; i < n / 2; i++) {   // jusqu'au milieu seulement
        int tmp = t[i];                 // sauvegarde temporaire
        t[i] = t[n - 1 - i];            // la case symétrique arrive à gauche
        t[n - 1 - i] = tmp;             // et la sauvegarde part à droite
    }
}

Pourquoi i < n / 2 et pas i < n ? Si on allait jusqu'au bout, on ré-échangerait chaque paire une seconde fois et on retomberait sur le tableau de départ ! On ne traite donc que la première moitié. La case symétrique de l'indice i est n - 1 - i.

Pourquoi la variable tmp ? Sans elle, t[i] = t[n-1-i] écraserait la valeur de t[i] avant qu'on ait pu la déplacer : on la sauvegarde d'abord.

Déroulé sur {10, 20, 30, 40, 50} : n = 5, donc n / 2 = 2 (division entière), i prend les valeurs 0 et 1. i=0 : échange t[0] et t[4] → {50, 20, 30, 40, 10}. i=1 : échange t[1] et t[3] → {50, 40, 30, 20, 10}. La case centrale t[2] = 30 ne bouge pas. On a fait 2 échanges.