Booléens¶
Cours¶
Opérateurs logiques ET, OU et NON¶
Les notions d”assertion logique et d”opérateur logique existent indépendamment de tout langage de programmation. L’énoncé \(2k+1 \geq 100\) où \(k\) est un entier, est un exemple d’assertion logique (elle est vraie ou fausse selon la valeur de \(k\), vraie si \(k=60\), fausse si \(k=25\)).
L’opérateur ET
¶
À partir de deux propositions logiques p
et q
, on peut former la proposition logique p ET q
. Par exemple, si on a les deux propositions logiques :
p : 5 > 3
, q : 4 > 7
alors
p
est vraieq
est faussep ET q
est une proposition fausse.
Règle : p ET q
est vraie uniquement si p
est vraie et si q
est également vraie.
Cette règle est conforme à l’usage habituel de la conjonction de coordination ET.
Voici donc la table de vérité de l’opérateur ET
:
p |
q |
p ET q |
Vrai | Vrai | Vrai |
Vrai | Faux | Faux |
Faux | Vrai | Faux |
Faux | Faux | Faux |
Ne pas accorder trop d’importance à cette table, en pratique assez peu utile. Une expression de la forme p ET q
s’appelle une conjonction et p
et q
s’appellent les opérandes de la conjonction.
La notion d’opérateur OU
¶
À partir de deux propositions logiques p
et q
, on peut former la proposition logique p OU q
. Par exemple, si
p : 5 > 3
, q : 4 > 7
alors :
p
est vraieq
est faussep OU q
est une proposition vraie.
Règle : p OU q
est fausse uniquement si p
est fausse et si q
est également fausse.
Une expression de la forme p OU q
s’appelle une disjonction. Les assertions p
et q
s’appellent les opérandes de la disjonction.
Voici la table de vérité de l’opérateur OU
:
p |
q |
p OU q |
Vrai | Vrai | Vrai |
Vrai | Faux | Vrai |
Faux | Vrai | Vrai |
Faux | Faux | Faux |
Ne pas accorder trop d’importance à cette table, en pratique assez peu utile.
Le OU
est non exclusif¶
Le OU
logique n’a pas valeur exclusive comme dans fromage ou dessert et qui signifie
soit fromage soit dessert mais pas les deux.
Autrement dit, dès que l’une des deux assertions p
ou q
sont les deux vraies alors l’assertion p OU q
est vraie.
Par exemple, si
p : 5 > 3
, q : 4 < 7
alors :
p
est vraie,q
est vraie,- la proposition
p OU q
est vraie.
L’opérateur logique NON
¶
La proposition NON p
est la négation de p
. Si
p : 5 > 3
alors :
p
est vraieNON p
est fausse.
Règle : toute proposition logique p
admet une négation q
, notée NON p
. La valeur logique de q
est
- vraie si
p
est fausse, - fausse si
p
est vraie.
Les booléens en Python¶
Les valeurs de vérité Vrai et Faux en Python sont représentées par deux constantes du langage :
True
pour VraiFalse
pour Faux
True
et False
sont des mots-clés du langage Python 3. Les booléens True
et False
appartiennent, comme les entiers ou les flottants, à un type, le type bool
.
Opérateurs de comparaison et booléen¶
Certaines expressions ont pour valeur des booléens. C’est le cas, par exemple, de toute expression représentant une comparaison. Par exemple, l’expression Python 42 > 45
vaut False
:
1 2 | print(42 > 45)
print(42 == 40 + 2)
|
3 4 | False
True
|
- Lignes 3-4 : l’assertion « 42 est strictement supérieur à 45 » vaut
False
. - Ligne 1 : l’assertion « 42 a même valeur que 40 + 2 » vaut
True
(elle est vraie).
Voici un exemple d’utilisation :
1 2 3 | n = 5 * 12 + 6 ** 3 - 42 + 17
print(n > 256)
print(n)
|
4 5 | False
251
|
- Ligne 1 :
n
est un entier dont la valeur explicite n’apparaît pas dans le code. - Ligne 2 : On teste pour savoir si l’entier
n
est plus grand que 256. - Ligne 4 : On lit que non (cf.
False
),n
n’est pas plus grand que 256. - Lignes 3 et 5 : le calcul explicite de
n
confirme que l’assertionn > 256
est fausse.
En pratique, les comparaisons utilisent souvent des variables. Par exemple, on se donne un entier k
et on cherche à savoir si \(\mathtt{2k+1\geq 100}\). En Python on écrira :
1 2 3 4 5 | k=10
print(2*k+1 >= 100)
k=60
print(2*k+1 >= 100)
|
6 7 | False
True
|
Opérateurs and
, or
et not
¶
L’opérateur logique ET
est représenté en Python par le mot-clé et opérateur and
:
1 2 3 4 5 | p = (5 > 3)
q = (4 > 7)
print(p)
print(q)
print(p and q)
|
6 7 8 | True
False
False
|
- Lignes 5 et 8 :
p and q
vautFalse
puisqueq
vautFalse
.
L’opérateur logique OU est représenté en Python par le mot-clé et opérateur or
.
1 2 3 4 5 | p = (5 > 3)
q = (4 > 7)
print(p)
print(q)
print(p or q)
|
6 7 8 | True
False
True
|
- Lignes 5 et 8 :
p or q
vautTrue
puisquep
vautTrue
.
L’opérateur NON
est représenté en Python par le mot-clé et opérateur not
.
1 2 3 4 5 | p = (5 == 2 + 3)
print(p, not p)
q = (3 > 4)
print(q, not q)
|
6 7 | True False
False True
|
Expressions booléennes¶
De la même façon qu’il existe des expressions arithmétiques comme
x*(x+1) - 4*x*y + 1
,
il existe des expressions booléennes, comme
p and (q or r) or (not p and q)
,
qui s’obtiennent en combinant des opérateurs logiques avec des expressions.
Évaluer une expression booléenne, c’est déterminer si elle vaut True ou False.
Par exemple
(1 == 2 and 2 == 3) or 1 == 1
est un expression booléenne dont la valeur est True
.
Bien se rendre compte que dans de nombreuses situations, les parenthèses figurant dans l’expression sont indispensables. Ainsi, comparer :
1 2 3 4 | a=1
b=2
print((not a) == b)
print(not a == b)
|
5 6 | False
True
|
Pour conclure, donnons deux exemples typiques d’expressions booléennes.
Exemple 1 : être positif¶
Il est fréquent que les expressions booléennes utilisent des variables. Par exemple, si x
est une variable, on peut définir une expression booléenne qui exprime si oui ou non x
représente un nombre positif : x >= 0
. On peut référencer ces expressions booléennes elles-mêmes par une variable. Ainsi :
1 2 3 4 5 6 7 8 | x = 2**19 - 10**6
estPos = (x >= 0)
print(estPos)
print(x)
vrai = True
print(estPos == vrai)
|
9 10 11 | False
-475712
False
|
- Ligne 2 : on a défini une « variable booléenne »
estPos
et qui ici permet de tester le caractère positif de n’importe quel nombrex
défini au préalable. L’usage des parenthèses n’est pas obligatoire, autrement dit, l’écritureestPos = x >= 0
, bien que moins lisible, est licite. - Ligne 4 : l’affichage (ligne 10) montre que
x
est négatif donc la valeur de la variableestPos
est bienFalse
(ligne 9). - Ligne 6 : on peut placer la constante
True
dans une variable. Idem pour la constanteFalse
. - Ligne 7 : si
b
est une variable booléenne, l’expressionb == True
a toujours même valeur queb
, autrement dit, en pratique, il n’est que rarement justifié d’écrire une expression de la formeb == True
.
Exemple 2 : comparer des heures¶
Cet exemple est traité en vidéo ICI.
On donne deux moments de la journée, désignés par M
et MM
, en heures et minutes, par exemple
\(\texttt{M = 14 h 52 min}\) et \(\texttt{MM = 14 h 51 min}\).
et on demande de dire si, oui ou non, M
est un moment de la journée strictement antérieur à MM
. Dans l’exemple ci-dessus, la réponse est non.
Chaque moment sera donné sous la forme de deux entiers h
, m
représentant les heures et les minutes pour M
et de même hh
, mm
pour MM
.
Pour exprimer que M
est antérieur à MM
, on compare les heures : \(\mathtt{h < hh}\). Si elles sont distinctes, on peut conclure, sinon c’est que l’expression booléenne \(\mathtt{h == hh}\) est True
, et il faut comparer les minutes (\(\mathtt{m < mm}\)) pour conclure. D’où l’expression booléenne suivante :
(h < hh) or (h == hh and m < mm)
Cette expression est vraie si et seulement si M
est strictement antérieur à MM
. Voici un exemple d’utilisation :
1 2 3 4 5 6 7 | h=14
m=52
hh=14
mm=51
print((h < hh) or (h == hh and m < mm))
|
8 | False
|
Exercice type : Année bissextile¶
Cet exercice est résolu en vidéo : ICI.
Une année bissextile est une année multiple de 4, non multiple de 100 à moins qu’elle ne soit multiple de 400. Ainsi,
- 2021 n’est pas bissextile puisque 2021 n’est pas un multiple de 4 ;
- 2024 est bissextile car elle est multiple de 4 et non multiple de 100 ;
- 3000 n’est pas bissextile car elle est multiple de 100 sans être multiple de 400;
- 2000 était bissextile car 2000 est multiple de 400.
Soit n
une année. En considérant que les restes de n
par 4, 100 ou 400 sont nuls ou pas, écrire un booléen estBissext
qui vaut True
si n
est bissextile et False
sinon.
Solution
Si on fait un dessin de toutes les années en distinguant les multiples de 4, de 100 et de 400, on voit que les années bissextiles se répartissent dans les deux zones rouges disjointes ci-dessous :
On distingue une couronne rouge et le disque rouge au centre. La couronne rouge représente les années \(\mathtt{n}\) multiples de 4 ET qui ne sont pas multiples de 100. Donc la couronne rouge représente le booléen
n % 4 == 0 and n % 100 != 0
Le disque au centre représente les années \(\mathtt{n}\) multiples de 400, donc le booléen n % 400 == 0
.
Une année est bissextile exactement si elle est dans la couronne OU dans le disque central, ce qui se traduit par le OU booléen suivant :
estBissext = (n % 4 == 0 and n % 100 != 0) or n % 400 == 0
On pouvait aussi remarquer que n
est bissextile si elle est multiple de 4 et ne fait pas partie des années telle 1900 ou 3000 qui sont multiples de 100 et pas de 400 (la couronne verte du dessin), autrement dit si : n
n’est pas multiple de 100 ou est multiple de 400. D’où le booléen suivant :
estBissext = (n % 4 == 0) and (n % 100 != 0 or n % 400 == 0)
D’où le code suivant qui traite les quatre cas possibles :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | n=2025
p = (n % 4)==0
q = (n % 100)==0
r = (n % 400)==0
estBissextile = p and (not q or r)
print(n, "->", estBissextile)
print("-------------------------------")
n=2020
p = (n % 4)==0
q = (n % 100)==0
r = (n % 400)==0
estBissextile = p and (not q or r)
print(n, "->", estBissextile)
print("-------------------------------")
n=3000
p = (n % 4)==0
q = (n % 100)==0
r = (n % 400)==0
estBissextile = p and (not q or r)
print(n, "->", estBissextile)
print("-------------------------------")
n=2000
p = (n % 4)==0
q = (n % 100)==0
r = (n % 400)==0
estBissextile = p and (not q or r)
print(n, "->", estBissextile)
print("-------------------------------")
|
32 33 34 35 36 37 38 39 | 2025 -> False
-------------------------------
2020 -> True
-------------------------------
3000 -> False
-------------------------------
2000 -> True
-------------------------------
|
Alternative¶
Il aurait aussi été possible d’écrire un booléen estNonBissextile
traduisant qu’une année n
est non bissextile en disant qu’elle n’est pas multiple de 4 (traduction : not p
) ou alors (traduction or
) qu’elle est multiple de 100 et pas multiple de 400 (traduction : q and not r
) puis en prenant la négation de estNonBissextile
:
1 2 3 4 5 6 7 8 | n=3000
p = (n % 4)==0
q = (n % 100)==0
r = (n % 400)==0
estNonBissextile =(not p) or (q and not r)
estBissextile =not estNonBissextile
print(n, "->", estBissextile)
|
Exercice type : 14 juillet¶
Une date est codée avec deux variables j
et m
où j
représente le jour du mois et m
le numéro du mois. Par exemple, le 2 novembre est codé avec j = 2
et m = 11
. On vous donne deux variables j
et m
représentant une date valide et vous devez construire une variable booléenne notée avant
et qui vaut True
si la date donnée tombe le 14 juillet ou les jours d’avant et False
si elle tombe à partir du 15 juillet. Ci-dessous, quelques exemples d’exécution du programme demandé :
1 2 3 4 5 6 7 | (10, 4) -> True
(15, 6) -> True
(10, 7) -> True
(14, 7) -> True
(20, 7) -> False
(2, 11) -> False
(25, 12) -> False
|
Solution
Pour savoir si une date (j, m)
est antérieure au 14 juillet, on commence par regarder si le mois m
vérifie m < 7
et si c’est le cas, la date est bien antérieure ; sinon, on regarde si m
vaut 7 et dans ce cas, la date sera antérieure selon que le jour sera ou pas, antérieur au 14. Dans tous les autres cas, la date n’est pas antérieure. D’où le code :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | j = 10
m =4
avant = m<7 or m==7 and j<=14
print((j,m), "->", avant)
j = 15
m =6
avant = m<7 or m==7 and j<=14
print((j,m), "->", avant)
j = 10
m =7
avant = m<7 or m==7 and j<=14
print((j,m), "->", avant)
j = 14
m =7
avant = m<7 or m==7 and j<=14
print((j,m), "->", avant)
j = 20
m =7
avant = m<7 or m==7 and j<=14
print((j,m), "->", avant)
j = 2
m =11
avant = m<7 or m==7 and j<=14
print((j,m), "->", avant)
j = 25
m =12
avant = m<7 or m==7 and j<=14
print((j,m), "->", avant)
|
35 36 37 38 39 40 41 | (10, 4) -> True
(15, 6) -> True
(10, 7) -> True
(14, 7) -> True
(20, 7) -> False
(2, 11) -> False
(25, 12) -> False
|
Exercice type : Mois de 31 jours¶
Cet exercice est résolu en vidéo : ICI.
On donne un numéro de mois m
entre 1 et 12. Créer une variable booléenne est_mois_31
(prenant comme valeur True
ou False
) qui teste si m
est le numéro d’un mois ayant 31 jours comme janvier (numéro 1) ou juillet (numéro 7) mais pas février (numéro 2).
Solution
On dispose de la liste des numéros de mois ayant 31 jours, donc il suffit de tester les uns après les autres le mois donné m
avec les mois possibles :
1 2 3 4 5 | m = 4
est_mois_31 = (m == 1 or m == 3 or m == 5 or
m == 7 or m == 8 or m== 10 or m== 12)
print(est_mois_31)
|
6 | False
|
- Lignes 2-3 : une expression placée entre des parenthèse peut être exceptionnellement écrite sur plusieurs lignes, cela évite d’écrire de longues lignes.
On peut aussi essayer de donner une condition plus synthétique. Un mois de 31 jours placé avant août est de numéro 1, 3, 5 ou 7 et donc impair ; à l’inverse, un mois de 31 jours placé à partir d’août est de numéro 8, 10 ou 12 et donc pair. D’où le code suivant :
1 2 3 | m = 9
est_mois_31 = ((m <= 7 and m % 2 == 1) or (m >= 8 and m % 2 == 0))
print(est_mois_31)
|
4 | False
|
On pouvait aussi remarquer qu’il y a plus de mois à 31 jours et donc il est (légèrement) plus court d’écrire de passer par la négation :
1 2 3 | m = 4
est_mois_31 = not (m==2 or m==4 or m==6 or m==9 or m==11)
print(est_mois_31)
|
4 | False
|
Exercices¶
Egaux ou opposés¶
Ecrire une variable booléenne egaux_ou_opp
qui à partir de deux entiers x
et y
teste si les deux nombres sont égaux ou opposés. Exemples de comportement :
x |
y |
egaux_ou_opp |
5 |
6 |
False |
42 |
42 |
True |
42 |
-42 |
True |
Nombres de même signe¶
Ecrire un booléen memeSigne
qui vaut True
si les nombres donnés a
et b
sont de même signe, et False
dans le cas inverse. On considérera que 0 est aussi bien positif que négatif. Exemples de comportements :
42 17 -> True
42 0 -> True
-42 17 -> False
42 -17 -> False
-42 -17 -> True
-42 0 -> True
0 -42 -> True
0 0 -> True
Entiers qui se suivent¶
On vous donne deux variables x
et y
représentant des entiers. Définir une variable booléenne ok
valant True
si
- les entiers sont entre 1 et 4 ET
- ou bien sont consécutifs
- ou bien l’un vaut 1 et l’autre vaut 4.
Sinon, ok
vaudra False
.
Exemples
5 2 -> False
2 3 -> True
3 2 -> True
4 4 -> False
7 8 -> False
4 1 -> True
3 1 -> False
Trois entiers consécutifs¶
On donne trois entiers a
, b
et c
. Construire un booléen sontConsecutifs
valant True si les trois entiers, lorsque on les range dans l’ordre croissant, sont consécutifs.
Voici quelques exemples de comportements du programme :
5 6 7 -> True
6 5 7 -> True
5 8 7 -> False
7 6 5 -> True
Négatif, positif et nul¶
On donne trois entiers a
, b
et c
. Construire un booléen ok
qui vaut True si parmi les trois entiers il y a un entier strictement positif, un entier strictement négatif et le nombre zéro, sinon ok
vaudra False
. Voici quelques exemples de comportements :
a = -4 b = 3 c = 0 -> True
a = -2 b = 0 c = 3 -> True
a = 4 b = 5 c = 2 -> False
a = 0 b = 0 c = 0 -> False
a = -1 b = -2 c = 4 -> False
a = 0 b = 0 c = 0 -> False
Test de la non-égalité de cinq entiers¶
On donne cinq entiers a, b, c, d et e. Soit la condition C suivante : les 5 entiers ne sont pas tous égaux. Par exemple
- si a=5, b=5, c=5, d=4 et e=4 alors C est True
- si a=5, b=5, c=5, d=5 et e=5 alors C est False
Ecrire une variable booléenne qui vaut True si la condition C est vraie et False sinon.
Conditions sur un entier¶
Dans cette question, x
est supposé être un entier. Créer une variable booléenne cond
(prenant comme valeur True
ou False
) qui teste si x
est ou bien multiple de 10 ou bien à la fois impair, non multiple de 3 et compris, au sens large, entre 42 et 421. Ainsi x = 2020
passe le test, x = 301
aussi, x = 420
également mais pas x = 81
.
Au moins un pair et au moins un supérieur à 100¶
On donne trois entiers positifs a
, b
et c
. Construire un booléen ok
qui vaut True
si parmi les trois nombres, il y a au moins un nombre pair et aussi s’il y a au moins un nombre supérieur ou égal à 100. Sinon, ok
vaut False
Exemples :
7 42 142 -> True
42 60 71 -> False
111 125 2015 -> False
80 111 31 -> True
7 41 142 -> True
Heures d’ouverture¶
Dans l’exercice, on supposera que
- les jours de la semaine sont codés à l’aide d’un entier \(\mathtt{j}\) avec \(\mathtt{j=1}\) pour lundi, \(\mathtt{j=2}\) pour mardi, et ainsi de suite jusqu’à dimanche (\(\mathtt{j=7}\))
- une heure est codée par une entier entre 0 (inclus) et 24 (exclu).
Un magasin est ouvert du lundi au vendredi de 8h à 18h et le samedi de 9h à 12h et il est fermé le reste du temps.
On donne un jour \(\mathtt{j}\) et une heure \(\mathtt{h}\) et on demande d’écrire un booléen estOuvert
et qui vaut True
si le magasin est ouvert le jour j
à l’heure h
et False
sinon.
Voici quelques exemples de comportements du programme :
j | h | Ouvert ? |
2 | 17 | True |
6 | 10 | True |
2 | 19 | False |
6 | 17 | False |
Vacances¶
On donne deux entiers j
et m
représentant une date valide où m
représente le numéro du mois (entre 1 et 12) et j
le jour du mois (entre 1 et 31). Ainsi,
- la donnée
j = 25
etm = 4
représente le 25 avril - le 31 septembre est représenté par
j = 31
etm = 9
.
Imaginons que les vacances d’été aient lieu à partir du 6 Juillet et jusqu’au 2 septembre. On donne le jour j
et le mois m
d’une date et on vous demande de construire une variable booléenne enVacances
valant True si la date correspond à un jour de vacances d’été et False
sinon. Exemples :
j = 1 et m = 5 -> False
j = 6 et m = 7 -> True
j = 7 et m = 7 -> True
j = 14 et m = 7 -> True
j = 2 et m = 8 -> True
j = 31 et m = 8 -> True
j = 3 et m = 9 -> False
j = 4 et m = 9 -> False
j = 7 et m = 9 -> False
j = 8 et m = 12 -> False
Jours de repos¶
À un jour donné, Léa se repose si le jour n’est pas un jour ouvrable (lundi à vendredi) ou si elle est en vacances. On vous donne
- un booléen
ouvrable
qui vautTrue
si le jour donné est un jour ouvrable etFalse
sinon, - un booléen
vacances
qui vautTrue
si le jour donné est un jour de vacances etFalse
sinon,
et on vous demande de définir un booléen repos
dépendant des deux variables précédentes et qui vaut True
si Léa se repose le jour donné et False
sinon.
Tous ou uniquement un positifs¶
On donne trois entiers a
, b
et c
. Écrire un booléen ok
qui vaut True
lorsque exactement un des trois entiers est strictement positif ou alors si les trois sont tous strictement positifs.
Voici quelques exemples de comportements du programme :
-5 12 3 -> False
0 1 5 -> False
-2 -8 -3 -> False
1 2 3 -> True
-2 6 -8 -> True
2 6 -8 -> False
-1 0 0 -> False
1 0 0 -> True
0 0 0 -> False
Exactement un positif¶
On donne deux entiers a
et b
. Construire un booléen unSeulPositif
valant True
si
- soit
a
- soit
b
est strictement positif et False
sinon.
Voici quelques exemples de comportements du programme :
-5 12 -> True
1 5 -> False
-2 -8 -> False
1 -2 -> True
0 6 -> True
0 -6 -> False
0 0 -> False
Entier ayant \(n\) chiffres¶
On vous donne un entier \(x>0\) et un autre entier \(n>0\). Créer une variable booléenne avoir_n_chiffres
(prenant comme valeur True ou False) qui teste si l’entier \(x\) admet exactement \(n\) chiffres dans son écriture en base 10. Par exemple, si \(x=421\) et \(n=2\), la condition vaut False et si \(n=3\), la condition vaut True. Pour trouver la condition, on pourra observer, en utilisant des puissances de 10, quel est le plus petit et le plus grand entier ayant \(n\) chiffres.
Entiers dans un rapport de 2 ou 3¶
On donne deux nombres entiers positifs \(\mathtt{a}\) et \(\mathtt{b}\) et on demande d’écrire une variable booléenne double_ou_triple
qui vaudra True
exactement si un des deux nombres est le double ou le triple de l’autre. Voici quelques exemples accompagnés d’une brève explication :
\(\mathtt{a}\) | \(\mathtt{b}\) | double_ou_triple |
Explication |
\(\mathtt{5}\) | \(\mathtt{15}\) | True |
\(\mathtt{b=3a}\) |
\(\mathtt{20}\) | \(\mathtt{10}\) | True |
\(\mathtt{a=2b}\) |
\(\mathtt{42}\) | \(\mathtt{30}\) | False |
\(\mathtt{a\neq 2b}\) \(\mathtt{a\neq 3b}\) \(\mathtt{b\neq 2a}\) \(\mathtt{b\neq 3b}\) |
\(\mathtt{0}\) | \(\mathtt{42}\) | False |
Idem |
\(\mathtt{0}\) | \(\mathtt{0}\) | True |
\(\mathtt{b=2a}\) |
Triangle valide ou pas¶
Il n’existe pas de triangle de côtés de longueur 42, 81 et 32. En effet, le côté d’un triangle a toujours une longueur valant strictement moins que la somme des deux autres et, ici, on a \(\mathtt{81 > 42+32}\). Et inversement, si on se donne trois nombres positifs tels que chacun soit strictement inférieur à la somme des deux autres, alors il existe bien un triangle ayant ces nombres pour longueur de côtés.
On donne trois entiers a
, b
et c
et on demande d’écrire, de préférence en une ligne de code, un booléen estValide
qui vaut True
si et seulement s’il existe un triangle de côtés de longeurs a
, b
et c
, et False
sinon.
Voici quelques exemples de comportement :
(-3, 4, 10) -> False
(42, 81, 32) -> False
(42, 81, 50) -> True
Intervalles disjoints ou pas¶
On donne deux intervalles réels \(\mathtt{I= ]a, b[}\) et \(\mathtt{J=]c, d[}\) tels que : \(\mathtt{a<b}\) et \(\mathtt{c<d}\) (pour éviter les ambiguïtés, les extrémités des intervalles sont exclues). Ecrire un booléen inter
qui vaut True
si les intervalles \(\mathtt{I}\) et \(\mathtt{J}\) s’intersectent en au moins un point et False
sinon. Voici un exemple de comportements du programme :
(2, 4), (3, 6) : True
(2, 3), (1, 4) : True
(5, 6), (1, 4) : False
(2, 4), (1, 2) : False
Le booléen inter
peut s’écrire en une seule ligne et ne dépend que de a
, b
, c
et d
. On essayera plutôt de traduire que les intervalles sont disjoints, autrement dit d’intersection vide.