# Solutions du chapitre 6

# Table des matières

Table des matières
Activité 1
Activité 2
Activité 3
Activité 4
Activité 5 (Exercice facultatif)
Activité 6
Activité 8
Activité 9
Activité 10
Activité 11
Activité 12
Activité 13
Activité 14 (*)
Activité 15
Activité 16
Activité 17
Activité 18
Activité 19
Activité 20
Activité 21
Activité 22
Activité 23
Activité 24
Activité 25
Activité 26
Activité 27
Activité 28
Activité 29
Activité 30
Activité 31
Activité 32
Activité 33
Activité 34
Activité 35
Activité 36
Activité 37
Activité 38
Questions de compréhension
Exercice 1
Exercice 2
Exercice 3
Exercice 4

# Activité 1

La stratégie pour résoudre ce problème est la suivante :

Développer une commande maison(taille) capable de dessiner une maison de taille taille.
Développer une commande carre(cote) et triangle(cote) pour réaliser la commande maison(). Dans la solution présentée dans le vidéo, on préfère développer une commande polygone(n, cote) qui permettra de dessiner aussi bien le carré que le triangle formant la maison.
D'abord assembler le programme avec des variables n et taille codées en dur dans le programme et tester le bon fonctionnement.
Demander à l'utilisateur de saisir les données désirées à stocker dans les variables n et taille lors de l'exécution du programme avec la commande input().

# Activité 2

# Activité 3

# Activité 4

Voici l'ordinogramme correspondant au code développé. Il permet de comprendre que le programme n'est pas optimisé car l'ordinateur va devoir effectuer tous les tests même si l'utilisateur a saisi "Jaune" et que tous les tests sauf le premier sont inutiles. Il est possible de remédier à ce problème en utilisant les mot-clés else ou, encore mieux, elif qui seront abordés par la suite.

# Activité 5 (Exercice facultatif)

L'exercice 5 est facultatif car il n'apporte rien de nouveau. Il suffit de développer une commande arbre() pour dessiner un arbre et une commande etoile() pour dessiner une étoile.

Ensuite, il suffit d'utiliser le programme

from gturtle import *

def arbre():
    # rajouter le code pour dessinesr l'arbre
    
def etoile():
    # rajouter le code pour dessinesr l'étoile

forme = input("Quelle forme voulez-vous dessiner?")

if forme == "arbre":
    arbre()
if forme == "étoile":
    etoile()

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Activité 6

Ordinogramme

# Activité 8

# Activité 9

# Activité 10

Avertissement

Comme on veut que l'utilisateur puisse diriger la tortue, il faut supprimer la commande hideTurtle() à la ligne 4 de l'exemple 8 dans le livre.

Cet exercice est presque un peu trop simple ... Il suffit en effet de remplacer les angles de 90° par 45° dans les commandes right() et left().

# Activité 11

Indice 1

Nous avions développé une commande pour dessiner des carrés pleins de taille 100 à la page 38.

Indice 2

Il est pratique de définir une commande carre_plein(taille) qui permet de dessiner des carrés pleins de n'importe quelle taille:

from gturtle import *

def ligne_epaisse(longueur):
    fd(longueur)
    rt(90)
    fd(1)
    rt(90)
    fd(longueur)
    right(180)
    
def carre_plein(taille):
    repeat taille - 1:
        ligne_epaisse(taille)

makeTurtle()
hideTurtle()
carre_plein(100)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# Activité 12

# Activité 13

# Activité 14 (*)

Avertissement

Cet exercice ne peut pas être résolu intelligemment avec vos connaissances actuelles. Lisez le chapitre "interrompre une boucle" pour apprendre à interrombre une boucle avec l'instruction break ou apprenez à utiliser les boucles while.

# Activité 15

En cours de préparation

# Activité 16

En cours de préparation

# Activité 17

La négation de l'affirmation $x > 2$ , est $x \leq 2$ et non $x < 2$ . Mathématiquement, cela peut être ramené à la théorie des ensembles.

Soit $X$ l'ensemble de toutes les valeurs possibles de la variable $x$
$X = \{\text{valeurs possibles de la variable }x\}$
Soit $A$ l'ensemble des valeurs de x telles que l'affirmation " $x > 2$ " est vraie
$A = \{x \in X \mid x > 2\}$
Alors l'affirmation contraire de $x > 2$ est vraie pour les valeurs de $x \in B$ , où
$B = \bar{A} := X \setminus A = \{x \in X \mid x \leq 2\}$

# Activité 18

$x < 1$
x est un nombre positif ou nul ( $x \geq 0$ )
La variable nom est différente du texte "rouge". En code cela s'écrirait de la manière suivante : nom != "rouge".
La négation de "au moins" est "moins que". La négation est donc "moins que 2 êtres humains sont assis dans la voiture". On pourrait également dire "0 ou 1 personne est assise dans la voiture".
Il y a quelque chose dans l'armoire (l'armoire n'est pas vide).

Attention

La négation n'est pas "L'armoire est pleine". Il suffit qu'il y ait juste un tout petit rien dans l'armoire pour quelle ne soit pas vide.
Le programme n'est pas écrit de manière erronée (donc il est écrit de manière correcte, sans erreur)
Le nombre de jeunes dans la classe est différent de 22
Demain, il fera moins de 24°C à Lausanne

# Activité 19

if x < 3
if nombre >= 0
if a <= b
if couleur != "rouge"

# Activité 20

En effectuant quelques tests, on peut constater que les deux commandes sont équivalentes. Il est judicieux de tester les commandes pour les valeurs $x \in \{-1, 0, 1\}$ .

test_1(-1)
test_2(-1)
test_1(0)
test_2(0)
test_1(1)
test_2(1)

1
2
3
4
5
6

# Activité 21

Remarque

Au lieu d'utiliser la fonction isInteger() qui n'existe pas en Python standard, on utiliser l'opérateur % pour vérifier si un nombre est diviseur d'un nombre. En gros, pour vérifier que x est un diviseur de n, il suffit de vérifier que $n$ est divisible par $x$ , autrement dit que le reste de la division de $n$ par $x$ est nul.

n = 24
x = input("entrer un nombre")

if n % x == 0:
    print(x, "est un diviseur de ", n)
else:
    print(x, "n'est pas un diviseur de ", n)

1
2
3
4
5
6
7

# Activité 22

Cet exercice n'a pas tellement de sens à ce stade du cours car il manque l'instruction break pour interrompre une boucle infinie.

x = 1
repeat:
    carre = x ** 2 
    if not carre > 100:
        print(carre)
    else:
        break

1
2
3
4
5
6
7
8

# Activité 23

Soit $A$ l'affirmation $x > 3$ et $B$ l'affirmation $x \leq 0$ .

Remarque

La question n'a de sens que si x est une variable entière ( $x \in \mathbb{Z}$ )

On considère l'ensemble $X_A = \{x \in \mathbb{Z} | x > 3\} = \{4, 5, 6, \ldots\}$ des valeurs de x qui satisfont à la condition $A$ et l'ensemble $X_B = \{x \in \mathbb{Z} | x \leq 0\} = \{0, -1, -2, , -3, \ldots\}$ des valeurs de x qui satisfont la condition $B$ .

L'ensemble des valeurs de x qui satisfont la condition $A$ ou $B$ est
$X_{A\text{ ou }B} = X_A \cup X_B = \mathbb{Z} \setminus \{1, 2, 3\}$
L'ensemble des valeurs de x qui satisfont la condition $A$ et $B$ est
$X_{A\text{ et }B} = X_A \cap X_B = \emptyset$

# Activité 24

La stratégie consiste à distinguer les cas dans la partie else du programme. Pour cela, il faut utiliser une structure if-elif-else imbriquée dans la partie else.

# Activité 25

Remarque

À ce stade, vous devriez être capable de résoudre ce problème assez aisément. Aucun corrigé complet n'est donc fourni.

Indice 1

La commande cercle(nombre_cotes, perimetre)` est maintenant bien connue :

def cercle(nombre_cotes, perimetre):
    repeat nombre_cotes:
        forward(perimetre / nombre_cotes)
        right(360 / nombre_cotes)

1
2
3
4
5

Indice 2

Il suffit de rajouter une instruction if avec une condition appropriée qui utilise l'opérateur logique and pour combiner les deux conditions qui doivent être satisfaites pour dessiner le cercle.

Indice 3

Il n'y a pas d'indice 3 ... il faut juste mettre ensemble les indices 1 et 2 😉

# Activité 26

Indice 1 : afficher les diviseurs de 54

Pour afficher les diviseurs de 54, on peut utiliser le code suivant qui consiste à parcourir tous les nombres entiers inférieurs à 54 et à les afficher s'ils divisent 54, à savoir si 54 % n == 0 (54 est un multiple de $n$ )

Indice 2 : afficher les diviseurs de 24

Pour afficher les diviseurs de 24, le code est très similaire

Indice " : afficher les diviseurs de 54 et 24

Pour afficher les diviseurs de 54 et 24, il suffit d'afficher les diviseurs de 24 qui sont en même temps des diviseurs de 54. Pour cela, il ne faut faire qu'une seule boucle mais changer la condition dans le if en utilisant un opérateur logique pour combiner les deux conditions.

Code complet

# Activité 27

Indice 1

Le code est très similaire à l'activité 26

Indice 2

Il faut répéter la boucle 1000 fois et incrémenter à chaque fois la variable n.

Indice 3

Il faut utiliser la condition suivante

if n % 7 == 0 and not n % 3 == 0:
    print(n)

1
2

suggérée dans le livre mais on peut également utiliser la condition

if n % 7 == 0 and n % 3 != 0:
    print(n)

1
2

qui est plus élégante.

Code complet

n = 1
repeat 999:
    if n % 7 == 0 and n % 3 != 0:
        print(n)
    n += 1

1
2
3
4
5

# Activité 28

def moyenne_harmonique(a, b):
    if a != 0 and b != 0:
        calcul = 1 / (1 / a + 1 / b)
        print(calcul)
    else:
        print "Impossible de calculer la moyenne harmonique de ", a, "et", b, ": a et b doivent être non nuls"

moyenne_harmonique(5, 10)
moyenne_harmonique(-5, 10)
moyenne_harmonique(5, 0)
moyenne_harmonique(0, 5)
moyenne_harmonique(0, 0)

1
2
3
4
5
6
7
8
9
10
11
12
13

# Activité 29

prenom = input("Quel est ton prénom?")
if not prenom == "Dennis" and not prenom == "Maria":
    print "Je ne te connais pas!"
else:
    print "Bienvenue! Quel plaisir!"

1
2
3
4
5

# Activité 30

# Activité 31

On utilise l'instruction break pour interrompre la boucle dès que la longueur du prochain segment à dessiner dépasser le maximum cote_max:

from gturtle import *

def spirale(cote, retrecissement, cote_min):
    repeat 1000:
        if cote < cote_min:
            break
        forward(cote)
        right(360 / 6)
        cote -= retrecissement

makeTurtle()
hideTurtle()
spirale(100, 5, 5)

1
2
3
4
5
6
7
8
9
10
11
12
13

# Activité 32

Pas de corrigé pour cet exercice pour le moment.

# Activité 33

Pas de corrigé pour cet exercice pour le moment.

# Activité 34

Pas de corrigé pour cet exercice pour le moment.

# Activité 35

Indice

Cet exercice est pratiquement identique à l'activité 31. On remplace simplement l'angle 360 / 6 par 360 / 8 pour dessiner une spirale octogonale et la boucle repeat par une boucle while. Cela permet d'éviter d'utiliser l'instruction break qui n'est généralement pas très élégante.


from gturtle import *

def spirale(cote, retrecissement, cote_min):
    while cote >= cote_min:
        forward(cote)
        right(360 / 8)
        cote -= retrecissement

makeTurtle()
hideTurtle()
spirale(100, 5, 10)

1
2
3
4
5
6
7
8
9
10
11
12

# Activité 36

def est_carre_parfait(nombre):
    a = 1
    while a * a < nombre:
        a += 1
        
    if a * a == nombre:
        print nombre, "est un carré parfait"
    else:
        print nombre, "n'est pas un carré parfait"

est_carre_parfait(267289)

1
2
3
4
5
6
7
8
9
10
11

# Activité 37

Pas de corrigé pour cet exercice pour le moment

# Activité 38

somme = 0
denominateur = 1

while somme < 5:
    somme += 1 / denominateur
    denominateur += 1
    
print "dernier denominateur", denominateur - 1
print "somme de toutes les fractions: ", somme

1
2
3
4
5
6
7
8
9

Remarque

Il faut afficher le nombre denominateur - 1 après la boucle puisque, juste avant que la boucle n'ait été interrompue, la ligne 6 a incrémenté la variable denominateur "une fois de trop".

# Questions de compréhension

On peut s'assurer qu'un programme n'effectue une tâche que lorsqu'une condition donnée est satisfaite à l'aide de l'instruction if. La syntaxe est la suivante:
```
if condition:
    instructions()
```
1
2

Pour choisir entre deux options mutuellement exclusives, on utilise la structure if-else:

if condition:
    instructions_si_condition_vraie()
else:
    instructions_si_condition_fausse()

1
2
3
4

Oui, c'est même le cas le plus fréquent. Pour modifier le comportement d'un programme selon les circonstances, on utilise précisément une instruction if dont la condition fait référence à des variables dont la valeur peut changer d'une fois à l'autre, par exemple en fonction d'une saisie utilisateur.
```
meteo = input("Quel temps fait-il?")
if meteo == "pluie":
    print "Il vaut mieux prendre le parapluie"
else:
    print "Il n'est pas nécessaire de prendre le parapluie aujourd'hui"
```
1
2
3
4
5
6
On peut interrompre prématurément l'exécution d'une boucle à l'aide de l'instruction break, le plus souvent utilisée dans une instruction conditionnelle if. On préfère par contre généralement éviter d'utiliser break et on préfère utiliser une boucle while à la place lorsque c'est possible.

La structure d'une boucle while est la suivante:

while condition:
    corps_de_la_boucle()

1
2

Très souvent, on utilisera une variable pour contrôler la condition de terminaison de la boucle. Cette variable peut être un compteur

i = 0
somme = 0
while i < 100:
    somme += i
    # très important d'incrémenter la variable de contrôle i, 
    # sinon, on crée une boucle infinie qui ne pourra jamais s'arrêter
    i += 1

1
2
3
4
5
6
7

# Exercice 1

Le corrigé de cet exercice est en cours de rédaction.

# Exercice 2

On teste simplement chaque paire de nombres pour voir s'il y en a une où les deux nombres sont égaux. on combine tous les tests avec l'opérateur logique or. Il suffit donc que l'une des paires contiennent deux nombres égaux pour afficher le message que deux nombres au moins sont égaux.

Les paires de nombres sont les suivantes $(a, b)$ , $(a, c)$ , $(b, c)$ . Il suffit donc de tester la condtion

a == b or a == c or b == c

Remarque

On définit une commande test() qui permet de tester tous les cas de figures possibles pour s'assurer que notre commande fonctionne correctement.

Les cas de figures sont les suivants

sont_differents(1,2,3)
sont_differents(1,1,2)
sont_differents(1,2,1)
sont_differents(1,2,2)
sont_differents(1,1,1)

1
2
3
4
5

def sont_differents(a, b, c):
    if a == b or a == c or b == c:
        print("Les trois nombres sont différents")
    else:
        print("Il y a au moins deux nombres égaux")
        
def test():
    sont_differents(1,2,3)
    sont_differents(1,1,2)
    sont_differents(1,2,1)
    sont_differents(1,2,2)
    sont_differents(1,1,1)
    
test()

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Exercice 3

Indice 1

Un exercice très similaire avant déjà été fait Cet exercice a déjà été effectué au chapitre précédent. Le code était alors le suivant

from gturtle import *

def triangle(cote):
    repeat 3:
        forward(cote)
        left(360 / 3)
        
def repositionnement(cote):
    forward(cote)
    left(60)

def figure(nombre_triangles, cote):
    cote = 256
    repeat 5:
        triangle(cote)
        repositionnement(cote)
        cote /= 2
            
makeTurtle()
speed(-1)
setPos(200, -200)
left(30)
figure(6, 350)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Indice 2

La seule différence avec l'exercice 3, page 75 du chapitre précédent est que l'on ne veut pas interrompre la boucle après avoir dessiné un nombre donné de triangles mais une fois que le dernier triangle est plus petit qu'une certaine valeur. Comme on ne sait pas à l'avance le nombre de triangles à dessiner, la boucle repeat n'est pas pratique et il vaut mieux utiliser une boucle while.

On veut exécuter la boucle tant que la taille du prochain triangle que l'on va dessiner est supérieure à la limite fixée.

Code complet

La seule chose qui change par rapport à l'exercice 3 du chapitre 5 est le premier paramètre de la commande figure() qui n'est plus le nombre de triangles dessiner mais la taille minimale des triangles.

Le seul autre changement est à la ligne 14 où l'on remplace la boucle repeat par la boucle while.

from gturtle import *

def triangle(cote):
    repeat 3:
        forward(cote)
        left(360 / 3)
        
def repositionnement(cote):
    forward(cote)
    left(60)

def figure(taille_min, cote):
    cote = 256
    while cote > taille_min:
        triangle(cote)
        repositionnement(cote)
        cote /= 2
            
makeTurtle()
speed(-1)
setPos(200, -200)
left(30)
figure(3, 350)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# Exercice 4

Le corrigé de cet exercice est en cours de rédaction.