{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# L3 E - S5 2018-19 - TDO - séance 2, solutions des exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 8 : années bissextiles\n",
    "\n",
    "Ecrire une fonction booléenne $\\texttt{bissectile(n)}$ qui renvoie 1 si $n$ est une année bissectile et 0 sinon. On rappelle que les années bissextiles reviennent tous les 4 ans, sauf lorsqu'elles sont un multiple de cent qui n'est pas un multiple de 400. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def bissextile(n):\n",
    "    if n%4 != 0:\n",
    "        return False\n",
    "    elif n %100 != 0:\n",
    "        return True\n",
    "    elif n %400 != 0:\n",
    "        return False\n",
    "    else:\n",
    "        return True\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True, False, True)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bissextile(1546),bissextile(1548), bissextile(1700),bissextile(1600)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On notera que l'usage des connecteurs logiques permet des formes beaucoup plus compactes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def bissextile2(n):\n",
    "    return ( (n==4==0)  and ( n% 100 != 0)) or (n%400==0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, False, False, True)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bissextile2(1546),bissextile2(1548), bissextile2(1700),bissextile2(1600)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercice 9 :  le crible d'Eratosthène\n",
    "\n",
    "Ecrire une liste qui contient les nombres premiers inférieurs à 100, obtenus en appliquant la méthode du crible d'Eratosthène."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n"
     ]
    }
   ],
   "source": [
    "K=[n for n in range(2,100)]\n",
    "L=[]\n",
    "i=1\n",
    "while len(K)>0:\n",
    "        i=K[0]\n",
    "        L.append(i)\n",
    "        K.remove(i)\n",
    "        for j in K:\n",
    "            if j%i==0:\n",
    "                K.remove(j)\n",
    "print (K)\n",
    "print (L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 10 : somme de carrés\n",
    "\n",
    "Ecrire une fonction qui, pour tout $M$ réel postif, retourne le couple $(n,m)$ où $n$ est le plus petit entier tel que $m=1+2^2+3^2+...+n^2 >=M$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def somme_des_carres_plus_grande_que(x):\n",
    "    m,n=1,1\n",
    "    while m<x:\n",
    "        n=n+1\n",
    "        m=m+n**2\n",
    "    return(m,n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 2)\n",
      "(30, 4)\n",
      "(10416, 31)\n"
     ]
    }
   ],
   "source": [
    "print(somme_des_carres_plus_grande_que(5))\n",
    "print(somme_des_carres_plus_grande_que(18))\n",
    "print(somme_des_carres_plus_grande_que(10000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 11 : présent ou pas\n",
    "\n",
    "Ecrire une fonction $\\texttt{present(x,L)}$ qui retourne $\\texttt{True}$ si $x$ est dans $L$ et $\\texttt{False}$ sinon (et qui vérifie que le second argument est bien une liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def present(x,L):\n",
    "    if type(L) != list:                ## si la condition est vérifiée, on fait...            \n",
    "        return(\"Le second argument doit être une liste !!\")  \n",
    "    else:     \n",
    "        for a in L:\n",
    "            if x==a:\n",
    "                return True\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 'fr', 'an', 6, 4.5, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48]\n",
      "(1, 4, 9)\n"
     ]
    }
   ],
   "source": [
    "a=[23,'fr','an',6,4.5]+[x for x in range(50) if x % 2 == 0]\n",
    "print(a)\n",
    "b=(1,4,9)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "present(12,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Le second argument doit être une liste !!'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "present(12,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def present2(x,L):\n",
    "    if type(L) != list:                ## si la condition est vérifiée, on fait...            \n",
    "        return(\"Le second argument doit être une liste !!\")  \n",
    "    else:     \n",
    "        if x in L:\n",
    "            return True\n",
    "        else:\n",
    "            return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "Le second argument doit être une liste !!\n"
     ]
    }
   ],
   "source": [
    "print(present2(44,a))\n",
    "print(present2(43,a))\n",
    "print(present2(44,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 12 : présence d'une lettre dans un mot\n",
    "\n",
    "Ecrire une fonction $\\texttt{presente(a,M)}$ qui retourne l'indice de la lettre $a$ dans la chaîne $M$ si $a$ est dans $M$, qui renvoie -1 sinon et qui vérifie que le second argument est bien une chaîne de caractères."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def presente(lettre,mot):\n",
    "    indice=0\n",
    "    if type(mot) != str:                ## si la condition est vérifiée, on fait...            \n",
    "        return(\"Le second argument doit être une chaîne de caractères !!\")  \n",
    "    while indice < len(mot):\n",
    "        if mot[indice]==lettre:\n",
    "            return indice\n",
    "        indice += 1\n",
    "    return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "presente('a','TRECFauia')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Le second argument doit être une chaîne de caractères !!'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "presente('a',456)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 13 : écriture en base 16\n",
    "\n",
    "Ecrire une fonction $\\texttt{H(n)}$ qui renvoie l'écriture en base 16 de l'entier n (les chiffres retenus pour l'écriture en base 16 sont $0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def H(n):\n",
    "    resultat=' '\n",
    "    while n >0:\n",
    "        m=n%16\n",
    "        if m <10: \n",
    "            m=str(m)\n",
    "        elif m==10:\n",
    "            m='A'\n",
    "        elif m==11:\n",
    "            m='B'\n",
    "        elif m==12:\n",
    "            m='C'\n",
    "        elif m==13:\n",
    "            m='D'\n",
    "        elif m==14:\n",
    "            m='E'\n",
    "        elif m==15:\n",
    "            m='F'\n",
    "        resultat=m + resultat\n",
    "        n=n//16\n",
    "    return resultat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('4 ', '12 ', 'E ', '28F8 ')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H(4),H(18),H(14),H(23*456)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 14 : Test de primalité \n",
    "\n",
    "Ecrire une fonction $\\texttt{est_premier(N)}$ qui retourne $\\texttt{True}$ si l'entier $N>=2$ est premier et $\\texttt{False}$ sinon en testant si $N$ admet un diviseur parmi les entiers inférieurs ou égaux à sa racine carrée. On utilisera la fonction $\\texttt{sqrt}$ (qu'il faudra peut-être importer, par exempel en tapant $\\texttt{from math import *}$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from math import *\n",
    "def est_premier(N):\n",
    "    if  (type(N) != int or N <2):                ## si la condition est vérifiée, on fait...            \n",
    "        return(\"on demande un entier >=2\")  \n",
    "    resultat = True\n",
    "    for i in range(2,int(sqrt(N))):\n",
    "        if N%i == 0 : \n",
    "            resultat = False\n",
    "    return resultat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "est_premier(29)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "est_premier(28)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 15 : décomposition en produit de facteurs premiers\n",
    "\n",
    "Ecrire une fonction $\\texttt{decomposition_en_facteurs_premiers(N)}$ qui retourne la décomposition en facteurs premiers de l'entier $\\texttt{N}>=2$\n",
    "(nota bene : le résultat est attendu sous la forme d'une chaîne de caractères)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def decomposition_en_facteurs_premiers(N):\n",
    "    resultat = ''\n",
    "    NN=N\n",
    "    p=2\n",
    "    while p<=NN :\n",
    "        if (NN%p ==0) :\n",
    "            if resultat=='': \n",
    "                resultat = str(p)\n",
    "            else :\n",
    "                resultat = resultat + '*'+str(p)\n",
    "            NN=NN/p\n",
    "        else  :\n",
    "            p=p+1\n",
    "    if resultat=='':\n",
    "        \n",
    "        return str(N)\n",
    "    else:\n",
    "        return resultat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2*3*3*17'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decomposition_en_facteurs_premiers(306)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2*2*2*2*3*7'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decomposition_en_facteurs_premiers(336)"
   ]
  },
  {
   "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
}