Ajout TP5 & TP6 & MàJ Échecs

.gitignore

@@ -54,5 +54,6 @@ docs/_build/
 target/
 
 # Custom
-*/sujet/*
+*/*/sujet
+*/*/aide
 *.zip

S1/Echecs/sprites/tstimg.py

@@ -0,0 +1,19 @@
+from tkinter import *
+
+
+
+
+##### Programme principal : ############    
+taille=600
+fen = Tk()
+can = Canvas(fen, width =taille, height =taille, bg ='ivory')
+img = PhotoImage(file ='./../sprites/reineN.gif')
+can.pack(side =TOP, padx =5, pady =5)
+i = img.subsample(2,2)
+can.create_image(150 ,150, image =i)
+j = img.subsample(4,4)
+can.create_image(300 ,300, image =j)
+k = img.subsample(8,8)
+can.create_image(400 ,400, image =k)
+
+fen.mainloop()

S1/Echecs/tests.py

@@ -0,0 +1,222 @@
+# INFOS
+
+# Pièces :
+
+# [1-6] : Blancs
+# [11-6] : Noirs
+
+# X1 : Pion
+# X2 : Tour
+# X3 : Cavalier
+# x4 : Fou
+# X5 : Dame
+# X6 : Roi
+
+
+# j_ jeu : le logique du jeu lui même
+# g_ GUI : l'interface graphique
+# f_ Frontend : ce qui associe les deux
+# _e : est
+# _c : crée
+# _d : déplace
+
+
+# IMPORTS
+from tkinter import *
+from random import randint
+
+# FONCTIONS
+
+
+# Jeu
+CASES_COTE = 8
+
+j_grille = None
+auxBlancs = None
+
+def j_eNoir(xD, yD): # TODO Peut être considérablement amélioré
+    i = 1
+    for x in range(0, CASES_COTE):
+        i += 1
+        for y in range(0, CASES_COTE):
+            i += 1
+            if x == xD and y == yD:
+                return i%2
+def j_cGrille():
+    global j_grille
+    j_grille = []
+    for x in range(CASES_COTE):
+        colonne = []
+        for y in range(CASES_COTE):
+            if j_eNoir(x, y):
+                colonne.append(0)
+            else:
+                colonne.append(-1)
+        j_grille.append(colonne)
+
+def j_remplirGrille():
+    global j_grille
+    j_grille[2][2] = 5
+
+def j_nvPartie():
+    j_cGrille()
+    j_remplirGrille()
+    global auxBlancs
+    auxBlancs = True
+
+def j_cPion(x, y, piece):
+    """
+    """
+    j_grille[x][y] = piece
+    return True
+
+def j_dPion(x1, y1, x2, y2):
+    # TODO Vérification du mouvement possible
+    assert(j_grille[x1][y1] > 0), "ERR1"
+    assert(j_grille[x2][y2] != 0), "ERR2"
+    j_grille[x2][y2] = j_grille[x1][y1]
+    return True
+
+# def poserPion(x, y):
+#     global auxBlancs
+#     if j_grille[x][y] == 0:
+#         j_grille[x][y] = 1
+#         pion(x, y, auxBlancs)
+#         auxBlancs = not auxBlancs
+#     elif j_grille[x][y] == -1:
+#         statut('On joue sur les cases noires !')
+#     else:
+#         statut('Il y a déjà quelque chose ici.')
+
+
+# GUI
+DECX = 0
+DECY = 0
+COTE_CASE = 50
+MARGE_PIONS = 5
+
+g_grilleDamier = None
+g_grillePions = None
+g_photos = []
+fen = None
+can = None
+chaine = None
+
+def g_fen():
+    global fen, can, chaine
+    fen = Tk()
+    fen.title("Jeu d'Échecs")
+    can = Canvas(fen, width=COTE_CASE*CASES_COTE, height=COTE_CASE*CASES_COTE, \
+        bg="ivory")
+    can.grid(row=0, column=1, columnspan=3)
+    can.bind('<Button-1>', f_clic)
+    chaine = Label(fen, text="Aux blancs")
+    chaine.grid(row=2, column=2, padx=3, pady=3)
+    Button(fen, text="Nv. Partie", command=f_nvPartie).grid(row=2, column=1, \
+        padx=3, pady=3)
+    Button(fen, text="Quitter", command=fen.destroy).grid(row=2, column=3, \
+        padx=3, pady=3)
+
+def g_statut(texte, delai=0):
+    chaine.config(text=texte)
+    print(texte)
+    # TODO Timeout effacer si parametre
+
+def g_cCase(x, y):
+    if j_eNoir(x, y):
+        couleur = 'black'
+    else:
+        couleur = 'white'
+    return can.create_rectangle(x*COTE_CASE, y*COTE_CASE, \
+        (x+1)*COTE_CASE, (y+1)*COTE_CASE, fill=couleur)
+
+def g_cDamier():
+    global g_grilleDamier
+    g_grilleDamier = []
+    for x in range(0, CASES_COTE):
+        colonne = []
+        for y in range(0, CASES_COTE):
+            colonne.append(g_cCase(x + DECX, y + DECY))
+        g_grilleDamier.append(colonne)
+
+def g_cPion(x, y, piece):
+    global g_grillePions
+    global g_photos
+    if piece > 0:
+        nom = 'sprites/'
+        if piece%10 == 5:
+            nom += 'reine'
+        else:
+            nom += 'pion'
+        if piece < 10:
+            nom += 'B'
+        else:
+            nom += 'N'
+        nom += '.gif'
+        g_photos.append(PhotoImage(file=nom))
+        sample = int(504/(COTE_CASE-MARGE_PIONS))
+        g_photos[-1] = g_photos[-1].subsample(sample)
+        g_grillePions[x][y] = can.create_image((x+.5)*COTE_CASE, (y+.5)*COTE_CASE, image=g_photos[-1])
+        # g_grillePions[x][y] = can.create_oval(x*COTE_CASE+MARGE_PIONS, y*COTE_CASE+MARGE_PIONS, \
+        #             (x+1)*COTE_CASE-MARGE_PIONS, (y+1)*COTE_CASE-MARGE_PIONS, \
+        #             outline='gray', width=2, fill='white' if piece < 10 else 'black')
+    else:
+        g_grillePions[x][y] = False
+
+def g_dPion(x1, y1, x2, y2):
+    global g_grillePions
+    pion = g_grillePions[x1][y1]
+    can.coords(pion, x2*COTE_CASE+MARGE_PIONS, y2*COTE_CASE+MARGE_PIONS, (x2+1)*COTE_CASE-MARGE_PIONS, (y2+1)*COTE_CASE-MARGE_PIONS)
+    g_grillePions[x1][y1] = False
+    g_grillePions[x2][y2] = pion
+
+def g_cGrille():
+    global g_grillePions
+    g_grillePions = []
+    for x in range(0, CASES_COTE): # Crée g_grillePions
+        colonne = []
+        for y in range(0, CASES_COTE):
+            colonne.append(False)
+        g_grillePions.append(colonne)
+
+def g_remplirGrille(j_grilleF):
+    global g_grillePions
+    for x in range(0, CASES_COTE): # Remplis g_grillePions
+        for y in range(0, CASES_COTE):
+            g_cPion(x, y, j_grilleF[x][y])
+
+
+# Frontend
+def f_cPion(x, y, piece):
+    if j_cPion(x, y, piece):
+        g_cPion(x, y, piece)
+        return True
+    else:
+        return False
+
+def f_cPionAlea():
+    g_cPion(randint(1, CASES_COTE), randint(1, CASES_COTE), 1)
+
+def f_dPion(x1, y1, x2, y2):
+    if j_dPion(x1, y1, x2, y2):
+        g_dPion(x1, y1, x2, y2)
+        return True
+    else:
+        return False
+
+def f_nvPartie():
+    j_nvPartie()
+    g_cDamier()
+    g_cGrille()
+    g_remplirGrille(j_grille)
+
+def f_clic(event):
+    x = event.x//COTE_CASE
+    y = event.y//COTE_CASE
+    f_cPion(x, y, 1)
+
+
+# MAIN
+
+g_fen()
+f_nvPartie()

S1/Echecs/testsQt.py

@@ -0,0 +1,222 @@
+# INFOS
+
+# Pièces :
+
+# [1-6] : Blancs
+# [11-6] : Noirs
+
+# X1 : Pion
+# X2 : Tour
+# X3 : Cavalier
+# x4 : Fou
+# X5 : Dame
+# X6 : Roi
+
+
+# j_ jeu : le logique du jeu lui même
+# g_ GUI : l'interface graphique
+# f_ Frontend : ce qui associe les deux
+# _e : est
+# _c : crée
+# _d : déplace
+
+
+# IMPORTS
+from tkinter import *
+from random import randint
+
+# FONCTIONS
+
+
+# Jeu
+CASES_COTE = 8
+
+j_grille = None
+auxBlancs = None
+
+def j_eNoir(xD, yD): # TODO Peut être considérablement amélioré
+    i = 1
+    for x in range(0, CASES_COTE):
+        i += 1
+        for y in range(0, CASES_COTE):
+            i += 1
+            if x == xD and y == yD:
+                return i%2
+def j_cGrille():
+    global j_grille
+    j_grille = []
+    for x in range(CASES_COTE):
+        colonne = []
+        for y in range(CASES_COTE):
+            if j_eNoir(x, y):
+                colonne.append(0)
+            else:
+                colonne.append(-1)
+        j_grille.append(colonne)
+
+def j_remplirGrille():
+    global j_grille
+    j_grille[2][2] = 5
+
+def j_nvPartie():
+    j_cGrille()
+    j_remplirGrille()
+    global auxBlancs
+    auxBlancs = True
+
+def j_cPion(x, y, piece):
+    """
+    """
+    j_grille[x][y] = piece
+    return True
+
+def j_dPion(x1, y1, x2, y2):
+    # TODO Vérification du mouvement possible
+    assert(j_grille[x1][y1] > 0), "ERR1"
+    assert(j_grille[x2][y2] != 0), "ERR2"
+    j_grille[x2][y2] = j_grille[x1][y1]
+    return True
+
+# def poserPion(x, y):
+#     global auxBlancs
+#     if j_grille[x][y] == 0:
+#         j_grille[x][y] = 1
+#         pion(x, y, auxBlancs)
+#         auxBlancs = not auxBlancs
+#     elif j_grille[x][y] == -1:
+#         statut('On joue sur les cases noires !')
+#     else:
+#         statut('Il y a déjà quelque chose ici.')
+
+
+# GUI
+DECX = 0
+DECY = 0
+COTE_CASE = 50
+MARGE_PIONS = 5
+
+g_grilleDamier = None
+g_grillePions = None
+g_photos = []
+fen = None
+can = None
+chaine = None
+
+def g_fen():
+    global fen, can, chaine
+    fen = Tk()
+    fen.title("Jeu d'Échecs")
+    can = Canvas(fen, width=COTE_CASE*CASES_COTE, height=COTE_CASE*CASES_COTE, \
+        bg="ivory")
+    can.grid(row=0, column=1, columnspan=3)
+    can.bind('<Button-1>', f_clic)
+    chaine = Label(fen, text="Aux blancs")
+    chaine.grid(row=2, column=2, padx=3, pady=3)
+    Button(fen, text="Nv. Partie", command=f_nvPartie).grid(row=2, column=1, \
+        padx=3, pady=3)
+    Button(fen, text="Quitter", command=fen.destroy).grid(row=2, column=3, \
+        padx=3, pady=3)
+
+def g_statut(texte, delai=0):
+    chaine.config(text=texte)
+    print(texte)
+    # TODO Timeout effacer si parametre
+
+def g_cCase(x, y):
+    if j_eNoir(x, y):
+        couleur = 'black'
+    else:
+        couleur = 'white'
+    return can.create_rectangle(x*COTE_CASE, y*COTE_CASE, \
+        (x+1)*COTE_CASE, (y+1)*COTE_CASE, fill=couleur)
+
+def g_cDamier():
+    global g_grilleDamier
+    g_grilleDamier = []
+    for x in range(0, CASES_COTE):
+        colonne = []
+        for y in range(0, CASES_COTE):
+            colonne.append(g_cCase(x + DECX, y + DECY))
+        g_grilleDamier.append(colonne)
+
+def g_cPion(x, y, piece):
+    global g_grillePions
+    global g_photos
+    if piece > 0:
+        nom = 'sprites/'
+        if piece%10 == 5:
+            nom += 'reine'
+        else:
+            nom += 'pion'
+        if piece < 10:
+            nom += 'B'
+        else:
+            nom += 'N'
+        nom += '.gif'
+        g_photos.append(PhotoImage(file=nom))
+        sample = int(504/(COTE_CASE-MARGE_PIONS))
+        g_photos[-1] = g_photos[-1].subsample(sample)
+        g_grillePions[x][y] = can.create_image((x+.5)*COTE_CASE, (y+.5)*COTE_CASE, image=g_photos[-1])
+        # g_grillePions[x][y] = can.create_oval(x*COTE_CASE+MARGE_PIONS, y*COTE_CASE+MARGE_PIONS, \
+        #             (x+1)*COTE_CASE-MARGE_PIONS, (y+1)*COTE_CASE-MARGE_PIONS, \
+        #             outline='gray', width=2, fill='white' if piece < 10 else 'black')
+    else:
+        g_grillePions[x][y] = False
+
+def g_dPion(x1, y1, x2, y2):
+    global g_grillePions
+    pion = g_grillePions[x1][y1]
+    can.coords(pion, x2*COTE_CASE+MARGE_PIONS, y2*COTE_CASE+MARGE_PIONS, (x2+1)*COTE_CASE-MARGE_PIONS, (y2+1)*COTE_CASE-MARGE_PIONS)
+    g_grillePions[x1][y1] = False
+    g_grillePions[x2][y2] = pion
+
+def g_cGrille():
+    global g_grillePions
+    g_grillePions = []
+    for x in range(0, CASES_COTE): # Crée g_grillePions
+        colonne = []
+        for y in range(0, CASES_COTE):
+            colonne.append(False)
+        g_grillePions.append(colonne)
+
+def g_remplirGrille(j_grilleF):
+    global g_grillePions
+    for x in range(0, CASES_COTE): # Remplis g_grillePions
+        for y in range(0, CASES_COTE):
+            g_cPion(x, y, j_grilleF[x][y])
+
+
+# Frontend
+def f_cPion(x, y, piece):
+    if j_cPion(x, y, piece):
+        g_cPion(x, y, piece)
+        return True
+    else:
+        return False
+
+def f_cPionAlea():
+    g_cPion(randint(1, CASES_COTE), randint(1, CASES_COTE), 1)
+
+def f_dPion(x1, y1, x2, y2):
+    if j_dPion(x1, y1, x2, y2):
+        g_dPion(x1, y1, x2, y2)
+        return True
+    else:
+        return False
+
+def f_nvPartie():
+    j_nvPartie()
+    g_cDamier()
+    g_cGrille()
+    g_remplirGrille(j_grille)
+
+def f_clic(event):
+    x = event.x//COTE_CASE
+    y = event.y//COTE_CASE
+    f_cPion(x, y, 1)
+
+
+# MAIN
+
+g_fen()
+f_nvPartie()

S1/TP 3/date Camille demo.py

@@ -1,136 +0,0 @@
-# Fonctions nécessaires au fonctionnement de afficher_calendrier()
-
-def est_divisible_par(a, b):
-    return a % b == 0
-
-def est_bissextile(annee):
-    return est_divisible_par(annee, 4) and \
-        (not est_divisible_par(annee, 100) or est_divisible_par(annee, 400))
-
-def nbre_jours(m, a):
-    assert(type(m) is int and m in range(1, 13)), \
-        "Le mois doit être un entier compris entre 1 et 12 inclus."
-    assert(type(a) is int and a > 1582), \
-        "L'année doit être un entier supérieur à 1582."
-
-    if m in [4, 6, 9, 11]:
-        return 30
-    elif m == 2:
-        if est_bissextile(a):
-            return 29
-        else:
-            return 28
-    else:
-        return 31
-
-def est_date_valide(j, m, a):
-    return type(j) is int and type(m) is int and type(a) is int and a > 1582 \
-        and m in range(1, 13) and j in range(1, nbre_jours(m, a)+1)
-
-def corrige_mois(m, a):
-    assert(type(a) is int and a > 1582), \
-        "L'année doit être un entier supérieur à 1582"
-    assert(type(m) is int and m in range(1, 13)), \
-        "Le mois doit être un entier compris entre 1 et 12 inclus"
-
-    liste_corrections_mois = [4, 0, 0, 3, 5, 1, 3, 6, 2, 4, 0, 2]
-
-    if est_bissextile(a):
-        liste_corrections_mois[0] = 3
-        liste_corrections_mois[1] = 6
-
-    return liste_corrections_mois[m-1]
-
-def num_jour(j, m, a):
-    assert(est_date_valide(j, m, a)), "La date n'est pas valide"
-
-    ab = a//100
-    cd = a%100
-    return (cd//4 + ab//4 + cd + corrige_mois(m, a) + j + 2 + 5 * ab) % 7
-
-
-# REGARDER À PARTIR D'ICI
-
-# Voici une fonction qui affiche un calendier approximatif,
-# sois sûre de la comprendre avant de t'attaquer au complet
-def imprimer_mois_simple(m, a):
-
-    # Première ligne
-    print("Mois", m, " Année", a)
-
-    # Deuxième ligne
-    print("di lu ma me je ve sa")
-
-    # Nombres
-    jour = 1
-    nbre_jours_mois = nbre_jours(m, a)
-    while jour <= nbre_jours_mois: # On parcourt les lignes
-        ligne = ["", "", "", "", "", "", ""] # On remet à zéro la liste des nombres sur la ligne
-        for jour_semaine in range(7): # On parcours les colonnes de la ligne
-            ligne[jour_semaine] = jour # On met le jour
-            jour += 1 # On augumente jour pour le prochain
-        print(ligne[0], ligne[1], ligne[2], ligne[3], ligne[4], ligne[5], \
-            ligne[6]) # On affiche la ligne
-
-# Démonstration
-print("Calendrier simple (et faux)")
-imprimer_mois_simple(9, 2014)
-
-
-# Voici la fonction complète, qui affichera un calendrier complet,
-# et possède tous les attributs d'une fonction
-def imprimer_mois(m, a):
-    """
-    Imprime le calendrier du mois de l'année donné.
-
-    CU : m entier, a entier, 1 ≤ m ≤ 12, a > 1582
-
-    Exemple :
-    >>> imprimer_mois(9, 2014)
-       Septembre 2014
-    di lu ma me je ve sa
-        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
-    """
-    assert(type(a) is int and a > 1582), \
-        "L'année doit être un entier supérieur à 1582"
-    assert(type(m) is int and m in range(1, 13)), \
-        "Le mois doit être un entier compris entre 1 et 12 inclus"
-
-    # On stocke les mois dans un tableau pour pouvoir y accéder facilement
-    liste_mois = ["Janvier", "Février", "Mars", "Avril", "Mai", "Juin", \
-        "Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"]
-
-    # Première ligne
-    print(liste_mois[m-1], a)
-
-    # Deuxième ligne
-    print("di lu ma me je ve sa")
-
-    # Nombres
-    jour = 1
-    jour_semaine_1er = num_jour(jour, m, a)
-    nbre_jours_mois = nbre_jours(m, a)
-    while jour <= nbre_jours_mois: # On parcourt les lignes
-        ligne = ["", "", "", "", "", "", ""] # On remet à zéro la liste des nombres sur la ligne
-        for jour_semaine in range(7): # On parcours les colonnes de la ligne
-            if jour == 1 and jour_semaine < jour_semaine_1er: # Si on est avant
-            # le premier jour du mois
-                ligne[jour_semaine] = "  " # On met un espace
-            elif jour <= nbre_jours_mois: # Si on est avant la fin du mois
-                ligne[jour_semaine] = jour # On met le jour
-                jour += 1 # On augumente jour pour le prochain
-        print(ligne[0], ligne[1], ligne[2], ligne[3], ligne[4], ligne[5], \
-            ligne[6]) # On affiche la ligne
-
-# Test
-print("")
-print("Calendrier complet")
-imprimer_mois(9, 2014)
-
-# Comme tu as pu le remarquer, les nombres <10 font un décalage
-# J'ai pas trouvé comment résoudre ça sans utiliser des trucs qu'on
-# a pas vu en cours.

S1/TP 4/plusOuMoinsYOLO.py

@@ -25,7 +25,7 @@ def jeu():
     essais = 0
     mystere = randint(minimum, maximum)
     dire()
-    if random() < 1:
+    if random() < 0.2:
         dire(["Donc je prend un nombre, tu vois, genre "+str(mystere)+", et tu dois le trouver, OK ?", str(mystere-2)+" ? "+str(mystere-1)+" ? "+str(mystere)+", c'est bien ça, "+str(mystere)+"...", str(mystere)+". EUH ! C'est pas "+str(mystere)+", pas du tout !"])
     else:
         dire(["Ayé, trouvé !", "Attends je cherche un nombre sympa...\nC'est bon !", "...\nAh oui ! Un nombre.\n...\nVoilà !","Je viens de penser à un nombre, tu vas devoir le trouver."])

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.

S1/TP 6/suites.py

@@ -0,0 +1,212 @@
+# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015
+# TP n°6 donné le 17/10/2014 - Calculs de suites
+# http://www2.lifl.fr/~mailliet/Initprog/TP6.pdf
+
+import doctest
+
+# Racine carrée
+
+def rac_car1(A, p):
+    """
+    Retourne une approximation de √A (flottant) en calculant le terme de rang p
+    de la suite de Héron.
+
+    CU : A numérique ≥ 0, p entier ≥ 0
+
+    >>> rac_car1(0, 10)
+    0
+    >>> rac_car1(5, 1)
+    2.25
+    >>> rac_car1(5, 10)
+    2.23606797749979
+    """
+    assert(type(A) is int or type(A) is float), "A doit être un numérique"
+    assert(type(p) is int and p >= 0), "p doit être un entier ≥ 0"
+
+    if A == 0: # Cas à différencier pour éviter une division par 0
+        return 0
+    else:
+        x = A/2 # Définition de x_0
+        for i in range(1, p+1): # Pour chaque terme de 1 à p (on a déjà x_0)
+            x = (x+A/x)/2 # On calcule le terme suivant
+        return x # Retour de la valeur
+
+def rac_car2(A):
+    """
+    Retourne une approximation de √A (flottant) en utilisant la suite de
+    Héron.
+
+    CU : A numérique ≥ 0
+
+    >>> rac_car2(0)
+    0
+    >>> rac_car2(5)
+    2.23606797749979
+    """
+    assert(type(A) is int or type(A) is float), "A doit être un numérique"
+
+    if A == 0: # Cas à différencier pour éviter une division par 0
+        return 0
+    else:
+        x = A/2 # Définition de x_0
+        xP = x + 1 # Initialisation par une valeur autre que x pour démarrer
+                   # la boucle
+        while x != xP: # Tant que Python peut calculer les décimales
+            xP = x # La valeur actuelle devient précédente
+            x = (x+A/x)/2 # On calcule le terme suivant
+        return x # Retour de la valeur
+
+
+# Somme et produit
+
+def factorielle(k):
+    """
+    Retourne k! (entier)
+
+    CU : k entier ≥ 0
+
+    >>> factorielle(0)
+    1
+    >>> factorielle(5)
+    120
+    """
+    assert(type(k) is int and k >= 0), "k doit être un entier ≥ 0"
+
+    f=1 # Initialisation du produit
+    for i in range(1, k+1): # De 1 à k
+        f = f * i # On ajoute un élément du produit
+    return f # Retour de la valeur
+
+def somme(n):
+    """
+    Retourne la somme des entiers de 1 à n (entier)
+
+    CU : n entier ≥ 0
+
+    >>> somme(0)
+    0
+    >>> somme(1)
+    1
+    >>> somme(3)
+    6
+    """
+    assert(type(n) is int and n >= 0), "n doit être un entier ≥ 0"
+
+    s = 0 # Initialisation de la somme
+    for i in range(1, n+1): # De 1 à n
+        s += i # On ajoute un élement de la somme
+    return s # Retour de la valeur
+
+def sommeA(n): # Alternative plus rapide à calculer
+    """
+    Retourne la somme des entiers de 1 à n (entier)
+
+    CU : n entier ≥ 0
+
+    >>> sommeA(0)
+    0
+    >>> sommeA(1)
+    1
+    >>> sommeA(3)
+    6
+    """
+    assert(type(n) is int and n >= 0), "n doit être un entier ≥ 0"
+
+    return n*(n+1)//2
+
+
+# Exponentielle
+
+def exponentielle(x):
+    """
+    Retourne une approximation de exp(x) (flottant)
+
+    CU : x numérique
+
+    >>> exponentielle(-5)
+    0.006737946999086907
+    >>> exponentielle(0)
+    1.0
+    >>> exponentielle(1)
+    2.7182818284590455
+    >>> exponentielle(5)
+    148.41315910257657
+    """
+    assert(type(x) is int or type(x) is float), "x doit être un numérique"
+
+    e = 0 # Initialisation de la somme
+    eP = 1 # Initialisation par une valeur autre que s pour démarrer la boucle
+    i = 0 # Initialisation de l'incrémenteur
+    while e != eP: # Tant que Python peut calculer les décimales
+        eP = e # La valeur actuelle devient précédente
+        e = e + (x ** i) / (factorielle(i)) # On ajoute un élement de la somme
+        i += 1 # On incrémente i
+    return e # Retour de la valeur
+
+
+# Sinus
+
+def sinus(X):
+    """
+    Retourne une approximation de sin(x) (flottant)
+
+    CU : X numérique
+
+    >>> sinus(-5)
+    0.9589242746631357
+    >>> sinus(0)
+    0.0
+    >>> sinus(5)
+    -0.9589242746631357
+    """
+    assert(type(X) is int or type(X) is float), "X doit être un numérique"
+
+    s = 0 # Initialisation de la somme
+    sP = 1 # Initialisation par une valeur autre que s pour démarrer la boucle
+    i = 0 # Initialisation de l'incrémenteur
+    while s != sP: # Tant que Python peut calculer les décimales
+        sP = s # La valeur actuelle devient précédente
+        if i % 2: # Si i est impair alors (-1)^i=-1, si pair =1 
+            p = -1
+        else:
+            p = 1
+        s += p * (X ** (2 * i + 1)) / factorielle(2 * i + 1) # On ajoute une
+                                                              # partie de la
+                                                              # somme
+        i += 1 # On incrémente i
+    return s # Retour de la valeur
+
+
+# Logarithme
+
+def ln(X):
+    """
+    Retourne une approximation de Ln(1+X) (flottant)
+
+    CU : X numérique ∈ [0,1]
+
+    >>> ln(0)
+    0.0
+    >>> ln(0.5)
+    0.4054651081081643
+    """
+    assert((type(X) is int or type(X) is float) and X >= 0 and X <= 1), \
+        "X doit être un numérique ∈ [0,1]"
+
+    l = 0 # Initialisation de la somme
+    lP = 1 # Initialisation par une valeur autre que l pour démarrer la boucle
+    i = 1 # Initialisation de l'incrémenteur
+    while l != lP : # Tant que Python peut calculer les décimales
+        lP = l # La valeur actuelle devient précédente
+        if i % 2: # Vérifier si i-1 est pair revient à vérifier si i est impair
+                  # cela revient à inverser les actions
+            p = 1
+        else:
+            p = -1
+        l += p * X**i / i # On ajoute un élement de la somme
+        i += 1 # On incrémente i
+    return l # Retour de la valeur
+
+
+def tester():
+    doctest.testmod(verbose=True)