Ajout TP5 & TP6 & MàJ Échecs

S1/TP 5/billard.py

@@ -0,0 +1,79 @@
+# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015
+# TP n°5 donné le 10/10/2014 - Billard
+# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/tp_itcond_tortue.html
+
+from turtle import *
+
+def dessiner_billard(dx, dy):
+    """
+    Dessine un billard centré en l'origine de coté 'dx' × 'dy'.
+
+    CU : dx et dy entiers strictement positifs
+
+    Exemple :
+    >>> dessiner_billard(400, 300)
+    """
+    assert(type(dx) is int and dx > 0), "dx doit être un entier strictement \
+positif"
+    assert(type(dy) is int and dy > 0), "dy doit être un entier strictement \
+positif"
+    penup()
+    pencolor("red")
+    goto(-dx//2, -dy//2)
+    pendown()
+    begin_fill()
+    for i in range(0, 4):
+        if i%2:
+            forward(dy)
+        else:
+            forward(dx)
+        left(90)
+    color("green")
+    end_fill()
+
+PAS = 1
+
+def billard(dx, dy, x, y, angle, bandes):
+    """
+    Dessine un billard centré en l'origine de coté 'dx' × 'dy' et la
+    trajectoire de la bille de position initiale ('x', 'y') et d'angle initial
+    'angle' jusqu'à 'bandes' bandes.
+
+    CU : dx, dy et bandes entiers strictement positifs, x, y et angle entiers
+    
+    Exemple :
+    >>> billard(400, 300, 50, -25, 80, 5)
+    """
+    assert(type(dx) is int and dx > 0), "dx doit être un entier strictement \
+positif"
+    assert(type(dy) is int and dy > 0), "dy doit être un entier strictement \
+positif"
+    assert(type(angle) is int and angle > 0), "angle doit être un entier \
+strictement positif"
+    assert(type(x) is int), "x doit être un entier"
+    assert(type(y) is int), "y doit être un entier"
+    assert(type(bandes) is int), "bandes doit être un entier"
+    
+    dessiner_billard(dx, dy)
+    penup()
+    pencolor("black")
+    goto(x, y)
+    pendown()
+    left(angle)
+    while bandes >= 1:
+        forward(PAS)
+        if xcor() >= dx//2:
+            left(180-2*heading())
+            bandes += -1
+        if xcor() <= -dx//2:
+            left(180-2*heading())
+            bandes += -1
+        if ycor() >= dy//2:
+            left(-2*heading())
+            bandes += -1
+        if ycor() <= -dy//2:
+            left(-2*heading())
+            bandes += -1
+
+# Exemple de test :
+# 

S1/TP 5/brownien.py

@@ -0,0 +1,68 @@
+# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015
+# TP n°5 donné le 10/10/2014 - Mouvement brownien
+# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/tp_itcond_tortue.html
+
+from turtle import *
+from random import randint
+
+# Constantes
+COTE = 400
+
+# Fonctions
+def tortue_sortie(cote):
+    """
+    Indique si la tortue est en dehors du carré de coté 'cote' centré en
+    l'origine.
+
+    CU : cote entier strictement positif 
+
+    Exemple :
+    >>> tortue_sortie(400)
+    """
+    assert(type(cote) is int and cote > 0), "cote doit être un entier \
+strictement positif"
+
+    return not (xcor() >= -cote/2 and xcor() <= cote/2 and \
+        ycor() >= -cote/2 and ycor() <= cote/2)
+
+def carre(cote):
+    """
+    Dessine un carré bleu de coté 'cote' centré en l'origine.
+
+    CU : cote entier strictement positif
+
+    Exemple :
+    >>> carre(50)
+    """
+    assert(type(cote) is int and cote > 0), "cote doit être un entier \
+strictement positif"
+
+    pencolor("blue")
+    penup()
+    goto(-cote/2, -cote/2)
+    pendown()
+    for i in range(0, 4):
+        forward(cote)
+        left(90)
+
+def mouvement_brownien():
+    """
+    Applique à la tortue une étape du mouvement brownien.
+
+    Exemple :
+    >>> mouvement_brownien()
+    """
+    left(randint(0, 359))
+    forward(randint(10, 30))
+
+
+# Mise en place
+carre(COTE)
+penup()
+pencolor("green")
+goto(0, 0)
+pendown()
+
+# Mouvement
+while not tortue_sortie(COTE):
+    mouvement_brownien()

S1/TP 5/carres.py

@@ -0,0 +1,120 @@
+# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015
+# TP n°5 donné le 10/10/2014 - Dessiner avec des carrés
+# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/tp_itcond_tortue.html
+
+from turtle import *
+
+# Instructions pour simplifier le code
+def suivant():
+    """
+    Suspend l'éxecution du script, attend la pression de l'utilisateur sur la
+    touche <Entrée> puis efface l'écran de turtle.
+    """
+    input("Appuyez sur <Entrée> pour continuer")
+    clearscreen()
+
+
+# [Question 1] Réalisez une procédure nommée carre
+
+def carre(c):
+    """
+    Dessine un carré de coté 'c' depuis l'état courant de la tortue.
+
+    CU : c entier strictement positif
+    """
+    assert(type(c) is int and c > 0), "c doit être un entier strictement positif"
+
+    pendown()
+    for i in range(0, 4):
+        forward(c)
+        left(90)
+
+print("Test de carre()")
+carre(50)
+
+# La tortue est revenue à son point de départ
+
+suivant()
+
+
+# [Question 2] Dix carrés alignés
+
+ESPACEMENT = 5
+COTE = 50
+NOMBRE = 10
+
+origine = -(ESPACEMENT + COTE)*NOMBRE//2
+
+print("Dix carrés alignés")
+
+penup()
+goto(origine, 0)
+for i in range(0, NOMBRE):
+    carre(COTE)
+    penup()
+    forward(COTE + ESPACEMENT)
+    # goto(xcor() + COTE + ESPACEMENT, ycor()) # Alternative
+
+suivant()
+
+
+# [Question 3] Un carré de cent carrés
+
+print("Un carré de cent carrés")
+
+penup()
+goto(origine, origine)
+for y in range(0, NOMBRE):
+    for x in range(0, NOMBRE):
+        carre(COTE)
+        penup()
+        forward(COTE + ESPACEMENT)
+        # goto(xcor() + COTE + ESPACEMENT, ycor()) # Alternative
+    goto(origine, origine + (COTE + ESPACEMENT) * (y + 1))
+    # Alternative
+        # forward(-(COTE + ESPACEMENT)*NOMBRE) # Retour à gauche
+        # left(90)
+        # forward(COTE + ESPACEMENT) # Montée
+        # right(90)
+
+suivant()
+
+
+# [Question 4] Cinquante carrés emboîtés
+
+print("Cinquante carrés emboîtés")
+
+NOMBRE_4 = 50
+INTERVALLE = 10
+
+origine_4 = -(NOMBRE_4*INTERVALLE)//2
+
+penup()
+goto(origine_4, origine_4)
+
+for j in range(0, NOMBRE_4):
+    carre( (j + 1) * INTERVALLE)
+
+suivant()
+
+
+# [Question 5] Réalisez une procédure carre_tournant
+
+def carre_tournant(n):
+    """
+    Dessine 'n' carrés de coté 100 pivotant autour de la position courante de
+    la tortue.
+
+    CU : n entier strictement positif
+    """
+    assert(type(n) is int and n > 0), "n doit être un entier strictement positif"
+
+
+    for i in range(0, n):
+        carre(100)
+        left(360/n)
+
+print("Sept carrés pivotant")
+
+goto(0, 0)
+carre_tournant(7)

S1/TP 5/module.py

@@ -0,0 +1,64 @@
+# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015
+# TP n°5 donné le 10/10/2014 - Le module turtle
+# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/tp_itcond_tortue.html
+
+from turtle import *
+
+
+# [Question 2]
+
+# Elle fait avancer la tortue dans la direction qui lui a été donné par les
+# fonctions left() et right().
+
+
+# [Question 3]
+
+# Elle dessine un trait uniquement si la fonction pendown() a été appelée plus
+# récemnent que la fonction penup().
+
+
+# [Question 4]
+
+# Elle recule, c'est à dire qu'elle va dans le sens inverse de celui où elle
+# irait si on avait donné un argument positif.
+
+
+# [Question 5]
+
+# Il doit s'exprimer en degrés. On peut le vérifier en testant quelques valeurs
+# connues : 360 (tour complet), 180 (demi-tour), 90 (quart de tour)...
+
+
+# [Question 6]
+
+# Elle déplace la tortue aux points de coordonnées (-200, 90), soit en haut
+# à gauche. Elle dessine un trait pour les mêmes conditions que la fonction
+# forward, c'est à dire si la fonction pendown() a été appelée plus
+# récemnent que la fonction penup().
+
+
+# [Question 7]
+
+# Définition de constantes pour rendre le code plus compréhensible
+TRAIT1X = -200
+TRAIT1Y = 170
+TRAIT2X = -100
+TRAIT2Y = 90
+LONGUEUR = 150
+ANGLE = 30
+
+# Trait 1
+penup()
+goto(TRAIT1X, TRAIT1Y)
+left(ANGLE)
+pencolor('red')
+pendown()
+forward(LONGUEUR)
+
+# Trait 2
+penup()
+goto(TRAIT2X, TRAIT2Y)
+# On ne change pas l'angle, c'est le même que pour le trait 1
+pencolor('green')
+pendown()
+forward(LONGUEUR)

S1/TP 5/polygones.py

@@ -0,0 +1,129 @@
+# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015
+# TP n°5 donné le 10/10/2014 - Dessiner des polygones réguliers
+# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/tp_itcond_tortue.html
+
+from turtle import *
+
+# Instructions pour simplifier le code
+def suivant():
+    """
+    Suspend l'éxecution du script, attend la pression de l'utilisateur sur la
+    touche <Entrée> puis efface l'écran de turtle.
+    """
+    input("Appuyez sur <Entrée> pour continuer")
+    clearscreen()
+
+DECALAGEX = 0
+DECALAGEY = -50
+ECART = 150
+COTE = 75
+def deplacer(x, y):
+    """
+    Déplace la tortue sans tracer de trait à une position ('x', 'y') sur
+    un tableau virtuel.
+
+    CU : x et y entiers
+
+    Exemple :
+    >>> deplacer(-1, 1)
+    """
+    assert(type(x) is int), "x doit être un entier"
+    assert(type(y) is int), "y doit être un entier"
+
+    penup()
+    goto(x*ECART + DECALAGEX, y*ECART + DECALAGEY)
+
+
+# Cas des polygones convexes
+
+# Q1
+
+# Cet angle est de 360°/n
+# En effet au total la tortue aura effecuté un tour complet (360°), mais en
+# n fois. Il faut donc diviser les 360° par n.
+
+
+# Q2 Réalisez une procédure nommée polygone_reg_convexe
+
+def polygone_reg_convexe(n, l):
+    """
+    Dessine un polygone régulier convexe à 'n' côtés de longueur 'l' depuis
+    l'état scourant de la tortue
+
+    CU : n et l entiers strictement positifs
+
+    Exemple :
+    >>> polygone_reg_convexe(5, 100)
+    """
+    assert(type(n) is int and n > 0), "n doit être un entier strictement \
+positif"
+    assert(type(l) is int and l > 0), "l doit être un entier strictement \
+positif"
+
+    pendown()
+    for i in range(0, n):
+        left(360/n)
+        forward(l)
+
+
+# Q3 Réalisez la figure Quatre polygones convexes.
+
+print("Quatre polygones convexes")
+deplacer(-1, 1)
+polygone_reg_convexe(4, COTE)
+deplacer(1, 1)
+polygone_reg_convexe(5, COTE)
+deplacer(-1, -1)
+polygone_reg_convexe(6, COTE)
+deplacer(1, -1)
+polygone_reg_convexe(7, COTE)
+
+
+suivant()
+
+
+# Cas des polygones étoilés
+
+
+# Q1 Réalisez une procédure nommée polygone_etoile
+
+def polygone_etoile(n, l, k):
+    """
+    Dessine un polygone régulier étoilé à 'n' côtés de longueur 'l' avec 'k'
+    étant l'ordre de parcours des sommets depuis l'état courant de la tortue.
+
+    CU : n, l et k entiers strictement positifs
+
+    Exemple :
+    >>> polygone_etoile(7, 100, 3)
+    """
+    assert(type(n) is int and n > 0), "n doit être un entier strictement \
+positif"
+    assert(type(l) is int and l > 0), "l doit être un entier strictement \
+positif"
+    assert(type(k) is int and k > 0), "k doit être un entier strictement \
+positif"
+
+    pendown()
+    for i in range(0, n):
+        left(k*360/n)
+        forward(l)
+
+
+# Q2 Réalisez la figure Quatre polygones étoilés.
+
+print("Quatre polygones étoilés")
+deplacer(-1, 1)
+polygone_etoile(5, COTE, 2)
+deplacer(1, 1)
+polygone_etoile(7, COTE, 3)
+deplacer(-1, -1)
+polygone_etoile(8, COTE, 3)
+deplacer(1, -1)
+polygone_etoile(9, COTE, 5)
+
+
+# Q3 Peut-on dessiner un hexagone étoilé ?
+
+# L'hexagone en bas à gauche de la figure Quatre polygones étoilés est un
+# hexagone étoilé, donc oui.