Un exercice au long cours

Certains exercices de ce site se suivent et doivent être réalisés dans l'ordre. 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 a droite». Lorsque l'indice est trop grand, le programme affiche «Cherche a 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.

Allez à l'exercice n°3 pour la première étape de cette recherche de programme.

Remplir une liste de listes

On considère une liste contenant 5 listes ayant chacune 3 éléments.
Remplir cette liste avec des entiers dans l'ordre croissant de 1 en 1, en commençant à 1 puis afficher correctement cette liste de listes.
La question précédente conduit à l'affichage :
```
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
[10, 11, 12]
[13, 14, 15]
```
A 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 remplit par des entiers dans l'ordre croissant.

Une piste ?
Une autre piste ?
Une piste pour le 3°/ ?

Avant de se lancer dans la programmation, il faut anticiper ! Posez-vous la question : comment calculer la valeur de chaque élément contenu dans cette liste de liste ?

Vous pouvez...

soit partir d'une liste de listes remplis de 0 puis modifier la valeur de leurs éléments
soit compléter la liste au fur et à mesure de la «création» de la valeur de ses éléments.

Le module random permet d'utiliser des fonctions qui génèrent du pseudo-hasard. Pour générer un entier aléatoire compris entre a et b (inclus), il faut faire appel à la fonction randint(a, b).

Dans cette solution, la liste est remplie de 0 «à la main», ce qui n'est ni efficace, ni recommandé !

Pour remplir la liste, on «triche» : on part d'une variable valeur initialisée à 1 puis, on augmente cette valeur de 1 après avoir modifié la valeur de l'élément correspondant dans la liste.
Pour se faire, on parcourt d'abord les lignes (les sous-listes) de la liste puis chaque élément de la ligne parcourue.


##----- Initialisation des variables -----##
liste = [[0, 0, 0],
         [0, 0, 0],
         [0, 0, 0],
         [0, 0, 0],
         [0, 0, 0]]
n = 1								# Valeur des éléments

##----- Remplissage de la liste -----##
for i in range(5):					# Parcours des sous-listes
    for j in range(3):				# Parcours des éléments de chaque sous-liste
        liste[i][j] = n
        n += 1

##----- Affichage -----##
for sous_liste in liste:
    print(sous_liste)

Dans cette solution, la liste est construite plus efficacement, directement à partir des valeurs finales des éléments de la liste. Cette valeur est obtenu par calcul arithmétique en fonction du numéro de la ligne (multiplié par 3 car il y a 3 éléments par ligne) puis de l'indice de l'élément (le numéro de la colonne).


##----- Initialisation des variables -----##
liste = []

##----- Remplissage de la liste -----##
for i in range(5):					# Parcours des sous-listes
    liste.append([])				# Création d'une nouvelle sous-liste
    for j in range(3):				# Parcours des éléments de chaque sous-liste
        liste[i].append(3*i+j+1)

##----- Affichage -----##
for sous_liste in liste:
    print(sous_liste)

Notez dans cette solution le nom explicite des variables utilisées.


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

##----- Initialisation des variables -----##
liste = []
nb_listes = randint(1, 10)
taille = randint(1, 10)


##----- Remplissage de la liste -----##
for i in range(nb_listes):					# Parcours des sous-listes
    liste.append([])						# Création d'une nouvelle sous-liste
    for j in range(taille):					# Parcours des éléments de chaque sous-liste
        liste[i].append(taille*i+j+1)		# Chaque sous-liste contient taille éléments

##----- Affichage -----##
for sous_liste in liste:
    print(sous_liste)

Numéro de ligne, de colonne

En repartant de l'exercice précédent, concevoir les programmes qui permettent 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]


liste=[]

for i in range(8):			# Numéro de ligne
    liste.append([])		# Ajout d'une liste vide
    for j in range(8):		# Numéro de colonne
        if j != i:
            liste[i].append(0)
        else:
            liste[i].append(1)

for ligne in liste:
    print(ligne)


liste=[]

for i in range(8):			# Numéro de ligne
    liste.append([])		# Ajout d'une liste vide
    for j in range(8):		# Numéro de colonne
        if j != 7-i:		# Testez sur quelques exemples
            liste[i].append(0)
        else:
            liste[i].append(1)

for ligne in liste:
    print(ligne)


liste=[]

for i in range(4):			# Première moitié de ligne (de 0 à 3)
    liste.append([])
    for j in range(7):
        if j+i == 3 or j-i == 3:
            liste[i].append(1)
        else:
            liste[i].append(0)

for i in range(4, 7):			# Numéro de ligne
    liste.append([])		# Ajout d'une liste vide
    for j in range(7):		# Numéro de colonne
        if i-j == 3 or j+i == 9:
            liste[i].append(1)
        else:
            liste[i].append(0)

for ligne in liste:
    print(ligne)

Chasse au trésor (1)

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 a droite», «Cherche a gauche» ou «Bravo !» selon la proposition de l'utilisateur.
afficher la liste pour vérifier cette réponse.

Une piste ?
Une autre 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 !

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


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

##----- Programme principal -----##
n = int(input("Entrez la valeur d'un entier : "))
liste = [0]*n						# Liste de n zéros

indice = randint(0, n-1)			# Indice de "1" dans la liste
liste[indice] = 1

prop = int(input("Donner un indice entre {} et {} : ".format(0, n-1)))
if prop == indice:
    print('Bravo !')
elif prop > indice:
    print('Cherche a gauche')
else:
    print('Cherche a droite')

print(liste)						# Vérification

La suite de cet exercice sera proposée dans la section suivante : ici.

Liste de crayons

La rosace ci-contre a été dessinée en utilisant un 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, etc...) 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 ?
Une autre piste ?
Encore 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...

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 !

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


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

##----- Définition des Fonctions -----##
def deplacer(liste_crayons, longueur, angle):
    """ Entrees : Une liste de crayons, longueur et angle sont des entiers
        Sorties : Deplacement de chaque crayon puis rotation sur lui-meme"""
    for stylo in liste_crayons:
        stylo.forward(longueur)
        stylo.left(angle)

##----- Déclaration/initialisation des Variables -----##
couleurs = ['blue', 'orange', 'green', 'red', 'brown', 'pink', 'black', 'purple']
nb_couleurs = len(couleurs)
liste_stylos = []
n = int(input('Donnez le nombre de crayons a manipuler : '))

angle = 360/n                                       # Ecart angulaire entre chaque crayon
orientation = 0                                     # Orientation du 1er crayon

##----- Création de la liste de crayons -----##
for i in range(n):
    stylo = Turtle()                                # Un crayon quelconque
    stylo.setheading(orientation)                   # On oriente
    stylo.width(2)                                  # Un peu d'épaisseur
    stylo.pencolor(couleurs[i%nb_couleurs])			# Un peu d'arithmétique
    stylo.speed(0)                                  # Vitesse maximale
    liste_stylos.append(stylo)
    orientation += angle

##----- Tracé de la rosace -----##
for i in range(16):
    deplacer(liste_stylos, 15, i)

for i in range(16, -2, -1):
    deplacer(liste_stylos, 15, i)

for stylo in liste_stylos:
    stylo.hideturtle()

exitonclick()

Les couleurs du tracé peuvent aussi être définies aléatoirement en ayant recours au format RGB. L'instruction colormode(255) initialise ce type de couleurs. Il ne reste qu'à utiliser stylo.pencolor(r, g, b) où r, g et b sont trois entiers compris entre 0 et 255.


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

##----- Définition des Fonctions -----##
def deplacer(liste_crayons, longueur, angle):
    """ Entrees : Une liste de crayons, longueur et angle sont des entiers
        Sorties : Deplacement de chaque crayon puis rotation sur lui-meme"""
    for stylo in liste_crayons:
        stylo.forward(longueur)
        stylo.left(angle)

##----- Déclaration/initialisation des Variables -----##
liste_stylos = []
n = int(input('Donnez le nombre de crayons a manipuler : '))

angle = 360/n                                       # Ecart angulaire entre chaque crayon
orientation = 0                                     # Orientation du 1er crayon

##----- Création de la liste de crayons -----##
for i in range(n):
    stylo = Turtle()                                # Un crayon quelconque
    stylo.setheading(orientation)                   # On oriente
    stylo.width(2)                                  # Un peu d'épaisseur
    stylo.pencolor(255*1/(i+1), 255*1/(n-i), 255*(n-i)/n)
    stylo.speed(0)                                  # Vitesse maximale
    liste_stylos.append(stylo)
    orientation += angle

##----- Tracé de la rosace -----##
for i in range(16):
    deplacer(liste_stylos, 15, i)

for i in range(16, -2, -1):
    deplacer(liste_stylos, 15, i)

for stylo in liste_stylos:
    stylo.hideturtle()

exitonclick()