From 758d4bbf7df2dcbcdc50d330b5482dee20f0d4c9 Mon Sep 17 00:00:00 2001 From: Florian Mathieu Date: Mon, 21 Sep 2026 10:15:29 +0200 Subject: [PATCH] =?UTF-8?q?TP=20diviser=20pour=20r=C3=A9gner=20publiable,?= =?UTF-8?q?=20doublon=20retir=C3=A9,=20fiche=20d'exercices=20ajout=C3=A9e?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Recursivité/Diviser_pour_regner/EXERCICES.md | 99 ++++++ Recursivité/TP/TP.md | 29 -- Recursivité/TP/TP_Recursivite.ipynb | 349 ------------------- Recursivité/TP/TP_recursivite.md | 103 ------ Recursivité/TP_Recursivite.ipynb | 2 +- 5 files changed, 100 insertions(+), 482 deletions(-) create mode 100644 Recursivité/Diviser_pour_regner/EXERCICES.md delete mode 100644 Recursivité/TP/TP.md delete mode 100644 Recursivité/TP/TP_Recursivite.ipynb delete mode 100644 Recursivité/TP/TP_recursivite.md diff --git a/Recursivité/Diviser_pour_regner/EXERCICES.md b/Recursivité/Diviser_pour_regner/EXERCICES.md new file mode 100644 index 0000000..1031e5d --- /dev/null +++ b/Recursivité/Diviser_pour_regner/EXERCICES.md @@ -0,0 +1,99 @@ +# Exercices : Diviser pour régner + +--- + +Les trois premiers exercices se traitent sur papier avant de toucher au clavier. Un algorithme que vous ne savez pas dérouler à la main est un algorithme que vous ne saurez pas déboguer à l'écran. Les derniers sont volontairement plus exigeants. + +--- + +## Exercice 1 : Dérouler le tri fusion + +On trie la liste suivante avec le tri fusion vu en cours : + +```python +[5, 3, 8, 1, 9, 2, 7] +``` + +**Questions :** + +1. Dessiner l'arbre des divisions, jusqu'à n'obtenir que des listes d'un seul élément. +2. Écrire, étage par étage, les fusions successives qui reconstituent la liste triée. +3. Combien d'étages de division compte-t-on pour une liste de 8 éléments ? De 16 éléments ? De 1024 éléments ? +4. En déduire la relation entre le nombre d'étages et la taille de la liste. Quel est le rapport avec la complexité annoncée en cours ? + +--- + +## Exercice 2 : La fusion vue de près + +On reprend la fonction `fusionner` du cours, celle qui réunit deux listes déjà triées. + +**Questions :** + +1. Dérouler l'appel `fusionner([2, 5, 9], [1, 3, 12])` dans un tableau, en notant à chaque tour de boucle les valeurs de `i`, de `j` et de `resultat`. +2. Combien de comparaisons entre éléments cette fusion a-t-elle demandées ? +3. Donner deux listes de trois éléments chacune dont la fusion ne demande que trois comparaisons. Expliquer ce qui se produit. +4. Quel est le nombre maximal de comparaisons pour fusionner une liste de *p* éléments et une liste de *q* éléments ? Justifier. +5. La fonction se termine par `return resultat + gauche[i:] + droite[j:]`. Pourquoi peut-on ajouter d'un seul coup tout ce qui reste, sans le comparer à quoi que ce soit ? + +--- + +## Exercice 3 : Recherche dichotomique + +Chercher une valeur dans une liste **triée** est le deuxième exemple canonique du diviser pour régner : on compare avec l'élément du milieu, et on élimine la moitié de la liste à chaque étape. + +**Questions :** + +1. Écrire une fonction récursive `recherche(tab, x)` qui renvoie `True` si `x` figure dans la liste triée `tab`, et `False` sinon. +2. Dérouler `recherche([1, 4, 6, 9, 12, 15, 20], 12)`. Quelles sous-listes sont successivement examinées, et combien d'appels sont nécessaires ? +3. On veut maintenant connaître l'**indice** de `x`, et plus seulement sa présence. Expliquer pourquoi la fonction de la question 1, qui découpe la liste en tranches, ne permet pas d'y répondre directement. +4. Écrire une fonction `indice(tab, x, debut, fin)` qui renvoie l'indice de `x` dans `tab`, ou `-1` s'il est absent, **sans jamais découper la liste**. +5. Sur une liste d'un million d'éléments, combien d'appels au maximum ? Combien pour une liste deux fois plus longue ? + +--- + +## Exercice 4 : Le maximum, avec et sans diviser pour régner + +**Questions :** + +1. Écrire une fonction récursive `maximum(tab)` qui applique le schéma du cours : si la liste ne contient qu'un élément, le renvoyer ; sinon la couper en deux, chercher le maximum de chaque moitié, et renvoyer le plus grand des deux résultats. +2. Combien de comparaisons cette fonction effectue-t-elle sur une liste de 8 éléments ? Et la boucle `for` que vous écririez spontanément ? +3. Le découpage apporte-t-il un gain ici ? Justifier. +4. Un tel découpage ne fait donc pas toujours gagner. À quelle condition sur l'étape « combiner » la méthode devient-elle intéressante ? Comparer avec le tri fusion. + +--- + +## Exercice 5 : Compter les occurrences dans une liste triée + +Un serveur de jeu conserve les scores de ses 500 000 joueurs dans une liste **triée par ordre croissant**. Plusieurs joueurs peuvent avoir exactement le même score, et l'on veut savoir combien. + +**Questions :** + +1. Écrire une fonction `compter_naif(tab, x)` qui parcourt la liste et compte les occurrences de `x`. Quelle est sa complexité ? +2. Écrire une fonction `premiere_occurrence(tab, x)` qui renvoie, par dichotomie, l'indice de la **première** apparition de `x`, ou `-1` s'il est absent. On prendra garde à ne pas s'arrêter à la première correspondance trouvée. +3. Écrire de même `derniere_occurrence(tab, x)`. +4. En déduire une fonction `compter(tab, x)` et donner sa complexité. +5. Sur les 500 000 scores, combien d'opérations séparent les deux méthodes, en ordre de grandeur ? + +--- + +## Exercice 6 : Compter les inversions + +Une **inversion** dans une liste `tab` est un couple d'indices (*i*, *j*) tel que *i* < *j* et `tab[i] > tab[j]`, autrement dit deux éléments rangés dans le mauvais ordre l'un par rapport à l'autre. Le nombre d'inversions mesure le désordre d'une liste : il vaut 0 pour une liste triée, et il est maximal pour une liste rangée à l'envers. Les sites de recommandation s'en servent pour estimer à quel point deux classements se ressemblent. + +**Questions :** + +1. Donner les inversions de la liste `[2, 4, 1, 3, 5]`. Combien y en a-t-il ? +2. Quelle liste de *n* éléments en compte le plus ? Combien exactement ? +3. Écrire une fonction `inversions_naif(tab)` qui les compte avec deux boucles imbriquées. Quelle est sa complexité ? +4. On veut faire mieux en s'appuyant sur le tri fusion. Pendant la fusion de `gauche` et de `droite`, toutes deux déjà triées, on prend parfois un élément de `droite` alors qu'il reste encore des éléments dans `gauche`. Combien d'inversions ce seul choix révèle-t-il d'un coup ? Justifier soigneusement. +5. Écrire `fusionner_et_compter(gauche, droite)` qui renvoie le couple formé de la liste fusionnée et du nombre d'inversions découvertes pendant cette fusion. +6. En déduire `tri_fusion_inversions(tab)` qui renvoie le couple formé de la liste triée et du nombre total d'inversions. Attention à ne pas oublier les inversions comptées dans chaque moitié. +7. Quelle est la complexité obtenue ? Sur une liste de 100 000 éléments, quel facteur sépare cette version de celle de la question 3 ? + +--- + +Auteur : Florian Mathieu + +Licence CC BY-SA + +Licence Creative Commons
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 4.0 International. diff --git a/Recursivité/TP/TP.md b/Recursivité/TP/TP.md deleted file mode 100644 index 743d4c6..0000000 --- a/Recursivité/TP/TP.md +++ /dev/null @@ -1,29 +0,0 @@ -## 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 -``` \ No newline at end of file diff --git a/Recursivité/TP/TP_Recursivite.ipynb b/Recursivité/TP/TP_Recursivite.ipynb deleted file mode 100644 index d37d77c..0000000 --- a/Recursivité/TP/TP_Recursivite.ipynb +++ /dev/null @@ -1,349 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "66904fb8", - "metadata": {}, - "source": [ - "# TP : La Récursivité et le Diviser pour Régner\n", - "\n", - "## Objectifs :\n", - "- Comprendre le principe de la récursivité.\n", - "- Appliquer la récursivité pour résoudre des problèmes simples.\n", - "- Approfondir la méthode du **diviser pour régner** à travers des exemples concrets.\n", - "- Compléter un algorithme de **tri fusion**.\n", - "\n", - "### Rappel sur la récursivité :\n", - "La récursivité est une méthode où une fonction s'appelle elle-même pour résoudre un problème. Chaque appel de la fonction permet de simplifier le problème jusqu'à atteindre une condition de base (appelée **cas de base**) qui permet de terminer la récursion.\n", - "\n", - "**Exemple classique :** Calcul de la factorielle d'un nombre entier positif `n`.\n", - "```python\n", - "def factorielle(n):\n", - " if n == 0:\n", - " return 1 # Cas de base\n", - " else:\n", - " return n * factorielle(n-1) # Appel récursif\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "bb057eb6", - "metadata": {}, - "source": [ - "### Exercice 1 : Fonction récursive `traduire_romain`\n", - "**But :** Écrire une fonction récursive `traduire_romain` qui prend en paramètre une chaîne de caractères non vide représentant un nombre écrit en chiffres romains, et qui renvoie son écriture décimale.\n", - "\n", - "**Consignes :**\n", - "- Chaque chiffre romain a une valeur : `I=1, V=5, X=10, L=50, C=100, D=500, M=1000`.\n", - "- Si un chiffre plus petit précède un chiffre plus grand (ex : IV), cela signifie qu'il faut soustraire la valeur du chiffre plus petit.\n", - " \n", - "**Exemple :**\n", - "```python\n", - "traduire_romain(\"IX\") # Renvoie 9\n", - "traduire_romain(\"MCMXCIV\") # Renvoie 1994\n", - "```\n", - "\n", - "**Indication :** Utilisez la récursion pour traiter un caractère à la fois, et soustrayez ou ajoutez en fonction de la position relative des caractères.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "ff49f2f3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "None\n" - ] - } - ], - "source": [ - "def traduire_romain(chaine):\n", - " pass\n", - "\n", - "\n", - "print(traduire_romain(\"IX\")) # Doit afficher 9\n" - ] - }, - { - "cell_type": "markdown", - "id": "1aedbf03", - "metadata": {}, - "source": [ - "### Exercice 2 : Compléter un Tri Fusion\n", - "**But :** Compléter l'algorithme du tri fusion.\n", - "\n", - "Le tri fusion est un exemple typique de la méthode de **diviser pour régner**. L'idée est de diviser le tableau en deux, de trier chaque moitié, puis de fusionner les deux moitiés triées.\n", - "\n", - "Voici un code partiellement écrit que vous devez compléter :\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "31d950ac", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[38, 27, 43, 3, 9, 82, 10]\n" - ] - } - ], - "source": [ - "def tri_fusion(tab):\n", - " if len(tab) <= 1:\n", - " return tab # Cas de base\n", - " milieu = len(tab) // 2\n", - " gauche = tri_fusion(tab[:milieu]) # Appel récursif\n", - " droite = tri_fusion(tab[milieu:]) # Appel récursif\n", - " return fusionner(gauche, droite)\n", - "\n", - "def fusionner(gauche, droite):\n", - " tableau_fusionne = []\n", - " i, j = 0, 0\n", - " # Complétez la fonction pour fusionner les deux sous-tableaux ici :\n", - " # ---------------------------------------------\n", - "\n", - " # ---------------------------------------------\n", - " # Ajoutez ici les éléments restants des sous-tableaux\n", - " tableau_fusionne += gauche[i:]\n", - " tableau_fusionne += droite[j:]\n", - " return tableau_fusionne\n", - "\n", - "# Test de la fonction tri_fusion\n", - "print(tri_fusion([38, 27, 43, 3, 9, 82, 10])) # Doit afficher une liste triée\n" - ] - }, - { - "cell_type": "markdown", - "id": "15791934", - "metadata": {}, - "source": [ - "### Exercice 3 : Diviser pour Régner — Recherche d'un élément dans un tableau\n", - "**But :** Implémenter la recherche d'un élément dans un tableau trié en utilisant la méthode de **diviser pour régner** (recherche dichotomique).\n", - "\n", - "La recherche dichotomique consiste à diviser le tableau en deux parties à chaque étape :\n", - "- Si l'élément recherché est au milieu, vous avez terminé.\n", - "- Si l'élément est plus petit que l'élément du milieu, il se trouve dans la première moitié du tableau.\n", - "- Sinon, il se trouve dans la deuxième moitié.\n", - "\n", - "Voici un squelette à compléter :\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "ab9509b5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "None\n" - ] - } - ], - "source": [ - "def recherche_dichotomique(tab, element, debut=0, fin=None):\n", - " if fin is None:\n", - " fin = len(tab) - 1\n", - " if debut > fin:\n", - " return -1 # L'élément n'est pas dans le tableau\n", - " milieu = (debut + fin) // 2\n", - " if tab[milieu] == element:\n", - " return # L'élément est trouvé\n", - " # Complétez ici avec les appels récursifs manquants :\n", - " # --------------------------------------------------\n", - " \n", - " # --------------------------------------------------\n", - " \n", - "# Test de la fonction\n", - "tab = [3, 9, 10, 27, 38, 43, 82]\n", - "element = 27\n", - "print(recherche_dichotomique(tab, element)) # Doit afficher l'index de l'élément trouvé\n" - ] - }, - { - "cell_type": "markdown", - "id": "99671e3b", - "metadata": {}, - "source": [ - "### Exercice 4 : \n", - "\n", - "On considère des tableaux de nombres dont tous les éléments sont présents\n", - "exactement trois fois à la suite, sauf un élément qui est présent une unique fois et\n", - "que l'on appelle « l'intrus ». \n", - "\n", - "\n", - "Voici quelques exemples :\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "f7a2fa7d", - "metadata": {}, - "outputs": [], - "source": [ - "tab_a = [3, 3, 3, 9, 9, 9, 1, 1, 1, 7, 2, 2, 2, 4, 4, 4, 8, 8, 8, 5,\n", - "5, 5]\n", - "#l'intrus est 7\n", - "tab_b = [8, 5, 5, 5, 9, 9, 9, 18, 18, 18, 3, 3, 3]\n", - "#l'intrus est 8\n", - "tab_c = [5, 5, 5, 1, 1, 1, 0, 0, 0, 6, 6, 6, 3, 8, 8, 8]\n", - "#l'intrus est 3" - ] - }, - { - "cell_type": "markdown", - "id": "f693789b", - "metadata": {}, - "source": [ - "On remarque qu'avec de tels tableaux : \n", - "\n", - "\n", - " pour les indices multiples de 3 situés strictement avant l'intrus, l'élément\n", - "correspondant et son voisin de droite sont égaux,\n", - "\n", - "\n", - " pour les indices multiples de 3 situés après l'intrus, l'élément correspondant et\n", - "son voisin de droite - s'il existe - sont différents.\n", - "\n", - "Ce que l'on peut observer ci-dessous en observant les valeurs des paires de voisins\n", - "marquées par des caractères ^" - ] - }, - { - "cell_type": "markdown", - "id": "b0549a7c", - "metadata": {}, - "source": [ - "[3, 3, 3, 9, 9, 9, 1, 1, 1, 7, 2, 2, 2, 4, 4, 4, 8, 8, 8, 5, 5, 5]\n", - "^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^\n", - "0 3 6 9 12 15 18 21 " - ] - }, - { - "cell_type": "markdown", - "id": "fbb578a8", - "metadata": {}, - "source": [ - "Dans des listes comme celles ci-dessus, un algorithme récursif pour trouver l'intrus\n", - "consiste alors à choisir un indice i multiple de 3 situé approximativement au milieu\n", - "des indices parmi lesquels se trouve l'intrus.\n", - "\n", - "\n", - "Puis, en fonction des valeurs de l'élément d'indice i et de son voisin de droite, à\n", - "appliquer récursivement l'algorithme à la moitié droite ou à la moitié gauche des\n", - "indices parmi lesquels se trouve l'intrus." - ] - }, - { - "cell_type": "markdown", - "id": "b0603315", - "metadata": {}, - "source": [ - "Par exemple, si on s’intéresse à l’indice 12, on voit les valeurs 2 et 4 qui sont\n", - "différentes : l’intrus est donc à gauche de l’indice 12 (indice 12 compris)\n", - "\n", - "\n", - "En revanche, si on s’intéresse à l’indice 3, on voit les valeurs 9 et 9 qui sont\n", - "identiques : l’intrus est donc à droite des indices 3-4-5, donc à partir de l’indice 6." - ] - }, - { - "cell_type": "markdown", - "id": "bb44af36", - "metadata": {}, - "source": [ - "Compléter la fonction récursive **trouver_intrus** proposée page suivante qui met\n", - "en œuvre cet algorithme." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "887c8914", - "metadata": {}, - "outputs": [ - { - "ename": "SyntaxError", - "evalue": "invalid character '–' (U+2013) (617363500.py, line 9)", - "output_type": "error", - "traceback": [ - "\u001b[0;36m Cell \u001b[0;32mIn[11], line 9\u001b[0;36m\u001b[0m\n\u001b[0;31m nombre_de_triplets = (d – g) // ...\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid character '–' (U+2013)\n" - ] - } - ], - "source": [ - "def trouver_intrus(tab, g, d):\n", - " \n", - " '''Renvoie la valeur de l'intrus situé entre les indices g et d dans la liste tab où :\n", - " tab vérifie les conditions de l'exercice, g et d sont des multiples de 3.\n", - " '''\n", - " if g == d:\n", - " return ...\n", - " else:\n", - " nombre_de_triplets = (d – g) // ...\n", - " indice = g + 3 * (nombre_de_triplets // 2)\n", - " if ... :\n", - " return ...\n", - " else:\n", - " return ..." - ] - }, - { - "cell_type": "markdown", - "id": "679501d0", - "metadata": {}, - "source": [ - "Exemples :" - ] - }, - { - "cell_type": "markdown", - "id": "d06a36b2", - "metadata": {}, - "source": [ - ">>> trouver_intrus([3, 3, 3, 9, 9, 9, 1, 1, 1, 7, 2, 2, 2, 4,\n", - "4, 4, 8, 8, 8, 5, 5, 5], 0, 21)\n", - "7\n", - ">>> trouver_intrus([8, 5, 5, 5, 9, 9, 9, 18, 18, 18, 3, 3, 3],\n", - "0, 12)\n", - "8\n", - ">>> trouver_intrus([5, 5, 5, 1, 1, 1, 0, 0, 0, 6, 6, 6, 3, 8,\n", - "8, 8], 0, 15)\n", - "3" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python (myenv)", - "language": "python", - "name": "myenv" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/Recursivité/TP/TP_recursivite.md b/Recursivité/TP/TP_recursivite.md deleted file mode 100644 index c62d251..0000000 --- a/Recursivité/TP/TP_recursivite.md +++ /dev/null @@ -1,103 +0,0 @@ -# TP Récursivité - ------- - -## 1. Courbe de Koch - -> Prérequis : Module turtle - -La courbe de Koch est une figure fractale récursive. Elle fait partie des premières fractales décrites mathématiquement (1904). - -### Principe de construction - -**Ordre 0** : Un simple segment de longueur `cote`. - -``` -───────────────────── -``` - -**Ordre 1** : Le segment est divisé en 3 parties égales. La partie centrale est remplacée par deux segments formant un triangle équilatéral sans sa base (un "chapeau" ^). - -``` - /\ - / \ -──────/ \────── -``` - -**Ordre 2 et suivants** : On applique la même transformation à chaque segment de la figure précédente. - -``` - /\ - / \ /\ - / \ / \ -─/ \──/ \─ -``` - -### Questions - -1. Écrire de manière récursive le code de la fonction `courbe_koch(n, cote)` permettant de dessiner cette courbe à l'ordre `n` avec des segments de longueur `cote`. - -Nous voulons obtenir maintenant un **flocon de Koch**. Celui-ci est composé de trois courbes de Koch disposées en triangle équilatéral. - -2. Écrire le code de la fonction `flocon(n, cote)` qui dessine le flocon de Koch. - -> **Indice** : Le flocon est formé de 3 courbes de Koch, avec un angle de 120° entre chaque courbe. - ---- - -## 2. Triangle de Pascal - -Le triangle de Pascal représente les coefficients binomiaux sous la forme d'un triangle : - -``` - 1 - 1 1 - 1 2 1 - 1 3 3 1 - 1 4 6 4 1 - 1 5 10 10 5 1 -``` - -La fonction `coef(n, p)` permet de calculer le coefficient à la ligne `n` et colonne `p` : - -$$ -coef(n, p) = \begin{cases} - 1 & \text{si } p = 0 \text{ ou } n = p\\ - coef(n-1, p-1) + coef(n-1, p) & \text{sinon} -\end{cases} -$$ - -### Questions - -1. Écrire le code de la fonction récursive `coef(n, p)`. - -Le sommet du triangle est le résultat de `coef(0, 0)`, la première ligne est représentée par `coef(1, 0)` et `coef(1, 1)`, ainsi de suite pour les autres lignes. - -2. À 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 de trouver un élément de façon optimale en O(log n). - -Voici le code de la recherche dichotomique (programme de 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 - if t[milieu] == v: - return True - elif t[milieu] > v: - fin = milieu - 1 - else: - debut = milieu + 1 - return False -``` - -### Question - -1. Réécrire ce code en version récursive. La fonction prendra en paramètres le tableau `t`, la valeur cherchée `v`, ainsi que les indices `debut` et `fin`. diff --git a/Recursivité/TP_Recursivite.ipynb b/Recursivité/TP_Recursivite.ipynb index cc70b3d..2dae5ce 100644 --- a/Recursivité/TP_Recursivite.ipynb +++ b/Recursivité/TP_Recursivite.ipynb @@ -259,7 +259,7 @@ " if g == d:\n", " return ...\n", " else:\n", - " nombre_de_triplets = (d – g) // ...\n", + " nombre_de_triplets = (d - g) // ...\n", " indice = g + 3 * (nombre_de_triplets // 2)\n", " if ... :\n", " return ...\n",