TP - Exercices pour progresser

Rappels utiles

Ces exercices doivent être utilisés pour vous entraîner à programmer. Ils sont généralement accompagnés d'aide et de leur solution pour vous permettre de progresser.

Avant de vous précipiter sur ces solutions dès la première difficulté, n'oubliez pas les conseils suivants :

Avez-vous bien fait un schéma au brouillon pour visualiser le problème posé ?
Avez-vous essayé de rédiger un algorithme en français, avec vos propres mots, avant de vous lancer dans la programmation sur machine ?
Avez-vous utilisé des affichages intermédiaires, des print(), pour visualiser au fur et à mesure le contenu des variables ?
Avez-vous testé le programme avec les propositions de tests donnés dans l'exercice ?
Avez-vous testé le programme avec de nouveaux tests, différents de ceux proposés ?

Tests du code et main

Le main est le code principal d'un programme. Il ne sera exécuté que si le fichier courant est directement exécuté. Par exemple, si un fichier contenant un main est importé, ce code ne sera pas exécuté.

Voici un exemple de ce qu'il faut faire :

# Rédigez ici vos fonctions

if __name__ == "__main__":
    # Ces lignes permettent d'exécuter les tests présents dans les docstrings
    import doctest
    doctest.testmod()

    # Rédigez ici votre code principal (tests, affichages ...)

Le doctest permet de tester les fonctions en utilisant les tests rédigés dans le docstring, c'est-à-dire le commentaire situé dans la définition de la fonction.

Exercice n°0 : Créer à la main une liste de listes

Revenez sur la page précédente puis écrivez chacun des codes Python donnés pour observer leur résultat.

Exercice n°1 : Remplir une liste de listes

On considère une liste contenant 5 listes ayant chacune 3 éléments. Remplir avec un programme Python cette liste avec, des entiers dans l'ordre croissant de 1 en 1, en commençant à 1 puis afficher correctement cette liste de listes.

Pour y parvenir, vous devez réaliser deux boucles for imbriquées : la première crée une liste, la deuxième remplit la liste créée. Voici un exemple :

ma_liste = []

for i in range(3): # 3 : nombre de lignes
    # Je crée une liste qui sera dans "ma_liste". Je crée donc une LIGNE
    une_liste = []
    for i in range(5): # 5 : nombre de colonnes
        # J'ajoute un élément dans "une_list". Chaque élément sera donc ajouté dans une COLONNE différente
        une_liste.append(0)  # J'ajoute 0, mais pour répondre à la question, je dois ajouter autre chose
    # J'ajoute cette liste créée dans "ma_liste"
    ma_liste.append(une_liste)

print(ma_liste)
# Je dois voir ceci :
# [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]

# Mais je dois l'afficher comme ceci en utilisant une boucle FOR et en affichant chaque élément de "ma_liste"
# qui est alors une liste (puisque "ma_liste" ne contient que des listes) :
# [0, 0, 0, 0, 0]
# [0, 0, 0, 0, 0]
# [0, 0, 0, 0, 0]

# for .... in ......:
#     print(.....)

La question précédente doit conduire à l'affichage :

[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
[10, 11, 12]
[13, 14, 15]

À présent, générer deux entiers aléatoires compris entre 1 et 10. Le premier correspond au nombre de listes et le second, au nombre d'éléments de chaque liste.

Adaptez les deux questions précédentes pour que la liste soit remplie par des entiers dans l'ordre croissant.

Exercice n°2 : Numéro de ligne, de colonne

En repartant de l'exercice précédent, concevoir les programmes qui permettent de créer et d'afficher les listes de listes ci-dessous.

Les deux premières sont des listes carrées contenant 8 sous-listes de 8 éléments tandis que la dernière contient 7 sous-listes de 7 éléments.

[1, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0]
[0, 0, 0, 0, 0, 1, 0, 0]
[0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 0, 0, 0, 0, 1]

[0, 0, 0, 0, 0, 0, 0, 1]
[0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 0, 0, 1, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 0]

[0, 0, 0, 1, 0, 0, 0]
[0, 0, 1, 0, 1, 0, 0]
[0, 1, 0, 0, 0, 1, 0]
[1, 0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 1, 0, 0]
[0, 0, 0, 1, 0, 0, 0]

Exercice n°3 : Chasse au trésor (1)

La chasse au trésor

Cet exercice fait partie d'une série d'exercices qui doivent être réalisés dans l'ordre indiqué. Leur but est de commencer à appréhender la notion de création d'un programme petit à petit, en améliorant ses fonctionnalités au fur et à mesure.

Le programme en question consiste à concevoir une chasse au trésor dont l'idée générale est la suivante :

Le programme génère une liste de n éléments, où n sera un entier saisi par l'utilisateur.
Tous les éléments sont égaux à 0, mis à part un élément de la liste, choisi au hasard par le programme, qui aura pour valeur 1.
Bien évidemment, l'utilisateur ne pourra pas voir cette liste à l'écran.
L'utilisateur devra alors, sur invitation du programme, essayer de deviner quel est l'indice du nombre 1.
Dans le cas où l'utilisateur donne un indice trop petit, le programme lui répond Cherche à droite. Lorsque l'indice est trop grand, le programme affiche Cherche à gauche.
Le programme s'interrompt lorsque l'utilisateur propose le bon indice. Un message de félicitations apparaît alors, accompagné du nombre total de propositions données par l'utilisateur.

Pour cette première partie, le programme doit :

demander à l'utilisateur un entier n puis générer une liste contenant n zéros.
donner aléatoirement la valeur 1 à un des éléments de cette liste.
demander une fois à l'utilisateur à quel indice se situe cette valeur 1 dans la liste.
répondre Cherche à droite, Cherche à gauche ou Bravo ! selon la proposition de l'utilisateur.
afficher la liste pour vérifier cette réponse.

Une piste ?

Lisez bien l'énoncé, relisez aussi le cours sur les listes. Cet exercice est à la portée de tous si l'on est patient et organisé. Courage !

Une autre piste ?

N'oubliez pas que les indices d'une liste sont numérotés à partir de 0.

Exercice n°4 : Liste de crayons

La rosace ci-contre a été dessinée en utilisant une liste de crayons. Chaque pétale a été tracé par un crayon différent. Voici quelques pistes pour reproduire cette figure :

Demander à l'utilisateur le nombre de pétales désirés.
Définir une liste vide qui contiendra les futurs crayons.
En utilisant une boucle, créer un nouveau crayon, définir ses caractéristiques (épaisseur, couleur, orientation...) puis ajouter ce crayon à la liste précédente.
Chaque crayon effectue ensuite une succession de déplacements de 15 pixels, entrecoupés d'une rotation dont l'angle va de 0 à 16 degrés puis revient à 0 degrés avec un pas de 1.

##----- Importation des Modules -----##
from turtle import *

##----- Définition des Fonctions -----##


##----- Déclaration/initialisation des Variables -----##


##----- Création de la liste de crayons -----##


##----- Tracé de la rosace -----##


exitonclick()

Une piste ?

Pour les couleurs, utilisez une liste de couleurs nommées pré-définies. Par exemple : ['blue', 'orange', 'green', 'red', 'brown', 'pink', ...]. S'il y a plus de tortues que de couleurs, il faudra revenir à la première couleur de la liste puis continuer...

Une autre piste ?

Chaque nouveau crayon inséré dans la liste doit avoir une orientation différente des crayons précédents. On rappelle qu'un plan est partagé en 360 degrés : papier, crayon et mathématiques seront nécessaires !

Encore une piste ?

Définir une fonction qui pilotera le déplacement de chaque crayon de la liste, comme spécifié dans l'énoncé.