ajout sequence recursivité

Recursivité/TP/Recherche_dicho.py

@@ -0,0 +1,24 @@
+def recherche_dichotomique(t, v):
+    debut = 0
+    fin = len(t)-1
+    while debut <= fin :
+        milieu = (debut + fin) // 2
+        print(milieu,debut,fin)
+        if t[milieu] == v :
+            return True 
+        else:
+            if t[milieu] > v :
+                fin = milieu - 1
+            else :
+                debut = milieu + 1
+    return False
+
+def recherche_recur(t,v):
+    if len(t) == 1:
+        return t[0] == v
+    else :
+        milieu = len(t)//2
+        if t[milieu] > v :
+            return recherche_recur(t[:milieu],v)
+        else :
+            return recherche_recur(t[milieu:],v)

Recursivité/TP/TP.md

@@ -0,0 +1,29 @@
+## Activité : La récursivité dans les jeux vidéo
+
+### Contexte :
+Imaginez un jeu vidéo populaire où le héros doit traverser différents niveaux pour sauver un personnage captif. Chaque niveau est plus difficile que le précédent, et chaque niveau contient des mini-boss qu'il faut vaincre avant de passer au suivant.
+
+### Objectif de l'activité :
+Utiliser la récursivité pour simuler le parcours du héros à travers les niveaux du jeu.
+
+### Instructions :
+
+### Présentation du problème :
+- Le héros commence au niveau 1 et doit atteindre le niveau `n`.
+- À chaque niveau, il y a un certain nombre de mini-boss à vaincre avant de passer au niveau suivant.
+- Si le héros vainc tous les mini-boss d'un niveau, il passe au niveau suivant, sinon il recommence le même niveau.
+
+### Modélisation en pseudo-code :
+Écrire une fonction récursive `traverse_levels` qui prend en entrée le niveau actuel et le nombre total de niveaux.
+
+- Si le niveau actuel est supérieur au nombre total de niveaux, le héros a gagné.
+- Sinon, le héros combat les mini-boss et passe au niveau suivant.
+
+### 3. Exemple de code en Python
+```python
+def combat_mini_bosses(level):
+    pass
+
+def traverse_levels(current_level, total_levels):
+   pass
+```

Recursivité/TP/TP_recursivite.md

@@ -0,0 +1,69 @@
+# TP Récursivité :
+
+------
+
+## 1. Courbe de Koch : 
+
+> Prérequis : Module turtle
+
+La courbe de koch est une figure récursive pouvant ressembler à cela : 
+
+> Inserer un exemple
+
+Celle-ci possède un cas de base d'ordre 0, il est représenté par un segment. Le cas d'ordre 1 est ce même segment découpé en 3, la partie du milieu est quand à elle un triangle équilatéral sans sa base (ou un chapeau ^). 
+
+> Insérer les image ordre 0 et 1
+
+Le cas d'ordre 2 reprend le cas d'ordre 1 est pour chaque segment, le redécoupe et dessine ce "triangle".
+
+Le cas d'ordre n reprend le cas d'ordre n-1 puis refait la même chose... Ainsi de suite
+
+1. Ecrire de manière récursive le code de la fonction courbe_koch(n, cote) permettant de dessiner cette courbe.  
+
+Nous voulons obtenir maintenant un flocon de koch. Celui-ci répète plusieurs fois la courbe de koch afin de revenir à son point initial.
+
+2.  Ecrire le code de la fonction flocon() qui dessine le flocon de la courbe de koch
+
+> inserer flocon courbe koch
+
+## 2. Triangle de Pascal : 
+
+Le triangle de pascal représente les coefficients binomiaux sous la forme d'un triangle :
+
+coef(n,p) : *fonction permettant de calculer les coefficients*
+
+coef(n,p) :
+
+- 1 **si p = 0 ou n == p**
+- coef(n-1,p-1) + coef(n-1,p) **sinon**
+
+1. Ecrire le code de la fonction coef(n,p)
+
+ Le sommet du triangle est le résultat de coef(0,0), la première ligne elle est représenté par coef(1,0) et coef(1,1), ainsi de suite pour les autres lignes
+
+2. A l'aide de deux boucles écrire un code permettant d'afficher les 6 premières lignes du triangle.
+
+## 3. Recherche dichotomique :
+
+La recherche dichotomique fonctionne sur un tableau trié, et permet en fonction de la longueur du tableau n de trouver un élément de façon optimale.
+
+Voici le code de la recherche dichotomique (programme 1ère) de manière itérative :
+
+```python
+def recherche_dichotomique(t, v):
+    debut = 0
+    fin = len(t)-1
+    while debut <= fin :
+        milieu = (debut + fin) // 2
+        print(milieu,debut,fin)
+        if t[milieu] == v :
+            return True 
+        else:
+            if t[milieu] > v :
+                fin = milieu - 1
+            else :
+                debut = milieu + 1
+    return False
+```
+
+1. Ecrire ce code en récursif

Recursivité/TP/TP_recursivite.py

@@ -0,0 +1,27 @@
+import turtle
+
+def courbe_koch(n, l):
+    if n == 0 :
+        turtle.forward(l)
+    else :
+        courbe_koch(n-1, l/3)
+        turtle.left(60)
+        courbe_koch(n-1, l/3)
+        turtle.left(-120)
+        courbe_koch(n-1, l/3)
+        turtle.left(60)
+        courbe_koch(n-1, l/3)
+
+def flocon(n,l,i=3):
+    if i != 0: 
+        courbe_koch(n,l)
+        turtle.left(-120)
+        flocon(n,l,i-1)
+
+turtle.setheading(0) # orientation intiale de la tête : vers la droite de l'écran
+turtle.hideturtle() # on cache la tortue
+turtle.speed(0)	 # on accélère la tortue
+turtle.color('green')
+#flocon(1,300)
+#courbe_koch(,400)
+print(8)

Recursivité/TP/Triangle_Pascal.py

@@ -0,0 +1,10 @@
+def coef(n,p):
+    if p==0 or n == p :
+        return 1
+    else :
+        return coef(n-1,p-1) + coef(n-1,p)
+    
+for i in range(19):
+    for j in range(i+1):
+        print(coef(i,j),' ',end='')
+    print()