Numérique et sciences informatiques (spécialité) · Première

Booléens et logique : exercices corrigés de NSI Première

Publié le 6 novembre 2026 · Mis à jour le 6 novembre 2026 · Signaler une erreur

L'essentiel

Un booléen est une valeur à deux états, vrai ou faux, qui sert à représenter une valeur de vérité ³.
Le ET (conjonction) vaut VRAI si, et seulement si, ses deux opérandes valent VRAI ; sinon il vaut FAUX ⁴.
VRAI et FAUX se codent par les bits 1 et 0, et le ET peut s'écrire avec le signe ∧ ou avec une multiplication ⁴.
Selon le langage, la vérité n'est pas représentée de la même façon : en C, 0 est faux et toute autre valeur est vraie ³.

Comment utiliser ces exercices

Ces exercices te font manipuler les booléens et le ET logique comme on le fait en NSI : avec des tables de vérité, des conditions Python et quelques comparaisons avec d'autres langages. Ils sont classés du plus simple au plus délicat. Cherche d'abord seul(e), sur papier, puis ouvre les indices, et seulement après la correction pas à pas.

Le programme de NSI en Première est concret et passe par la programmation, le plus souvent en Python ². Tu peux donc tester chaque réponse dans un interpréteur Python : c'est un bon réflexe pour vérifier un raisonnement, à condition d'avoir d'abord écrit ta prévision.

Les exercices

Exercice 1 La table de vérité du ET

★☆☆Environ 5 min

On considère deux opérandes booléens $a$ et $b$ , chacun valant $0$ (faux) ou $1$ (vrai).

Écris toutes les combinaisons possibles de $(a\,;\,b)$ .
Pour chacune, donne la valeur de $a \land b$ (le ET de $a$ et $b$ ).
Combien de combinaisons donnent le résultat $1$ ?

Indice 1

Deux variables qui prennent chacune deux valeurs donnent $2 \times 2$ combinaisons.

Indice 2

Le ET ne vaut vrai que dans un seul cas : relis sa définition.

Voir la correction pas à pas

On liste les quatre combinaisons : $(0\,;\,0)$ , $(0\,;\,1)$ , $(1\,;\,0)$ et $(1\,;\,1)$ .
On applique la règle : le ET retourne VRAI si, et seulement si, les deux opérandes sont VRAI ⁴. Seule la combinaison $(1\,;\,1)$ répond à cette condition.
On obtient donc : $0 \land 0 = 0$ , $0 \land 1 = 0$ , $1 \land 0 = 0$ , $1 \land 1 = 1$ .
On compte les lignes dont le résultat vaut $1$ : il y en a une seule.

Le ET est un opérateur exigeant : une seule opérande fausse le rend faux. Retiens la table : trois lignes à $0$ , une seule à $1$ .

Exercice 2 Évaluer des conditions en Python

★☆☆Environ 8 min

En Python, la variable x vaut 7. On évalue trois conditions :

C1 : x > 5 and x < 10
C2 : x % 2 == 0 and x > 0
C3 : x != 3 and x <= 7

(x % 2 est le reste de la division de x par 2.)

Donne la valeur booléenne de chaque condition.
Combien de ces conditions sont vraies ?

Indice 1

Découpe chaque condition en deux comparaisons et évalue-les une par une.

Indice 2

Pour C2, calcule d'abord le reste de $7$ divisé par $2$ .

Voir la correction pas à pas

C1 : 7 > 5 est vrai et 7 < 10 est vrai. Les deux opérandes sont vraies, donc C1 est vraie ⁴.
C2 : 7 % 2 vaut $1$ , donc 7 % 2 == 0 est faux. Une opérande fausse suffit : C2 est fausse, sans qu'il soit utile d'examiner x > 0.
C3 : 7 != 3 est vrai et 7 <= 7 est vrai (l'égalité suffit). C3 est vraie.
Deux conditions sur trois sont vraies : C1 et C3.

Une comparaison produit une valeur booléenne, et le ET combine deux de ces valeurs. Attention à <= : il accepte l'égalité, ce qui rend C3 vraie.

Exercice 3 Des interrupteurs en série

★☆☆Environ 8 min

On simule le ET avec des interrupteurs normalement ouverts montés en série : le courant ne passe que si tous sont fermés, et une lampe affiche le résultat. Un interrupteur fermé vaut $1$ , ouvert vaut $0$ .

Avec deux interrupteurs $a$ et $b$ , que fait la lampe si $a = 1$ et $b = 0$ ?
On ajoute un troisième interrupteur $c$ en série. Sur les huit combinaisons de $(a\,;\,b\,;\,c)$ , combien allument la lampe ?

Indice 1

Dans un montage en série, le courant traverse les interrupteurs l'un après l'autre.

Indice 2

Pour la question 2, cherche combien de combinaisons ont les trois interrupteurs fermés.

Voir la correction pas à pas

Le montage en série de deux interrupteurs simule la fonction ET, et la lampe représente le résultat ⁴.
Pour $a = 1$ et $b = 0$ : le second interrupteur est ouvert, le circuit est coupé, la lampe reste éteinte ( $1 \land 0 = 0$ ).
Avec trois interrupteurs, on prolonge le raisonnement : le courant ne passe que si les trois sont fermés.
Il n'existe qu'une combinaison où $a$ , $b$ et $c$ valent tous $1$ , parmi les huit possibles : la lampe ne s'allume que dans ce cas.

Plus on ajoute d'opérandes dans un ET, plus il devient rare qu'il soit vrai : avec $n$ interrupteurs, une seule combinaison sur $2^n$ allume la lampe.

Exercice 4 Le ET comme multiplication

★★☆Environ 8 min

Le ET peut être noté par le signe de la multiplication. On pose $a = 1$ , $b = 1$ , $c = 0$ et $d = 1$ .

Calcule le produit $a \times b \times c \times d$ .
Explique pourquoi ce produit donne bien le résultat du ET de ces quatre valeurs.
Pour quelles valeurs de $(a\,;\,b\,;\,c\,;\,d)$ le produit vaut-il $1$ ?

Indice 1

Dans un produit, un facteur nul rend tout le produit nul.

Indice 2

Pour la question 3, demande-toi quelle valeur doit prendre chaque facteur pour que le produit ne soit pas nul.

Voir la correction pas à pas

Le ET est aussi représentable par le signe de la multiplication, avec VRAI codé $1$ et FAUX codé $0$ ⁴.
On calcule : $1 \times 1 \times 0 \times 1 = 0$ .
Ce $0$ correspond à FAUX, ce qui est cohérent : une des opérandes (ici $c$ ) est fausse, donc le ET est faux.
Pour que le produit vaille $1$ , aucun facteur ne doit être nul, donc chacun doit valoir $1$ . Le produit vaut $1$ seulement si $a = b = c = d = 1$ .

Sur les valeurs $0$ et $1$ , multiplier revient à appliquer le ET : le $0$ est « absorbant » et le $1$ ne change rien au produit. Cette équivalence est très pratique en programmation.

Exercice 5 Vrai ou faux dans le langage C

★★☆Environ 10 min

En langage C, les comparaisons et les opérateurs logiques donnent $1$ pour vrai et $0$ pour faux, et les tests considèrent toute valeur non nulle comme vraie. On déclare int i = 5, j = 3; puis :

int r1 = (i > j) && (i - 5);
int r2 = (i > j) && j;

Donne la valeur de chaque opérande de r1 puis celle de r1.
Même question pour r2.
Calcule $r_1 + r_2$ .

Indice 1

Une expression entière est vraie si elle est différente de $0$ .

Indice 2

i - 5 n'est pas une comparaison : c'est un simple calcul entier.

Voir la correction pas à pas

En C, les opérateurs de comparaison renvoient $1$ pour vrai et $0$ pour faux, et le zéro est considéré comme faux tandis que toute autre valeur est vraie ³.
Pour r1 : i > j vaut $1$ (vrai). Puis i - 5 vaut $0$ , donc il est faux. Le ET d'une opérande vraie et d'une opérande fausse est faux : r1 vaut $0$ .
Pour r2 : i > j vaut $1$ et j vaut $3$ , valeur non nulle donc vraie. Les deux opérandes sont vraies, donc r2 vaut $1$ .
On additionne : $r_1 + r_2 = 0 + 1 = 1$ .

En C, un entier peut jouer le rôle d'un booléen : c'est une convention du langage, pas une propriété universelle. L'opérateur && donne toujours $0$ ou $1$ , même si ses opérandes sont d'autres entiers.

Exercice 6 Filtrer des élèves avec deux critères

★★☆Environ 10 min

Un professeur veut repérer les élèves majeurs ET ayant au moins 10 de moyenne. Il dispose de couples (âge, moyenne) :

[(17, 12), (18, 9), (18, 10), (19, 15), (16, 8), (20, 10)]

Écris la condition Python qui teste un couple (age, note).
Combien d'élèves satisfont cette condition ?

Indice 1

Majeur signifie ici que l'âge est supérieur ou égal à $18$ .

Indice 2

Teste chaque couple séparément : les deux critères doivent être vrais en même temps.

Voir la correction pas à pas

La condition s'écrit age >= 18 and note >= 10. C'est un ET : les deux critères doivent être remplis ⁴.
On teste chaque couple. $(17\,;\,12)$ : l'âge est insuffisant, faux. $(18\,;\,9)$ : la note est insuffisante, faux. $(18\,;\,10)$ : les deux vrais, valide.
$(19\,;\,15)$ : valide. $(16\,;\,8)$ : les deux sont faux, faux. $(20\,;\,10)$ : valide.
Trois élèves satisfont la condition.

Remarque que le choix de >= plutôt que > change le résultat : $(18\,;\,10)$ et $(20\,;\,10)$ seraient exclus avec des inégalités strictes. Les bornes sont la première source d'erreurs dans une condition.

Exercice 7 Table de vérité à trois variables

★★★Environ 15 min

On considère l'expression Python (a and not b) or c, où a, b, c sont des booléens. Dans cet exercice, not inverse une valeur booléenne et or vaut vrai dès qu'au moins une de ses opérandes est vraie.

Dresse la table de vérité complète de l'expression.
Combien de lignes donnent le résultat vrai ?
Quelle sous-expression est un ET, et à quel moment est-elle vraie ?

Indice 1

Il y a huit lignes : fais varier $c$ plus lentement que $a$ et $b$ pour t'organiser.

Indice 2

Si c est vrai, que vaut le or quel que soit le reste ?

Voir la correction pas à pas

On liste les huit combinaisons de $(a\,;\,b\,;\,c)$ en notant $1$ pour vrai et $0$ pour faux.
On calcule d'abord not b, puis a and not b. Ce ET est vrai seulement si $a = 1$ et $b = 0$ ⁴.
Si $c = 1$ , le or est vrai quelles que soient les valeurs de $a$ et $b$ : cela fait quatre lignes vraies.
Si $c = 0$ , le résultat est celui de a and not b, vrai uniquement pour $(a\,;\,b) = (1\,;\,0)$ : une ligne de plus.
Au total, cinq lignes sur huit donnent vrai.

Décompose toujours une expression complexe en petites parties. Ici, la sous-expression a and not b est un ET dont la seconde opérande est la négation de b : elle n'est vraie qu'avec $a = 1$ et $b = 0$ .

Exercice 8 La vérité en Lisp et en C

★★★Environ 12 min

En Lisp, la valeur logique faux est représentée par la liste vide (), qui est aussi notée nil, et toute autre expression est traitée comme vraie. En C, zéro est faux et toute autre valeur est vraie.

On considère cinq valeurs Lisp : (), nil, (1 2), 0 et l'atome t.

Combien de ces valeurs sont considérées comme vraies par une structure conditionnelle Lisp ?
Parmi elles, laquelle change de statut si on la traite avec la convention du C ?

Indice 1

Repère d'abord les deux écritures qui désignent la liste vide.

Indice 2

Relis la convention du C : quelle valeur numérique y est fausse ?

Voir la correction pas à pas

En Lisp, les structures conditionnelles prennent la liste vide (), équivalente à l'atome nil, comme valeur fausse ; tout le reste compte comme vrai ³.
Les valeurs () et nil sont donc fausses. Les valeurs (1 2), 0 et t sont vraies : il y en a trois.
En C, le zéro est faux et toutes les autres valeurs sont vraies ³. La valeur 0 est vraie en Lisp mais fausse en C.
La valeur dont le statut change entre les deux conventions est donc 0.

Une même écriture, 0, est vraie dans un langage et fausse dans l'autre. Retiens que la représentation de la vérité est propre à chaque langage ; seul un type booléen explicite lève l'ambiguïté.

Exercice 9 Écrire une fonction ET

★★★Environ 15 min

On représente les booléens par les entiers $0$ et $1$ .

Écris en Python une fonction et(a, b) qui renvoie le ET de a et b, sans utiliser le mot and, en t'appuyant sur la multiplication.
Écris une seconde version de et(a, b) avec une structure if, sans multiplication ni and.
Donne les quatre appels qui testent complètement ta fonction et les résultats attendus.

Indice 1

Le ET peut s'écrire avec le signe de la multiplication.

Indice 2

Pour la version avec if, imbrique deux tests : le premier sur a, le second sur b.

Voir la correction pas à pas

Première version, par multiplication : def et(a, b): return a * b. Elle est correcte car le ET est représentable par une multiplication sur les valeurs $0$ et $1$ ⁴.
Seconde version, par tests imbriqués : def et(a, b): puis if a == 1: suivi de if b == 1: return 1, et enfin return 0 à la fin de la fonction. On ne renvoie $1$ que si les deux tests réussissent, ce qui reprend la règle : vrai si, et seulement si, les deux opérandes sont vraies ⁴.
Les quatre appels : et(0, 0) renvoie $0$ , et(0, 1) renvoie $0$ , et(1, 0) renvoie $0$ et et(1, 1) renvoie $1$ .
On vérifie que les deux versions donnent les mêmes résultats sur ces quatre cas : comme il n'y a que quatre combinaisons, le test est exhaustif.

Quand une fonction n'a que quelques entrées possibles, on peut la tester sur tous les cas, ce qui vaut preuve. C'est un avantage propre aux booléens.

Les questions qu'on se pose

Pourquoi représente-t-on vrai et faux par 1 et 0 ?

Parce que ces deux états correspondent aux deux valeurs d'un bit. Les valeurs VRAI et FAUX peuvent être représentées par les valeurs binaires 0 et 1 ⁴. Cela permet de manipuler la logique avec les mêmes circuits et les mêmes outils que les nombres en base 2, et de traduire le ET par une multiplication.

Tous les langages de programmation ont-ils un type booléen ?

Non. Certains langages n'ont pas de type de données booléen, comme C90 et Lisp, et représentent alors la vérité par un autre type de données ³. En C, on utilise des entiers : zéro est faux, toute autre valeur est vraie ³. En Python, les comparaisons donnent directement des booléens, ce qui rend les conditions plus lisibles.

Comment être sûr d'avoir bien rempli une table de vérité ?

Compte d'abord les lignes : $n$ variables donnent $2^n$ combinaisons. Évalue ensuite les sous-expressions une par une plutôt que d'un seul coup. Pour un ET, vérifie qu'il n'y a de résultat vrai que sur la ligne où toutes les opérandes sont vraies ⁴. Enfin, tu peux confirmer en Python en testant chaque ligne.

Sources

Programme visé : Programme officiel NSI Première - Représentation des données : types et valeurs de base · Ministère de l'Éducation nationale et de la Jeunesse

Programme officiel NSI Première - Représentation des données : types et valeurs de base, Ministère de l'Éducation nationale et de la Jeunesse. Consulté le 6 novembre 2026.
La spécialité Numérique et Sciences Informatiques au bac, Ministère de l'Éducation nationale et de la Jeunesse. Consulté le 6 novembre 2026.
Booléen, Wikipédia. Consulté le 6 novembre 2026.
Fonction logique ET, Wikipédia. Consulté le 6 novembre 2026.

Les numéros dans le texte renvoient à ces sources. Une source qui ne dit pas ce qu'on lui fait dire ? Signale-le.

Signaler une erreur sur cette page

Booléens et logique : exercices corrigés de NSI Première

L'essentiel

Comment utiliser ces exercices

Les exercices

Exercice 1 La table de vérité du ET

Exercice 2 Évaluer des conditions en Python

Exercice 3 Des interrupteurs en série

Exercice 4 Le ET comme multiplication

Exercice 5 Vrai ou faux dans le langage C

Exercice 6 Filtrer des élèves avec deux critères

Exercice 7 Table de vérité à trois variables

Exercice 8 La vérité en Lisp et en C

Exercice 9 Écrire une fonction ET

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur