Calculatrice en mode examen et Python

À l'écrit de l'E3, la calculatrice est autorisée selon la réglementation des examens : une calculatrice « type collège » sans mémoire, ou une calculatrice graphique dont le mode examen est activé dans la salle, à la demande du surveillant. Pour l'algorithmique, aucun langage n'est imposé ; en pratique, la plupart des sections travaillent en Python. Ce chapitre donne les règles, la manipulation du mode examen sur les modèles les plus courants, les fonctions utiles pour l'E3 et une petite boîte à outils Python pour vérifier tes résultats.

Ce que dit la réglementation

L'usage des calculatrices aux examens est fixé par la circulaire n° 2015-178 du 1er octobre 2015 (Bulletin officiel n° 42 du 12 novembre 2015), dont le mode examen s'applique aux examens depuis la session 2020, et qui est toujours citée par les circulaires d'organisation des BTS. Deux familles de calculatrices sont autorisées :

• les calculatrices non programmables sans mémoire alphanumérique, les modèles « type collège » ;
• les calculatrices avec mémoire alphanumérique ou écran graphique qui disposent d'un mode examen, à condition de l'activer.

Le mode examen bloque ou efface tout ce que contient la mémoire (programmes, fichiers, notes) pendant l'épreuve, et le signale par une diode qui clignote sur la tranche haute de la calculatrice. Une graphique sans mode examen, une calculatrice dont tu ne sais pas activer le mode examen, un téléphone ou une montre connectée ne sont pas autorisés.

Le jour de l'épreuve :

1. Tu arrives avec ta calculatrice éteinte, mode examen non activé : le surveillant vérifie que la diode ne clignote pas.
2. Le surveillant annonce l'activation : tu actives le mode examen devant lui.
3. Il vérifie que toutes les diodes clignotent, puis distribue les sujets.
4. Tu n'utilises qu'une seule calculatrice. Si elle tombe en panne, tu demandes au surveillant l'autorisation d'en changer.

Le sujet indique toujours si la calculatrice est autorisée. À l'E3, le référentiel l'autorise pour l'écrit de la situation B, et le sujet de l'écrit ponctuel de la session 2026 l'autorisait en mode examen ; en situation A, tu travailles sur un poste informatique fourni par le centre d'examen.

Activer le mode examen

La manipulation tient en quelques touches. Fais-la au moins une fois avant l'examen, par exemple pendant un devoir surveillé, pour ne pas la découvrir le jour J.

Pour un autre modèle, la notice du fabricant décrit la manipulation. Si le mode examen est déjà actif en début d'épreuve, la même manipulation le réinitialise sur la TI-83 Premium CE et la Graph 90+E, devant le surveillant.

Sortir du mode examen demande une connexion : à un ordinateur (logiciel du fabricant ou câble USB selon le modèle) ou à une autre calculatrice de la même marque qui n'est pas en mode examen. Fais-le après l'épreuve pour retrouver tes programmes et économiser la pile.

Les fonctions de la calculatrice utiles à l'E3

L'E3 se fait surtout à la main, mais la calculatrice t'épargne des erreurs de calcul et te permet de vérifier.

• Matrices. Le programme demande les calculs d'ordre 3 ou plus à la calculatrice, y compris une puissance et un inverse.
  • Sur la TI-83 Premium CE, le menu matrice s'ouvre par 2nde puis x⁻¹. Dans l'onglet ÉDIT, choisis [A], saisis la dimension puis les coefficients. Dans l'écran de calcul, insère [A] depuis le même menu : [A]*[B] donne un produit, [A]^3 une puissance, [A] suivi de la touche x⁻¹ l'inverse.
  • Sur la Casio Graph 90+E, dans le menu Exe-Mat, la touche F3 (MAT/VCT) ouvre la liste des matrices, et F3 (DIM) fixe la dimension avant la saisie. Dans l'écran de calcul, OPTN, puis F2 (MAT/VCT) et F1 (Mat) insèrent une matrice : Mat A×Mat B, Mat C^3, Mat E⁻¹.
  • Sur la Casio Graph Math+, les matrices se définissent et se calculent dans le menu Calculs, par la touche VARIABLE (rubrique Matrice).
• Bases de numération. La Graph Math+ a une application Base-N dans son menu HOME. Sur les autres modèles, la façon la plus sûre est l'application Python de la calculatrice (int("2F4A", 16), bin(45), hex(255)).
• Division euclidienne. Une division ordinaire donne un décimal : le quotient est sa partie entière, et le reste se retrouve par r = a − b × q. Ne prends jamais la partie décimale pour le reste.
• Matrices d'adjacence. Une puissance Mᵏ se calcule comme n'importe quelle puissance de matrice. Pour une puissance booléenne, remplace par 1 chaque coefficient non nul du résultat.

Python à l'E3 : ce qui est attendu

Les textes n'imposent aucun langage : selon la définition de l'épreuve, « aucun langage ni formalisme particulier n'est imposé pour l'écriture des algorithmes ». Le programme de mathématiques des BTS invite à privilégier un langage « simple d'utilisation et libre d'installation », et accepté par le centre d'examen : en pratique, c'est le plus souvent Python. Concrètement :

• En situation A, tu programmes sur machine dans le langage travaillé en cours, avec l'aide syntaxique de l'environnement. Aucun formalisme n'est imposé pour écrire tes algorithmes sur table : pseudo-code ou Python, pourvu que ce soit lisible et cohérent.
• À l'écrit, les algorithmes du sujet sont le plus souvent en pseudo-code (« Pour i allant de 1 à n faire », « Tant que… faire », ← pour l'affectation). Tu les complètes dans le même formalisme. On ne te demande pas une syntaxe Python exacte, mais une logique juste.
• Pour réviser, Python sert à vérifier : une conversion, un PGCD, un produit de matrices, une table de vérité, une fermeture transitive. Les cours de chaque module donnent les programmes correspondants, et le cours d'algorithmique les rassemble.

Une boîte à outils Python pour vérifier tes calculs

Ce programme n'utilise que la bibliothèque standard de Python. Lance-le sur ton ordinateur ; chaque ligne affichée est commentée avec le résultat attendu.

# Vérifier un calcul de l'E3 avec Python (bibliothèque standard uniquement)
from itertools import product
from math import gcd

# Bases de numération
print(int("101101", 2))      # 45
print(int("2F4A", 16))       # 12106
print(format(45, "08b"))     # 00101101
print(format(12106, "X"))    # 2F4A
print(bin(45), hex(255))     # 0b101101 0xff

# Division euclidienne, PGCD, congruences
print(divmod(2026, 16))      # (126, 10)
print(gcd(9, 24))            # 3
print(-15 % 26)              # 11 : avec un diviseur positif, le reste est positif ou nul en Python
print(pow(7, -1, 24))        # 7 : inverse de 7 modulo 24 (Python 3.8 et plus)


# Produit et puissance de matrices
def produit(A, B):
    n, p, q = len(A), len(B), len(B[0])
    return [[sum(A[i][k] * B[k][j] for k in range(p)) for j in range(q)] for i in range(n)]


def puissance(M, k):
    R = M
    for _ in range(k - 1):
        R = produit(R, M)
    return R


A = [[2, 1], [5, 3]]
B = [[3, -1], [-5, 2]]
print(produit(A, B))         # [[1, 0], [0, 1]] : B est l'inverse de A

# Table de vérité d'une expression booléenne
for a, b, c in product([0, 1], repeat=3):
    E = (a and b) or c
    print(a, b, c, int(bool(E)))


# Fermeture transitive (algorithme de Roy-Warshall)
def fermeture(M):
    n = len(M)
    F = [ligne[:] for ligne in M]
    for k in range(n):
        for i in range(n):
            if F[i][k]:
                for j in range(n):
                    if F[k][j]:
                        F[i][j] = 1
    return F


M = [[0, 1, 1, 0, 0],
     [0, 0, 1, 1, 0],
     [0, 0, 0, 1, 1],
     [0, 0, 0, 0, 1],
     [0, 0, 0, 0, 0]]
print(puissance(M, 3)[0])    # [0, 0, 0, 1, 3]
for ligne in fermeture(M):
    print(ligne)

Les huit lignes de la table de vérité s'affichent dans l'ordre 000, 001, … 111, et la fermeture transitive donne [0, 1, 1, 1, 1], [0, 0, 1, 1, 1], [0, 0, 0, 1, 1], [0, 0, 0, 0, 1] et [0, 0, 0, 0, 0] : c'est le graphe du sujet corrigé du chapitre 7.

Exercices

def cle(hexa):
    """Reste de la division par 7 d'un nombre écrit en hexadécimal."""
    return int(hexa, 16) % 7


print(cle("2F4A"))   # 3, car (2F4A)₁₆ = 12 106 = 7 × 1 729 + 3
print(cle("7E5"))    # 5, car (7E5)₁₆ = 2 021 = 7 × 288 + 5