Adloun

algorithmique (école d'ingénieur) · Chapitre 11 · Application directe du cours

Exponentiation rapide

Programmes justes : logique de Hoare et invariants · niveau 2

Énoncé

  • Dérouler puissance(2, 21) en donnant les valeurs successives de .
  • Montrer que le nombre de tours de boucle est , où est le nombre de chiffres de en base et son nombre de chiffres « 1 » ().
  • Adapter la fonction pour calculer sans dépassement de capacité lorsque , en énonçant l'invariant. Calculer .

Corrigé

  • Avec en binaire :

(p, x, e) = (1, 2, 21)
(p, x, e) = (2, 2, 20)
(p, x, e) = (2, 4, 10)
(p, x, e) = (2, 16, 5)
(p, x, e) = (32, 16, 4)
(p, x, e) = (32, 256, 2)
(p, x, e) = (32, 65536, 1)
(p, x, e) = (2097152, 65536, 0)
tours = 7

On vérifie à chaque ligne .

  • Un tour « pair » supprime le dernier chiffre binaire de (un ) ; un tour « impair » transforme le dernier chiffre en . Chaque chiffre coûte donc un tour impair, et chaque chiffre sauf le premier coûte un tour pair (le dernier , celui de tête, fait passer à sans division). Total : tours, entre et . Par exemple : tours ; : tours ; ( chiffres, sept « 1 ») : tours.
  • Invariant : , avec . Comme , le produit tient dans un long (moins de ) :

static long puissanceMod(long a, long b, long m) {
    long p = 1 % m, x = a % m, e = b; // a^b ≡ p × x^e (mod m)
    while (e != 0) {                  // a^b ≡ p × x^e (mod m) et e ≠ 0
        if (e % 2 == 0) { x = x * x % m; e = e / 2; }
        else            { p = p * x % m; e = e - 1; }
    }                                 // a^b ≡ p × x^0 = p (mod m)
    return p;
}

puissanceMod(3, 1000000, 1000) retourne , en tours au lieu d'un million de multiplications.

100 % gratuit

La suite du chapitre est sur Adloun

Exercice suivant et tuteur

Sans compte : le cours et le premier QCM. Exercices et tuteur : inscription gratuite en 30 secondes, sans carte bancaire.

Le cours du chapitre · Tous les exercices du chapitre

Exercice suivant et tuteur →