Booléens

\(\newcommand{\ds}{\displaystyle}\) \(\newcommand{\Frac}{\ds\frac}\) \(\renewcommand{\r}{\mathbb{ R}}\) \(\newcommand{\C}{\mathbb{ C}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\z}{\mathbb{ Z}}\) \(\newcommand{\Q}{\mathbb{ Q}}\) \(\newcommand{\N}{\mathbb{ N}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\ol}{\overline}\) \(\newcommand{\abs}[1]{\left| \,{#1} \right|}\) \(\newcommand{\pv}{\;;\;}\) \(\newcommand{\ens}[1]{\left\{ {#1} \right\}}\) \(\newcommand{\mens}[1]{\setminus\left\{ {#1} \right\}}\) \(\newcommand{\Par}[1]{\left({#1}\right)}\) \(\newcommand{\pe}[1]{\left\lfloor {#1} \right\rfloor}\) \(\newcommand{\trans}[1]{\,^t\!{#1}}\)

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\)\(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 vraie
  • q est fausse
  • p 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 vraie
  • q est fausse
  • p 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 vraie
  • NON 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 Vrai
  • False 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’assertion n > 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 vaut False puisque q vaut False.

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 vaut True puisque p vaut True.

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 nombre x défini au préalable. L’usage des parenthèses n’est pas obligatoire, autrement dit, l’écriture estPos = 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 variable estPos est bien False (ligne 9).
  • Ligne 6 : on peut placer la constante True dans une variable. Idem pour la constante False.
  • Ligne 7 : si b est une variable booléenne, l’expression b == True a toujours même valeur que b, autrement dit, en pratique, il n’est que rarement justifié d’écrire une expression de la forme b == 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 :

../../../_images/bissextiles.png

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 mj 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 et m = 4 représente le 25 avril
  • le 31 septembre est représenté par j = 31 et m = 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 vaut True si le jour donné est un jour ouvrable et False sinon,
  • un booléen vacances qui vaut True si le jour donné est un jour de vacances et False 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.