2015-10-15 - TD8 - Boucles imbriquées.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le TD a commencé par un petit contrôle... que nous avons ensuite (partiellement) corrigé. \n",
    "\n",
    "**Correction de l'exercice mystère.**\n",
    "\n",
    "Rappel du sujet initial :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-1-7234389ae404>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-1-7234389ae404>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    def mystere(unparametre)\u001b[0m\n\u001b[1;37m                            ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "def mystere(unparametre)\n",
    "    unevariable = True\n",
    "    uneautrevariable = 0\n",
    "    while unevariable:\n",
    "        truc = unparametre // 10\n",
    "        uneautrevariable+=1\n",
    "        if truc = 0:\n",
    "        print(\"truc 0\")\n",
    "        if truc > 0:\n",
    "            unparametre = truc\n",
    "        else:\n",
    "            unevariable = False\n",
    "    return uneautrevariable\n",
    "\n",
    "print(mystere(1))\n",
    "print(mystere(22))\n",
    "print(mystere(4444))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*1 : Correction des trois erreurs de syntaxe*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "truc 0\n",
      "1\n",
      "truc 0\n",
      "2\n",
      "truc 0\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def mystere(unparametre): # il manquait les deux points ici...\n",
    "    unevariable = True\n",
    "    uneautrevariable = 0\n",
    "    while unevariable:\n",
    "        truc = unparametre // 10\n",
    "        uneautrevariable+=1\n",
    "        if truc == 0: # la condition du if doit être une formule booléenne... il fallait donc un == et non un =\n",
    "            print(\"truc 0\") # Il y avait un problème d'in\n",
    "        if truc > 0:\n",
    "            unparametre = truc\n",
    "        else:\n",
    "            unevariable = False\n",
    "    return uneautrevariable\n",
    "\n",
    "print(mystere(1))\n",
    "print(mystere(22))\n",
    "print(mystere(4444))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*2 : Que fait le programme ?*\n",
    "\n",
    "Le programme retourne le nombre de chiffres dans l'écriture en base 10 d'un nombre passé en paramètre. Le premier if fait un print qui ne sert à rien. \n",
    "\n",
    "*3 : Quelles valeurs choisir pour le test*\n",
    "\n",
    "Les valeurs aux limites des conditions : par exemple, 0, 10 ou 100... \n",
    "Les valeurs négatives. \n",
    "Les nombres flotants. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice du damier :**\n",
    "\n",
    "\n",
    "\n",
    "L'objectif de cet exercice est d'afficher un damier de M\\*N cases, chaque case étant soit vide (caractère espace) soit dessinée par un ensemble de lettre.\n",
    "\n",
    "\n",
    "Chaque case du damier aura pour dimension 2M\\*N (cf. plus bas pour l'explication du 2M).\n",
    "\n",
    "\n",
    "Par exemple, si l'on demande l'affichage d'un damier de 5\\*4, on aura 20 cases en tout, et le damier fera 5 colonnes par 4 lignes. Chaque case du damier fera quant à elle 10 caractères de large, et 4 caractères de haut.\n",
    "\n",
    "\n",
    "Les cases pleines sont dessinées avec deux caractères passés en paramètres de la méthode. On affiche d'abord M fois le premier caractère, puis M fois le second. La largeur d'une case est donc de 2M. On doit répéter l'opération N fois, car la case doit avoir une hauteur de N. Les cases vides fonctionnent selon le même principe, sauf qu'au lieu d'afficher des caractères passés en paramètres, on affiche des espaces.\n",
    "\n",
    "\n",
    "L'une des principales difficultés, outre les aspects algorithmiques, est que l'affichage doit se faire ligne par ligne (et non case par case), et qu'il va donc nous falloir décomposer le problème en fonction de cette contrainte.\n",
    "\n",
    "Cet exercice est artificiellement difficile. Il a pour but de vous apprendre à décomposer un problème compliqué en plusieurs étapes \"simples\", et de vous faire travailler le concept de boucles imbriquées.\n",
    "\n",
    "\n",
    "Nous allons donc le corriger par étapes.\n",
    "\n",
    "\n",
    "*Étape 1.*\n",
    "\n",
    "\n",
    "Tout d'abord, nous allons écrire et tester le code qui permet d'afficher une ligne (en faisant le choix arbitraire que la première case de la ligne est une case pleine.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---666      ---666\n"
     ]
    }
   ],
   "source": [
    "def afficher_damier(m, n, c, d):\n",
    "    '''\n",
    "    :entree m: nombre de cases en largeur dans le damier\n",
    "    :entree n: nombre de cases en hauteur dans le damier\n",
    "    :entree c: premier caractère choisi pour l'affichage\n",
    "    :entree d: deuxieme caractère choisi pour l'affichage\n",
    "    :pre-cond: m et n sont des entiers strictement positifs\n",
    "    :pre-cond: c et d sont des chaînes de caractères de longueur 1 (autrement dit, des caractères)\n",
    "    :post-cond: un damier de m*n cases est affiché à l'écran, en utilisant les caractères c et d, comme dans l'exemple ci-dessous :\n",
    "    afficher_damier(2,3, \"n\", \"z\") \n",
    "    nnzz\n",
    "    nnzz\n",
    "    nnzz\n",
    "        nnzz\n",
    "        nnzz\n",
    "        nnzz\n",
    "    nnzz\n",
    "    nnzz\n",
    "    '''   \n",
    "    case = 1 # On utilise une variable pour repérer sur quelle case on est.\n",
    "    chaine = \"\" # On utilise une variable pour stocker la chaine à afficher et on s'occupera de l'affichage de cette chaine à chaque fin de ligne\n",
    "    for compteur in range(m): # On fait une boucle pour construire une ligne entière de cases\n",
    "        if case % 2 == 0: # Si on est sur une case paire, on ajoute à la chaine le nombre d'espaces (2M)\n",
    "            chaine = chaine + (2*m* \" \")\n",
    "        else: # Sinon (i.e. la case est impaire), on ajoute à la chaine M fois le premier caractère, puis M fois le second. \n",
    "            chaine = chaine + (m*c + m*d)\n",
    "        case += 1 # Quand on a fini d'écrire une case, on passe à la case suivante\n",
    "    print(chaine) # Quand on a fini d'écrire une ligne entière, on l'affiche.\n",
    "\n",
    "\n",
    "afficher_damier(3, 4, \"-\", \"6\") # Hop, et on n'oublie pas de tester notre travail.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Étape 2.* Bien. Maintenant que l'on affiche une ligne correctement, on va s'occuper d'afficher toutes les lignes nécessaires à l'affichage de la première rangée de cases de notre damier. On reprend notre code précédent, et on le modifie un peu... Dans le code ci-dessous, seules les lignes modifiées ont été commentées. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---666      ---666\n",
      "---666      ---666\n",
      "---666      ---666\n",
      "---666      ---666\n"
     ]
    }
   ],
   "source": [
    "def afficher_damier(m, n, c, d):\n",
    "    '''\n",
    "    idem\n",
    "    '''   \n",
    "    for compteur_ligne in range(n): # On ajoute juste une boucle pour itérer sur la hauteur que doit faire une case... \n",
    "        case = 1 \n",
    "        chaine = \"\" \n",
    "        for compteur in range(m): \n",
    "            if case % 2 == 0: \n",
    "                chaine = chaine + (2*m* \" \")\n",
    "            else: \n",
    "                chaine = chaine + (m*c + m*d)\n",
    "            case += 1 \n",
    "        print(chaine) \n",
    "\n",
    "afficher_damier(3, 4, \"-\", \"6\") # Hop, et on n'oublie pas de tester notre travail.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Étape 3.* Parfait. Nous avons réalisé la première ligne de cases de notre damier. Maintenant, il s'agit de répéter le processus pour le reste du damier... mais il nous faut trouver une astuce pour gérer le décalage que doivent avoir les cases d'une ligne sur l'autre. Ici, on utilise l'observation suivante. On numérote les cases de 1 à m, et les lignes de 1 à n. On a fait le choix que la case 1 de la ligne 1 était une case pleine. Ainsi, la case 2 de la ligne 1 est une case vide, mais la case 1 de la ligne 2 est vide aussi. En généralisant, on observe assez vite que lorsque la somme du rang de la case et du numéro de ligne est paire, la case est pleine, et dans l'autre cas, la case est vide. C'est cette observation que l'on va utiliser dans le code suivant. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---666      ---666\n",
      "---666      ---666\n",
      "---666      ---666\n",
      "---666      ---666\n",
      "      ---666      \n",
      "      ---666      \n",
      "      ---666      \n",
      "      ---666      \n",
      "---666      ---666\n",
      "---666      ---666\n",
      "---666      ---666\n",
      "---666      ---666\n",
      "      ---666      \n",
      "      ---666      \n",
      "      ---666      \n",
      "      ---666      \n",
      "gggggg!!!!!!            gggggg!!!!!!            gggggg!!!!!!            \n",
      "gggggg!!!!!!            gggggg!!!!!!            gggggg!!!!!!            \n",
      "            gggggg!!!!!!            gggggg!!!!!!            gggggg!!!!!!\n",
      "            gggggg!!!!!!            gggggg!!!!!!            gggggg!!!!!!\n"
     ]
    }
   ],
   "source": [
    "def afficher_damier(m, n, c, d):\n",
    "    '''\n",
    "    idem\n",
    "    '''   \n",
    "    ligne = 1 # On introduit un compteur pour savoir quelle ligne on est en train de traiter \n",
    "    for compteur_lignes_damier in range(n): # On itère sur les lignes\n",
    "        for compteur_ligne in range(n): \n",
    "            case = 1 \n",
    "            chaine = \"\" \n",
    "            for compteur in range(m): \n",
    "                if (case + ligne) % 2 != 0: # On modifie la condition qui nous permet de savoir ce que l'on doit écrire dans la case...  \n",
    "                    chaine = chaine + (2*m* \" \")\n",
    "                else: \n",
    "                    chaine = chaine + (m*c + m*d)\n",
    "                case += 1 \n",
    "            print(chaine) \n",
    "        ligne += 1 # Quand on a fini d'écrire une ligne complète, on pense à incrémenter notre compteur de ligne...\n",
    "\n",
    "afficher_damier(3, 4, \"-\", \"6\") # Hop, et on n'oublie pas de tester notre travail.\n",
    "afficher_damier(6, 2, \"g\", \"!\") \n",
    "\n"
   ]
  },
  {
   "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}