Niveau0FormationLycee.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Eléments de programmation au lycée"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classe de seconde :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Une consolidation des acquis du cycle 4 est proposée autour de deux idées essentielles :\n",
    "\n",
    "\n",
    "\n",
    "- la notion de fonction ; \n",
    "- la programmation comme production d’un texte dans un langage informatique. \n",
    "\n",
    "Dans le cadre de cette activité, les élèves s’exercent à :\n",
    "\n",
    "- décrire des algorithmes en langage naturel ou dans un langage de programmation ; \n",
    "- en réaliser quelques-uns à l’aide d’un programme simple écrit dans un langage de programmation textuel ;\n",
    "- interpréter, compléter ou modifier des algorithmes plus complexes.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables et instructions élémentaires"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Connaissances :  Variables informatiques de type entier, flottant, chaîne de caractère.\n",
    "\n",
    "Capacités associées : Choisir ou déterminer le type d’une variable (entier, flottant ou chaîne de caractères).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "#typage dnamique sous Python\n",
    "a=1\n",
    "b=a/3\n",
    "print(type(a))\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Le symbole d'affectation sous Python est donné par le signe  =\n",
    "\n",
    "> Le test d'égalité se fait par le symbole  =="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tester les instructions suivantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=1\n",
    "b=4\n",
    "b==a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=1\n",
    "b=4\n",
    "b=a\n",
    "print(b)\n",
    "b==a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Le type   float (flottant) ne doit pas être confondu avec un type décimal ou réel an mathématiques (La représentation en base 2 des nombres décimaux peut conduire à certains écueils)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#tester si le triangle de côtés 3, 4 et 5 est rectangle\n",
    "a=3\n",
    "b=4\n",
    "c=5\n",
    "a**2+b**2==c**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#tester si le triangle de côtés 36, 15 et 39 est rectangle\n",
    "a=36\n",
    "b=15\n",
    "c=39\n",
    "a**2+b**2==c**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#tester si le triangle de côtés 3.6, 1.5 et 3.9 est rectangle\n",
    "a=3.6\n",
    "b=1.5\n",
    "c=3.9\n",
    "a**2+b**2==c**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Correctif : voir plus loin dans la partie instruction conditionnelle "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Connaissances : Affectation (notée ← en langage naturel).\n",
    "\n",
    "Capacités associées: Concevoir et écrire une instruction d’affectation, une séquence d’instructions, une instruction conditionnelle.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "Connaissances : Séquence d’instructions.\n",
    "\n",
    "Capacités associées:Écrire une formule permettant un calcul combinant des variables.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# fff\n",
    "On considère la fonction $f$ définie par $f(x)=x^2-4x+5$.\n",
    "Calculer les images de $-5$, $3$ et $2020$ par $f$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50 2 4072325\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    return x**2-4*x+5\n",
    "\n",
    "a=-5\n",
    "b=3\n",
    "c=2020\n",
    "print(f(a), f(b), f(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Connaissances : Instruction conditionnelle.\n",
    "\n",
    "Capacités associées: Concevoir et écrire une instruction conditionnelle.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compléter le programme suivant afin qu'il retourne la valeur absolue du nombre x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la valeur absolue de  -56  est égale à 56\n"
     ]
    }
   ],
   "source": [
    "x=-56\n",
    "if x>0:\n",
    "    print(\"la valeur absolue de \",x,\" est égale à\",x)\n",
    "else:\n",
    "    print(\"la valeur absolue de \",x,\" est égale à\",-x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Connaissances : Boucle bornée (for), boucle non bornée (while).\n",
    "\n",
    "Capacités associées: Programmer, dans des cas simples, une boucle bornée, une boucle non bornée.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compléter le programme suivant afin qu'il calcule la somme des entiers de 0 à n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "n=5\n",
    "s=0\n",
    "for k in range(1,n+1):\n",
    "    s=s+k\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifier le programme suivant afin qu'il retourne le plus grand entier dont le carré est inférieur à l'entier $n$ donné"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "547\n"
     ]
    }
   ],
   "source": [
    "n=546\n",
    "k=0\n",
    "while k <=n:\n",
    "    k=k+1\n",
    "print(k)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Capacités : Dans des cas plus complexes : lire, comprendre, modifier ou compléter un algorithme ou un programme.\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Voir les  fiches niveau 1 et niveau 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Notion de fonction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Connaissances :\n",
    "\n",
    "\n",
    "- Fonctions à un ou plusieurs arguments.\n",
    "- Fonction renvoyant un nombre aléatoire. \n",
    "- Série statistique obtenue par la répétition de l’appel d’une telle fonction.\n",
    "\n",
    "Capacités associées\n",
    "\n",
    "- Écrire des fonctions simples ; lire, comprendre, modifier, compléter des fonctions plus complexes. Appeler une fonction.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction suivante affiche la valeur absolue du paramètre x.\n",
    "\n",
    "Modifier cette fonction afin qu'elle puisse être utilisée dans des calculs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ValAbs(x):\n",
    "    if x>=0:\n",
    "        return x\n",
    "    else:\n",
    "        return -x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la distance est de 10\n"
     ]
    }
   ],
   "source": [
    "a=5\n",
    "b=15\n",
    "distance=ValAbs(a-b)\n",
    "print(\"la distance est de\", distance)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "Lire et comprendre une fonction renvoyant une moyenne, un écart type. Aucune connaissance sur les listes n’est exigée.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Version naïve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Donner le nombre de valeurs de la série7\n",
      "Valeur ?0\n",
      "Valeur ?1\n",
      "Valeur ?2\n",
      "Valeur ?3\n",
      "Valeur ?4\n",
      "Valeur ?5\n",
      "Valeur ?6\n",
      "3.0\n"
     ]
    }
   ],
   "source": [
    "n=int(input(\"Donner le nombre de valeurs de la série\"))\n",
    "s=0\n",
    "for k in range(n):\n",
    "    val=float(input(\"Valeur ?\"))\n",
    "    s=s+val\n",
    "print(s/n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Programmer une version avec une liste.\n",
    "On pourra utiliser certaines des commandes suivantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "[5, 6, 4, 8, 9, 10]\n",
      "5\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "#ne pas hésiter à modifier certaines des valeurs suivantes :\n",
    "l=[5,6,4,8,9,10] \n",
    "n=len(l)\n",
    "print(n)\n",
    "print(l)\n",
    "print(l[0])\n",
    "print(l[n-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def moy(l):#reçoit une liste en paramètre et retourne sa moyenne\n",
    "    m=0\n",
    "    for k in range(0,len(l)):\n",
    "        m=m+l[k] \n",
    "    return m/len(l)\n",
    "\n",
    "moy(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "    Écrire des fonctions renvoyant le résultat numérique d’une expérience aléatoire, d’une répétition d’expériences aléatoires indépendantes.\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partir des commandes suivantes, concevoir une fonction, de parmètre $n$, qui retourne une liste de $n$ entiers aléatoires compris entre 0 et 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import * ## inutile si librairie déjà présente\n",
    "print(randrange(5))\n",
    "print(random())\n",
    "for k in range(10):\n",
    "    print(randrange(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[]\n",
    "print(l)\n",
    "l.append(5)\n",
    "print(l)\n",
    "l.append(2)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ListeAlea100(n):\n",
    "    return 0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice : à partir de 1000 listes d'entiers aléatoires compris entre 0 et 100, établir la liste des moyennes de chacune de ces listes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Pour aller plus loin : afficher l'histogramme de ces moyennes (voir le notebook sur Matplolib) fiche niveau 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classe de première"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">L’enseignement de spécialité de mathématiques de classe de première vise la consolidation\n",
    "des notions de variable, d’instruction conditionnelle et de boucle ainsi que l’utilisation des\n",
    "fonctions. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"> La seule notion nouvelle est celle de liste qui trouve naturellement sa place dans\n",
    "de nombreuses parties du programme et aide à la compréhension de notions\n",
    "mathématiques telles que les suites numériques, les tableaux de valeurs, les séries\n",
    "statistiques...\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "L’accent est mis sur la programmation modulaire qui permet de découper une tâche\n",
    "complexe en tâches plus simples.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Notion de liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">La génération des listes en compréhension et en extension est mise en lien avec la notion\n",
    "d’ensemble. Les conditions apparaissant dans les listes définies en compréhension\n",
    "permettent de travailler la logique. Afin d’éviter des confusions, on se limite aux listes sans\n",
    "présenter d’autres types de collections.\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Capacités attendues"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Générer une liste (en extension, par ajouts successifs ou en compréhension).</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifier le programme suivant afin qu'il retourne la liste des entiers multiples de 3 ou de 5 compris entre 0 et 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 9, 15, 21, 25, 27, 33, 35, 39, 45, 51, 55, 57, 63, 65, 69, 75, 81, 85, 87, 93, 95, 99]\n"
     ]
    }
   ],
   "source": [
    "l=[]\n",
    "for k in range(101):\n",
    "    if k%3==0 or k%5==0:\n",
    "        l.append(k)\n",
    "        if k%2==0 :\n",
    "            l.remove(k)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Manipuler des éléments d’une liste (ajouter, supprimer...) et leurs indices.\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifier le programme ci-dessous afin qu'il retourne la liste $li$ privée de ses éléments pairs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On pourra utiliser certaines des commandes suivantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=5\n",
    "print(n%3)\n",
    "l=[3,5,6,7]\n",
    "l.remove(5)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "li=[978, 416, 473, 574, 300, 703, 888, 730, 615, 18, 888, 752, 174, 906, 127, 347, 588, 683, 86, 352, 286, 876, 926, 822, 848, 346, 184, 249, 438, 969, 970, 166, 515, 747, 93, 866, 599, 966, 907, 989, 872, 190, 909, 531, 768, 811, 258, 518, 340, 91, 517, 368, 796, 711, 835, 250, 420, 530, 639, 524, 756, 345, 917, 229, 469, 568, 873, 439, 952, 758, 904, 511, 956, 967, 852, 134, 461, 396, 868, 534, 351, 405, 573, 730, 432, 949, 2, 133, 867, 24, 456, 717, 153, 734, 209, 528, 545, 567, 26, 384, 374, 321, 874, 187, 314, 572, 388, 415, 514, 680, 676, 970, 806, 837, 757, 931, 829, 119, 226, 236, 513, 524, 696, 170, 378, 347, 361, 850, 253, 743, 436, 766, 363, 426, 443, 563, 29, 63, 180, 997, 449, 154, 87, 989, 342, 892, 534, 969, 79, 813, 819, 838, 486, 124, 292, 405, 686, 319, 405, 74, 507, 357, 669, 189, 695, 526, 50, 196, 483, 244, 109, 265, 567, 337, 469, 69, 465, 515, 573, 960, 880, 401, 76, 145, 892, 911, 975, 598, 121, 650, 484, 447, 189, 282, 941, 852, 854, 769, 936, 253, 877, 61, 889, 208, 188, 259, 661, 233, 33, 244, 958, 194, 603, 852, 143, 34, 218, 100, 640, 25, 881, 662, 499, 735, 3, 974, 301, 906, 443, 654, 945, 254, 200, 269, 546, 454, 697, 225, 470, 905, 785, 429, 791, 255, 934, 845, 456, 29, 439, 229]\n",
    "print(li)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Parcourir une liste.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifier le programme suivant afin qu'il retourne le plus grand élément de la iste $l$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 288\n",
      "1 373\n",
      "6 485\n",
      "10 495\n"
     ]
    }
   ],
   "source": [
    "from random import * ## inutile si librairie déjà présente\n",
    "\n",
    "l=[]\n",
    "n=100\n",
    "for k in range(n):\n",
    "    l.append(randrange(500))\n",
    "max=l[0]\n",
    "for k in range(0,n):\n",
    "    if l[k]>=max :\n",
    "        max=l[k]\n",
    "        print(k,l[k])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">Itérer sur les éléments d’une liste.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecrire un programme qui inverse la liste $li$\n",
    "\n",
    "exemple li=[1,4,7,3]  -> li=[3,7,4,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "li=[405, 686, 319, 405, 74, 507, 357, 669, 189, 695, 526, 50, 196, 483, 244, 109, 265, 567, 337, 469, 69, 465, 515, 573, 960, 880, 401, 76, 145, 892, 911, 975, 598, 121, 650, 484, 447, 189, 282, 941, 852, 854, 769, 936]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice :\n",
    "\n",
    "- exécuter le programme ci-dessous;\n",
    "- interpréter le résultat obtenu;\n",
    "- expliquer...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[85, 381, 53, 457, 137, 183, 490, 19, 11, 144, 159, 275, 98, 72, 199, 91, 402, 353, 223, 126, 149, 278, 31, 415, 93, 146, 462, 477, 32, 102, 323, 445, 473, 123, 425, 282, 133, 466, 473, 183, 162, 269, 156, 78, 321, 370, 292, 123, 284, 467, 314, 416, 64, 56, 342, 411, 176, 145, 480, 306, 35, 429, 35, 129, 118, 86, 48, 187, 395, 120, 262, 312, 248, 55, 20, 457, 320, 364, 307, 91, 461, 257, 284, 45, 143, 237, 137, 278, 271, 71, 319, 123, 246, 350, 396, 227, 296, 123, 238, 96]\n",
      "[11, 19, 20, 31, 32, 35, 35, 45, 48, 53, 55, 56, 64, 71, 72, 78, 85, 86, 91, 91, 93, 96, 98, 102, 118, 120, 123, 123, 123, 123, 126, 129, 133, 137, 137, 143, 144, 145, 146, 149, 156, 159, 162, 176, 183, 183, 187, 199, 223, 227, 237, 238, 246, 248, 257, 262, 269, 271, 275, 278, 278, 282, 284, 284, 292, 296, 306, 307, 312, 314, 319, 320, 321, 323, 342, 350, 353, 364, 370, 381, 395, 396, 402, 411, 415, 416, 425, 429, 445, 457, 457, 461, 462, 466, 467, 473, 473, 477, 480, 490]\n"
     ]
    }
   ],
   "source": [
    "from random import * ## inutile si librairie déjà présente\n",
    "l=[]\n",
    "for k in range(100):\n",
    "    l.append(randrange(500))\n",
    "lc=[]\n",
    "for k in range(500):\n",
    "    lc.append(0)\n",
    "for k in range(100):\n",
    "    p=l[k]\n",
    "    lc[p]=lc[p]+1\n",
    "lt=[]\n",
    "for k in range(500):\n",
    "    n=lc[k]\n",
    "    for i in range(n):\n",
    "        lt.append(k)\n",
    "print(l)\n",
    "print(lt)\n"
   ]
  },
  {
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}