NSI_1_Programmation2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link rel=\"stylesheet\" type=\"text/css\" href=\"custom.css\">\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%HTML\n",
    "<link rel=\"stylesheet\" type=\"text/css\" href=\"custom.css\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Boucles et tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Les boucles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Boucle indéterminée\n",
    "\n",
    "C'est une suite d'instructions effectuées un certain nombre de fois tant qu'une condition est réalisée."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Exemples\n",
    "\n",
    "On lance un dé cubique tant qu'on n'a pas obtenu un $6$. C'est une boucle indéterminée. On peut écrire un algorithme qui réalise cette situation :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "lance $\\longleftarrow -1$<br/>\n",
    "Tant que lance $\\neq 6$<br/>\n",
    "$\\hspace{1cm} lance \\longleftarrow$ générer aléatoirement un entier compris entre 1 et 6<br/>\n",
    "Fin Tant que\n",
    "\n",
    "Ci-dessous, le code Python pour traduire cet algorithme :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from random import randint #Ceci permet la génération d'entier de manière aléatoire\n",
    "lance = -1\n",
    "while lance != 6 : # L'opérateur \"!=\" représente la non égalité\n",
    "    lance = randint(1,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On peut faire afficher le contenu de la variable **lance** à chaque fois."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "lance = -1\n",
    "while lance != 6 : # L'opérateur \"!=\" représente la non égalité\n",
    "    lance = randint(1,6)\n",
    "    print(\"lance = \",lance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "On peut aussi compter le nombre de lancers effectués pour avoir un $6$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "lance = -1\n",
    "compteur = 0\n",
    "while lance != 6 : # L'opérateur \"!=\" représente la non égalité\n",
    "    compteur = compteur + 1\n",
    "    lance = randint(1,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 1**\n",
    "\n",
    "On considère l'algorithme suivant : \n",
    "\n",
    "$n \\longleftarrow 0$<br/>\n",
    "$C \\longleftarrow 3,4$<br/>\n",
    "Tant que $C\\geqslant 1$<br/>\n",
    "$\\hspace{1cm}n \\longleftarrow n+1$<br/>\n",
    "$\\hspace{1cm}C \\longleftarrow 0,8 \\times C$<br/>\n",
    "Fin Tant que\n",
    "\n",
    "1. Construire un tableau représentant les états de la mémoire lors de l'exécution de cet algorithme.\n",
    "2. Écrire le code Python traduisant cet algorithme."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Boucle déterminée\n",
    "\n",
    "C'est une suite d'instructions effectuées un certain nombre de fois connu à l'avance.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Exemple\n",
    "\n",
    "On lance $10$ fois un dé cubique. On peut écrire un algorithme pour simuler ces $10$ lancers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Pour compteur allant de $0$ à $9$<br/>\n",
    "$\\hspace{1cm}$ lance $\\longleftarrow$ générer aléatoirement un entier compris entre 1 et 6<br/>\n",
    "Fin Pour\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Le code Python :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "for compteur in range(-2,1):#On crée un compteur qui prend les valeurs de 0 à 9\n",
    "    lance = randint(1,6)\n",
    "    print(\"Lancer n° \",compteur,\" : \",lance)\n",
    "    a = compteur**2\n",
    "    print(\"a = \",a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Exercice 2**\n",
    "\n",
    "Que fait l'algorithme suivant ?\n",
    "\n",
    "$s\\longleftarrow 0$<br/>\n",
    "Pour $n$ allant de $0$ à $100$ :<br/>\n",
    "$\\hspace{1cm}s\\longleftarrow s+1$<br/>\n",
    "Fin Pour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Le code Python correspondant :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "s = 0\n",
    "for n in range(101):\n",
    "    s=s+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Exercice 3**\n",
    "\n",
    "On considère l'algorithme suivant : \n",
    "\n",
    "$S\\longleftarrow 0$<br/>\n",
    "Pour $i$ allant de $1$ à $5$ <br/>\n",
    "$\\hspace{1cm}j\\longleftarrow 0$<br/>\n",
    "$\\hspace{1cm}$Tant que $j<i$<br/>\n",
    "$\\hspace{2cm}S\\longleftarrow S+j$<br/>\n",
    "$\\hspace{2cm}j\\longleftarrow j+1$<br/>\n",
    "$\\hspace{1cm}$Fin Tant que<br/>\n",
    "Fin Pour\n",
    "\n",
    "1. Que contient la variable $j$ à la fin de l'exécution de l'algorithme ?\n",
    "2. Compléter le tableau ci-dessous en ajoutant les lignes nécessaires :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "|Valeurs de $i$|Valeurs de $j$|Valeur du test $j<i$|Valeur de $S$|\n",
    " |:---:|:---:|:---:|:---:|\n",
    "|$1$|$0$|$Faux$|$0$| \n",
    "|$2$|$?$|$?$|$?$| \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "3. En déduire la valeur contenue dans la variable $S$ après l'exécution de l'algorithme.\n",
    "4. Écrire un code Python traduisant cet algorithme."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Réponse du 4**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "S=0\n",
    "for i in range(1,6):\n",
    "    j = 0\n",
    "    while j<i :\n",
    "        S = S+j\n",
    "        j = j+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Les tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Dans un algorithme ou dans un programme il arrive que l'exécution d'une instruction dépende du résultat d'une condition. On dit alors que c'est une instruction conditionnelle.\n",
    "\n",
    "Considérons l'algorithme suivant :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$a \\longleftarrow$ entier naturel non nul<br/>\n",
    "Si $a$ est pair alors <br/>\n",
    "$\\hspace{1cm}a\\longleftarrow \\dfrac{a}{2}$<br/>\n",
    "Fin Si<br/>\n",
    "Sinon<br/>\n",
    "$\\hspace{1cm}a\\longleftarrow 3 a+1$<br/>\n",
    "Fin Sinon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "L'affectation de la variable $a$ après l'évaluation de la parité de $a$ est conditionnée par le résultat de celle-ci."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Exemples.\n",
    "\n",
    "* Si $a=8$ alors  $a$ prend la veleur $4$. \n",
    "* Si $a=3$ alors $a$ prend la valeur $10$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Exercice 3**\n",
    "\n",
    "Exécuter l'algorithme suivant et dresser la liste des différentes valeurs affectées à $a$ durant l'exécution de l'algorithme.\n",
    "\n",
    "$a \\longleftarrow 3$<br/>\n",
    "Tant que $a>1$<br/>\n",
    "$\\hspace{1cm}$Si $a$ est pair alors <br/>\n",
    "$\\hspace{2cm}a\\longleftarrow \\dfrac{a}{2}$<br/>\n",
    "$\\hspace{1cm}$Fin Si<br/>\n",
    "$\\hspace{1cm}$Sinon<br/>\n",
    "$\\hspace{2cm}a\\longleftarrow 3 \\times a+1$<br/>\n",
    "$\\hspace{1cm}$Fin Sinon<br/>\n",
    "Fin Tant que"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Solution**\n",
    "\n",
    "Tableau de valeurs des états de la variable $a$ lors de l'exécution de l'algorithme.\n",
    "\n",
    "|Valeurs de $a$|Test $a$ est pair|Test $a$$>$$1$|\n",
    "|:--:|:--:|:--:|\n",
    "|$3$|Faux|Vrai|\n",
    "|$10$|Vrai|Vrai|\n",
    "|$5$|Faux|Vrai|\n",
    "|$16$|Vrai|Vrai|\n",
    "|$8$|Vrai|Vrai|\n",
    "|$4$|Vrai|Vrai|\n",
    "|$2$|Vrai|Vrai|\n",
    "|$1$|Vrai|Faux|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Écrire un code Python traduisant cet algorithme.\n",
    "\n",
    "**Solution**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Entrer un entier :  3\n"
     ]
    }
   ],
   "source": [
    "a = input(\"Entrer un entier : \")\n",
    "a = int(a)\n",
    "val_a = []\n",
    "while a>1:\n",
    "    if a%2 == 0 :\n",
    "        a = a//2\n",
    "    else :\n",
    "        a = 3*a+1\n",
    "    val_a.append(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Exercice 4**\n",
    "\n",
    "Soit $a$, $b$ et $c$ trois entiers relatifs. Écrire un algorithme qui détermine les solutions de l'équation du second degré $a x^2+b x+c =0$ en fonction de $a$, $b$ et $c$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Solution**\n",
    "\n",
    "Données : $a$, $b$ et $c$ trois entiers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Si $a=0$ alors<br/>\n",
    "$\\hspace{1cm}$ Ce n'est pas une équation du 2nd degré.<br/>\n",
    "Fin Si<br/>\n",
    "Sinon <br/>\n",
    "$\\hspace{1cm}D\\longleftarrow b^2-4 a c$<br/>\n",
    "$\\hspace{1cm}$Si $D<0$ alors <br/>\n",
    "$\\hspace{2cm}$Aucune solution réelle<br/>\n",
    "$\\hspace{1cm}$Fin Si<br/>\n",
    "$\\hspace{1cm}$Sinon<br/>\n",
    "$\\hspace{2cm}$Si $D=0$ alors <br/>\n",
    "$\\hspace{3cm}$Une solution<br/>\n",
    "$\\hspace{3cm}x_1 \\longleftarrow -\\dfrac{b}{2 a}$<br/>\n",
    "$\\hspace{2cm}$Fin Si<br/>\n",
    "$\\hspace{2cm}$Sinon<br/>\n",
    "$\\hspace{3cm}$Deux solutions réelles<br/>\n",
    "$\\hspace{3cm}x_1 \\longleftarrow \\dfrac{-b+\\sqrt{D}}{2 a}$<br/>\n",
    "$\\hspace{3cm}x_1 \\longleftarrow \\dfrac{-b-\\sqrt{D}}{2 a}$<br/>\n",
    "$\\hspace{2cm}$Fin Sinon<br/>\n",
    "$\\hspace{1cm}$Fin Sinon<br/>\n",
    "Fin Sinon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}