Aller au contenu principal
ESPRIT VIF
Créer un compte
Se connecterMon compteCréer un compte
Mon compte

BonjourÉlèveParentEnseignant

Se déconnecter

Toutes les disciplines

Informatique

59 compétences réparties sur 3 niveaux du programme français.

59 compétences · 14 domaines

59 leçons complètes sont publiées dans cette discipline

Seconde — 16 compétences · 16 avec exercices

  • Adresses IP, adresses symboliques et DNS

    Difficulté 1 sur 5

    Chaque machine connectée a une adresse IP numérique et hiérarchique (en IPv4, quatre nombres de 0 à 255, soit 32 bits) ; l'utilisateur emploie plutôt des adresses symboliques (noms de domaine) ; le système DNS, réparti sur de nombreux serveurs, traduit un nom de domaine en adresse IP ; réseaux pair-à-pair, où chaque ordinateur est à la fois émetteur et récepteur, leurs intérêts et leurs usages illicites.

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (3)
    • Croire qu'un nom de domaine suffit aux routeurs : ils n'acheminent que des adresses IP, d'où la consultation préalable d'un serveur DNS.
    • Écrire une adresse IPv4 avec un nombre supérieur à 255 : chaque nombre tient sur un octet.
    • Penser que le DNS est un serveur unique : c'est un système réparti sur un grand nombre d'ordinateurs.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Données structurées, descripteurs et métadonnées

    Difficulté 1 sur 5

    Une donnée est une valeur décrivant un objet ; un descripteur nomme la caractéristique décrite (nom, date…) ; une collection d'objets partageant les mêmes descripteurs se présente en table (objets en ligne, descripteurs en colonne) ; le format CSV enregistre une table en texte avec des séparateurs ; les métadonnées décrivent un fichier ; une donnée personnelle se rapporte à une personne identifiable ; stockage dans le nuage et consommation énergétique des centres de données.

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (3)
    • Confondre la valeur d'une donnée (« Lyon ») et son descripteur (« ville »).
    • Croire qu'une donnée n'est personnelle que si elle contient un nom : une adresse IP ou une position peuvent suffire à identifier une personne.
    • Penser qu'un fichier CSV contient des formules ou une mise en forme : c'est du texte brut, une ligne par objet.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Identité numérique, modèle économique et cyberviolence

    Difficulté 1 sur 5

    Identité numérique, e-réputation, identification et authentification ; distinguer des réseaux sociaux selon leurs caractéristiques et paramétrer la confidentialité de ses données ; sources de revenus des entreprises de réseautage social (publicité ciblée à partir des données des utilisateurs) ; algorithmes de recommandation et bulles informationnelles ; formes de cyberviolence et ressources pour s'en protéger, dispositions de l'article 222-33-2-2 du code pénal.

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (2)
    • Confondre identification (dire qui on est) et authentification (le prouver, par exemple avec un mot de passe).
    • Croire qu'un service gratuit ne se rémunère pas : il se rémunère par les données de ses utilisateurs et la publicité.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Instructions conditionnelles

    Difficulté 1 sur 5

    Instruction if, avec elif et else : une seule branche est exécutée, la première dont la condition est vraie ; conditions écrites avec les comparaisons (==, !=, <, <=, >, >=) et les opérateurs booléens ; le bloc d'une branche est délimité par l'indentation.

    Prérequis : Variables, types et affectation

    Erreurs typiques (4)
    • Écrire = (affectation) au lieu de == (comparaison) dans une condition.
    • Croire que plusieurs branches elif peuvent s'exécuter : dès qu'une condition est vraie, les suivantes ne sont plus testées.
    • Mal indenter une instruction et la faire sortir du bloc : elle s'exécute alors quelle que soit la condition.
    • Ordonner les tests du plus large au plus restrictif (if note >= 10 avant if note >= 16) : la seconde branche n'est jamais atteinte.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Le Web : HTML, CSS, URL, HTTP et modèle client-serveur

    Difficulté 1 sur 5

    Le Web est un système de pages reliées par des liens hypertextes et accessibles par Internet ; une page est écrite en HTML (contenu et structure, balises) et mise en forme par CSS (style) ; chaque page a une adresse unique, l'URL, qui se décompose en protocole, nom de domaine et chemin ; le navigateur (client) envoie des requêtes HTTP au serveur, qui renvoie des pages stockées ou fabriquées à la demande ; HTTPS chiffre les échanges ; repères historiques (naissance du Web au CERN en 1989) ; notions juridiques (licence, droit d'auteur, droit d'usage) ; réglages de sécurité et de confidentialité du navigateur (cookies).

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (3)
    • Confondre le Web et Internet : le Web est un service qui utilise le réseau Internet, comme le courrier électronique.
    • Mettre la couleur ou la police dans le HTML : le style relève du CSS.
    • Croire qu'un cadenas HTTPS garantit l'honnêteté du site : il garantit seulement que l'échange est chiffré.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Objets connectés : capteurs, actionneurs et IHM

    Difficulté 1 sur 5

    Un système informatique embarqué reçoit des informations de capteurs (mesures physiques) et d'une interface homme-machine, et agit sur le monde physique par des actionneurs (moteur, lampe, haut-parleur) ; identifier l'algorithme de contrôle d'un objet courant ; écrire des programmes simples d'acquisition de données ou de commande d'un actionneur ; contraintes de temps réel, de consommation, de sûreté et de sécurité.

    Prérequis : Instructions conditionnelles

    Erreurs typiques (2)
    • Confondre capteur (qui mesure : thermomètre, caméra) et actionneur (qui agit : moteur, chauffage).
    • Croire qu'un objet connecté est à l'abri des attaques parce qu'il est petit : les objets mal sécurisés servent à lancer des attaques.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Photosites, pixels, résolution et profondeur de couleur

    Difficulté 1 sur 5

    Le capteur est formé de photosites (par carrés de quatre : deux verts, un rouge, un bleu) ; l'image finale est formée de pixels, chacun codé par trois nombres R, V, B ; définition d'une image (nombre de pixels, en mégapixels), qui n'est pas forcément égale à celle du capteur ; profondeur de couleur, en général 8 bits par composante, soit 256 niveaux et 256³ = 16 777 216 couleurs ; taille d'une image non compressée (largeur × hauteur × 3 octets) ; métadonnées EXIF ; formats RAW, BMP, TIFF, JPEG, avec ou sans perte.

    Prérequis : Données structurées, descripteurs et métadonnées

    Erreurs typiques (3)
    • Confondre photosite (élément du capteur, sensible à une seule couleur) et pixel (élément de l'image, porteur des trois composantes).
    • Compter un octet par pixel en couleurs RVB : il en faut trois (un par composante).
    • Croire que le JPEG conserve exactement l'image : sa compression est avec perte, contrairement au TIFF.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Variables, types et affectation

    Difficulté 1 sur 5

    Une variable désigne une valeur stockée en mémoire ; l'affectation x = expression calcule d'abord l'expression puis range le résultat dans x, en remplaçant l'ancienne valeur ; types de base de Python : entier (int), flottant (float), booléen (bool), chaîne de caractères (str) ; séquence d'instructions exécutées dans l'ordre ; opérateurs + − * / // % et leurs types de résultat.

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (4)
    • Lire « x = x + 1 » comme une équation sans solution : c'est une instruction qui remplace x par sa valeur augmentée de 1.
    • Échanger deux variables par « a = b » puis « b = a » : la première affectation écrase a, les deux variables finissent égales.
    • Confondre / (division qui donne un flottant, 7 / 2 vaut 3.5) et // (quotient entier, 7 // 2 vaut 3).
    • Additionner une chaîne et un nombre ("3" + 4) : Python refuse de mélanger les types str et int.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Boucles bornées et non bornées

    Difficulté 2 sur 5

    Boucle bornée for, en particulier for i in range(a, b) qui fait prendre à i les valeurs a, a + 1, …, b − 1 ; boucle non bornée while, répétée tant que sa condition est vraie ; dérouler une boucle à la main dans un tableau de suivi des variables (traçage) ; accumulateur (somme, compteur) ; choix entre les deux boucles.

    Prérequis : Variables, types et affectation, Instructions conditionnelles

    Erreurs typiques (4)
    • Croire que range(1, 5) va jusqu'à 5 : la borne de fin est exclue, i prend les valeurs 1, 2, 3, 4.
    • Oublier de modifier, dans le corps d'un while, la variable de la condition : la boucle ne s'arrête jamais.
    • Initialiser l'accumulateur à l'intérieur de la boucle : il est remis à zéro à chaque tour.
    • Compter un tour de trop ou de moins en déroulant un while : la condition est testée AVANT chaque tour, y compris le premier.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Décoder une trame NMEA 0183

    Difficulté 2 sur 5

    Un récepteur GPS fournit sa position sous forme de trames texte normalisées NMEA 0183, champs séparés par des virgules ; dans une trame GGA, la latitude est écrite ddmm.mmm (deux chiffres de degrés, puis les minutes avec leur partie décimale) suivie de N ou S, la longitude dddmm.mmm (trois chiffres de degrés) suivie de E ou W ; un dernier champ, après « * », est une somme de contrôle ; conversion en degrés décimaux : degrés + minutes / 60, avec un signe négatif au sud et à l'ouest.

    Prérequis : Données structurées, descripteurs et métadonnées

    Erreurs typiques (3)
    • Lire 4851.20 comme 48,5120 degrés : ce sont 48 degrés et 51,20 minutes, soit 48 + 51,20/60 ≈ 48,8533 degrés.
    • Oublier le signe : une latitude S ou une longitude W est négative en degrés décimaux.
    • Découper la longitude comme la latitude : la longitude a trois chiffres de degrés (dddmm.mmm).

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Définition et appel de fonctions

    Difficulté 2 sur 5

    Définir une fonction avec def, ses paramètres et l'instruction return qui renvoie un résultat et termine l'exécution de la fonction ; appeler une fonction avec des arguments ; variables locales ; différence entre renvoyer une valeur (return) et l'afficher (print).

    Prérequis : Variables, types et affectation

    Erreurs typiques (4)
    • Afficher le résultat avec print au lieu de le renvoyer avec return : la fonction renvoie alors None et le résultat est inutilisable par l'appelant.
    • Croire que les instructions placées après un return s'exécutent encore : return termine la fonction.
    • Placer le return à l'intérieur de la boucle : la fonction s'arrête dès le premier tour.
    • Définir la fonction sans jamais l'appeler, et s'étonner que rien ne se passe.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Géolocalisation par satellites et cartes numériques

    Difficulté 2 sur 5

    Principe de la géolocalisation par satellites (GPS, Galileo) : chaque satellite porte une horloge atomique et émet des messages datés ; le récepteur déduit de la durée de propagation, à la vitesse de la lumière, sa distance à chaque satellite, puis sa position en suivant plusieurs satellites ; couches d'information d'une carte numérique ; carte collaborative (OpenStreetMap) ; calcul d'itinéraire vu comme la recherche d'un plus court chemin dans un graphe ; confidentialité de la position.

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (3)
    • Croire que le récepteur GPS émet vers les satellites : il ne fait que recevoir leurs signaux.
    • Penser qu'un seul satellite suffit à se localiser : une distance seule laisse une infinité de positions possibles.
    • Croire qu'un itinéraire « le plus court » minimise toujours la distance : le poids des arêtes peut être une durée.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Graphe d'un réseau social : rayon, diamètre et centre

    Difficulté 2 sur 5

    Un réseau social se représente par un graphe (sommets = personnes, arêtes = relations) ; distance entre deux sommets = nombre minimal d'arêtes d'un chemin qui les relie ; écartement d'un sommet = sa plus grande distance aux autres ; diamètre = plus grand écartement ; rayon = plus petit écartement ; centre = sommet(s) d'écartement égal au rayon ; notion de « petit monde » et expérience de Milgram (1967).

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (3)
    • Prendre comme distance la longueur d'un chemin quelconque au lieu du plus court.
    • Confondre diamètre (le plus grand écartement) et rayon (le plus petit écartement).
    • Croire que le centre est le sommet qui a le plus de voisins : c'est celui dont la plus grande distance aux autres est la plus petite.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Internet : protocole TCP/IP, paquets et routage

    Difficulté 2 sur 5

    Les informations circulent sur Internet découpées en paquets contenant les données et les adresses de l'émetteur et du destinataire ; le protocole IP identifie les machines et achemine chaque paquet de routeur en routeur, chacun choisissant le suivant d'après sa table ; le protocole TCP fiabilise la communication (accusés de réception, réémission des paquets perdus, remise dans l'ordre) mais ne garantit aucun délai d'arrivée ; un paquet est détruit au-delà d'un nombre maximal de routeurs traversés ; Internet est indépendant du réseau physique (fibre, Wi-Fi, 4G, Ethernet…).

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (3)
    • Croire que tous les paquets d'un même message suivent le même chemin : chacun est routé individuellement.
    • Confondre les rôles : IP adresse et achemine, TCP fiabilise et réordonne.
    • Penser que TCP garantit un délai : il garantit l'arrivée (sauf panne), pas le moment, d'où les saccades d'une vidéo en direct.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Moteurs de recherche : collecte, indexation et classement

    Difficulté 2 sur 5

    Un moteur de recherche parcourt automatiquement le Web avec des robots pour collecter les pages, les indexe sur les mots qu'elles contiennent (index inversé associant à chaque mot les URL des pages où il apparaît), puis classe les pages répondant à une requête selon leur popularité (liens reçus), leur pertinence et l'ordre des mots de la requête ; calcul de popularité sur un graphe simple ; analyse critique des résultats et liens promotionnels.

    Prérequis : Le Web : HTML, CSS, URL, HTTP et modèle client-serveur

    Erreurs typiques (2)
    • Croire que le moteur parcourt le Web au moment de la requête : il consulte son index, construit à l'avance.
    • Penser que les premiers résultats sont toujours les plus fiables : le classement mesure la popularité et la pertinence, et des liens sont payés.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Traitement d'image par programme

    Difficulté 2 sur 5

    Transformer une image par programme en agissant sur les trois composantes de chaque pixel : passage en niveaux de gris par moyenne des composantes R, V, B, négatif (255 − c pour chaque composante), seuillage, extraction de contours par comparaison de pixels voisins ; rôle des algorithmes dans les appareils photo (exposition, mise au point, balance des blancs, fusion d'images, compression).

    Prérequis : Photosites, pixels, résolution et profondeur de couleur, Boucles bornées et non bornées

    Erreurs typiques (3)
    • Calculer le négatif par −c au lieu de 255 − c : une composante reste comprise entre 0 et 255.
    • Faire la moyenne avec / et obtenir un flottant là où une composante doit être un entier (on utilise // ou round).
    • Modifier l'image en place pendant une détection de contours : les pixels voisins comparés ont déjà été modifiés.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

Première — 23 compétences · 23 avec exercices

  • Objets connectés : capteurs, actionneurs et IHM

    Difficulté 1 sur 5

    Un système informatique embarqué reçoit des informations de capteurs (mesures physiques) et d'une interface homme-machine, et agit sur le monde physique par des actionneurs (moteur, lampe, haut-parleur) ; identifier l'algorithme de contrôle d'un objet courant ; écrire des programmes simples d'acquisition de données ou de commande d'un actionneur ; contraintes de temps réel, de consommation, de sûreté et de sécurité.

    Prérequis : Instructions conditionnelles

    Erreurs typiques (2)
    • Confondre capteur (qui mesure : thermomètre, caméra) et actionneur (qui agit : moteur, chauffage).
    • Croire qu'un objet connecté est à l'abri des attaques parce qu'il est petit : les objets mal sécurisés servent à lancer des attaques.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de sciences numériques et technologie de seconde générale et technologique, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf)

  • Booléens, opérateurs et tables de vérité

    Difficulté 2 sur 5

    Valeurs booléennes (vrai, faux ; 1, 0) ; opérateurs and, or, not et ou exclusif (xor) ; table de vérité d'une expression booléenne ; évaluation séquentielle de and et or en Python (le second opérande n'est évalué que si nécessaire) ; addition binaire comme application (somme = xor, retenue = and).

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (4)
    • Lire « a or b » comme un ou exclusif : il vaut vrai aussi quand a et b sont vrais tous les deux.
    • Oublier la priorité de not sur and, et de and sur or : « not a or b » se lit (not a) or b.
    • Écrire une table de vérité à n variables avec moins de 2^n lignes, en oubliant des combinaisons.
    • Ignorer l'évaluation séquentielle : dans « x != 0 and 10 // x > 1 », la division n'est jamais faite quand x vaut 0.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Dictionnaires par clés et valeurs

    Difficulté 2 sur 5

    Un dictionnaire associe des valeurs à des clés uniques : lecture d'une valeur par sa clé, ajout ou modification d'une entrée, test d'appartenance d'une clé ; itération sur les clés, les valeurs ou les couples avec keys(), values() et items().

    Prérequis : Boucles bornées et non bornées

    Erreurs typiques (3)
    • Lire d[c] pour une clé absente : Python lève une erreur KeyError ; on teste d'abord « c in d ».
    • Croire que « c in d » cherche parmi les valeurs : il cherche parmi les clés.
    • Penser qu'une même clé peut apparaître deux fois : une nouvelle affectation remplace l'ancienne valeur.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Écriture d'un entier positif en base 2, 10 et 16

    Difficulté 2 sur 5

    Écriture positionnelle d'un entier naturel dans une base b : valeur de chaque chiffre selon son rang (puissances de b) ; passage de la base 10 à la base 2 par divisions successives et inversement ; base 16 (chiffres 0 à 9 et A à F) et regroupement des bits par paquets de quatre ; bit et octet.

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (4)
    • Lire les restes des divisions successives dans l'ordre où on les obtient : le premier reste est le chiffre des unités, il s'écrit à DROITE.
    • Donner au bit le plus à droite le poids 2 au lieu de 1 (2⁰), ce qui double la valeur lue.
    • Écrire 10 pour le chiffre hexadécimal de valeur dix au lieu de A, et mélanger ainsi deux chiffres en un.
    • Regrouper les bits par quatre en partant de la gauche pour passer en hexadécimal : on groupe à partir de la droite (les unités).

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Interactions entre l'homme et la machine sur le Web

    Difficulté 2 sur 5

    Composants graphiques d'une page (boutons, champs de formulaire) décrits en HTML, et comportement programmé (en JavaScript) en réaction à des événements comme un clic ; distinguer ce qui est exécuté sur le client et sur le serveur, et dans quel ordre ; ce qui est mémorisé par le client et retransmis au serveur (cookies) ; formulaire et passage de paramètres par les requêtes GET (dans l'URL) ou POST (dans le corps de la requête) ; quand et pourquoi la transmission est chiffrée.

    Prérequis : Le Web : HTML, CSS, URL, HTTP et modèle client-serveur, Définition et appel de fonctions

    Erreurs typiques (3)
    • Envoyer un mot de passe par une requête GET : il apparaît en clair dans l'URL et dans l'historique.
    • Croire que POST chiffre les données : sans HTTPS, le corps de la requête circule en clair.
    • Penser que le code JavaScript d'une page s'exécute sur le serveur : il est envoyé au navigateur et exécuté par le client.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Nombre de bits d'un entier, d'une somme, d'un produit

    Difficulté 2 sur 5

    Nombre de bits nécessaires pour écrire un entier naturel n en base 2 (le plus petit k tel que n < 2^k) ; plus grand entier représentable sur k bits (2^k − 1) ; une somme de deux entiers de k bits tient sur k + 1 bits, un produit sur 2k bits ; tailles courantes des entiers (8, 16, 32 ou 64 bits) ; entiers de taille arbitraire de Python.

    Prérequis : Écriture d'un entier positif en base 2, 10 et 16

    Erreurs typiques (3)
    • Croire que 2^k est représentable sur k bits : sur k bits, le plus grand entier est 2^k − 1 (sur 8 bits, 255 et non 256).
    • Penser qu'un produit de deux nombres de k bits tient encore sur k bits, ou sur k + 1 bits comme une somme.
    • Confondre le nombre de valeurs représentables (2^k) avec la plus grande valeur (2^k − 1).

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • p-uplets et p-uplets nommés

    Difficulté 2 sur 5

    Un p-uplet (tuple en Python) regroupe un nombre fixé de valeurs, éventuellement de types différents, accessibles par leur indice et non modifiables ; une fonction peut renvoyer plusieurs valeurs sous forme d'un p-uplet et l'appelant les récupère par affectation multiple ; un p-uplet nommé associe un nom à chaque champ (en Python, on l'implémente par un dictionnaire).

    Prérequis : Définition et appel de fonctions

    Erreurs typiques (3)
    • Vouloir modifier un élément d'un p-uplet par affectation (t[0] = 5) : un tuple n'est pas modifiable.
    • Oublier que les indices commencent à 0 : le deuxième élément de t est t[1].
    • Écrire (5) pour un p-uplet à un élément : c'est l'entier 5 ; le p-uplet s'écrit (5,).

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Repères de l'histoire de l'informatique

    Difficulté 2 sur 5

    Situer dans le temps les principaux événements de l'histoire de l'informatique et leurs protagonistes : algorithmes présents dès l'Antiquité, machines à calculer à partir du XVIIe siècle, concept de machine universelle capable d'exécuter tous les algorithmes en 1936 (Alan Turing), premiers ordinateurs en 1948, réseau Internet développé depuis 1969 ; évolution des rôles relatifs des logiciels et des matériels.

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (2)
    • Croire que l'informatique commence avec les premiers ordinateurs : la notion d'algorithme est bien plus ancienne.
    • Confondre la naissance d'Internet (le réseau) et celle du Web (1989, un service utilisant ce réseau).

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Représentation d'un texte : ASCII, ISO-8859-1, Unicode

    Difficulté 2 sur 5

    Un texte est une suite de caractères, chacun codé par un nombre : ASCII code 128 caractères sur 7 bits, sans lettres accentuées ; ISO-8859-1 (Latin-1) étend à 256 caractères sur un octet ; Unicode attribue un numéro (point de code) à chaque caractère de toutes les écritures, et UTF-8 l'écrit sur 1 à 4 octets en restant compatible avec ASCII ; un fichier lu avec un autre encodage que celui de son écriture affiche des caractères erronés.

    Prérequis : Écriture d'un entier positif en base 2, 10 et 16

    Erreurs typiques (3)
    • Confondre Unicode (la table qui numérote les caractères) et UTF-8 (une manière d'écrire ces numéros en octets).
    • Croire qu'un caractère occupe toujours un octet : en UTF-8, « é » en occupe deux et « € » trois.
    • Penser que les caractères « é » à la place de « é » viennent d'une faute de frappe : c'est un texte UTF-8 lu comme du Latin-1.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Spécification, assertions et jeux de tests

    Difficulté 2 sur 5

    Prototyper une fonction (nom, paramètres, type du résultat) et la documenter ; décrire des préconditions sur les arguments et des postconditions sur le résultat ; les vérifier par des assertions (assert) ; construire un jeu de tests couvrant les cas ordinaires et les cas limites ; un jeu de tests réussi ne prouve pas la correction d'un programme ; diversité des langages et constructions élémentaires communes.

    Prérequis : Définition et appel de fonctions

    Erreurs typiques (3)
    • Conclure qu'un programme est correct parce que tous les tests passent : les tests ne couvrent qu'un nombre fini de cas.
    • Oublier les cas limites dans un jeu de tests (tableau vide, un seul élément, valeur absente).
    • Confondre précondition (ce que l'appelant doit garantir) et postcondition (ce que la fonction garantit en retour).

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Systèmes d'exploitation et ligne de commande

    Difficulté 2 sur 5

    Fonctions d'un système d'exploitation : lancer et gérer les programmes, gérer la mémoire, les fichiers, les périphériques et les utilisateurs ; systèmes libres et propriétaires ; commandes de base en ligne de commande (se déplacer dans l'arborescence, lister, créer, copier, déplacer, supprimer des fichiers) ; droits et permissions d'accès aux fichiers (lecture, écriture, exécution, pour le propriétaire, le groupe et les autres).

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (3)
    • Confondre chemin absolu (depuis la racine /) et chemin relatif (depuis le répertoire courant).
    • Croire que le droit d'écriture sur un fichier permet de le lire.
    • Lire les permissions rwxr-x--- comme s'appliquant à tout le monde : les trois groupes de lettres concernent le propriétaire, le groupe, puis les autres.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Tableaux indexés et tableaux de tableaux

    Difficulté 2 sur 5

    Tableau (list en Python) dont les éléments sont de même type : lecture et modification d'un élément par son indice, de 0 à len(t) − 1 ; parcours par indice ou par élément ; construction par compréhension ; tableau de tableaux pour représenter une matrice, élément a[i][j] à la ligne i et à la colonne j.

    Prérequis : Boucles bornées et non bornées

    Erreurs typiques (3)
    • Accéder à t[len(t)] : le dernier indice est len(t) − 1, et l'accès suivant provoque une erreur IndexError.
    • Inverser ligne et colonne dans a[i][j] : le premier indice choisit la ligne.
    • Croire que « for x in t » donne les indices : x prend successivement les VALEURS des éléments.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Algorithme des k plus proches voisins

    Difficulté 3 sur 5

    Exemple d'algorithme d'apprentissage : pour prédire la classe d'un nouvel élément, on calcule sa distance à chaque élément d'un jeu de données déjà classé, on retient les k plus proches et on attribue la classe majoritaire parmi eux ; influence du choix de k et de la distance ; un k impair évite les égalités entre deux classes.

    Prérequis : Traitement de données en tables, Parcours séquentiel d'un tableau

    Erreurs typiques (3)
    • Prendre la classe du seul voisin le plus proche quand k est supérieur à 1.
    • Comparer des distances sans avoir mis les descripteurs à des échelles comparables : un descripteur en milliers écrase les autres.
    • Croire que l'algorithme « apprend » une règle : il garde tout le jeu de données et recalcule les distances à chaque prédiction.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Algorithmes gloutons

    Difficulté 3 sur 5

    Un algorithme glouton construit une solution pas à pas en faisant à chaque étape le choix qui paraît le meilleur sur le moment, sans revenir en arrière ; rendu de monnaie (rendre la plus grande pièce possible), problème du sac à dos ; la solution obtenue n'est pas toujours optimale : elle l'est pour le rendu de monnaie avec les pièces et billets en euros, pas avec un système comme (1, 3, 4).

    Prérequis : Parcours séquentiel d'un tableau

    Erreurs typiques (3)
    • Croire qu'un algorithme glouton donne toujours la meilleure solution : avec les pièces 1, 3 et 4, il rend 6 en trois pièces (4 + 1 + 1) alors que deux suffisent (3 + 3).
    • Oublier de trier les pièces par valeur décroissante avant de les parcourir.
    • Pour le sac à dos, choisir les objets par valeur seule sans tenir compte de leur masse.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Coût d'un algorithme : ordre de grandeur du nombre d'opérations

    Difficulté 3 sur 5

    Estimer comment le nombre d'opérations d'un algorithme varie avec la taille n des données : coût constant, logarithmique (la donnée est divisée par deux à chaque étape), linéaire (une boucle sur les n éléments), quadratique (deux boucles imbriquées) ; quand n double, un coût linéaire double, un coût quadratique est multiplié par quatre, un coût logarithmique augmente d'une étape ; intérêt de passer d'un coût quadratique en n² à n log₂ n, ou de n à log₂ n, sur des données nombreuses.

    Prérequis : Boucles bornées et non bornées

    Erreurs typiques (4)
    • Croire que deux boucles qui se suivent donnent un coût quadratique : elles s'additionnent (coût linéaire) ; ce sont deux boucles IMBRIQUÉES qui se multiplient.
    • Juger le coût sur la longueur du programme plutôt que sur le nombre de tours de ses boucles.
    • Penser qu'une boucle qui divise n par deux à chaque tour est linéaire : elle ne fait qu'environ log₂ n tours.
    • Croire qu'une boucle dont le nombre de tours est fixé (range(10)) dépend de n.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Entiers relatifs en complément à deux

    Difficulté 3 sur 5

    Représentation d'un entier relatif sur n bits par le complément à deux : le bit de poids fort a le poids −2^(n−1) ; intervalle représentable de −2^(n−1) à 2^(n−1) − 1 ; codage de −x en inversant les bits de x puis en ajoutant 1 ; l'addition binaire ordinaire reste valable, la retenue sortante étant ignorée ; dépassement de capacité.

    Prérequis : Écriture d'un entier positif en base 2, 10 et 16, Nombre de bits d'un entier, d'une somme, d'un produit

    Erreurs typiques (4)
    • Coder −x en mettant simplement le bit de poids fort à 1 (représentation « signe et valeur absolue ») au lieu d'inverser les bits et d'ajouter 1.
    • Oublier d'ajouter 1 après l'inversion des bits (on obtient alors le complément à un).
    • Croire que l'intervalle est symétrique : sur 8 bits, −128 est représentable mais +128 ne l'est pas.
    • Lire un motif commençant par 1 comme un entier positif, sans tenir compte de la convention annoncée.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Modèle d'architecture de von Neumann

    Difficulté 3 sur 5

    Constituants d'une machine : unité arithmétique et logique, unité de commande, mémoire contenant à la fois le programme et les données, dispositifs d'entrée-sortie, reliés par des bus ; architectures monoprocesseur et multiprocesseur ; dérouler l'exécution d'une séquence d'instructions simples de type langage machine (lecture, calcul, écriture, saut) ; les circuits combinatoires réalisent des fonctions booléennes.

    Prérequis : Booléens, opérateurs et tables de vérité

    Erreurs typiques (3)
    • Croire que le programme est rangé dans une mémoire séparée des données : dans le modèle de von Neumann, ils partagent la même mémoire.
    • Confondre unité de commande (qui lit et décode les instructions) et unité arithmétique et logique (qui calcule).
    • Oublier, en déroulant un programme machine, qu'un saut modifie l'adresse de la prochaine instruction.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Nombres flottants : une représentation approchée des réels

    Difficulté 3 sur 5

    Un nombre flottant est représenté en base 2 avec un nombre fini de chiffres significatifs : seuls certains décimaux sont exacts (ceux qui s'écrivent avec un dénominateur puissance de 2, comme 0,25 ou 0,5) ; 0,1 et 1/3 n'ont pas d'écriture binaire finie ; en Python, 0.1 + 0.2 == 0.3 vaut False ; il faut éviter de tester l'égalité de deux flottants et comparer plutôt leur écart à une tolérance.

    Prérequis : Écriture d'un entier positif en base 2, 10 et 16

    Erreurs typiques (3)
    • Croire qu'un nombre décimal court comme 0,1 est stocké exactement : il n'a pas d'écriture finie en base 2.
    • Tester l'égalité de deux résultats de calculs flottants avec == au lieu de comparer leur écart à une petite tolérance.
    • Penser que toute erreur d'arrondi vient d'un bug du langage : elle vient de la représentation, et tous les langages utilisant la même norme donnent le même résultat.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Traitement de données en tables

    Difficulté 3 sur 5

    Une table est une liste de p-uplets nommés (ou un tableau doublement indexé) partageant les mêmes descripteurs : importer une table depuis un fichier CSV ; rechercher les lignes vérifiant un critère écrit en logique propositionnelle ; trier une table selon une colonne ; construire une table en fusionnant deux tables sur un descripteur commun ; repérer doublons et incohérences.

    Prérequis : Données structurées, descripteurs et métadonnées, Tableaux indexés et tableaux de tableaux, Dictionnaires par clés et valeurs, Booléens, opérateurs et tables de vérité

    Erreurs typiques (3)
    • Comparer des nombres lus dans un CSV sans les convertir : ce sont des chaînes, et "9" > "10" est vrai.
    • Écrire un critère « âge > 15 or ville == "Paris" » quand l'énoncé demande les deux conditions à la fois (and).
    • Fusionner deux tables sans vérifier que le descripteur commun a le même domaine de valeurs dans les deux.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Transmission de données dans un réseau

    Difficulté 3 sur 5

    Intérêt du découpage des données en paquets et de leur encapsulation (chaque couche de protocole ajoute son en-tête) ; dérouler un protocole simple de récupération de perte de paquets, le protocole du bit alterné (chaque message porte un bit 0 ou 1 alternativement, l'accusé de réception renvoie ce bit, et l'émetteur réémet après un délai sans accusé) ; rôle des constituants d'un réseau local ; simuler un réseau.

    Prérequis : Internet : protocole TCP/IP, paquets et routage

    Erreurs typiques (3)
    • Croire que le bit alterné numérote les messages : il ne prend que deux valeurs et sert seulement à distinguer un message de sa réémission.
    • Confondre encapsulation (ajout d'en-têtes successifs) et chiffrement.
    • Penser qu'un message perdu est signalé par le récepteur : dans le bit alterné, c'est l'absence d'accusé de réception qui déclenche la réémission.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Tris par sélection et par insertion

    Difficulté 3 sur 5

    Tri par sélection : à l'étape i, on cherche le minimum de la partie non triée et on l'échange avec l'élément d'indice i ; il effectue toujours n(n − 1)/2 comparaisons. Tri par insertion : on insère chaque élément à sa place dans la partie déjà triée, en décalant les plus grands ; de n − 1 comparaisons (tableau déjà trié) à n(n − 1)/2 (tableau trié à l'envers). Invariant de boucle (« après l'étape i, les i + 1 premiers éléments sont triés »), terminaison, coût quadratique dans le pire cas.

    Prérequis : Parcours séquentiel d'un tableau

    Erreurs typiques (4)
    • Confondre les deux tris : la sélection cherche le minimum du reste, l'insertion place l'élément courant dans la partie triée.
    • Croire que le tri par sélection est plus rapide sur un tableau déjà trié : il fait exactement le même nombre de comparaisons.
    • Énoncer l'invariant du tri par sélection sans la seconde moitié : les éléments placés sont aussi inférieurs ou égaux à tous ceux qui restent.
    • Dire qu'un coût quadratique double quand n double : il est multiplié par quatre.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

Terminale — 23 compétences · 23 avec exercices

  • Repères de l'histoire de l'informatique

    Difficulté 2 sur 5

    Situer dans le temps les principaux événements de l'histoire de l'informatique et leurs protagonistes : algorithmes présents dès l'Antiquité, machines à calculer à partir du XVIIe siècle, concept de machine universelle capable d'exécuter tous les algorithmes en 1936 (Alan Turing), premiers ordinateurs en 1948, réseau Internet développé depuis 1969 ; évolution des rôles relatifs des logiciels et des matériels.

    Prérequis : Aucun prérequis : on peut commencer par là.

    Erreurs typiques (2)
    • Croire que l'informatique commence avec les premiers ordinateurs : la notion d'algorithme est bien plus ancienne.
    • Confondre la naissance d'Internet (le réseau) et celle du Web (1989, un service utilisant ce réseau).

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Services d'un système de gestion de bases de données

    Difficulté 2 sur 5

    Un système de gestion de bases de données relationnelles (SGBD) assure la persistance des données, gère les accès concurrents de plusieurs utilisateurs ou programmes, traite les requêtes efficacement et sécurise les accès (droits des utilisateurs) ; ce que permet une base de données et que ne permet pas un simple fichier de table.

    Prérequis : Modèle relationnel

    Erreurs typiques (2)
    • Croire qu'un fichier CSV partagé suffit à plusieurs utilisateurs qui écrivent en même temps : rien n'y empêche deux modifications contradictoires.
    • Confondre la base de données (les données et leur structure) et le système qui la gère.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Systèmes sur puce

    Difficulté 2 sur 5

    Un système sur puce regroupe dans un seul circuit des fonctions autrefois réparties sur une carte : microprocesseurs, mémoires, interfaces radio et filaires, gestion d'énergie, contrôleurs vidéo, accélérateur graphique ; avantages de cette intégration en vitesse et en consommation ; exemple du circuit d'un téléphone.

    Prérequis : Modèle d'architecture de von Neumann

    Erreurs typiques (2)
    • Croire qu'un système sur puce ne contient qu'un processeur.
    • Penser que l'intégration augmente la consommation : rapprocher les composants réduit les distances parcourues par les signaux et l'énergie dépensée.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Arbres binaires : vocabulaire et mesures

    Difficulté 3 sur 5

    Structure hiérarchique : nœuds, racine, feuilles, sous-arbre gauche et sous-arbre droit ; taille (nombre de nœuds) et hauteur (avec une convention à préciser : un arbre réduit à sa racine a pour hauteur 1, l'arbre vide 0) ; encadrement h ⩽ n ⩽ 2^h − 1 entre la hauteur h et la taille n d'un arbre binaire non vide ; situations nécessitant une structure arborescente (arborescence de fichiers, expression arithmétique).

    Prérequis : Interface et implémentation d'une structure de données

    Erreurs typiques (3)
    • Mélanger deux conventions de hauteur (racine seule de hauteur 0 ou 1) dans un même calcul.
    • Compter les arêtes au lieu des nœuds pour la taille.
    • Croire qu'une feuille a au moins un fils : une feuille n'a aucun fils.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Chiffrement symétrique et asymétrique

    Difficulté 3 sur 5

    Chiffrement symétrique : la même clé, partagée, sert à chiffrer et à déchiffrer ; chiffrement asymétrique : une clé publique chiffre, seule la clé privée associée déchiffre ; en HTTPS, un protocole asymétrique sert à échanger une clé symétrique de session, puis les échanges sont chiffrés symétriquement (plus rapide) ; exemples de chiffrements simples (décalage, ou exclusif).

    Prérequis : Booléens, opérateurs et tables de vérité

    Erreurs typiques (3)
    • Croire qu'on chiffre avec sa propre clé privée pour qu'un message reste secret : on chiffre avec la clé PUBLIQUE du destinataire.
    • Penser que HTTPS chiffre tous les échanges de façon asymétrique : l'asymétrique ne sert qu'à échanger la clé symétrique.
    • Confondre chiffrement (réversible avec la clé) et encodage (comme UTF-8, réversible par tous).

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Coût d'un algorithme : ordre de grandeur du nombre d'opérations

    Difficulté 3 sur 5

    Estimer comment le nombre d'opérations d'un algorithme varie avec la taille n des données : coût constant, logarithmique (la donnée est divisée par deux à chaque étape), linéaire (une boucle sur les n éléments), quadratique (deux boucles imbriquées) ; quand n double, un coût linéaire double, un coût quadratique est multiplié par quatre, un coût logarithmique augmente d'une étape ; intérêt de passer d'un coût quadratique en n² à n log₂ n, ou de n à log₂ n, sur des données nombreuses.

    Prérequis : Boucles bornées et non bornées

    Erreurs typiques (4)
    • Croire que deux boucles qui se suivent donnent un coût quadratique : elles s'additionnent (coût linéaire) ; ce sont deux boucles IMBRIQUÉES qui se multiplient.
    • Juger le coût sur la longueur du programme plutôt que sur le nombre de tours de ses boucles.
    • Penser qu'une boucle qui divise n par deux à chaque tour est linéaire : elle ne fait qu'environ log₂ n tours.
    • Croire qu'une boucle dont le nombre de tours est fixé (range(10)) dépend de n.

    Source : BO spécial n°1 du 22 janvier 2019 — programme de spécialité numérique et sciences informatiques de première générale, annexe (https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/26/8/spe633_annexe_1063268.pdf)

  • Graphes : vocabulaire et représentations

    Difficulté 3 sur 5

    Structure relationnelle : sommets, arêtes (graphe non orienté) ou arcs (graphe orienté), voisins, degré, chemin ; modéliser une situation (réseau routier, réseau électrique, Internet, réseau social) par un graphe ; représenter un graphe par une matrice d'adjacence ou par des listes de successeurs (ou de prédécesseurs), passer d'une représentation à l'autre et choisir selon le traitement.

    Prérequis : Interface et implémentation d'une structure de données, Graphe d'un réseau social : rayon, diamètre et centre

    Erreurs typiques (3)
    • Écrire une matrice d'adjacence non symétrique pour un graphe non orienté.
    • Oublier, dans une liste de successeurs d'un graphe non orienté, d'inscrire chaque arête dans les deux sens.
    • Confondre le nombre d'arêtes d'un chemin et le nombre de sommets qu'il traverse.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Interface et implémentation d'une structure de données

    Difficulté 3 sur 5

    Spécifier une structure de données par son interface (les opérations disponibles et leur effet) ; distinguer l'interface de l'implémentation (la façon de programmer ces opérations) ; écrire plusieurs implémentations d'une même structure, par exemple une file avec un tableau ou avec deux piles ; modularité et utilisation de bibliothèques.

    Prérequis : Spécification, assertions et jeux de tests, Tableaux indexés et tableaux de tableaux

    Erreurs typiques (2)
    • Croire qu'un programme utilisateur doit changer quand on change l'implémentation : seule l'interface compte pour lui.
    • Confondre la structure abstraite (une pile) et le type Python qui sert à la programmer (une liste).

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Listes, piles et files

    Difficulté 3 sur 5

    Structures linéaires caractérisées par leurs opérations : pile (empiler, dépiler, tester si vide ; mode LIFO, le dernier entré est le premier sorti) ; file (enfiler, défiler ; mode FIFO, le premier entré est le premier sorti) ; liste (tête et queue) ; dictionnaire (accès par clé) ; choisir la structure adaptée à une situation ; une recherche dans une liste est linéaire, un accès par clé dans un dictionnaire ne parcourt pas les éléments.

    Prérequis : Interface et implémentation d'une structure de données, Dictionnaires par clés et valeurs

    Erreurs typiques (3)
    • Confondre pile et file : une pile rend l'élément le plus RÉCENT, une file le plus ANCIEN.
    • Dépiler une pile vide sans tester si elle est vide.
    • Croire qu'une file d'attente au guichet se modélise par une pile.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Modèle relationnel

    Difficulté 3 sur 5

    Une relation (table) est décrite par un schéma : son nom et ses attributs, chacun avec son domaine de valeurs ; une clé primaire identifie chaque enregistrement de façon unique ; une clé étrangère référence la clé primaire d'une autre relation ; contraintes d'intégrité de domaine, de relation et de référence ; distinguer la structure d'une base (ensemble des schémas) de son contenu ; repérer des anomalies (redondances, anomalies d'insertion, de suppression, de mise à jour).

    Prérequis : Traitement de données en tables

    Erreurs typiques (3)
    • Choisir comme clé primaire un attribut qui peut se répéter (un nom de famille, une ville).
    • Croire qu'une clé étrangère doit être unique dans sa table : plusieurs enregistrements peuvent référencer la même ligne.
    • Recopier les mêmes informations dans plusieurs tables, au lieu de les relier par une clé étrangère, ce qui crée des anomalies de mise à jour.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Paradigmes de programmation et mise au point

    Difficulté 3 sur 5

    Distinguer sur des exemples les paradigmes impératif, fonctionnel et objet, et les combiner dans un même programme ; reconnaître les causes typiques de bugs : problèmes de typage, effets de bord non désirés, débordement d'indice dans un tableau, instruction conditionnelle non exhaustive, mauvais choix d'inégalité, comparaison de flottants, mauvais nommage des variables ; utiliser spécification, assertions et tests pour les anticiper.

    Prérequis : Spécification, assertions et jeux de tests, Vocabulaire de la programmation objet

    Erreurs typiques (3)
    • Modifier un tableau reçu en argument alors que l'appelant ne s'y attend pas (effet de bord non désiré).
    • Écrire < au lieu de <= dans une condition de boucle et manquer la dernière case (ou l'inverse et déborder).
    • Croire qu'un paradigme exclut les autres : Python permet d'écrire, dans un même programme, du code impératif, fonctionnel et objet.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Processus, ordonnancement et interblocage

    Difficulté 3 sur 5

    Un processus est un programme en cours d'exécution, créé par le système d'exploitation ; états d'un processus (prêt, élu, bloqué) ; l'ordonnanceur partage le processeur entre plusieurs processus ; risque d'interblocage quand plusieurs processus attendent chacun une ressource détenue par un autre ; observer les processus actifs d'une machine.

    Prérequis : Systèmes d'exploitation et ligne de commande

    Erreurs typiques (3)
    • Confondre programme (fichier sur le disque) et processus (exécution en cours, avec sa mémoire).
    • Croire que plusieurs processus « en même temps » sur un seul cœur s'exécutent simultanément : ils alternent très vite.
    • Penser qu'un interblocage se résout tout seul en attendant : chaque processus attend indéfiniment l'autre.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Programmes récursifs

    Difficulté 3 sur 5

    Une fonction récursive s'appelle elle-même sur une donnée plus petite ; elle comporte au moins un cas de base, traité sans appel récursif, qui garantit l'arrêt ; analyser un appel par la pile des appels ou l'arbre des appels ; compter les appels effectués ; écrire une version récursive d'un calcul (factorielle, puissance, somme des chiffres).

    Prérequis : Définition et appel de fonctions, Boucles bornées et non bornées

    Erreurs typiques (4)
    • Oublier le cas de base, ou le placer après l'appel récursif : la fonction s'appelle sans fin (RecursionError en Python).
    • Appeler la fonction sur une donnée qui ne diminue pas (f(n) qui appelle f(n)) : aucun cas de base n'est atteint.
    • Oublier de renvoyer le résultat de l'appel récursif (écrire f(n − 1) au lieu de return … f(n − 1)).
    • Croire que les appels se terminent dans l'ordre où ils commencent : le dernier appel lancé est le premier terminé.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Protocoles de routage RIP et OSPF

    Difficulté 3 sur 5

    Identifier la route empruntée par un paquet selon le protocole de routage : RIP choisit la route qui traverse le moins de routeurs (nombre de sauts) ; OSPF choisit la route de coût total minimal, le coût de chaque liaison dépendant de son débit ; lien avec la recherche d'un plus court chemin dans un graphe pondéré ; tables de routage données.

    Prérequis : Transmission de données dans un réseau, Graphes : vocabulaire et représentations

    Erreurs typiques (3)
    • Appliquer à OSPF la règle de RIP : la route la plus courte en sauts n'est pas forcément la moins coûteuse.
    • Additionner les débits des liaisons au lieu de leurs coûts.
    • Croire qu'une liaison à haut débit a un coût élevé : avec OSPF, plus le débit est grand, plus le coût est faible.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Requêtes d'interrogation en SQL

    Difficulté 3 sur 5

    Identifier les composants d'une requête ; construire des requêtes d'interrogation avec SELECT (colonnes, DISTINCT, fonctions d'agrégation COUNT, SUM, AVG, MIN, MAX), FROM, WHERE (conditions combinées par AND, OR, NOT), ORDER BY (ASC, DESC) et JOIN … ON pour relier deux tables par une clé étrangère.

    Prérequis : Modèle relationnel, Booléens, opérateurs et tables de vérité

    Erreurs typiques (4)
    • Mettre dans SELECT une colonne qui n'existe que dans l'autre table sans faire de jointure.
    • Écrire une jointure sans condition ON : chaque ligne est associée à toutes les lignes de l'autre table.
    • Croire que ORDER BY trie par ordre décroissant par défaut : l'ordre par défaut est croissant (ASC).
    • Utiliser COUNT(*) en croyant compter des valeurs distinctes : il faut COUNT(DISTINCT colonne).

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Requêtes de mise à jour en SQL

    Difficulté 3 sur 5

    Construire des requêtes d'insertion (INSERT INTO … VALUES), de modification (UPDATE … SET … WHERE) et de suppression (DELETE FROM … WHERE) ; une requête de mise à jour doit respecter les contraintes d'intégrité (clé primaire unique, clé étrangère existante, domaine).

    Prérequis : Requêtes d'interrogation en SQL

    Erreurs typiques (3)
    • Oublier la clause WHERE d'un UPDATE ou d'un DELETE : la modification touche toutes les lignes de la table.
    • Insérer une ligne dont la clé primaire existe déjà : le système de gestion la refuse.
    • Supprimer une ligne encore référencée par une clé étrangère d'une autre table.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Vocabulaire de la programmation objet

    Difficulté 3 sur 5

    Une classe décrit un type d'objets ; un objet (instance) est créé en appelant la classe, ce qui exécute la méthode __init__ ; attributs (données propres à chaque objet) et méthodes (fonctions de la classe, dont le premier paramètre self désigne l'objet) ; accès par la notation pointée objet.attribut et objet.methode().

    Prérequis : Définition et appel de fonctions

    Erreurs typiques (3)
    • Oublier le paramètre self dans la définition d'une méthode.
    • Confondre la classe et l'objet : la classe est le modèle, chaque appel Classe(…) fabrique un nouvel objet.
    • Écrire un attribut sans self. dans __init__ : on crée une variable locale qui disparaît à la fin de la méthode.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Algorithmes sur les arbres binaires et les arbres binaires de recherche

    Difficulté 4 sur 5

    Calculer récursivement la taille et la hauteur d'un arbre binaire ; parcours en profondeur dans les ordres préfixe (racine, gauche, droite), infixe (gauche, racine, droite) et suffixe (gauche, droite, racine), et parcours en largeur ; dans un arbre binaire de recherche, rechercher et insérer une clé en descendant à gauche ou à droite selon la comparaison ; coût proportionnel à la hauteur, logarithmique si l'arbre est équilibré ; le parcours infixe d'un arbre binaire de recherche donne les clés dans l'ordre croissant.

    Prérequis : Arbres binaires : vocabulaire et mesures, Programmes récursifs

    Erreurs typiques (3)
    • Confondre les ordres préfixe et infixe : en préfixe, la racine est visitée la première.
    • Croire que la recherche dans un arbre binaire de recherche est toujours logarithmique : dans un arbre filiforme, elle est linéaire.
    • Insérer une clé en la comparant seulement à la racine, sans descendre jusqu'à une place vide.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Diviser pour régner et tri fusion

    Difficulté 4 sur 5

    Méthode « diviser pour régner » : découper le problème en sous-problèmes de même nature plus petits, les résoudre (souvent récursivement) puis combiner leurs solutions ; tri fusion : couper le tableau en deux moitiés, les trier, puis fusionner deux tableaux triés ; coût en n log₂ n dans tous les cas, contre n² pour les tris par sélection et par insertion dans le pire cas.

    Prérequis : Programmes récursifs, Tris par sélection et par insertion

    Erreurs typiques (3)
    • Oublier le cas de base du tri fusion (tableau de longueur 0 ou 1), ce qui fait boucler la récursion.
    • Fusionner en concaténant les deux moitiés puis en triant : la fusion doit parcourir les deux tableaux triés en parallèle.
    • Croire que le gain d'un coût n log₂ n sur n² est négligeable : pour un million d'éléments, c'est environ 2 × 10⁷ contre 10¹² opérations.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Parcours de graphes

    Difficulté 4 sur 5

    Parcours en profondeur d'abord (avec une pile ou par récursivité) et en largeur d'abord (avec une file) en marquant les sommets déjà visités ; chercher un chemin entre deux sommets ; repérer la présence d'un cycle ; le parcours en largeur d'un graphe non pondéré atteint chaque sommet par un chemin ayant le moins d'arêtes possible ; exemples du labyrinthe et du routage.

    Prérequis : Graphes : vocabulaire et représentations, Listes, piles et files

    Erreurs typiques (3)
    • Oublier de marquer les sommets visités : sur un graphe avec un cycle, le parcours ne s'arrête pas.
    • Utiliser une pile pour le parcours en largeur (ou une file pour le parcours en profondeur).
    • Croire que le parcours en profondeur donne un plus court chemin en nombre d'arêtes.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Programmation dynamique

    Difficulté 4 sur 5

    Résoudre un problème en combinant les solutions de sous-problèmes qui se chevauchent, chacune calculée une seule fois et mémorisée (de haut en bas avec mémoïsation, ou de bas en haut en remplissant un tableau) ; exemples du rendu de monnaie optimal (nombre minimal de pièces) et de l'alignement de séquences ; coût en mémoire de la table.

    Prérequis : Programmes récursifs, Algorithmes gloutons, Dictionnaires par clés et valeurs

    Erreurs typiques (3)
    • Écrire la récursion sans mémoriser les résultats : les mêmes sous-problèmes sont recalculés un nombre exponentiel de fois.
    • Confondre programmation dynamique et diviser pour régner : dans le second cas, les sous-problèmes sont indépendants et ne se répètent pas.
    • Remplir la table dans un ordre où une case utilise une case pas encore calculée.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Programme comme donnée, calculabilité et problème de l'arrêt

    Difficulté 4 sur 5

    Tout programme est aussi une donnée, que peuvent lire ou produire d'autres programmes (interpréteur, compilateur, système d'exploitation, téléchargement) ; la calculabilité ne dépend pas du langage de programmation utilisé ; le problème de l'arrêt (décider, pour tout programme et toute entrée, si le programme s'arrête) est indécidable : aucun programme ne peut le résoudre dans tous les cas, ce que montre un raisonnement par l'absurde.

    Prérequis : Programmes récursifs

    Erreurs typiques (3)
    • Croire que l'indécidabilité de l'arrêt signifie qu'on ne peut jamais savoir si UN programme donné s'arrête : pour beaucoup de programmes, on le prouve ; c'est l'outil universel qui est impossible.
    • Penser qu'un langage plus puissant ou un ordinateur plus rapide résoudrait le problème de l'arrêt.
    • Confondre « non décidable » et « très long à calculer ».

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

  • Recherche textuelle : algorithme de Boyer-Moore

    Difficulté 4 sur 5

    Rechercher un motif dans un texte : l'algorithme naïf compare le motif à chaque position ; l'algorithme de Boyer-Moore compare le motif de droite à gauche et, grâce à un prétraitement du motif (table de la dernière position de chaque caractère dans le motif), décale le motif de plusieurs positions en cas de non-correspondance.

    Prérequis : Parcours séquentiel d'un tableau, Dictionnaires par clés et valeurs

    Erreurs typiques (3)
    • Comparer le motif de gauche à droite en croyant appliquer Boyer-Moore.
    • Décaler le motif d'une seule position après chaque échec, ce qui revient à l'algorithme naïf.
    • Oublier le cas d'un caractère du texte absent du motif : le motif peut alors sauter entièrement au-delà de ce caractère.

    Source : BO spécial n°8 du 25 juillet 2019 — programme de spécialité numérique et sciences informatiques de terminale générale, annexe (https://eduscol.education.fr/document/30010/download)

Accès rapide

Où souhaitez-vous aller ?