{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Première Cours Suites Partie 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sur la page [https://repl.it/@fredericjunier/PremiereSuitesPartie1](https://repl.it/@fredericjunier/PremiereSuitesPartie1) vous pourrez aussi tester les codes ci-dessous." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Activité 1 : châteaux de cartes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pour tout entier naturel $n \\geqslant 1$, on a :\n", "* le nombre de cartes au niveau $n$ vérifie $u_{n}=3n$\n", "* le nombre total de cartes pour construire $n$ niveaux vérifie $v_{n+1}=u_{n+1} + v_{n}$" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "def chateau(n):\n", " u = 0\n", " v = 0\n", " for k in range(1, n + 1):\n", " u = u + 3 #u = k * 3\n", " v = v + u\n", " return v" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 3, 9, 18, 30, 45, 63, 84]" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[chateau(n) for n in range(0, 8)]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Activité 2 Modèle d’évolution d’une population" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On a $u_{0}=27500$ étudiants en Septembre 2016.\n", "\n", "En notant $u_{n}$ le nombre d'étudiants en Septembre $2016 + n$, en juin $2016+n+1$, après une perte de $150$ étudiants, on a $u_{n}-150$ étudiants. Puis on a une augmentation de cet effectif, à la rentrée de Septembre, cest-à-dire $1,04(u_{n}-150)=1,04u_{n}-156$ étudiants en Septembre $2016+n+1$. \n", "\n", "Pour tout entier $n \\geqslant 0$, on a donc : $u_{n+1}=1,04u_{n}-156$.\n", "\n", "La capacité maximale de l'établissement est de $33000$. D'après l'algorithme de seuil ci-dessous, à la rentrée de Septembre $2022$, la capacité maximale d'accueil sera dépassée." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def seuil():\n", " n = 0\n", " u = 27500\n", " while u <= 33000:\n", " n = n + 1\n", " u = 1.04 * u - 156\n", " return n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Capacité 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Question 1 a) : $a_{2} \\approx 14400$ et $a_{8} \\approx 17200$\n", "* Question 1 b) : Le montant de l'APA en 2013 était de $a_{7} = 16744$\n", "* Question 2) a) : $a_{10} = a_{9} \\times 1,05 = 18070 \\times 1,05 = 18973,5$\n", "* Question 2) b) : [feuille de calcul en ligne](https://lite.framacalc.org/9el4-premiereg5-lyceeparc-suites-capacite2)\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
n91011121314
a(n)1807018973.519922.17520918.2837521964.197937523062.407834375
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Capacité 3 " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Soit la suite définie par : $u_0 = 4$ et, pour tout entier naturel $n$, $u_{n+1} = -\\frac{1}{2}u_n + 2$.\n", "\n", "* Question 1) a) : $u_{1}=-\\frac{1}{2}u_0 + 2=0$ et $u_{2}=-\\frac{1}{2}0 + 2=2$ \n", "\n", "* Question 1) b) : calcul de $u_{n}$ avec une fonction Python\n", "\n", "~~~Python\n", "def suiteU_capacite3_question1(n):\n", " u = 4\n", " for k in range(n):\n", " u = -0.5 * u + 2\n", " return u\n", "~~~\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.33349609375\n" ] } ], "source": [ "def suiteU_capacite3_question1(n):\n", " u = 4\n", " for k in range(n):\n", " u = -0.5 * u + 2\n", " return u\n", "\n", "#calcul de u(14)\n", "print(suiteU_capacite3_question1(14))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Soit la suite définie par $u_{0}=2$ et pour tout entier naturel $n$, par $u_{n+1}=u_{n}+n^2+1$.\n", "\n", "\n", "* Question 1) a) : $u_{1}=u_0 + 0^{}=0$ et $u_{2}=-\\frac{1}{2}\\times 0 + 2=2$ \n", "\n", "* Question 1) b) : calcul de $u_{n}$ avec une fonction Python\n", " \n", "\n", "~~~python\n", "def suiteU_capacite3_question2(n):\n", " u = 2\n", " for k in range(n):\n", " u = u + k ** 2 + 1\n", " return u\n", "~~~\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "297\n" ] } ], "source": [ "def suiteU_capacite3_question2(n):\n", " u = 2\n", " for k in range(n):\n", " u = u + k ** 2 + 1\n", " return u\n", "\n", "print(suiteU_capacite3_question2(10))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Capacité 4\n", "\n", "* Question 1) : soit la suite définie pour tout entier $n \\geqslant 1$ par $v_{n}=\\frac{2^{n}+1}{2+(-1)^{n}2^{n+1}}$.\n", "\n", " - $v_{1}=\\frac{2^{1}+1}{2+(-1)^{1}2^{1+1}}=-\\frac{3}{4}$\n", " - $v_{2}=\\frac{2^{2}+1}{2+(-1)^{2}2^{2+1}}=\\frac{5}{10}$\n", " - $v_{3}=\\frac{2^{3}+1}{2+(-1)^{3}2^{3+1}}=-\\frac{9}{14}$\n", "\n", "\n", "* Question 2) : soit la suite définie par $u_{0}=0$ et pour tout entier $n \\geqslant 1$, $u_{n}=u_{n-1} + 2n - 1$\n", "\n", " - $u_{1}=u_{0} + 2\\times 1 - 1 = 1$\n", " - $u_{2}=u_{1} + 2\\times 2 - 1 = 4$\n", " - $u_{3}=u_{2} + 2\\times 3 - 1 = 9$\n", "\n", "Calculs de tous les termes entre $u_{0}$ et $u_{n}$ avec une fonction Python\n", " \n", "\n", "~~~python\n", "def suiteU_capacite4(n):\n", " u = 0\n", " print(u)\n", " for k in range(1, n + 1):\n", " u = u + 2 * k - 1\n", " print(u)\n", "~~~\n", "\n", "On peut conjecturer que pour tout entier $n \\geqslant 0$, on a $u_{n}=n^2$.\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "4\n", "9\n", "16\n", "25\n", "36\n", "49\n", "64\n", "81\n", "100\n", "121\n", "144\n", "169\n", "196\n", "225\n", "256\n", "289\n", "324\n", "361\n", "400\n" ] }, { "data": { "text/plain": [ "400" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def suiteU_capacite4(n):\n", " u = 0\n", " print(u)\n", " for k in range(1, n + 1):\n", " u = u + 2 * k - 1\n", " print(u)\n", "\n", "suiteU_capacite4(20)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Capacité 5 : manipuler les listes en Python" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "843\n", "852\n", "True\n", "[2, 16]\n" ] } ], "source": [ "###Question 1\n", "L1 = [852, 843, 954]\n", "print(L1[1])\n", "#843\n", "print(L1[0])\n", "#852\n", "#print(L[3])\n", "#provoque une erreur\n", "\n", "###Question 2\n", "L2 = [k * 2 - 1 for k in range(3)]\n", "\n", "\n", "###Question 3\n", "from math import sin\n", "L3 = []\n", "for k in range(1, 50):\n", " if sin(k) >= 0:\n", " L3.append(k)\n", "#équivalent à \n", "L32 = [k for k in range(1, 50) if sin(k) >= 0]\n", "print(L3 == L32)\n", "##True\n", "\n", "### Question 4\n", "L4 = list(range(2, 5))\n", "L4.pop()\n", "L4.append(14)\n", "L4.pop(1)\n", "L4.pop(1)\n", "L4.append(16)\n", "print(L4)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Suite de syracuse" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "def syracuse(u , n):\n", " \"\"\"Retourne la liste des premiers termes \n", " de la suite de syracuse de premier terme u\"\"\"\n", " L = [u]\n", " for k in range(n):\n", " if u % 2 == 0:\n", " u = u // 2\n", " else:\n", " u = 3 * u + 1\n", " L.append(u)\n", " return L" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[634,\n", " 317,\n", " 952,\n", " 476,\n", " 238,\n", " 119,\n", " 358,\n", " 179,\n", " 538,\n", " 269,\n", " 808,\n", " 404,\n", " 202,\n", " 101,\n", " 304,\n", " 152,\n", " 76,\n", " 38,\n", " 19,\n", " 58,\n", " 29,\n", " 88,\n", " 44,\n", " 22,\n", " 11,\n", " 34,\n", " 17,\n", " 52,\n", " 26,\n", " 13,\n", " 40,\n", " 20,\n", " 10,\n", " 5,\n", " 16,\n", " 8,\n", " 4,\n", " 2,\n", " 1,\n", " 4,\n", " 2]" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "syracuse(634 , 40)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1]\n", "[11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4]\n", "[12, 6, 3, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1]\n", "[13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1]\n", "[14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4]\n", "[15, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4]\n", "[16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2]\n", "[17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1]\n", "[18, 9, 28, 14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4]\n", "[19, 58, 29, 88, 44, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4]\n", "[20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2]\n" ] } ], "source": [ "for k in range(10, 21):\n", " print(syracuse(k, 21))" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def tempsVol(u):\n", " \"\"\"Retourne le plus petit indice du terme de la suite de syracuse\n", " de premier terme u, qui est égal à 1\"\"\"\n", " i = 0\n", " while u != 1:\n", " if u % 2 == 0:\n", " u = u // 2\n", " else:\n", " u = 3 * u + 1\n", " i = i + 1\n", " return i" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "38" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tempsVol(634)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Capacité 6 : Suite définie par des motifs géométriques ou combinatoires\n", "\n", "* Question 1) : On a $t_{1}=1$ et pour tout entier $n \\geqslant 2$, on a $t_{n}=t_{n-1}+n$.\n", "* Question 2) : On admet que pour tout entier $n \\geqslant 1$, on a $t_{n}+t_{n-1}=n^{2}$. On en déduit que $t_{n}+t_{n}-n=n^{2}$ c'est-à-dire $t_{n}=\\frac{n(n+1)}{2}$. Notons que pour tout entier $n \\geqslant 1$, $t_{n}=1+2+\\ldots +n$ donc $1+2+\\ldots +n==\\frac{n(n+1)}{2}$\n", "* Question 3) a) : On a $u_{1}=0$ et pour tout entier $n \\geqslant 1$, on a $u_{n+1}=u_{n}+n$ ou encore pour tout entier $n \\geqslant 2$, on a $u_{n}=u_{n-1}+n-1$. \n", " * Question 3) b) : On peut remarquer que $u_{n}=1+2+\\ldots+n-1$. D'après la question précédente, on a, pour tout entier $n \\geqslant 1$, $u_{n}=\\frac{(n-1)n}{2}$. On peut aussi noter que $u_{1}=0=t_{1}-1$ puis $u_{2}=u_{1}-1+1=t_{1}$ puis $u_{3}=t_{1}+2=t_{2}$ puis $u_{4}=t_{2}+3=t_{3}$. En terminale, on pourra démontrer par récurrence que pour tout entier $n \\geqslant 2$, on a $u_{n}=t_{n-1}=\\frac{(n-1)n}{2}$.\n", " \n", " * Question 4) : On peut assimiler le nombre total de poignées de mains échangées dans une assemblée de $n$ personnes qui se saluent toutes deux à deux, par la valeur de $u_{n}$ définie dans la question précédente. En effet, on peut considérer que les personnes arrivent successivement dans la salle et que tout nouvel arrivant salue toutes les personnes déjà présentes.\n", "\n", " On résout donc l'équation $\\frac{(n-1)n}{2}=45 \\Longleftrightarrow n^{2}-n-90=0 \\Longleftrightarrow \\begin{cases}n=\\frac{1+19}{2}=10 \\\\ \\text{ou }\\frac{1-19}{2}=-9<0 \\text{ impossible} \\end{cases}$.\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Algorithmique 2 : Factorielle de n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def factorielle(n):\n", " u = 1\n", " for k in range(1, n + 1):\n", " u = u * k\n", " return u" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[factorielle(n) for n in range(10)]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Capacité 7 : Modéliser un phénomène discret à croissance linéaire\n", "\n", "* Question 1) : $v_{1}=20$ et $v_{2}=v_{1}-0,6=19,4$.\n", "* Question 2) : pour tout entier $n$ tel que $1 \\leqslant n \\leqslant 23$, on a $v_{n+1}=v_{n}-0,6$.\n", "* Question 3) : au douzième mois, le montant de la mensualité est de $v_{12}=v_{1}-11 \\times 0,6=20-6,6=13,4$ euros.\n", "Plus généralement, pour tout entier $n$ tel que $1 \\leqslant n \\leqslant 24$, on aura $v_{n}=v_{1}-0,6(n-1)=20,6-0,6n$.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Capacité 8 : Modéliser un phénomène discret à croissance exponentielle\n", "\n", "* Question 1) : $C_{1}=820$ euros et $C_{2}=C_{1} \\times 1,025=840,5$ euros.\n", "* Question 2) : Pour tout entier naturel $n$, on a $C_{n+1}=1,025 \\times C_{n}$ (formule de récurrence) et $C_{n}=C_{0} \\times 1,025^{n}$ (formule explicite)\n", "* Question 3) : Algorithme de seuil en Python, fonction retournant le plus petit entier $n$ tel que $C_{n}>s$\n", "\n", "~~~python\n", "def seuil(s):\n", " c = 800\n", " n = 0\n", " while c <= s:\n", " c = 1.025 * c\n", " n =n + 1\n", " return n\n", "~~~" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 800\n", "1 819.9999999999999\n", "2 840.4999999999998\n", "3 861.5124999999997\n", "4 883.0503124999997\n", "5 905.1265703124996\n", "6 927.7547345703119\n", "7 950.9486029345696\n", "8 974.7223180079338\n", "9 999.0903759581321\n", "10 1024.0676353570852\n", "10\n" ] } ], "source": [ "def seuil(s):\n", " c = 800\n", " n = 0\n", " print(n, c)\n", " while c <= s:\n", " c = 1.025 * c\n", " n =n + 1\n", " print(n, c)\n", " return n\n", "\n", "print(seuil(1000))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Capacité 11 Déterminer une relation pour une suite définie par un motif géométrique" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* __Question 1__ : pour tout entier $n \\geqslant 1$, on a $a_{n+1}=a_{n}=2$ avec $a_{1}=1$. La suite $\\left(a_{n}\\right)$ est donc arithmétique de raison $2$ et pour tout entier naturel $n\\geqslant 1$, on a $a_{n}=a_{1} + (n-1) \\times 2=1+2(n-1)=2n-1$.\n", "\n", "* __Question 2__ : D'après la formule sur la somme des termes consécutifs d'uen suite arithmétique, on a $\\sum_{k=1}^{n}a_{k}=\\frac{a_{1}+a_{n}}{2} \\times n= \\frac{1+2n-1}{2} \\times n = n^{2}$.\n", "\n", "* __Question 3__ : On résout l'inéquation $\\sum_{k=1}^{n}a_{k} \\geqslant 1 \\Longleftrightarrow n^{2} \\geqslant 1000 \\Longleftrightarrow n \\geqslant \\sqrt{1000} \\Longleftrightarrow n \\geqslant 32$. Le robot doit donc effectuer au moin $32$ trajets en ligne droite (le dernier sera incomplet) et $31$ virage, ce qui pour une distance de $1$ kilomètres soit $10^{5}$ centimètres représente un temps de $\\frac{10^{5}}{20} + 31 \\times 2 =5062$ secondes.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Capacité 12 Modéliser un phénomène discret à croissance exponentielle, calculer le terme général d’une suite géométrique" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* __Question 1__ : $u_{0}=60$, $u_{1}=30$ et $u_{2}=15$.\n", "* __Question 2__ : Pour tout entier naturel $n$, on a $u_{n+1}=0,5u_{n}$ donc la suite $\\left(u_{n}\\right)$ est géométrique de raison $0,5$ et donc $u_{n}=0,5^{n}u_{0}=\\frac{60}{2^{n}}$. On en déduit que $u_{5}=\\frac{60}{2^{5}}=1,875$.\n", "* __Question 3__ : Fonction `seuil()` qui retourne le plus petit entier n à partir duquel $u_{n}<0,25$. Elle retourne $8$ donc au bout de $8$ demi-vies soit $8 \\times 3=24$ jours, l’activité radioactive de cet échantillon est strictement inférieure à $0,25$." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def seuil():\n", " u = 60 \n", " n = 0\n", " while u >= 0.25:\n", " u = u / 2\n", " n = n + 1\n", " return n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "8" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seuil()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Capacité 13 : Calculer la somme de termes consécutifs d'une suite géométrique\n", "\n", "Pour tout entier naturel $n$, on considère la somme $s_{n}=1+\\frac{1}{2}+\\ldots+\\frac{1}{2^n}=\\sum_{k=0}^{n}\\frac{1}{2^{k}}$.\n", "\n", "1. Pour tout entier naturel $n$, on a : $s_{n}=1 \\times \\frac{1-\\frac{1}{2^{n}}}{1-\\frac{1}{2}}=2-\\frac{1}{2^{n-1}}$. En effet $s_{n}$ est la somme des $n$ premiers termes de la suite géométrique de premier terme $r_{1}=1$ et de raison $\\frac{1}{2}$.\n", " \n", "2. On peut conjecturer que lorsque $n$ tend vers $+\\infty$, $s_{n}$ tend vers $2$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Capacité 14 Déterminer une relation explicite ou une relation de récurrence pour une suite définie par un motif géométrique ou une question de dénombrement\n", "\n", "\n", "1. On note $u_{n}$ la surface restante de la feuille après $n$ découpes. Ainsi $u_{0}=400$.\n", "\n", " a. Pour tout entier naturel $n$, on a $u_{n + 1}=\\frac{8}{9}u_{n}$. La suite $\\left(u_{n}\\right)$ est donc géométrique de raison $\\frac{8}{9}$.\n", "\n", " b. On peut conjecturer que pour $n$ assez grand $u_{n}$ deviendra aussi proche de $0$ que l'on veut.\n", "\n", " c. Fonction seuil :\n", "\n", " ~~~python\n", " def seuil(s):\n", " n = 0\n", " u = 400\n", " while u > s:\n", " u = 8 * u / 9\n", " n = n + 1\n", " return n\n", " ~~~\n", "\n", " `seuil(10)` retourne la valeur 32.\n", "\n", "2. On note $v_{n}$ le nombre de nouveaux carrés découpés lors de la $n^{ième}$ découpe avec $n \\geqslant 1$. Ainsi $v_{1}=1$, $v_{2}=8$.\n", "\n", " a. Pour tout entier naturel $n$, on a $v_{n + 1}=8v_{n}$. La suite $\\left(v_{n}\\right)$ est donc géométrique de raison $8$.\n", "\n", " b. On peut conjecturer que pour $n$ assez grand $v_{n}$ deviendra aussi grand que l'on veut.\n", "\n", " c. Fonction somme :\n", "\n", " ~~~python\n", " def somme(n):\n", " v = 1\n", " t = v\n", " for k in range(2, n + 1):\n", " v = 8 * v\n", " t = t + v\n", " return t\n", " ~~~\n", "\n", " `somme(10)` retourne la valeur 153391689.\n", " \n", " d. D'après une formule du cours :\n", "$$t_{n}=v_{1}+v_{2}+\\ldots+v_{n}=v_{1}\\times \\frac{1-8^{n}}{1-8}=\\frac{8^{n}-1}{7}$$" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def seuil(s):\n", "\tn = 0\n", "\tu = 400\n", "\twhile u > s:\n", "\t\tu = 8 * u / 9\n", "\t\tn = n + 1\n", "\treturn n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "32" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seuil(10)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def somme(n):\n", " v = 1\n", " t = v\n", " for k in range(2, n + 1):\n", " v = 8 * v\n", " t = t + v\n", " return t" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "153391689" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "somme(10)" ] } ], "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.9" } }, "nbformat": 4, "nbformat_minor": 2 }