{"cells":[{"metadata":{"init_cell":true,"run_control":{"marked":false},"hide_output":true,"hide_input":true,"trusted":true},"cell_type":"code","source":"# Permet de tout executer au lancement du notebook + conserver le notebook actif pendant 2h\nfrom IPython.display import Javascript\nfrom masquer import *\nJavascript(\"\"\"\nfunction repeter(){\nIPython.notebook.kernel.execute(\"a=1\");\n}\n// execute a = 1 en python toutes les 8 minutes pendant 2h\nlet timerId = setInterval(() => repeter(), 4800);\nsetTimeout(() => { clearInterval(timerId); alert('fin de cession'); }, 7200000);\n\n// Supprimer la taille limite pour la sortie d'une cellule\nIPython.OutputArea.prototype._should_scroll = function(lines) {\n    return false;\n};\nIPython.notebook.kernel.execute(\"url = '\" + window.location + \"'\");\n\n// Exécuter toutes les cellule du notebook\n    require(\n        ['base/js/namespace', 'jquery'], \n        function(jupyter, $) {\n            \n                \n                jupyter.actions.call('jupyter-notebook:run-all-cells-below');\n                jupyter.actions.call('jupyter-notebook:save-notebook');\n                Jupyter.actions.call('jupyter-notebook:hide-header')\n\n        }\n    );\"\"\")","execution_count":32,"outputs":[{"output_type":"execute_result","execution_count":32,"data":{"text/plain":"<IPython.core.display.Javascript object>","application/javascript":"\nfunction repeter(){\nIPython.notebook.kernel.execute(\"a=1\");\n}\n// execute a = 1 en python toutes les 8 minutes pendant 2h\nlet timerId = setInterval(() => repeter(), 4800);\nsetTimeout(() => { clearInterval(timerId); alert('fin de cession'); }, 7200000);\n\n// Supprimer la taille limite pour la sortie d'une cellule\nIPython.OutputArea.prototype._should_scroll = function(lines) {\n    return false;\n};\nIPython.notebook.kernel.execute(\"url = '\" + window.location + \"'\");\n\n// Exécuter toutes les cellule du notebook\n    require(\n        ['base/js/namespace', 'jquery'], \n        function(jupyter, $) {\n            \n                \n                jupyter.actions.call('jupyter-notebook:run-all-cells-below');\n                jupyter.actions.call('jupyter-notebook:save-notebook');\n                Jupyter.actions.call('jupyter-notebook:hide-header')\n\n        }\n    );"},"metadata":{}}]},{"metadata":{"run_control":{"marked":false},"hide_input":true,"hide_output":true,"trusted":true},"cell_type":"code","source":"HTML(\"\"\"<style>\nh1 {\n  font-family: 'Permanent Marker', cursive;\n  text-align: center;\n  color: red;\n  \n}\nol {\n  list-style-position: inside;\n  margin-left: 1em;\n  list-style-position: outside;\n}\nh2 {\n  font-family: 'Permanent Marker', cursive;\n  color: blue;\n}\n</style>\"\"\")","execution_count":3,"outputs":[{"output_type":"execute_result","execution_count":3,"data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"<style>\nh1 {\n  font-family: 'Permanent Marker', cursive;\n  text-align: center;\n  color: red;\n  \n}\nol {\n  list-style-position: inside;\n  margin-left: 1em;\n  list-style-position: outside;\n}\nh2 {\n  font-family: 'Permanent Marker', cursive;\n  color: blue;\n}\n</style>"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"# TD_01_1 : Structures de données"},{"metadata":{},"cell_type":"markdown","source":"## Exercice I : Notation postfixe"},{"metadata":{},"cell_type":"markdown","source":"L'écriture des expressions arithmétiques nécessite souvent l'emploi de parenthèses. Par exemple:\n$$9 + 4 * (7 + 2) * (4 + 5)$$\nLa notation **postfixe** ou **notation polonaise inverse** permet d'écrire de façon non ambiguë les formules arithmétiques sans utiliser de parenthèses. L'expression précédente en notation polonaise inverse devient:\n$$ 9\\ 4\\ 7\\ 2\\ +\\ *\\ 4\\ 5\\ +\\ *\\ +$$\n\n\nDérivée de la notation polonaise utilisée pour la première fois en 1924 par le mathématicien polonais **Jan Łukasiewicz**, la NPI a été inventée par le philosophe et informaticien australien **Charles Leonard Hamblin** dans le milieu des années 1950, pour permettre les calculs sans faire référence à une quelconque adresse mémoire.\n\nÀ la fin des années 1960, elle a été diffusée dans le public comme interface utilisateur avec les calculatrices de bureau de Hewlett-Packard (HP-9100), puis avec la calculatrice scientifique HP-35 en 1972. [source](https://fr.wikipedia.org/wiki/Notation_polonaise_inverse)\n\n\nUne expression en NPI est évaluée de la gauche vers la droite. Dès qu'un opérateur est rencontré, il est appliqué aux deux opérandes immédiatement à sa gauche. Le résultat remplace alors l'operation dans l'expression postfixe et on pousuit l'évaluation.\nAinsi l'expression precedente devient:\n$$ 9\\ 4\\ 7\\ 2\\ +\\ *\\ 4\\ 5\\ +\\ *\\ +$$\n$$ 9\\ 4\\ 9\\ *\\ 4\\ 5\\ +\\ *\\ +$$\n$$ 9\\ 36\\ 4\\ 5\\ +\\ *\\ +$$\n$$ 9\\ 36\\ 9\\ *\\ +$$\n$$ 9\\ 324\\ +$$\n$$ 333$$\nA la fin, si l'expression est valide, il ne reste qu'une valeur numérique dans l'expression qui est le résultat.\n"},{"metadata":{},"cell_type":"markdown","source":"1. Comment s'écrit (3 + (4 + (5 + (6 + (7 + (8 + 9)))))) en NPI ?"},{"metadata":{},"cell_type":"markdown","source":"3 4 5 6 7 8 9 + + + + + +"},{"metadata":{},"cell_type":"markdown","source":"On considère l'expression en NPI suivante: <span style=\"border:1px solid black; padding:3px;\">**3 4 5 6 7 8 9 + + + + + +**</span>. Cette expression est donnée sous forme d'une liste, les valeurs chiffrées seront de type **int** et les opérateurs rentrés comme les chaînes de caractère **\"+\"**.\n2. Entrer dans une variable L la liste décrite précédemment."},{"metadata":{"run_control":{"marked":false},"trusted":true},"cell_type":"code","source":"# question 2\nL = [3, 4, 5, 6, 7, 8, 9, \"+\", \"+\", \"+\", \"+\", \"+\", \"+\"]","execution_count":4,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"3. Ecrire les fonctions **init, isEmpty, push et pop** permettant d'avoir un comportement de pile. Vous ajouterez aussi une fonction **top** permettant de lire l'élément au sommet de la pile sans la modifier."},{"metadata":{"run_control":{"marked":false},"trusted":true},"cell_type":"code","source":"# question 3\ndef init():\n    return []\n\ndef isEmpty(s):\n    return s == []\n\ndef push(val,s):\n    s.append(val)\n    \ndef pop(s):\n    return s.pop()\n\ndef top(s):\n    return s[-1]","execution_count":5,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"4. Ecrire une fonction **evalue** qui prend comme argument une liste comme décrit ci-dessus. Cette fonction doit:\n    - initialiser une **pile** pour le calcul\n    - balayer la liste de gauche à droite\n    - lorsqu'on rencontre une valeur chiffrée, on l'empile\n    - lorsqu'on rencontre un opérateur, on dépile deux éléments, on calcule et on empile le résultat.\n    - renvoyer le résultat final"},{"metadata":{"run_control":{"marked":false},"trusted":true},"cell_type":"code","source":"# question 4\ndef evalue(l):\n    pile = init()\n    for val in l:\n        if type(val) == int:\n            push(val,pile)\n        else:\n            b = pop(pile)\n            a = pop(pile)\n            commande = str(a)+val+str(b)\n            reponse = eval(commande)\n            push(reponse,pile)\n    return pop(pile)\n        ","execution_count":6,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# On essaye avec la liste d'entrée précédente:\nL = [3, 4, 5, 6, 7, 8, 9, \"+\", \"+\", \"+\", \"+\", \"+\", \"+\"]\nevalue(L)","execution_count":7,"outputs":[{"output_type":"execute_result","execution_count":7,"data":{"text/plain":"42"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Et avec celle du début\nL = [9, 4, 7, 2, \"+\", \"*\", 4, 5, \"+\", \"*\", \"+\"]\nevalue(L)","execution_count":8,"outputs":[{"output_type":"execute_result","execution_count":8,"data":{"text/plain":"333"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Ca marche aussi avec d'autres opérateurs:\nL = [26, 2, 10, \"**\", \"+\", 50, \"//\"]\nevalue(L)","execution_count":9,"outputs":[{"output_type":"execute_result","execution_count":9,"data":{"text/plain":"21"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"## Exercice 2 : Le labyrinthe"},{"metadata":{},"cell_type":"markdown","source":"Un labyrinthe est dit parfait si:\n- il existe un chemin menant de tout point du labyrinthe à tout autre\n- et si ce chemin est unique.\n\nNous allons construire de tels labyrinthes de manière aléatoire en utilisant une structure de pile.\n\n\nUn labyrinthe sera représenté par un rectangle de largeur **l** et de hauteur **h** contenant **$l \\times h$** cases carrées blanches ou noires. Une case blanche représentant un chemin et une case noire représentant un mur.\n\n\nNous travaillerons d'abord sur une matrice contenant uniquement des **1** (cases blanches) et des **0** (cases noires). puis dans un deuxième temps sur l'affichage.\n\n"},{"metadata":{},"cell_type":"markdown","source":"1. Ecrire une fonction **init** qui prend comme arguments deux entiers **l** et **h** et qui renvoie la matrice correspondante contenant uniquement des 0."},{"metadata":{"run_control":{"marked":false},"hide_input":true,"trusted":true},"cell_type":"code","source":"def init2(l=51,h=51):\n    return [[0 for i in range(l)] for j in range(h)]\n","execution_count":38,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"2. Ecrire une fonction **blanchir** qui prend comme paramètre deux arguments, la carte et un couple d'entier correspondant aux coordonnées de la case à blanchir."},{"metadata":{"run_control":{"marked":false},"hide_input":true,"trusted":true},"cell_type":"code","source":"def blanchir(carte, coord):\n    x,y = coord\n    carte[y][x] = 1","execution_count":39,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"3. Ecrire une fonction **estBlanc** qui prend comme paramètre deux arguments, la carte et un couple d'entier correspondant aux coordonnées de la case testée. Cette fonction doit renvoyer un booléen. Si la case considérée est hors de la carte, elle doit renvoyer True."},{"metadata":{"run_control":{"marked":false},"hide_input":true,"trusted":true},"cell_type":"code","source":"def estBlanc(carte, coord):\n    x,y = coord\n    if x < 0 or y < 0 or y>=len(carte) or x >=len(carte[0]):\n        return True\n    return carte[y][x] == 1","execution_count":40,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"4. Ecrire une fonction **voisins** qui prend comme paramètre la carte courante et les coordonnées d'une case. Cette fonction doit renvoyer la liste des couples de coordonnées des cases encore noires à une distance de 2 cases de la case considérée."},{"metadata":{"run_control":{"marked":false},"hide_input":true,"trusted":true},"cell_type":"code","source":"def voisins(carte, coord):\n    x,y = coord\n    l = []\n    for dx,dy in [(-2,0), (2,0), (0,-2), (0,2)]:\n        if not estBlanc(carte,(x+dx,y+dy)):\n            l.append((x+dx,y+dy))\n    return l\n\ndef voisins2(carte, coord):\n    x,y = coord\n    l = []\n    if not estBlanc(carte,(x-2,y)):\n        l.append((x-2,y))\n    if not estBlanc(carte,(x+2,y)):\n        l.append((x+2,y))\n    if not estBlanc(carte,(x,y-2)):\n        l.append((x,y-2))\n    if not estBlanc(carte,(x,y+2)):\n        l.append((x,y+2))\n    return l","execution_count":41,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"5. Ecrire une fonction **milieu** qui prend comme paramètre les coordonnées de deux cases séparées par une seule et qui renvoie les coordonnées de cette case."},{"metadata":{"run_control":{"marked":false},"hide_input":true,"trusted":true},"cell_type":"code","source":"def milieu(coord1,coord2):\n    x1, y1 = coord1\n    x2, y2 = coord2\n    x, y = (x1 + x2)//2, (y1 + y2)//2\n    return (x, y)","execution_count":42,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"6. Ecrire une fonction **choix** qui prend comme argument une liste de cases et qui en renvoie une prise au hasard. Vous pourrez utiliser la bibliothèque **random** ainsi que sa documentation accessible avec la fonction **help** afin de choisir la bonne fonction."},{"metadata":{"run_control":{"marked":false},"hide_input":true,"trusted":true},"cell_type":"code","source":"from random import choice, randint\n\ndef choix(l):\n    return choice(l)\n\ndef choix2(l):\n    return l[randint(0,len(l)-1)]","execution_count":43,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"L'algorithme utilise une structure de pile:\n1. On initialise une structure de pile vide\n2. On initialise une matrice ne contenant que des cases noires de dimension $l \\times h$\n2. Les coordonnées de la case de départ (1,1) sont empilées et on blanchit cette case\n3. tant que la pile est non vide\n    * On fait la liste des cases accessibles à 2 cases de distance\n    * Si la liste est vide\n        * on dépile la case et on reprend à l'étape 4.\n    * sinon\n        * On en prend une case au hasard dans cette liste\n        * On détermine les coordonnées de la case du milieu (entre celle tirée au hasard et la case courante)\n        * On blanchit les 2 cases\n        * On empile la case et on reprend à l'étape 4.\n4. On tire au hasard deux cases de la forme (0,2n+1) (2n+1,0) (l-1,2n+1) ou (2n+1,h-1) pour servir d'entrée et de sortie\n4. On renvoie la carte terminée\n\n\nVoici ce que cela donne dans une petite animation afin de mieux comprendre\n![test gif](laby.gif)"},{"metadata":{},"cell_type":"markdown","source":"7. Implémentez cet algorithme en python dans une fonction **maze**"},{"metadata":{"run_control":{"marked":false},"hide_input":true,"trusted":true},"cell_type":"code","source":"# question 7\ndef maze(l,h):\n    data = [] # etape 1.\n    carte = init2(l,h) # etape 2.\n    data.append((1,1)) # etape 3.\n    blanchir(carte,(1,1)) # etape 3.\n    while data != []: # etape 4.\n        lv = voisins(carte,data[-1]) # etape 4.1\n        if lv == []: # condition 4.2\n            data.pop() # 4.2.1\n        else: # condition 4.3\n            coord = choix(lv) # 4.3.1\n            coord2 = milieu(data[-1],coord) # 4.3.2\n            blanchir(carte,coord) # 4.3.3\n            blanchir(carte,coord2) # 4.3.3\n            data.append(coord) # 4.3.4\n    #etape 5.\n    entree_sortie = [(0,2*i+1) for i in range(h//2)]\n    entree_sortie += [(2*i+1,0) for i in range(l//2)]\n    entree_sortie += [(l-1,2*i+1) for i in range(h//2)]\n    entree_sortie += [(2*i+1,h-1) for i in range(l//2)]\n    entree = choix(entree_sortie)\n    sortie = choix(entree_sortie)\n    while entree == sortie:\n        sortie = choix(entree_sortie)\n    blanchir(carte,entree)\n    blanchir(carte,sortie)\n    return carte # etape 6.","execution_count":44,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Voici quelques lignes de code pour tester votre fonction et afficher l'image correspondante, vous pouvez ajuster l et h mais gardez bien un nombre impair! L'affichage doit changer à chaque appel du bloc car un nouveau labyrinthe aléatoire est généré. Vous pourrez même récupérer le fichier image si vous le souhaitez."},{"metadata":{"run_control":{"marked":false},"trusted":true},"cell_type":"code","source":"import matplotlib.pyplot as plt\nim = plt.imshow(maze(51,51),interpolation='none')\nim.set_cmap('gray')\nplt.axis(False)\nplt.savefig('monlabyrinthe.png')\nplt.show()","execution_count":45,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"metadata":{},"cell_type":"markdown","source":"## Exercice 3 : Suite de l'exercice 2 pour les plus rapides"},{"metadata":{},"cell_type":"markdown","source":"8. Ecrire une fonction **solve** qui prend comme argument une carte de labyrinthe (comme la renvoie la fonction maze). Cette fonction devra résoudre le labirynthe et construire une image sur laquelle la solution apparait."},{"metadata":{"run_control":{"marked":false},"trusted":true},"cell_type":"code","source":"def marquer(carte, coord): # Marquer la case comme atteinte appartenant au chemin actif\n    x,y = coord\n    carte[y][x] = 2\n    \ndef liberer(carte, coord): # Marquer la case comme atteinte mais hors du chemin actif\n    x,y = coord\n    carte[y][x] = 3\n    \ndef es(carte): # Renvoie les coordonnées de l'entrée et de la sortie du labyrinthe\n    l = len(carte[0])\n    h = len(carte)\n    e_s = []\n    for i in range(1,l,2):\n        if carte[0][i] == 1:\n            e_s.append((i, 0))\n        if carte[h-1][i] == 1:\n            e_s.append((i, h-1))\n    for i in range(1,h,2):\n        if carte[i][0] == 1:\n            e_s.append((0, i))\n        if carte[i][l-1] == 1:\n            e_s.append((l-1, i))\n    return tuple(e_s)\n\ndef voisins3(carte, coord): # Cherche les voisins à une case de distance\n    x,y = coord\n    l = []\n    for dx,dy in [(-1,0), (1,0), (0,-1), (0,1)]:\n        if estBlanc2(carte,(x+dx,y+dy)):\n            l.append((x+dx,y+dy))\n    return l\n\ndef estBlanc2(carte, coord): # On cherche les cases blanches, l'exterieur est considéré comme un mur\n    x,y = coord\n    if x < 0 or y < 0 or y>=len(carte) or x >=len(carte[0]):\n        return False\n    return carte[y][x] == 1\n\ndef solve(carte): # Renvoie la carte sur laquelle la solution est marquée\n    e, s = es(carte)\n    pile = []\n    pile.append(e)\n    marquer(carte,e)\n    courante = pile[-1]\n    while pile[-1] != s:\n        lv = voisins3(carte, courante)\n        if lv == []:\n            pile.pop()\n            liberer(carte,courante)\n            courante = pile[-1]\n        else:\n            courante = choix(lv)\n            pile.append(courante)\n            marquer(carte,courante)\n    return carte\n","execution_count":118,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Le labyrinthe généré\ncarte = maze(51,51)\nim = plt.imshow(carte,interpolation='none')\nim.set_cmap('gray')\nplt.axis(False)\nplt.show()","execution_count":126,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Recherche de solution\n# en jaune les cases balayées inutilement\n# en vert la solution\ncarte = solve(carte)\nim = plt.imshow(carte,interpolation='none')\nplt.axis(False)\nplt.show()","execution_count":127,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"metadata":{},"cell_type":"markdown","source":"9. Ecrire une fonction **save** qui prend comme entrée une carte et qui construit un fichier texte contenant:\nlargeur espace hauteur sur la première ligne (c'est l'entête)\nDes 0 et des 1 ensuite représentant les données à partir de la deuxième ligne. \n    - les 0 et les 1 devront être collés sans espace. \n    - Vous pourrez changer de ligne n'importe quand, il n'est pas obligatoire d'écrire une ligne du labyrinthe par ligne de fichier\nLa fonction devra sauvegarder votre fichier avec un nom raisonnable"},{"metadata":{"run_control":{"marked":false},"trusted":true},"cell_type":"code","source":"def save(carte):\n    f = open(\"carte.txt\",\"w\")\n    f.write(\"{} {}\\n\".format(len(carte[0]),len(carte)))\n    compteur = 0 # servira à limiter les lignes à 80 caractères affichés\n    for i in range(len(carte)):\n        for j in range(len(carte[0])):\n            if compteur == 80:\n                f.write(\"\\n\")\n                compteur = 0\n            f.write(str(carte[i][j]))\n            compteur += 1\n    f.close()","execution_count":48,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Creation d'une carte et sauvegarde dans un fichier.\n# La carte ets affichée pour comparer à la carte après lecture du fichier\ncarte = maze(51,51)\nsave(carte)\nim = plt.imshow(carte,interpolation='none')\nim.set_cmap('gray')\nplt.axis(False)\nplt.show()","execution_count":49,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"metadata":{},"cell_type":"markdown","source":"10. Ecrire une fonction **read** qui prend comme entrée le nom (avec extension!) d'un fichier labyrinthe sous forme d'une chaine de caractères. Votre fonction devra lire le fichier et renvoyer une carte sous forme de matrice (opération inverse de la fonction save)."},{"metadata":{"run_control":{"marked":false},"trusted":true},"cell_type":"code","source":"def read(file):\n    f = open(file, \"r\")\n    entete = f.readline()\n    entete = entete.strip().split(\" \")\n    l,h = entete\n    carte = init2(int(l),int(h))\n    for i in range(len(carte)):\n        for j in range(len(carte[0])):\n            val = f.read(1)\n            while val!= \"0\" and val != \"1\":\n                val = f.read(1)\n            carte[i][j] = int(val)\n    f.close()\n    return carte","execution_count":52,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Lecture du fichier carte.txt et tracé de la carte obtenue\ncarte = read(\"carte.txt\")\nim = plt.imshow(carte,interpolation='none')\nim.set_cmap('gray')\nplt.axis(False)\nplt.show()","execution_count":53,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"metadata":{},"cell_type":"markdown","source":"11. Construire un fichier labyrinthe, échanger ces fichiers labyrinthes avec un autre élève du groupe, lire le fichier (éventuellement corriger votre fonction **read**) et résoudre le labyrinthe."}],"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.7.8","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"celltoolbar":"None"},"nbformat":4,"nbformat_minor":4}