Représentation des données : types et valeurs de base

1. Convertir $214$ (écrit en base 10) en base 2, puis en base 16.
2. Convertir $10110101_2$ en base 10, puis en base 16.
3. On considère les entiers naturels $a = 200$ et $b = 100$. a. Combien de bits sont nécessaires pour coder chacun d'eux en binaire ? b. En déduire un majorant du nombre de bits nécessaires pour coder $a+b$, puis $a \times b$, sans les calculer. c. Vérifier en calculant réellement $a+b$ et $a \times b$, et en donnant leur nombre de bits exact.

On considère l'entier $237$ (écrit en base dix).

1. Convertir $237$ en base 8 (octale) à l'aide de divisions euclidiennes successives par $8$, en détaillant chaque division comme dans le cours.
2. Convertir également $237$ en base 2 (binaire).
3. Dans l'écriture binaire obtenue à la question précédente, regrouper les chiffres par paquets de $3$ en partant de la droite (en complétant par un $0$ à gauche si besoin), puis convertir chaque paquet en un chiffre octal. Comparer avec le résultat de la question 1.

On rappelle la fonction entier_vers_binaire vue dans le cours, qui convertit un entier naturel en base 2 par divisions euclidiennes successives par 2.

1. En s'inspirant de cette fonction, écrire une fonction Python entier_vers_base(n, b) qui renvoie, sous forme d'une chaîne de caractères, l'écriture en base $b$ de l'entier naturel $n$ (on suppose $2 \leqslant b \leqslant 9$, de sorte que chaque chiffre obtenu reste un chiffre décimal unique).
2. Dérouler à la main l'exécution de entier_vers_base(68, 5), en présentant dans un tableau, à chaque tour de boucle, la valeur de n en début de tour, le reste n % 5, le quotient n // 5 et la valeur de chiffres après la mise à jour.
3. Vérifier le résultat obtenu en calculant $2\times 5^2 + 3\times 5^1 + 3\times 5^0$.

D'après des fiches d'exercices de NSI Première.

Convertir chaque nombre dans la base demandée. Les indices indiquent la base de départ.

Problèmes.

1. Quel est le plus petit entier dont l'écriture binaire, convertie en base 10, dépasse 100 ? Donner son écriture binaire.
2. Convertir $11111111_2$ en bases 8, 16 et 10.
3. Quel est le plus grand nombre qui s'écrit avec deux chiffres hexadécimaux ? Le convertir en base 10 et en base 2.

D'après des fiches d'exercices de NSI Première.

1. Conversions croisées.

• En binaire : $965$, $607_8$ et $\mathrm{A8B}_{16}$.
• En octal : $10111010_2$, $1157$ et $\mathrm{F1F}_{16}$.
• En hexadécimal : $10110110011101_2$, $7106_8$ et $3589$.
• En décimal : $10010111_2$, $146_8$ et $\mathrm{C0E}_{16}$.

2. Vers la base 10. $333_8$, $4721_8$, $\mathrm{A4B}_{16}$, $\mathrm{EF1}_{16}$, puis en base 4 : $123_4$, $103_4$, $200_4$.

3. Depuis la base 10. Convertir $150$, $1500$, $2018$ et $2230$ en base 8 et en base 16.

4. Bases 5 et 7. Convertir $4432_5$ et $56243_7$ en binaire : d'abord en passant par la base 10, puis en expliquant pourquoi on ne peut pas utiliser de regroupement de chiffres comme entre les bases 2, 8 et 16.

5. Retrouver la base. On sait que $25 = (100)_b$. Que vaut $b$ ? Même question avec $545 = (1406)_b$.

D'après des fiches d'exercices de NSI Première.

Effectuer les opérations suivantes directement dans la base indiquée, puis vérifier en base 10.

D'après un TD de NSI Première (math93.com) et les sujets 0 du baccalauréat NSI.

Ces fonctions sont très souvent demandées à l'épreuve pratique : il faut savoir les écrire sans aide. On n'utilise pas bin, hex ni int(..., base), sauf pour vérifier ses résultats.

1. conversion_B10_B2(nb) reçoit un entier naturel nb et renvoie son écriture en base 2, sous forme de chaîne de caractères.
2. conversion_B2_B10(chaine) reçoit une chaîne écrite en base 2 et renvoie l'entier correspondant.
3. conversion_B10_B16(nb) et conversion_B16_B10(chaine) font de même avec la base 16.
4. Tester les quatre fonctions sur $543$, $2^8$, $1025$, $101101_2$ et $\mathrm{FAB}_{16}$.

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°07, exercice 1.

On considère dans cet exercice une représentation binaire d'un entier non signé en tant que tableau de booléens. Si

tab = [True, False, True, False, False, True, True]

est un tel tableau, alors l'entier qu'il représente est $2^6 + 2^4 + 2^1 + 2^0 = 83$. Cette représentation, qui consiste à placer en premier le booléen indiquant la puissance la plus élevée de 2, est dite big-endian ou grand-boutiste.

Écrire une fonction gb_vers_entier qui prend en paramètre un tel tableau et renvoie l'entier qu'il représente.

Exemple :

>>> gb_vers_entier([])
0
>>> gb_vers_entier([True])
1
>>> gb_vers_entier([True, False, True,
        False, False, True, True])
83
>>> gb_vers_entier([True, False, False, False,
        False, False, True, False])
130

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°15, exercice 2.

On considère la fonction binaire ci-dessous. Cette fonction prend en paramètre un entier positif a en écriture décimale et renvoie son écriture binaire sous la forme d'une chaîne de caractères.

L'algorithme utilise la méthode des divisions euclidiennes successives par 2 : par exemple, $83 = 2 \times 41 + 1$, $41 = 2 \times 20 + 1$, $20 = 2 \times 10 + 0$, $10 = 2 \times 5 + 0$, $5 = 2 \times 2 + 1$, $2 = 2 \times 1 + 0$ et $1 = 2 \times 0 + 1$. Les restes, lus du dernier au premier, donnent l'écriture binaire 1010011.

Compléter le code de la fonction binaire.

def binaire(a):
    '''convertit un nombre entier a en sa representation
    binaire sous forme de chaine de caractères.'''
    if a == 0:
        return ...
    bin_a = ...
    while ... :
        bin_a = ... + bin_a
        a = ...
    return bin_a

Exemples :

>>> binaire(83)
'1010011'
>>> binaire(6)
'110'
>>> binaire(127)
'1111111'
>>> binaire(0)
'0'

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°16, exercice 1.

Écrire une fonction ecriture_binaire_entier_positif qui prend en paramètre un entier positif n et renvoie une chaîne de caractères correspondant à l'écriture binaire de n.

On rappelle que :

• l'écriture binaire de 25 est 11001, car $25 = 1 \times 2^4 + 1 \times 2^3 + 0 \times 2^2 + 0 \times 2^1 + 1 \times 2^0$ ;
• n % 2 vaut 0 ou 1 selon que n est pair ou impair ;
• n // 2 donne le quotient de la division euclidienne de n par 2.

Il est interdit dans cet exercice d'utiliser la fonction bin de Python.

Exemples :

>>> 5 % 2
1
>>> 5 // 2
2
>>> ecriture_binaire_entier_positif(0)
'0'
>>> ecriture_binaire_entier_positif(2)
'10'
>>> ecriture_binaire_entier_positif(105)
'1101001'

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°17, exercice 2.

Pour rappel, la conversion d'un nombre entier positif en binaire peut s'effectuer à l'aide des divisions successives par 2. Pour 77 :

On lit les restes du dernier au premier : l'écriture binaire de 77 est 1001101.

Voici une fonction Python basée sur la méthode des divisions successives permettant de convertir un nombre entier positif en binaire. Compléter la fonction binaire.

def binaire(a):
    '''convertit un nombre entier a en sa representation
    binaire sous forme de chaine de caractères.'''
    if a == 0:
        return '0'
    bin_a = ...
    while ...:
        bin_a = ... + bin_a
        a = ...
    return bin_a

Exemples :

>>> binaire(0)
'0'
>>> binaire(77)
'1001101'

1. Coder en complément à deux, sur 8 bits, les entiers relatifs $-45$ et $-100$.
2. Traduire en base dix les entiers relatifs suivants, codés en complément à deux sur 8 bits : $11110110_2$ et $01011010_2$.

On rappelle que sur 8 bits, le complément à deux permet de représenter les entiers relatifs de $-2^7$ à $2^7-1$, soit de $-128$ à $127$.

1. Vérifier que $-128$ appartient à cet intervalle, mais que $+128$ n'y appartient pas.
2. Coder $-128$ en complément à deux sur 8 bits, en détaillant les trois étapes du cours (écriture de la valeur absolue sur 8 bits, complément à 1, ajout de 1).
3. Décoder le résultat obtenu à la question 2, en appliquant la méthode de décodage du cours, pour vérifier qu'on retombe bien sur $-128$.

Une propriété remarquable du complément à deux est que l'on peut additionner deux entiers relatifs directement en binaire, bit à bit avec retenues, exactement comme une addition binaire habituelle — sans jamais traiter le signe séparément. Le résultat, tronqué au nombre de bits utilisé, est automatiquement correct... sauf en cas de dépassement de capacité (overflow).

1. Coder en complément à deux sur 8 bits les entiers $25$ et $-40$.
2. Additionner bit à bit, avec retenues, les deux codes obtenus (sur 8 bits, en ignorant une éventuelle retenue sortant au-delà du 8ᵉ bit). Décoder le résultat pour vérifier qu'on retrouve bien $25 + (-40) = -15$.
3. On code maintenant $100$ et $50$ en complément à deux sur 8 bits. Additionner bit à bit leurs codes, puis décoder le résultat obtenu. Ce résultat est-il cohérent avec le calcul $100+50=150$ ? Expliquer ce phénomène.

D'après un TD de NSI Première (math93.com) et les sujets 0 du baccalauréat NSI.

On travaille sur 8 bits : les entiers représentables vont de $-128$ à $127$.

1. Donner le code sur 8 bits de : $100$ et $-100$ ; $75$ et $-75$ ; $50$ et $-50$ ; $89$ et $-89$ ; $125$ et $-125$ ; $0$ ; $-1$ ; $-56$ ; $-128$ et $128$ ; $175$.
2. Quels entiers relatifs sont codés par $11001011$, $11010100$, $10000010$, $10101010$, $01101100$ et $11101101$ ?
3. Comment se lisent $0000\,0011$, $1000\,0001$ et $1111\,1111$ en binaire naturel (entiers sans signe), puis en complément à deux ?
4. Sur 16 bits, quel entier relatif est codé par $1010\,1010\,1010\,1010$ ?
5. Coder $a = -17$ et $b = -111$, puis additionner bit à bit leurs codes en ignorant une éventuelle retenue au-delà du 8ᵉ bit. Le résultat est-il cohérent ?
6. Même travail pour calculer $20 - 15$ comme la somme $20 + (-15)$.
7. Écrire une fonction representation_8bits(nb) qui renvoie le code sur 8 bits de l'entier nb, sous forme de chaîne, ou "IMPOSSIBLE" si nb n'est pas représentable.

1. Coder le nombre $6{,}5$ selon la norme IEEE 754 simple précision (32 bits), en détaillant chaque étape.
2. Écrire $0{,}5$ en base 2. Son écriture est-elle finie ou infinie ?
3. En une phrase, expliquer pourquoi le test 0.1 + 0.2 == 0.3 renvoie False en Python.

On donne la représentation IEEE 754 (simple précision, 32 bits) suivante :

1. Lire le bit de signe : le nombre codé est-il positif ou négatif ?
2. Lire les 8 bits d'exposant. En déduire l'exposant réel (on rappelle que l'exposant est codé avec un biais de $127$).
3. Lire les 23 bits de mantisse, et en déduire l'écriture normalisée du nombre sous la forme $1{,}\ldots \times 2^e$.
4. Calculer la valeur décimale du nombre codé.

Partie A. On donne la représentation IEEE 754 suivante :

1. Lire l'exposant codé (8 bits), puis calculer l'exposant réel. Que remarque-t-on par rapport à l'exercice précédent ?
2. En déduire l'écriture normalisée du nombre, puis sa valeur décimale (on pourra l'exprimer sous forme d'une fraction avant de la convertir en décimal).

Partie B. On donne à présent :

3. Lire le bit de signe et les 23 bits de mantisse.
4. Calculer la valeur décimale du nombre codé, signe compris.

D'après un TD de NSI Première (math93.com) et les sujets 0 du baccalauréat NSI.

Un nombre dyadique est une fraction dont le dénominateur est une puissance de 2 : ce sont exactement les nombres qui ont une écriture binaire finie.

1. Écrire en binaire : $\dfrac{75}{16}$, $\dfrac{101}{8}$, $14{,}75$, $30{,}5$ et $4{,}125$.
2. Donner l'écriture décimale de $100{,}0101_2$, puis l'écriture en base 10 et en base 16 de $11111111{,}000111_2$.
3. Écrire en binaire $0{,}5$ ; $0{,}25$ ; $0{,}2$ ; $0{,}9$ et $\dfrac13$. Lesquels ont une écriture finie ?
4. Écrire en binaire $\dfrac{11}{16}$ puis $\dfrac{11}{15}$. Donner le début de l'écriture binaire de la somme $\dfrac{11}{16} + \dfrac{11}{15}$. Un ordinateur peut-il stocker exactement cette somme ?
5. Écrire en binaire $\dfrac87$ et $\dfrac{11}{3}$.
6. Écrire $0{,}1$ en binaire. Que remarque-t-on ? Quelle conséquence pour les calculs de Python ?

Banque nationale de sujets 2026 de l'épreuve pratique, sujet n°08 (situation d'évaluation d'une heure).

Calculs monétaires et codage BCD

En informatique, utiliser des nombres flottants pour manipuler des valeurs monétaires est une erreur de conception classique. Les ordinateurs utilisant le système binaire (base 2), certains nombres décimaux comme 0.1 ne peuvent pas être représentés de manière exacte et génèrent une infinité de décimales dans leur représentation binaire flottante (0.00011001100110011…). Lors de calculs financiers, ces erreurs d'arrondi s'accumulent et faussent les bilans comptables.

Question 1. La chaîne de restauration « RESTO NSI » comprend 1 000 restaurants qui délivrent chacun 500 menus par jour. Un menu est composé d'une entrée à 2.27 €, d'un plat à 5.19 € et d'un dessert à 1.81 €. Écrire, dans le fichier addition_BCD.py, une fonction calcul_recettes() qui additionne le prix de chaque menu vendu dans la journée en utilisant une boucle. Afficher le résultat de cette fonction. Sachant que la valeur théorique exacte est de 4 635 000 €, justifier le comportement observé.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Historiquement, pour pallier ce problème dans les calculatrices et les systèmes financiers, on utilise le système BCD (Binary Coded Decimal). Le principe est de coder chaque chiffre du nombre décimal séparément sur 4 bits (un quartet). La virgule n'étant pas codée, on utilise la convention monétaire « virgule implicite deux rangs avant la fin ». Il faut donc au minimum 3 quartets pour représenter une somme.

Le fichier addition_BCD.py contient des fonctions permettant de manipuler ces données.

Question 2. Écrire la fonction convertir_BCD_vers_decimal(liste_quartets) qui prend en paramètre une liste de chaînes de caractères représentant des quartets BCD, et renvoie la valeur décimale correspondante (de type float). Ajouter une assertion pour vérifier que convertir_BCD_vers_decimal(['0001', '0011', '0101', '0110']) renvoie bien la valeur 13.56.

Indication : on pourra utiliser le fait que int(s, 2) renvoie le nombre dont l'écriture binaire est donnée par la chaîne de caractères s.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Afin de réaliser une addition de deux nombres donnés en BCD, on additionne les nombres quartet par quartet, de droite à gauche. Si le résultat d'une addition binaire de quartets est supérieur ou égal à 10 (soit '1010' en binaire) ou s'il génère une retenue, le format BCD n'est plus valide. Il faut alors appliquer une correction en ajoutant 6 (soit '0110') à ce quartet et propager la retenue.

Question 3. La fonction additionner_nombres_format_BCD(a, b) fournie dans le fichier réalise cette addition. L'évaluation de l'appel additionner_nombres_format_BCD('27', '35') devrait correspondre à 62, mais la liste renvoyée est fausse. Analyser le code fourni. Identifier l'oubli de l'étape de correction dans l'algorithme, puis insérer un appel à la fonction corriger_BCD (déjà fournie) au bon endroit pour résoudre ce problème. Refaire le test pour valider la réparation.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Question 4. Tester maintenant l'addition de 23 et de 4 avec votre code et décrire ce que vous observez. Modifier la fonction aligner_quartets(q1, q2) pour qu'elle ajoute des quartets '0000' au début du nombre le plus court jusqu'à ce que les deux listes aient la même longueur et effectuer à nouveau des tests.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Fichier fourni : addition_BCD.py

#############################################################################
# Question 1 : Mise en évidence du problème des flottants                   #
#############################################################################
# Écrire ci-dessous la fonction calcul_recettes() et son appel
 
 
#############################################################################
# Question 2 : Conversion BCD vers Décimal                                  #
#############################################################################
# Écrire ci-dessous la fonction convertir_BCD_vers_decimal(liste_quartets)
# et l'assertion de test demandée
 
 
#############################################################################
# Code fourni pour les questions 3 et 4                                     #
#############################################################################
 
def convertir_dec_vers_BCD(decimal):
    """
    Convertit une chaîne représentant un décimal vers une liste de quartets BCD.
    Convention : virgule implicite avant les deux derniers quartets.
    """
    ajouter_zero = False
    liste_quartets = []
 
    if '.' not in decimal:
        decimal = decimal + '.00'
 
    for i in range(len(decimal)):
        if decimal[i] != '.':
            # convertit en binaire le nombre decimal[i]
            # en rajoutant des 0 devant pour obtenir un quartet
            quartet = bin(int(decimal[i]))[2:].zfill(4)
            liste_quartets.append(quartet)
 
        # Si le nombre n'a qu'un seul chiffre après la virgule
        if decimal[i] == '.' and i == len(decimal) - 2:
            ajouter_zero = True
 
    if ajouter_zero:
        liste_quartets.append('0000')
 
    return liste_quartets
 
 
def additionner_binaire_quartets(quartet1, quartet2, retenue):
    """
    Additionne bit à bit deux quartets binaires purs.
    Renvoie un tuple (somme_binaire_str, nouvelle_retenue_int).
    """
    somme = ""
    for i in range(4):
        # Lecture de la droite vers la gauche
        bit1 = int(quartet1[3 - i])
        bit2 = int(quartet2[3 - i])
        total = bit1 + bit2 + retenue
 
        if total == 0:
            somme = '0' + somme
            retenue = 0
        elif total == 1:
            somme = '1' + somme
            retenue = 0
        elif total == 2:
            somme = '0' + somme
            retenue = 1
        elif total == 3:
            somme = '1' + somme
            retenue = 1
 
    return somme, retenue
 
 
def corriger_BCD(somme, retenue):
    """
    Applique la correction BCD si le quartet dépasse 9 ou génère une retenue.
    Ajoute '0110' (6) au quartet invalide.
    """
    # Si somme >= 10 ('1010' ou '1011' ou '1100' etc.)
    if somme[0] == '1' and (somme[1] == '1' or somme[2] == '1'):
        somme, retenue = additionner_binaire_quartets(somme, '0110', 0)
        return somme, retenue
 
    # S'il y a eu dépassement naturel lors de l'addition binaire
    if retenue == 1:
        somme, _ = additionner_binaire_quartets(somme, '0110', 0)
        return somme, retenue
 
    return somme, retenue
 
 
def aligner_quartets(q1: list, q2: list) -> tuple:
    """
    Doit équilibrer les deux listes en ajoutant des '0000' à gauche 
    de la liste la plus courte.
    """
    return q1, q2
 
 
def additionner_nombres_format_BCD(a, b):
    """
    Additionne deux nombres au format BCD, quartet par quartet.
    """
    liste_quartets1 = convertir_dec_vers_BCD(a)
    liste_quartets2 = convertir_dec_vers_BCD(b)
 
    # Ajustement de la longueur
    liste_quartets1, liste_quartets2 = aligner_quartets(
        liste_quartets1, liste_quartets2)
 
    retenue = 0
    resultat = []
    longueur_max = max(len(liste_quartets1), len(liste_quartets2))
 
    for i in range(longueur_max):
        index = longueur_max - i - 1
 
        # Addition binaire simple des quartets
        somme, retenue = additionner_binaire_quartets(
            liste_quartets1[index], liste_quartets2[index], retenue)
 
        resultat.insert(0, somme)
 
    # Gestion de la dernière retenue éventuelle
    if retenue == 1:
        resultat.insert(0, '0001')
 
    return resultat

Dresser la table de vérité de l'expression booléenne à trois variables $(a \text{ or not } b) \text{ and } c$ (8 lignes). Vérifier ensuite le résultat obtenu pour $a=\text{True}$, $b=\text{False}$, $c=\text{True}$ à l'aide d'un petit programme Python.

On considère six portes logiques usuelles à deux entrées $A$ et $B$, produisant une sortie $S$ : ET (AND), OU (OR), NON-ET (NAND), NON-OU (NOR), OU exclusif (XOR) et NON-OU exclusif (XNOR).

1. Pour chacune de ces six portes, donne l'expression booléenne de $S$ en fonction de $A$ et $B$ (on notera $A \cdot B$ le ET, $A + B$ le OU, et $\overline{A}$ la négation de $A$).
2. Complète, pour chacune des six portes, la table de vérité à deux entrées (4 lignes : $AB = 00$, $01$, $10$, $11$).
3. La porte OU exclusif (XOR) est parfois appelée « détecteur de parité impaire ». En observant, pour les lignes où $S=1$, le nombre de $1$ présents en entrée, explique pourquoi ce surnom est justifié. Que dirais-tu alors de la porte XNOR ?

On rappelle les lois de base de l'algèbre de Boole, pour toute variable booléenne $A$ :

On y ajoute la loi de distributivité : $A \cdot (B + C) = A\cdot B + A \cdot C$, ainsi que les deux lois de De Morgan :

1. Simplifie $S_1 = A\cdot B + A \cdot \overline{B}$ en indiquant, à chaque étape, la loi utilisée.
2. Simplifie $S_2 = A + A\cdot B$ (indication : fais apparaître un facteur $A \cdot 1$).
3. En généralisant les lois de De Morgan à trois variables, donne une expression de $\overline{A\cdot B\cdot C}$ (NON-ET à 3 entrées) ne comportant plus de négation portant sur un produit, puis de $\overline{A+B+C}$ (NON-OU à 3 entrées) ne comportant plus de négation portant sur une somme.
4. On ne dispose que de portes NAND (NON-ET) à deux entrées. Montre qu'en reliant les deux entrées d'une porte NAND entre elles, on obtient un inverseur (porte NON), puis explique comment construire une porte ET à partir de deux portes NAND.

On considère l'expression booléenne $S = \overline{A}\cdot B + A\cdot \overline{B}$, où $A$ et $B$ sont deux entrées booléennes.

1. Construis la table de vérité de $S$ (4 lignes) et identifie la porte logique usuelle à laquelle cette expression correspond.
2. Décris un logigramme (schéma à portes logiques) réalisant cette expression à partir des seules entrées $A$ et $B$, en n'utilisant que des portes NON, ET et OU. Précise le nombre de portes de chaque type nécessaires.
3. Un circuit électrique à interrupteurs peut aussi représenter une expression booléenne : un interrupteur fermé vaut 1, un interrupteur ouvert vaut 0 ; deux interrupteurs en série réalisent un ET, deux branches en parallèle réalisent un OU. Décris, à l'aide de quatre interrupteurs notés $a$, $\overline{a}$, $b$ et $\overline{b}$, un circuit électrique entre deux bornes qui réalise cette même fonction $S$.

Pour une expression booléenne à $n$ entrées, une table de vérité complète comporte $2^n$ lignes : il faut lister méthodiquement toutes les combinaisons possibles des entrées, par exemple en les numérotant de 0 à $2^n-1$ et en écrivant chaque numéro en binaire sur $n$ bits.

Partie A (3 entrées). On considère l'expression $S = (A\cdot B) + C$.

1. Construis la table de vérité complète de $S$ (8 lignes, entrées $A$, $B$, $C$ énumérées de $000$ à $111$).
2. Combien de lignes donnent $S=1$ ?

Partie B (4 entrées). On considère l'expression $S = (A+B)\cdot(C+D)$.

1. En énumérant méthodiquement les 16 combinaisons possibles de $A$, $B$, $C$, $D$ (de $0000$ à $1111$), donne le nombre de lignes pour lesquelles $S=1$, en expliquant ton raisonnement plutôt qu'en construisant nécessairement les 16 lignes une à une.

D'après une fiche d'exercices de NSI Première.

Pour chacun des trois circuits suivants, à deux entrées A et B et une sortie S : (a) écrire l'équation de S ; (b) dresser la table de vérité ; (c) reconnaître la fonction logique réalisée et donner son symbole.

Circuit 1. A et B passent chacune par une porte NON. Les deux résultats entrent dans une porte OU, dont la sortie passe par une porte NON pour donner S.

Circuit 2. A et B passent chacune par une porte NON. Les deux résultats entrent dans une porte ET, dont la sortie passe par une porte NON pour donner S.

Circuit 3. Il ne comporte que des portes NON-ET à deux entrées. Une première porte reçoit A et B et produit X. Une deuxième porte reçoit A et X, une troisième reçoit B et X. Une dernière porte reçoit les sorties de la deuxième et de la troisième, et produit S.

D'après une fiche d'exercices de NSI Première.

Un circuit a quatre entrées A, B, C, D et une sortie S. A et B entrent dans une porte NON-OU. C et D passent chacune par une porte NON, et les deux résultats entrent dans une porte NON-ET. Une porte ET reçoit les sorties de la porte NON-OU et de la porte NON-ET, et produit S.

1. Déterminer l'équation de S, puis la simplifier.
2. Pour quelles valeurs des entrées S vaut-elle 1 ?
3. Réaliser le même circuit en n'utilisant que des portes NON-ET à deux entrées.

D'après une fiche d'exercices de NSI Première.

Un circuit a trois entrées A, B, C et une sortie S :

• A et B entrent dans une porte OU exclusif, qui produit X ;
• C passe par une porte NON ;
• une porte OU reçoit X et $\overline{C}$, et produit Y ;
• une porte NON-OU exclusif (XNOR) reçoit Y et C, et produit Z ;
• une porte ET reçoit Y et Z, et produit S.

1. Compléter la table de vérité de S, pour les huit combinaisons de C, B, A.
2. En déduire une équation simple de S.
3. Un chronogramme montre l'évolution des signaux au cours du temps. Les entrées prennent successivement les valeurs suivantes, sur neuf intervalles de temps de même durée. Donner la valeur de S sur chaque intervalle.

D'après une fiche d'exercices de NSI Première.

Démontrer les égalités suivantes à l'aide des lois de l'algèbre de Boole (distributivité, absorption, $X + \overline{X} = 1$, $X \cdot \overline{X} = 0$, lois de De Morgan…), puis contrôler l'une d'elles par une table de vérité.

1. $\overline{A} \cdot (A + \overline{B}) \cdot (\overline{A} + B) = \overline{A} \cdot \overline{B}$
2. $(B + A B + C)(A + \overline{B} + \overline{A}\,\overline{C}) = \overline{B} C + A B + B \overline{C}$
3. $A B + A C D + \overline{B} D = A B + \overline{B} D$
4. $(\overline{A} + B)(A + C)(B + C) = (\overline{A} + B)(A + C)$
5. $A B + \overline{B} C = (A + \overline{B})(B + C)$
6. $\overline{A \overline{B} + \overline{A} B} = A B + \overline{A}\,\overline{B}$
7. $\overline{(A + B)(\overline{A} + C)} = (A + \overline{B})(\overline{A} + \overline{C})$

D'après une fiche d'exercices de NSI Première.

Simplifier au maximum les expressions suivantes, puis vérifier le résultat sur quelques lignes de la table de vérité.

• $E = \overline{a} b c + a c + a \overline{b}\,\overline{c} + \overline{a}\,\overline{b}$
• $F = (\overline{a} + b)(a + b + d)\,\overline{d}$
• $G = (a + b)(a + c) + (b + c)(b + a) + (c + a)(c + b)$
• $H = a b c + a \overline{b} c + a b \overline{c}$

D'après une fiche de math93.com (M. Courtois, M. Duffaud).

On peut réaliser ces circuits avec le logiciel libre de simulation Logisim, qui affiche directement leur table de vérité.

1. A et B passent chacune par une porte NON, et les deux résultats entrent dans une porte ET, qui donne S.

• a. Écrire l'expression de S et sa table de vérité.
• b. Par quel circuit de seulement deux portes peut-on le remplacer ? Quelle porte unique réalise la même fonction ?

2. Une porte OU reçoit A et B ; une porte ET reçoit B et C ; une seconde porte OU reçoit les sorties des deux premières et donne S.

• a. Écrire l'expression de S et sa table de vérité.
• b. En déduire une expression de S qui ne dépend que de A et B.

D'après une fiche de math93.com (M. Courtois, M. Duffaud).

Un multiplexeur a plusieurs entrées de données, une sortie, et des entrées de commande qui choisissent laquelle des entrées de données est recopiée sur la sortie. On en trouve partout où plusieurs signaux se partagent une même voie de transmission.

1. Multiplexeur à deux entrées. Il a deux entrées de données E1 et E2, une commande C et une sortie Out. C passe par une porte NON. Une porte ET reçoit E1 et $\overline{C}$, une autre porte ET reçoit E2 et C, et une porte OU réunit leurs sorties pour donner Out.

• a. Écrire l'expression de Out.
• b. Dresser la table de vérité (C, E1, E2). Quel est le rôle de C ?

2. Multiplexeur à quatre entrées. Il a quatre entrées E1 à E4 et deux commandes C0 et C1.

• Un premier bloc reçoit E1 et E3 : $E_1 \cdot \overline{C_1}$ et $E_3 \cdot C_1$ entrent dans une porte OU.
• Un second bloc reçoit E2 et E4 : $E_2 \cdot \overline{C_1}$ et $E_4 \cdot C_1$ entrent dans une porte OU.
• La sortie du premier bloc entre dans une porte ET avec $\overline{C_0}$, celle du second dans une porte ET avec $C_0$ ; une porte OU finale réunit ces deux résultats et donne Out.

Écrire l'expression de Out, puis donner les valeurs de C0 et C1 qui sélectionnent chacune des entrées E1, E2, E3 et E4.

D'après une fiche de math93.com (M. Courtois, M. Duffaud). Complété d'après un TP Logisim de NSI Première.

1. Demi-additionneur. Un circuit a deux entrées A et B et deux sorties : S, sortie d'une porte OU exclusif qui reçoit A et B, et C, sortie d'une porte ET qui reçoit A et B.

• a. Donner les expressions de S et de C, et leurs tables de vérité.
• b. Expliquer pourquoi ce circuit additionne deux bits. Que représentent S et C ?

2. Additionneur complet. Pour additionner des nombres de plusieurs bits, il faut aussi tenir compte de la retenue venant du rang précédent, notée $C_{in}$. L'additionneur complet a trois entrées A, B, $C_{in}$ et deux sorties :

• une porte OU exclusif calcule $X = A \oplus B$, puis une seconde porte OU exclusif calcule $S = X \oplus C_{in}$ ;
• la retenue sortante est $C_{out} = X \cdot C_{in} + A \cdot B$ (deux portes ET et une porte OU).

Compléter la table de vérité de $C_{out}$ et de S pour les huit combinaisons d'entrées.

3. Additionneur 4 bits. On enchaîne quatre additionneurs complets : la retenue sortante de chacun devient la retenue entrante du suivant, et la retenue entrante du premier vaut 0. Détailler, rang par rang, le calcul de $1011_2 + 0110_2$.

D'après une fiche de math93.com (M. Courtois, M. Duffaud).

1. Une fonction f de deux variables vaut 1 pour (A, B) = (0, 0), (0, 1) et (1, 0), et 0 pour (1, 1). Retrouver son expression et nommer la porte correspondante.

2. On donne les tables de vérité de trois fonctions U, V et W des variables A, B, C. Pour chacune, écrire une expression booléenne, la simplifier si possible, et décrire un circuit qui la réalise.

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°32, exercice 1.

L'opérateur « ou exclusif » entre deux bits renvoie 0 si les deux bits sont égaux et 1 s'ils sont différents. Il est symbolisé par le symbole $\oplus$. Ainsi :

• $0 \oplus 0 = 0$
• $0 \oplus 1 = 1$
• $1 \oplus 0 = 1$
• $1 \oplus 1 = 0$

Écrire une fonction ou_exclusif qui prend en paramètres deux tableaux de 0 ou de 1 de même longueur et qui renvoie un tableau où l'élément situé à position i est le résultat, par l'opérateur « ou exclusif », des éléments à la position i des tableaux passés en paramètres.

Exemples :

>>> ou_exclusif([1, 0, 1, 0, 1, 1, 0, 1], [0, 1, 1, 1, 0, 1, 0, 0])
[1, 1, 0, 1, 1, 0, 0, 1]
>>> ou_exclusif([1, 1, 0, 1], [0, 0, 1, 1])
[1, 1, 1, 0]

On souhaite enregistrer le mot "café" (4 caractères, avec un é accentué) dans un fichier texte.

1. Quelle est la taille de ce mot en octets s'il est encodé en ISO-8859-1 (1 octet par caractère, accents compris) ?
2. En UTF-8, les caractères ASCII de base (dont "c", "a", "f") sont codés sur 1 octet, et le caractère "é" est codé sur 2 octets. Quelle est alors la taille du mot en UTF-8 ?
3. Vérifier ces deux résultats en Python à l'aide de la fonction encode et de len.

Le fichier poeme.txt, enregistré en UTF-8, contient une seule ligne :

Élève café

Ce texte comporte 10 caractères (espace compris) : "É", "l", "è", "v", "e", " ", "c", "a", "f", "é". Les caractères accentués "É", "è" et "é" sont codés sur 2 octets chacun en UTF-8 ; les 7 autres caractères sont codés sur 1 octet chacun.

1. Écrire un programme Python qui ouvre poeme.txt en lecture avec l'encodage "utf-8", lit son contenu dans une variable texte, puis écrit ce contenu dans un nouveau fichier poeme_latin1.txt, avec l'encodage "iso-8859-1" cette fois.
2. En utilisant les informations données ci-dessus, calculer la taille en octets du fichier poeme.txt (en UTF-8).
3. Sachant qu'en ISO-8859-1 chaque caractère (accentué ou non) est codé sur exactement 1 octet, calculer la taille en octets du fichier poeme_latin1.txt.
4. Vérifier ces deux résultats en Python à l'aide de encode et de len.

Le fichier mots.txt a été enregistré en UTF-8 et contient le mot café. Un camarade tente de le lire avec le programme suivant, en se trompant d'encodage :

with open("mots.txt", "r", encoding="ascii") as f:
    contenu = f.read()
print(contenu)

Le mot café, une fois encodé en UTF-8, correspond à la suite de 5 octets suivante (valeurs décimales) : 99, 97, 102, 195, 169 (les octets 99, 97 et 102 codent respectivement "c", "a" et "f" ; les octets 195 et 169 codent ensemble le caractère "é", sur 2 octets).

1. Rappeler l'intervalle des codes ASCII valides (cf. cours). Parmi les 5 octets ci-dessus, lesquels appartiennent à cet intervalle, et lesquels en sont exclus ?
2. En déduire pourquoi le programme du camarade provoque une erreur UnicodeDecodeError à l'exécution, plutôt que d'afficher café.
3. Réécrire ce programme pour qu'il lise correctement le fichier, en utilisant le bon encodage.
4. Proposer une version plus robuste du programme original (avec l'encodage "ascii"), qui utilise un bloc try/except pour intercepter une éventuelle UnicodeDecodeError et afficher un message d'erreur explicite plutôt que de laisser le programme planter.

D'après un TD de NSI Première (math93.com) et les sujets 0 du baccalauréat NSI.

1. À l'aide de la table ASCII (où 'a' a pour code 97), retrouver le mot codé par les octets suivants :

01101000 01100101 01101100 01101100 01101111

2. On tape le texte Le petit dans un traitement de texte, que l'on enregistre une première fois au format .docx, puis une seconde fois comme « texte brut » encodé en UTF-8. Le fichier .docx pèse environ 12 Ko, et le fichier texte… combien d'octets ? Expliquer cette différence.

3. On recommence avec le texte J'étais, aussitôt !, enregistré cette fois en UTF-8, puis en ASCII. Combien d'octets pèse la version UTF-8 ? Que se passe-t-il pour la version ASCII ?

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°46, exercice 2.

Le codage de César transforme un message en changeant chaque lettre en la décalant dans l'alphabet. Par exemple, avec un décalage de 3, le A se transforme en D, le B en E, …, le X en A, le Y en B et le Z en C. Les autres caractères ('!', '?'…) ne sont pas codés.

La fonction position_alphabet ci-dessous prend en paramètre un caractère lettre et renvoie la position de lettre dans la chaîne de caractères alphabet s'il s'y trouve.

La fonction cesar prend en paramètre une chaîne de caractères message et un nombre entier decalage et renvoie le nouveau message codé avec le codage de César utilisant le décalage decalage.

alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
def position_alphabet(lettre):
    '''Renvoie la position de la lettre dans l'alphabet'''
    return ord(lettre) - ord('A')
 
def cesar(message, decalage):
    '''Renvoie le message codé par la méthode de César
    pour le decalage donné'''
    resultat = ''
    for ... in message:
        if 'A' <= c and c <= 'Z':
            indice = (...) % 26
            resultat = resultat + alphabet[indice]
        else:
            resultat = ...
    return resultat

Compléter la fonction cesar.

Exemples :

>>> cesar('BONJOUR A TOUS. VIVE LA MATIERE NSI !', 4)
'FSRNSYV E XSYW. ZMZI PE QEXMIVI RWM !'
>>> cesar('GTSOTZW F YTZX. ANAJ QF RFYNJWJ SXN !', -5)
'BONJOUR A TOUS. VIVE LA MATIERE NSI !'

Banque nationale de sujets 2026 de l'épreuve pratique, sujet n°22 (situation d'évaluation d'une heure).

QR code simplifié

Un QR code dans sa version simplifiée est une image constituée de carrés noirs disposés sur un fond blanc. Ces carrés définissent l'information que contient le code et seront convertis en une chaîne de caractères lors du déchiffrement du code par un appareil.

Prenons par exemple un code de 6 × 8 carrés : chacun des 48 carrés est une case qui est soit noire et représente un bit de valeur 1, soit blanche et représente un bit de valeur 0. Chaque ligne de 8 cases est représentée par un tuple de 8 bits et le QR code entier par une liste de tuples.

Figure 1 : exemple de QR code simplifié (█ = case noire, · = case blanche) et sa représentation en liste de tuples.

· █ · · █ █ · █        (0,1,0,0,1,1,0,1)
· · █ · █ █ █ ·        (0,0,1,0,1,1,1,0)
· █ · · █ · · ·        (0,1,0,0,1,0,0,0)
· █ █ · · · · █        (0,1,1,0,0,0,0,1)
· █ █ █ · · █ ·        (0,1,1,1,0,0,1,0)
· █ █ · · · · █        (0,1,1,0,0,0,0,1)

Le décodage du QR code s'effectue alors en deux étapes :

• chaque tuple est vu comme la représentation binaire d'un entier naturel en base 10. Par exemple, le tuple (0,1,1,0,0,0,0,1) représente le nombre binaire 01100001 qui vaut 97 en base 10 ;
• chaque entier obtenu est ensuite associé à un caractère selon une table de correspondance. On utilisera la table des codes ASCII (American Standard Code for Information Interchange, figure 2 du sujet), qui fournit un caractère unique pour chaque entier compris entre 0 et 127. Par exemple, l'entier 97 code le caractère a.

La liste de tuples représentant le QR code devient donc une liste d'entiers, puis une chaîne de caractères, c'est-à-dire l'information du QR code.

Question 1. Écrire une fonction en Python nommée bin2dec qui prend en paramètre un tuple représentant un nombre binaire et qui renvoie l'entier naturel en base 10 correspondant. À l'aide des informations ci-dessus, déterminer la chaîne de caractères contenue dans le QR code de la figure 1 pour découvrir le nom de l'inventeur de ce système de codage.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Question 2. Écrire une fonction en Python nommée qrcode2dec qui prend en paramètre une liste de tuples représentant un QR code et qui renvoie une liste d'entiers décimaux correspondant à chacune des lignes du QR code. Proposer un test de qrcode2dec qui utilisera la représentation du QR code de la figure 1 fournie dans le module ascii.py.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Question 3. La table ASCII est ici implémentée dans le dictionnaire dict_ascii du module ascii.py. Il est utilisé par la fonction fournie dec2str qui prend en paramètre une liste d'entiers et renvoie une chaîne formée des caractères correspondants dans la table ASCII. Exécuter la fonction fournie test_dec2str et observer les résultats affichés. Identifier le problème et proposer une modification de la fonction dec2str pour l'éviter. Après modification, la fonction dec2str devra toujours renvoyer une chaîne lisible.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Question 4. On souhaite maintenant réaliser l'opération inverse : générer un QR code à partir d'un texte. La fonction str2qrcode(message) a été rédigée dans ce but. Elle parcourt les caractères du message, retrouve leur code ASCII, le convertit en binaire et génère le tuple correspondant. Cependant, en exécutant cette fonction sur la chaîne contenue dans le QR code de la figure 1, on obtient un résultat qui n'est pas exactement le QR code de la figure 1. Analyser le code de la fonction str2qrcode. Identifier la source de ce problème, puis proposer une modification du code afin de garantir l'obtention d'un QR code simplifié valide.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Fichiers fournis

Le dossier comporte une version PDF de l'énoncé, le code source de départ qrcode.py et un module ascii.py contenant le dictionnaire de conversion dict_ascii et des données de tests.

qrcode.py

import ascii
 
#############################################################################
# Question 1 et 2 : Écrire les codes des fonctions bin2dec et qrcode2dec
#              Proposer un test de qrcode2dec
#############################################################################
 
 
# implémentation du QR Code de la figure 1:
qrcode_fig1 = ascii.figure1
 
 
#############################################################################
# Question 3 : Fonctions dec2str et test_dec2str
#############################################################################
def dec2str(liste_dec):
    """ entrée: liste d'entiers décimaux
        sortie: chaine de caractère formée des caractères correspondant
        de la table ascii """
    table_ascii = ascii.dict_ascii
    chaine = ""
    for entier in liste_dec:
        chaine += table_ascii[entier]
    return chaine
 
 
def test_dec2str():
    """ Teste la fonction dec2str avec des données issues du module fourni """
    tests = [ascii.test1, ascii.test2, ascii.test3]
    for test in tests:
        print(dec2str(test))
 
 
def qrcode2str(qrcode):
    return dec2str(qrcode2dec(qrcode))
 
#############################################################################
# Question 4 : Fonction str2qrcode déficiente
#############################################################################
 
 
def str2qrcode(message):
    """
    Convertit une chaine de caractères en liste de tuples binaires.
    """
    qrcode = []
    table_inverse = {valeur: cle for cle, valeur in ascii.dict_ascii.items()}
 
    for caractere in message:
        entier = table_inverse.get(caractere, 63)
        binaire_str = bin(entier)[2:]
        ligne = tuple(int(bit) for bit in binaire_str)
        qrcode.append(ligne)
 
    return qrcode

ascii.py

figure1 = [(0, 1, 0, 0, 1, 1, 0, 1),
           (0, 0, 1, 0, 1, 1, 1, 0),
           (0, 1, 0, 0, 1, 0, 0, 0),
           (0, 1, 1, 0, 0, 0, 0, 1),
           (0, 1, 1, 1, 0, 0, 1, 0),
           (0, 1, 1, 0, 0, 0, 0, 1)]
 
dict_ascii = {
    0: "NUL", 1: "SOH", 2: "STX", 3: "ETX", 4: "EOT", 5: "ENQ", 6: "ACK", 7: "BEL",
    8: "BS", 9: "HT", 10: "LF", 11: "VT", 12: "FF", 13: "CR", 14: "SO", 15: "SI",
    16: "DLE", 17: "DC1", 18: "DC2", 19: "DC3", 20: "DC4", 21: "NAK", 22: "SYN", 23: "ETB",
    24: "CAN", 25: "EM", 26: "SUB", 27: "ESC", 28: "FS", 29: "GS", 30: "RS", 31: "US",
    32: " ", 33: "!", 34: "\"", 35: "#", 36: "$", 37: "%", 38: "&", 39: "'",
    40: "(", 41: ")", 42: "*", 43: "+", 44: ",", 45: "-", 46: ".", 47: "/",
    48: "0", 49: "1", 50: "2", 51: "3", 52: "4", 53: "5", 54: "6", 55: "7",
    56: "8", 57: "9", 58: ":", 59: ";", 60: "<", 61: "=", 62: ">", 63: "?",
    64: "@", 65: "A", 66: "B", 67: "C", 68: "D", 69: "E", 70: "F", 71: "G",
    72: "H", 73: "I", 74: "J", 75: "K", 76: "L", 77: "M", 78: "N", 79: "O",
    80: "P", 81: "Q", 82: "R", 83: "S", 84: "T", 85: "U", 86: "V", 87: "W",
    88: "X", 89: "Y", 90: "Z", 91: "[", 92: "\\", 93: "]", 94: "^", 95: "_",
    96: "`", 97: "a", 98: "b", 99: "c", 100: "d", 101: "e", 102: "f", 103: "g",
    104: "h", 105: "i", 106: "j", 107: "k", 108: "l", 109: "m", 110: "n", 111: "o",
    112: "p", 113: "q", 114: "r", 115: "s", 116: "t", 117: "u", 118: "v", 119: "w",
    120: "x", 121: "y", 122: "z", 123: "{", 124: "|", 125: "}", 126: "~", 127: "DEL"
}
 
test1 = [84, 101, 115, 116, 32, 49, 32, 114, 101, 117, 115, 115, 105, 33]
 
test2 = [84, 101, 115, 116, 32, 50, 32, 114, 101, 117, 115, 115, 105, 33]
 
test3 = [84, 101, 115, 116, 32, 51, 32, 114, 233, 117, 115, 115, 105, 33]