CH1TP1CORR.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CH1 TP1 Programmer des fonctions CORRECTION\n",
    "\n",
    "- - -\n",
    "\n",
    "Dans ce TP on tentera \n",
    "\n",
    "- de respecter les exigences de la programmation fonctionnelle\n",
    "- de documenter correctement les fonctions avec des docstrings (préconditions et post conditions)\n",
    "- de proposer un jeu de test pertinent par fonction, soit avec doctest , soit avec assert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ex 1 : La fonction factorielle\n",
    "\n",
    "rappel : 5 ! = 5x4x3x2x1 = 120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def facto(n):\n",
    "    '''\n",
    "    entree : n est un entier\n",
    "    sortie : n! (entier)\n",
    "    '''\n",
    "    f = 1 # initialisation\n",
    "    for i in range(1,n+1):\n",
    "        f=f*i\n",
    "    return f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# jeu de tests\n",
    "assert facto(5)==120\n",
    "assert facto(1)==1\n",
    "assert facto(2)==2\n",
    "assert facto(3)==6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ex 2 : Nombre d'occurrences. (BAC)\n",
    "\n",
    "Dans la phrase \"J'aime les champignons\", le \"e\" apparaît 2 fois.\n",
    "Réaliser la fonction occurrences qui en arguments prend un texte et un caractère et retourne le nombre d'occurrences de ce caractère dans le texte :\n",
    "\n",
    "**occurrences(\"J'aime les champignons\",\"e\") -> 2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def occurrences(chaine,car):\n",
    "    '''\n",
    "    entrees : chaine de type string, car le caractère \n",
    "    sortie : int : le nombre d'occurrences de car dans chaine   \n",
    "    '''\n",
    "    n= 0 # nb occurrences\n",
    "    for c in chaine:\n",
    "        if c == car:\n",
    "            n+=1\n",
    "    return n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tests\n",
    "assert occurrences(\"J'aime les champignons\",\"e\")==2\n",
    "assert occurrences(\"Toto\",\"z\")==0\n",
    "assert occurrences(\"divisibilité\",\"i\")==5\n",
    "assert occurrences(\"divisibilité\",\"b\")==1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ex 3  : Max et tableau (BAC)\n",
    "\n",
    "Réaliser une fonction max qui prend en argument un tableau de nombres et retourne son maximum.\n",
    "\n",
    "**max([1,3,5,6,9,2]) -> 9**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def maxi(l):\n",
    "    '''\n",
    "    entree : liste non vide de nombres\n",
    "    sortie : le max de cette liste\n",
    "    '''\n",
    "    maxtemporaire=l[0]\n",
    "    for e in l:\n",
    "        if e > maxtemporaire:\n",
    "            maxtemporaire = e\n",
    "    return maxtemporaire\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert maxi([1,3,5,6,9,2]) == 9\n",
    "assert maxi([1,3,9,6,9,2]) == 9\n",
    "assert maxi([4])==4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ex 4 : Calcul de la moyenne (BAC)\n",
    "\n",
    "Réaliser une fonction moyenne qui prend en argument un tableau de nombres et retourne la moyenne\n",
    "\n",
    "**moyenne([1,2]) -> 1.5**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def moyenne(l):\n",
    "    '''\n",
    "    entree : liste de nombres non vide\n",
    "    sortie : la valeur moyenne (float)'''\n",
    "    somme = 0 # initialisation\n",
    "    for e in l:\n",
    "        somme +=e\n",
    "    return somme/len(l)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# jeu de tests\n",
    "assert moyenne([1,2])==1.5\n",
    "assert moyenne([1])==1\n",
    "assert moyenne([1,2,3])==2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ex 5 : fonction recherche (BAC)\n",
    "\n",
    "Réaliser une fonction recherche qui donne l'index de  la première occurrence d'un élément e dans un tableau, et -1 si l'élément n'est pas trouvé\n",
    "\n",
    "**recherche(5,[1,3,5,6,9,2])) -> 2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recherche(elem,tab):\n",
    "    '''\n",
    "    entree: elem élément de type qconque, tab un tableau non vide\n",
    "    sortie : indice de la première occurrence de elem dans tab, -1 sinon\n",
    "    '''\n",
    "    assert len(tab)>0,'le tableau est vide' #vérification\n",
    "    for i in range(len(tab)):\n",
    "        if tab[i]==elem:\n",
    "            return i\n",
    "    return -1 # élément non trouvé en sortie de boucle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert recherche(5,[1,3,5,6,9,2])== 2\n",
    "assert recherche(7,[1,3,5,6,9,2])== -1\n",
    "assert recherche(1,[1,3,5,6,9])== 0\n",
    "assert recherche(1,[1])== 0"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}