2015-10-22 - TD10 - Les chaînes de caractères - suite.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Rappels :** Il est possible d'itérer sur une chaine de caractères. Il est également possible (en Python) de vérifier qu'un caractère est présent dans une chaîne, mais attention, ceci ne fonctionne pas dans tous les langages ! Voir les exemples ci-dessous.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "chaine = \"Hello World\"\n",
    "for i in chaine:\n",
    "    print(i)    \n",
    "\n",
    "if \"a\" in \"abcd\":\n",
    "    print(\"Oui, a est là\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Rappel : les chaînes sont des objets immutables... démo :\n",
    "\n",
    "chaine = \"Bonjour\"\n",
    "for i in range(len(chaine)):\n",
    "    chaine[i] = \"a\"\n",
    "\n",
    "# => on n'a pas le droit de modifier chaine !!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 1 :** Écrire une méthode qui compte le nombre d'occurences (apparitions) d'un caractère dans une chaîne de caractères, tous deux passés en paramètres. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%load_ext doctestmagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def compte_car(chaine, lettre):\n",
    "    '''\n",
    "    :entree chaine: chaine de caractères\n",
    "    :entree lettre: un caractère recherché\n",
    "    :sortie compteur: int, un entier\n",
    "    :post-cond: compteur donne le nb d'occurences du caractère recherché dans la chaîne. \n",
    "    >>> compte_car(\"bonjour\", \"o\")\n",
    "    2\n",
    "    >>> compte_car(\"\", \"i\")\n",
    "    0\n",
    "    >>> compte_car(\"etoile\", \"j\")\n",
    "    0\n",
    "    '''\n",
    "    compteur = 0\n",
    "    for caractere in chaine:\n",
    "        if caractere == lettre:\n",
    "            compteur +=1\n",
    "    return compteur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%doctest compte_car"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 2 :** Même question, mais cette fois, avec un 'while' et non un 'for'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def compte_car_bis(chaine, lettre):\n",
    "    compteur = 0\n",
    "    i = 0\n",
    "    while i < len(chaine):\n",
    "        if chaine[i] == lettre:\n",
    "            compteur += 1\n",
    "        i += 1\n",
    "    return compteur\n",
    "\n",
    "print(\"Test de compte_car\")\n",
    "print(compte_car(\"Villeurbanne\", \"l\"))\n",
    "print(compte_car(\"La vie est belle\", \"e\"))\n",
    "print(compte_car(\"Toto\", \"z\"))\n",
    "\n",
    "print(\"Test de compte_car_bis\")\n",
    "print(compte_car_bis(\"Villeurbanne\", \"l\"))\n",
    "print(compte_car_bis(\"La vie est belle\", \"e\"))\n",
    "print(compte_car_bis(\"Toto\", \"z\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Exercice 3 :** Écrire une méthode qui retourne l'indice de la première occurrence d'un caractère dans une chaîne. Attention à ce que vous allez dire dans le contrat. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def indice_min_char(chaine, caractere):\n",
    "    '''\n",
    "    :entree chaine: str\n",
    "    :entre caractere: str\n",
    "    :sortie indice: indice\n",
    "    :post-condition: indice donne l'indice du premier caractere dans la chaine et est égal à -1 \n",
    "     si la chaine est vide ou le caractère non présent\n",
    "    >>> indice_min_char(\"Bonjour\", \"j\")\n",
    "    3\n",
    "    >>> indice_min_char(\"\",\"x\")\n",
    "    -1\n",
    "    >>> indice_min_char(\"hello beauty\", \"k\")\n",
    "    -1\n",
    "    >>> indice_min_char(\"hell\", \"l\")\n",
    "    2\n",
    "    >>> indice_min_char(\"hello\",\"o\")\n",
    "    5\n",
    "    '''\n",
    "    indice = -1\n",
    "    i = 0\n",
    "    while i <= len(chaine):\n",
    "        if chaine[i] == caractere:\n",
    "            indice = i\n",
    "            i = len(chaine) + 1\n",
    "    return indice\n",
    "\n",
    "indice_min_char(\"ttata\", \"c\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%doctest indice_min_char"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice 4.** Écrire une méthode estMiroir qui prend en paramètres deux chaînes de caractères de même longueur et qui renvoie True si les chaînes sont miroir l'une de l'autre, et False sinon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def estMiroir(ch1,ch2):\n",
    "    '''\n",
    "    :entree ch1: une chaine de caractères\n",
    "    :entree ch2: une autre chaîne de caractères\n",
    "    :sortie bool: True si les chaînes sont miroir, False sinon\n",
    "    :pre-cond: les chaînes sont de même longueur\n",
    "    '''\n",
    "    invertCh1 = \"\"\n",
    "    \n",
    "    for i in range(len(ch1)):\n",
    "        invertCh1 =  invertCh1 + ch1[len(ch1)-i-1]\n",
    "    \n",
    "    return invertCh1 == ch2\n",
    "\n",
    "a =\"toto\"\n",
    "b = \"otot\"\n",
    "c = \"truc\"\n",
    "d = \"trrr\"\n",
    "\n",
    "print(estMiroir(a,b))\n",
    "print(estMiroir(c,d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ci-dessous une solution plus simple (en deux lignes, dans laquelle on réutilise miroir, que l'on a défini la dernière fois.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def miroir(chaine):\n",
    "    '''\n",
    "    :entre la chaine de caractère\n",
    "    :sortie la chaine de caractere avec les caracteres inversés\n",
    "    '''\n",
    "    stri=\"\"\n",
    "\n",
    "    for i in range(0,len(chaine)):\n",
    "        stri+=chaine[len(chaine)-i-1]\n",
    "        \n",
    "    return stri\n",
    "\n",
    "def estMiroir(a, b):\n",
    "    return a == miroir(b)\n",
    "\n",
    "print(estMiroir(\"Toto\", \"tata\"))\n",
    "print(estMiroir(\"titi\", \"itit\"))"
   ]
  }
 ],
 "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}