Suites.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utilisation de l'interface\n",
    "Le texte qui suit est divisé en cellule. Certaines cellules contiennent du code Python. Ce code Python peut être modifié et exécuté.\n",
    "\n",
    "Pour modifier le code d'une cellule, il suffit de cliquer dans la cellule.\n",
    "\n",
    "**Pour exécuter le code d'une cellule, cliquer dans la cellule puis $\\boxed{Ctrl}$ + $\\boxed{Entr\\acute{e}e}$** (ou l'icone Exécuter).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exemples d'algorithmes\n",
    "## A. En première\n",
    "Ces algorithmes apparaissent dans le programme de spécialité en première générale, et dans le tronc commun en première technologique.\n",
    "\n",
    "Pour (re)voir l'utilisation des boucles `for` et `while` on peut suivre ce lien : [Boucles](https://mybinder.org/v2/gh/perrumaths/CAPES/master?filepath=Boucles.ipynb).\n",
    "### 1. Calcul des termes d'une suite\n",
    "**a) Avec une suite définie par une formule explicite**\n",
    "\n",
    "**Exemple** Soit $(u_n)$ la suite définie par $u_n=3n+(-1)^n$.\n",
    "Pour calculer un nombre donné de termes, on peut faire une boucle. Par exemple, pour obtenir $10$ termes, exécutez le programme suivant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in range(10):       # Les instructions indentées suivantes sont exécutées pour n = 0, 1, 2, ... 9.\n",
    "    u = 3*n + (-1)**n\n",
    "    print(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 1** Modifier le programme précédent pour qu'il affiche 5 termes, 100 termes.\n",
    "\n",
    "\n",
    "\n",
    "On peut utiliser une fonction pour pouvoir changer le nombre de termes affichés. Exécuter le programme suivant qui définit la fonction `termesu`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def termesu(nb):          # Définition d'une fonction, de paramètre nb : nb est le nombre de termes qui seront affichés\n",
    "    for n in range(nb):\n",
    "        u = 3*n + (-1)**n\n",
    "        print(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 2** Tester la fonction `termesu` dans la cellule suivante, en affichant 5 termes, 10 termes, 200 termes…"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "termesu(?)    # Appel à la fonction termesu. Mettre une valeur à la place du point d'interrogation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin, on peut modifier la fonction `termesu` pour qu'elle retourne une **liste** Python. Exécuter le programme suivant, qui définit la fonction `listetermesu`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def listetermesu(nb):\n",
    "    L = []                   # Crée une liste L vide\n",
    "    for n in range(nb):\n",
    "        u = 3*n + (-1)**n\n",
    "        L = L + [u]          # Au lieu d'afficher la valeur de u, on ajoute l'élément u à la liste L\n",
    "    return L                 # On retourne la liste L, une fois la boucle terminée"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 3** Tester la fonction `listetermesu` dans la cellule suivante, en demandant 5 termes, 10 termes, 200 termes…"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "listetermesu(?)   # Appel à la fonction listetermesu. Mettre une valeur à la place du point d'interrogation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**b) Avec une suite définie par une formule explicite**\n",
    "\n",
    "Le principe est le même, mais le calcul de chaque terme se fait à partir du terme précédent, et non à partir de l'indice.\n",
    "\n",
    "**Exemple** Soit $(v_n)$ la suite définie par $v_0=1$ et $v_{n+1}=\\dfrac{v_n}{2}+\\dfrac{1}{v_n}$.\n",
    "\n",
    "Exécuter le programme suivant, qui affiche les $5$ termes de la suite qui suivent $v_0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = 1\n",
    "for n in range(5):       # Les instructions indentées suivantes sont exécutées pour n = 0, 1, 2, ... 4, donc 5 fois\n",
    "    u = u/2 + 1/u\n",
    "    print(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 4** Compléter le code de la cellule suivante pour définir une fonction `termesv`, de paramètres `nb`, qui retourne la liste des nb termes suivant $v_0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def termesv(nb):\n",
    "    L =                                     # Liste vide initiale\n",
    "    u = 1\n",
    "    for n in range(?):                      # Boucle à exécuter nb fois\n",
    "        u =                                 # Calcul du nouveau terme u\n",
    "        L =                                 # Ajout de l'élément u à la liste L\n",
    "    return L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tester la fonction dans la cellule suivante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "termesv(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 5** Soit $a$ un nombre réel. On définit la suite $w_n$ par\n",
    "$$w_0=1\\mbox{ et }w_{n+1}=\\dfrac{w_n}{2}+\\dfrac{a}{2w_n}$$\n",
    "\n",
    "(La suite $(v_n)$ précédente correspond donc au cas $a=2$.)\n",
    "\n",
    "Écrire dans la cellule suivante une fonction `termesw` ayant 2 paramètres, `a` et `nb`, et retournant nb termes de la suite."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 6** Dans la cellule suivante, vérifier avec différentes valeurs de $a$, que $w_5$ est très proche de $\\sqrt{a}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**c) Un exemple plus complexe : la suite de Syracuse**\n",
    "\n",
    "Soit $A$ un entier naturel non nul. La suite de Syracuse $(S_n)$ est définie en donnant son premier terme $S_0=A$, puis\n",
    "* Si $S_n$ est pair, alors $S_{n+1}=\\dfrac{S_n}{2}$,\n",
    "* sinon $S_{n+1}=3S_n+1$.\n",
    "\n",
    "**Exercice 7** Compléter la fonction suivante pour qu'elle retourne une liste de nb termes de la suite de Syracuse commençant par A."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Syracuse(A,nb):\n",
    "    L = []\n",
    "    u =                             # Terme initial\n",
    "    for n in range(?):              # Boucle à exécuter nb fois\n",
    "        if u%2 == 0:                # u%2 est le reste dans la division euclidienne de u par 2\n",
    "            u = u//2                # u//2 est le quotient dans la division euclidienne de u par 2\n",
    "        else:                       # sinon\n",
    "            u = \n",
    "        L = L + [u]\n",
    "    return L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vérifier dans la cellule suivante que quelle que soit la valeur initiale A, la suite finit par donner 4, 2, 1, 4, 2, 1.\n",
    "\n",
    "Même en partant de 27…"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Syracuse(7,20)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}