{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# L3 E - S5 2018-19- TDO - séance 1, solutions des exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#  TDO 1 - Exercices  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Exercice 1 -  Conversion de secondes \n",
    "\n",
    "1. Ecrire un programme qui convertit en années, mois, jours, heures, minutes et secondes une durée de 123456789 secondes et afficher le résultat sous la forme \n",
    "123456789 secondes =  a années j jours h heures m minutes s secondes\n",
    "\n",
    "2. Ecrire un programme qui convertit en millénaires, siècles, années, mois, jours, heures, minutes et secondes une durée de 123456789987654321 secondes et afficher le résultat sous la forme \n",
    "123456789987654321 secondes =  M millénaires S siècles a années j jours h heures m minutes s secondes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "on ote 9 secondes et il reste 123456780 secondes\n",
      "on ote 33 minutes et il reste 123454800 secondes\n",
      "on ote 21 heures et il reste 123379200 secondes\n",
      "on ote 333 jours et il reste 94608000 secondes\n",
      "on ote 3 années et il reste 0 secondes\n",
      "\n",
      " 123456789 secondes =  3 années 333 jours 21 heures 33 minutes 9 secondes\n"
     ]
    }
   ],
   "source": [
    "n=123456789\n",
    "s=n%60\n",
    "n1=(n-s)//60\n",
    "m= n1% 60\n",
    "n2=(n1-m)//60\n",
    "h=n2 % 24\n",
    "n3=(n2-h)//24\n",
    "j=n3 % 365\n",
    "a=(n3-j)//365\n",
    "print(\"on ote\",s, \"secondes et il reste\", n-s, \"secondes\" )\n",
    "print(\"on ote\",m, \"minutes et il reste\", n-s-60*m, \"secondes\" )\n",
    "print(\"on ote\",h, \"heures et il reste\", n-s-60*m-3600*h, \"secondes\" )\n",
    "print(\"on ote\",j, \"jours et il reste\", n-s-60*m-3600*h-24*3600*j, \"secondes\" )\n",
    "print(\"on ote\",a, \"années et il reste\", n-s-60*m-3600*h-24*3600*j-365*3600*24*a, \"secondes\" )\n",
    "print(\"\\n\", n, \"secondes = \", a, \"années\", j, \"jours\", h, \"heures\", m, \"minutes\", s, \"secondes\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 123456789 secondes =  3 années 333 jours 21 heures 33 minutes 9 secondes\n"
     ]
    }
   ],
   "source": [
    "n=123456789\n",
    "s=n%60\n",
    "m=n//60 %60\n",
    "h=n//3600 %24\n",
    "j=n//(24*3600) %365\n",
    "a=n//(24*3600*365)\n",
    "\n",
    "print(\"\\n\", n, \"secondes = \", a, \"années\", j, \"jours\", h, \"heures\", m, \"minutes\", s, \"secondes\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Une version plus rapide :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "il reste 123456789987654300 secondes\n",
      "25\n",
      "il reste 123456789987652800 secondes\n",
      "12\n",
      "il reste 123456789987609600 secondes\n",
      "179\n",
      "il reste 123456789972144000 secondes\n",
      "29\n",
      "il reste 123456789057600000 secondes\n",
      "1\n",
      "il reste 123456785904000000 secondes\n",
      "3914789\n",
      "il reste 0 secondes\n",
      "\n",
      " 123456789987654321 secondes =  3914789 millénaires 1 siècles 29 années 179 jours 12 heures 25 minutes 21 secondes\n"
     ]
    }
   ],
   "source": [
    "n=123456789987654321\n",
    "\n",
    "s=n%60\n",
    "n1=(n-s)//60\n",
    "m= n1% 60\n",
    "n2=(n1-m)//60\n",
    "h=n2 % 24\n",
    "n3=(n2-h)//24\n",
    "j=n3 % 365\n",
    "n4=(n3-j)//365\n",
    "a=n4%100\n",
    "n5=(n4-a)//100\n",
    "S=n5%10\n",
    "M=(n5-S)//10\n",
    "print(s)\n",
    "print(\"il reste\", n-s, \"secondes\" )\n",
    "print(m)\n",
    "print(\"il reste\", n-s-60*m, \"secondes\" )\n",
    "print(h)\n",
    "print(\"il reste\", n-s-60*m-3600*h, \"secondes\" )\n",
    "print(j)\n",
    "print(\"il reste\", n-s-60*m-3600*h-24*3600*j, \"secondes\" )\n",
    "print(a)\n",
    "print(\"il reste\", n-s-60*m-3600*h-24*3600*j-365*3600*24*a, \"secondes\" )\n",
    "print(S)\n",
    "print(\"il reste\", n-s-60*m-3600*h-24*3600*j-365*3600*24*a-100*365*3600*24*S, \"secondes\" )\n",
    "print(M)\n",
    "print(\"il reste\", n-s-60*m-3600*h-24*3600*j-365*3600*24*a-100*365*3600*24*S-1000*365*3600*24*M, \"secondes\" )\n",
    "print(\"\\n\", n, \"secondes = \", M, \"millénaires\", S, \"siècles\", a, \"années\", j, \"jours\", h, \"heures\", m, \"minutes\", s, \"secondes\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Et la version plus rapide :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 123456789987654321 secondes =  3914789 millénaires 1 siècles 29 années 179 jours 12 heures 25 minutes 21 secondes\n"
     ]
    }
   ],
   "source": [
    "n=123456789987654321\n",
    "s=n%60\n",
    "m=n//60 %60\n",
    "h=n//3600 %24\n",
    "j=n//(24*3600) %365\n",
    "a=n//(24*3600*365) %100\n",
    "S=n//(24*3600*365*100) %10\n",
    "M=n//(24*3600*365*1000) \n",
    "print(\"\\n\", n, \"secondes = \", M, \"millénaires\", S, \"siècles\", a, \"années\", j, \"jours\", h, \"heures\", m, \"minutes\", s, \"secondes\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Exercice 2 -   Conversion de degrés en radians\n",
    "\n",
    "Ecrire un programme qui covertit en radians un angle A de 55 degrés 36 minutes et 28 secondes en affichant le résultat sous la forme : \n",
    "                un angle de  155 ° 8 ' 13 \" vaut x radians"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Un angle de  155 ° 8 ' 13 \" vaut 2.7076504720390804  radians\n"
     ]
    }
   ],
   "source": [
    "from math import *\n",
    "deg,min,sec=155,8,13\n",
    "angle_en_degres=deg+min/60+sec/3600\n",
    "angle_en_radians= angle_en_degres * pi /180\n",
    "print(\"Un angle de \",deg,\"°\",min,\"'\",sec,\"\\\" vaut\" , angle_en_radians, \" radians\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##   Exercice 3 -  Alphabets\n",
    "\n",
    "a) A partir de la chaîne 'abcdefghijklmnopqrstuvwxyz' (qu'on appellera alpha), utiliser la boucle while pour construire une chaîne 'a b c d e f g h i j k l m n o p q r s t u v w x y z' (qu'on appellera nouvel_alpha).\n",
    "\n",
    "b) Recommencer le même exercice avec la chaîne 'saperlipopette'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a) nouvel alphabet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nouvel_alpha = a b c d e f g h i j k l m n o p q r s t u v w x y z \n"
     ]
    }
   ],
   "source": [
    "alpha='abcdefghijklmnopqrstuvwxyz'\n",
    "i=0\n",
    "nouvel_alpha=\"\"\n",
    "while i<26:\n",
    "    t=alpha[i]\n",
    "    nouvel_alpha=nouvel_alpha+t+' '\n",
    "    i=i+1\n",
    "nouvel_alpha\n",
    "print('nouvel_alpha =', nouvel_alpha)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nouvel_alpha = T e l m o   f i e u x \n"
     ]
    }
   ],
   "source": [
    "alpha='Telmo fieux'\n",
    "i=0\n",
    "nouvel_alpha=\"\"\n",
    "while i<11:\n",
    "    t=alpha[i]\n",
    "    nouvel_alpha=nouvel_alpha+t+' '\n",
    "    i=i+1\n",
    "nouvel_alpha\n",
    "print('nouvel_alpha =', nouvel_alpha)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### nouveau saperlipopette"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nouveau_saper = s a p e r l i p o p e t t e \n"
     ]
    }
   ],
   "source": [
    "saper='saperlipopette'\n",
    "i=0\n",
    "nouveau_saper=\"\"\n",
    "while i<len(saper):\n",
    "    t=saper[i]\n",
    "    nouveau_saper=nouveau_saper+t+' '\n",
    "    i=i+1\n",
    "nouveau_saper\n",
    "print('nouveau_saper =', nouveau_saper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Exercice 4 -  Tables de multiplication \n",
    "\n",
    "a) Utiliser la boucle while pour afficher la table de multiplication de 6 sous la forme :\n",
    "\n",
    "1 x 6 = 6\n",
    "2 x 6 = 12\n",
    "3 x 6 = 18\n",
    "etc...\n",
    "\n",
    "jusqu'à 10 x 6 =60\n",
    "\n",
    "b) Sur le même modèle, utiliser deux boucles while pour afficher les tables de multiplication de 2 à 12 ; les tables de multiplications de deux entiers successifs seront séparées par une ligne vide.\n",
    "\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a) la table de multiplication de 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 x 6 = 6\n",
      "2 x 6 = 12\n",
      "3 x 6 = 18\n",
      "4 x 6 = 24\n",
      "5 x 6 = 30\n",
      "6 x 6 = 36\n",
      "7 x 6 = 42\n",
      "8 x 6 = 48\n",
      "9 x 6 = 54\n",
      "10 x 6 = 60\n"
     ]
    }
   ],
   "source": [
    "m=1\n",
    "while m < 11:\n",
    "    print(m, \"x 6 =\", 6*m)\n",
    "    m = m +1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b) les tables de multiplication de 2 à 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 x 2  = 2\n",
      "2 x 2  = 4\n",
      "3 x 2  = 6\n",
      "4 x 2  = 8\n",
      "5 x 2  = 10\n",
      "6 x 2  = 12\n",
      "7 x 2  = 14\n",
      "8 x 2  = 16\n",
      "9 x 2  = 18\n",
      "10 x 2  = 20\n",
      "\n",
      "\n",
      "1 x 3  = 3\n",
      "2 x 3  = 6\n",
      "3 x 3  = 9\n",
      "4 x 3  = 12\n",
      "5 x 3  = 15\n",
      "6 x 3  = 18\n",
      "7 x 3  = 21\n",
      "8 x 3  = 24\n",
      "9 x 3  = 27\n",
      "10 x 3  = 30\n",
      "\n",
      "\n",
      "1 x 4  = 4\n",
      "2 x 4  = 8\n",
      "3 x 4  = 12\n",
      "4 x 4  = 16\n",
      "5 x 4  = 20\n",
      "6 x 4  = 24\n",
      "7 x 4  = 28\n",
      "8 x 4  = 32\n",
      "9 x 4  = 36\n",
      "10 x 4  = 40\n",
      "\n",
      "\n",
      "1 x 5  = 5\n",
      "2 x 5  = 10\n",
      "3 x 5  = 15\n",
      "4 x 5  = 20\n",
      "5 x 5  = 25\n",
      "6 x 5  = 30\n",
      "7 x 5  = 35\n",
      "8 x 5  = 40\n",
      "9 x 5  = 45\n",
      "10 x 5  = 50\n",
      "\n",
      "\n",
      "1 x 6  = 6\n",
      "2 x 6  = 12\n",
      "3 x 6  = 18\n",
      "4 x 6  = 24\n",
      "5 x 6  = 30\n",
      "6 x 6  = 36\n",
      "7 x 6  = 42\n",
      "8 x 6  = 48\n",
      "9 x 6  = 54\n",
      "10 x 6  = 60\n",
      "\n",
      "\n",
      "1 x 7  = 7\n",
      "2 x 7  = 14\n",
      "3 x 7  = 21\n",
      "4 x 7  = 28\n",
      "5 x 7  = 35\n",
      "6 x 7  = 42\n",
      "7 x 7  = 49\n",
      "8 x 7  = 56\n",
      "9 x 7  = 63\n",
      "10 x 7  = 70\n",
      "\n",
      "\n",
      "1 x 8  = 8\n",
      "2 x 8  = 16\n",
      "3 x 8  = 24\n",
      "4 x 8  = 32\n",
      "5 x 8  = 40\n",
      "6 x 8  = 48\n",
      "7 x 8  = 56\n",
      "8 x 8  = 64\n",
      "9 x 8  = 72\n",
      "10 x 8  = 80\n",
      "\n",
      "\n",
      "1 x 9  = 9\n",
      "2 x 9  = 18\n",
      "3 x 9  = 27\n",
      "4 x 9  = 36\n",
      "5 x 9  = 45\n",
      "6 x 9  = 54\n",
      "7 x 9  = 63\n",
      "8 x 9  = 72\n",
      "9 x 9  = 81\n",
      "10 x 9  = 90\n",
      "\n",
      "\n",
      "1 x 10  = 10\n",
      "2 x 10  = 20\n",
      "3 x 10  = 30\n",
      "4 x 10  = 40\n",
      "5 x 10  = 50\n",
      "6 x 10  = 60\n",
      "7 x 10  = 70\n",
      "8 x 10  = 80\n",
      "9 x 10  = 90\n",
      "10 x 10  = 100\n",
      "\n",
      "\n",
      "1 x 11  = 11\n",
      "2 x 11  = 22\n",
      "3 x 11  = 33\n",
      "4 x 11  = 44\n",
      "5 x 11  = 55\n",
      "6 x 11  = 66\n",
      "7 x 11  = 77\n",
      "8 x 11  = 88\n",
      "9 x 11  = 99\n",
      "10 x 11  = 110\n",
      "\n",
      "\n",
      "1 x 12  = 12\n",
      "2 x 12  = 24\n",
      "3 x 12  = 36\n",
      "4 x 12  = 48\n",
      "5 x 12  = 60\n",
      "6 x 12  = 72\n",
      "7 x 12  = 84\n",
      "8 x 12  = 96\n",
      "9 x 12  = 108\n",
      "10 x 12  = 120\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "n=2\n",
    "while n<=12:\n",
    "    m=1\n",
    "    while m < 11:\n",
    "        print(m, \"x\", n,\" =\", n*m)\n",
    "        m = m +1\n",
    "    print('\\n')\n",
    "    n=n+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercice 5 -   La plus petite puissance négative de 2\n",
    "\n",
    "Utiliser la condition while pour trouver  le plus petit réel strictement positif de la forme $1/(2^n)$ et indiquer pour quel entier n il est atteint."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la plus petite puissance négative de 2 est 5e-324 , obtenue pour n= 1074\n"
     ]
    }
   ],
   "source": [
    "x=1\n",
    "n=0\n",
    "while x >0.00:\n",
    "    x=x/2\n",
    "    n=n+1\n",
    "print(\"la plus petite puissance négative de 2 est\",1/(2**(n-1)),\", obtenue pour n=\", n-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercice 6 -  Les nombres de Fibonacci\n",
    "\n",
    "On rappelle que la suite de Fibonacci est définie par $F(0)=F(1)=1$ et $F(n+2)=F(n)+F(n+1)$.\n",
    "\n",
    "a) Utiliser la boucle $\\texttt{while}$ pour calculer $F(100)$.\n",
    "\n",
    "b) Trouver le plus grand entier $n$ tel que $F(n)<10^{20}$ puis afficher $n$ et $F(n)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n",
      "F( 10 )= 89\n"
     ]
    }
   ],
   "source": [
    "a,b=1,1\n",
    "n=0\n",
    "while n <10:\n",
    "    a,b=b,a+b\n",
    "    n=n+1\n",
    "    print(a)\n",
    "print(\"F(\",n,\")=\",a)    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le plus grand entier n tel que F(n)<10^(20) est 96 et F( 96 )= 83621143489848422977\n"
     ]
    }
   ],
   "source": [
    "a,b=1,1\n",
    "n=0\n",
    "while b<10**(20):\n",
    "    a,b=b,a+b\n",
    "    n=n+1\n",
    "    #print(a)\n",
    "print(\"Le plus grand entier n tel que F(n)<10^(20) est\", n,\"et F(\",n,\")=\",a )    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercice 7 - Calcul du pgcd\n",
    "Pour obtenir le PGCD de a et de b, on effectue la division euclidienne $a=b*q_1+r_1$, puis $b=r_1*q_2+r_2$, puis $r_1=r_2*q_2+r_3$, etc... Le dernier reste non nul dans cette suite de divisions est le PGCDde a et b. Utiliser l'instruction $\\texttt{while}$ pour calculer le PGCD de 573804 et 348096 à l'aide de cette méthode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "84\n"
     ]
    }
   ],
   "source": [
    "a,b=573804, 348096\n",
    "while b!=0:\n",
    "    a,b=b,a%b\n",
    "print(a)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}