Vos réalisations, vos exercices et plus encore !

Sur suggestion de l'auteur je fais une proposition d'exercices assez faciles (ils ne figurent pas dans mon tuto actuellement en bêta).

Bon amusement !

EXERCICES

Cube

Dessiner un cube.

Centre de gravité

Soient les points $\mathtt{a=(50,50)}$, $\mathtt{b=(-200,-100)}$ et $\mathtt{c=(300,-300)}$.

1) Construire le triangle $\mathtt{abc}$.

2) Rappelons qu'une médiane d'un triangle est une droite qui joint un sommet et le milieu du côté opposé. On sait que les trois médianes se coupent en le centre de gravité du triangle ($\mathtt{g}$ ci-dessous).

a) Construire les médianes du triangle $\mathtt{abc}$. On utilisera que si on a deux points représentés respectivement par les couples $\mathtt{x}$ et $\mathtt{y}$ alors le milieu est représenté par le couple :

b) Une fois les médianes tracées, le triangle $\mathtt{abc}$ est divisé en 6 triangles. Colorier chacun de ses triangles avec les couleurs suivantes :

On rappelle que pour activer une couleur de remplissage, on utilise une instruction du genre :

Rappel : pour exécuter un remplissage, on encadre les instructions de parcours de la zone à remplir, au début, d'une instruction begin_fill()

et, à la fin, d'une instruction end_fill(False).

On utilisera que les trois médianes concourent en $\mathtt{g}$ avec

Le résultat devra ressembler au dessin suivant :

Grille de Sudoku

Dessiner une grille de sudoku comme ci-dessous :

Pour faire varier l'épaisseur du trait, on placera tantôt la commande

(pour les traits épais) et tantôt la commande

pour les traits fins.

Pour écrire un chiffre, on placera d'abord le curseur où on souhaite placer le chiffre et on appellera une commande du genre :

dont la signification se devine aisément. Le placement précis du chiffre pourra nécessiter des ajustements par essais/erreurs.

Cœur

Dessiner un cœur rose en ajustant des arcs de cercles :

On total, on utilisera 6 arcs de cercles : deux demi-cercles et 4 autres arcs de cercles. La fermeture du cœur pourra nécessiter des ajustements par essais/erreurs.

Triangles emboîtés

Construire un emboîtements de triangles comme dans la figure ci-dessous.

Le principe est simple : étant donné un triangle $ABC$, on construit un autre triangle $A'B'C'$ tel que $A'$ soit sur le segment AB et tel que $AA'=AB/10$ et de même pour les autres côtés :

Il suffit ensuite de répéter cette construction avec le triangle $A'B'C'$.

On aura besoin de la transformation $\mathtt{T(A, B)}$ qui renvoie les coordonnées du point $\mathtt{A'}$ :

1
2

def T(u, v):
    return (u[0]+(v[0]-u[0])/10, u[1]+(v[1]-u[1])/10)

On écrira une fonction emboiter(A, B, C) qui étant donné un triangle $\mathtt{ABC}$ comme ci-dessus dessine sous Turtle le triangle $\mathtt{A'B'C'}$ et renvoie la liste des coordonnées de $\mathtt{A'}$, $\mathtt{B'}$ et $\mathtt{C'}$. Les coordonnées de ces point seront obtenues en appliquant la fonction position du module standard turtle.

Dans le dessin ci-dessus, la fonction emboiter a été appelée 25 fois. Pour des raisons esthétiques, on préférera un triangle équilatéral pour triangle initial.

Adapter à des carrés :

Graphe de Petersen

Construire le graphe de Petersen :

On fera comme si on avait deux cercles concentriques, on placera les 5 sommets sur chaque cercle en utilisant la formule

$\mathtt{sommet=(r*cos(t), r*sin(t))}$

puis on tracera les segments reliant les sommets. Les sommets seront marqués avec la fonction dot().

Voici un template de 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

from turtle import *
from math import cos, sin, pi

def pentagone(r):
    """Le nord d'abord puis
    on génère dans le sens
    inverse des aiguilles d'une montre"""
    alpha=2*pi/5
    a=(0,r)
    # VOTE CODE ICI
    return [a,b,c,d,e]

def polygone(L):
    """Trace la ligne 
     polygonale fermée
     définie par L"""
    # VOTE CODE ICI

def segment(u,v):
    "Dessine le segment"
    # VOTE CODE ICI

ht()    

a,b,c,d,e=pentagone(100)
aa, bb, cc, dd, ee=pentagone(150)

# VOTE CODE ICI

exitonclick()

Étoile de David

Dessiner une étoile de David :

Voici une suggestion de méthode :

• Écrire une fonction equilateral(R, t) qui renvoie les coordonnées des sommets du triangle équilatéral inscrit dans le cercle de centre (0, 0) et de rayon R et dont un des sommets fait un angle polaire t ; il faut regarder les angles et savoir que le côté d'un tel triangle vaut $\mathtt{R\sqrt 3}$ ; on utilisera la fonction position du module turtle ;

• Ecrire une fonction fill_quadri(sommets) qui colorie l'intérieur d'un quadrilatère convexe.

• Ecrire une fonction fill_equi(inside, outside) qui appelle fill_quadri(sommets) pour colorier la zone comprise entre deux triangles emboîtés.

Dessine-moi la lune !

Dessiner un croissant de lune :

On utilisera les couleur "gold" et "white".

Un autre mais séparé des précédents car plus avancé.

La fourmi de Langton

Certaines fonctionnalités avancées de Turtle permettent une implémentation très efficace du problème ci-dessous.¹

La fourmi de Langton est une expérience de simulation informatique d'automate cellulaire. On dispose d'un quadrillage dont toutes les cases au départ sont blanches.

Au début de l'expérience, une fourmi est placée sur une case et elle va effectuer une suite de mouvements définis par la règle suivante :

• si la fourmi est sur une case blanche elle se déplace dans la case qui est à sa droite ;

• si la fourmi est sur une case noire elle se déplace dans la case qui est à sa gauche ;

• chaque fois que la fourmi se déplace de la case (disons A) à une case voisine, la couleur de la case A change (noire si A est blanche et blanche si A est noire).

Au départ, la fourmi regarde vers le nord et est placée sur une case blanche. L'expérience consiste à analyser l'allure globale des déplacements de la fourmi.

Méthode de résolution

D'abord, la tortue va simuler les mouvements de la fourmi avec les commandes habituelles (fd, up, left et right). On récupère la position courante avec la fonction position.

Ensuite, on va cacher la tête de la tortue (ht) et ne pas rendre visibles ses traits de déplacements (up) ce qui a le gros avantage de déléguer à turtle la tache de gérer les paramètres de position et d'orientation de la fourmi.

Et on va utiliser les deux possibilités suivantes offertes par le module Turtle:

• choisir une nouvelle tête pour la tortue : un carré noir (shape("square")) de taille par défaut 20x20 ; optionnel : modifier la taille de ce carré pour que la simulation ne sorte pas de la fenêtre.
• appeler la fonction stamp pour tamponner le plateau de la tête carrée de la tortue et clearstamp pour effacer la case noire ; bien regarder dans le tuto comment marchent ces fonctions.

Pour mémoriser les cases noires, on utilise un dictionnaire qui à chaque case noire en position (i, j) associe l'id du stamp correspondant.

Bien penser à déplacer la tortue d'un nombre égal à la largeur du carré qui forme sa tête.

Autre détail : bien que les positions soient, en théorie, des entiers (normal si on se déplace sur un quadrillage !), le calcul par Turtle se fait en flottants donc pensez à utiliser à chaque fois round sur les coordonnées sinon la recherche dans le dictionnaire échouera.

Et c'est tout, ça tient en 25 lignes de code ! Si vous itérez 11000 fois vous verrez la fameuse *Langton's highway.

Ci-dessous 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

from turtle import *

SQUARE_DEFAULT=20
SCALE=0.5
BLOCK=SCALE*SQUARE_DEFAULT
ht()
up()
shape("square")
shapesize(SCALE, SCALE)

left(90)
black={}

for i in range(11000):
   x, y= map(round, position())
   if (x, y) in black:
       left(90)
       fd(BLOCK)
       clearstamp(black[(x,y)])
       del black[(x,y)]
   else:
       right(90)
       black[(x,y)]=stamp()
       fd(BLOCK)

exitonclick()