02_Estructuras_de_datos_y_algoritmos_1/P11/EDyA11_I.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/logo.png\" height=\"400\" width=\"200\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Guía práctica de estudio 11: <br>*Estrategias para la construcción de algoritmos*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elaborado por:\n",
    "\n",
    "* M.C. Edgar E. García Cano\n",
    "* Ing. Jorge A. Solano Gálvez\n",
    "\n",
    "### Autorizado por:\n",
    "* M.C. Alejandro Velázquez Mena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetivo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">El objetivo de esta guía es implementar, al menos, dos enfoques de diseño (estrategias) de algoritmos y analizar las implicaciones de cada uno de ellos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Actividades:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Revisar el concepto y un ejemplo de diversas estrategias para construir algoritmos (fuerza bruta, algoritmo ávido, bottom-up, top-down, divide y vencerás, etc)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conceptos a revisar en Python:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Escribir y leer en archivos.\n",
    "- Graficar funciones usando la biblioteca Matplotlib.\n",
    "- Generar listas de números aleatorios.\n",
    "- Medir y graficar tiempos de ejecución."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Repositorio de la guía:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Jupyter Notebook GitHub: [[ipynb](https://github.com/eegkno/FI_UNAM/blob/master/02_Estructuras_de_datos_y_algoritmos_1/P11/EDyA11_I.ipynb)]<br>\n",
    ">Jupyter Notebook Visualizador: [[nbviewer](http://nbviewer.jupyter.org/github/eegkno/FI_UNAM/blob/master/02_Estructuras_de_datos_y_algoritmos_1/P11/EDyA11_I.ipynb)]<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<i class=\"fa fa-exclamation-triangle fa-2x\" aria-hidden=\"true\"></i> **Es sumamente importante respetar las indentaciones al momento de escribir código en Python. Se recomienda usar 4 espacios por nivel de indentación, los espacios son preferidos sobre el uso de tabuladores (https://www.python.org/dev/peps/pep-0008/#code-lay-out)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Fuerza bruta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El objetivo de resolver problemas por medio de fuerza es bruta es hacer una búsqueda exhaustiva de todas las posibilidades que lleven a la solución del problema. Un ejemplo de esto es encontrar una contraseña haciendo una combinación exhaustiva de caracteres alfanuméricos generando cadenas de cierta longitud. La desventaja de resolver problemas por medio de esta estrategia es el tiempo que toman."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A continuación se muestra una implementación de un buscador de contraseñas de entre 3 y 4 caracteres. Para este ejemplo se va a usar la biblioteca **string**, de ésta se van a importar los caracteres y dígitos.\n",
    "\n",
    "También se usa la biblioteca **itertools** (https://docs.python.org/3/library/itertools.html#). La biblioteca **itertools** tiene una función llamada **product()** (https://docs.python.org/3/library/itertools.html#itertools.product) la cual se va a utilizar para realizar las combinaciones en cadenas de 3 y cuatro caracteres."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las diferentes combinaciones generadas por el algoritmo se van a guardar en un archivo. Para guardar datos en un archivo se utiliza la función **open()**, que es para tener una referencia del archivo que se quiere abrir (https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files). Con la referencia creada se utiliza la función **write()**, que recibe la cadena que se va a escribir en el archivo. Finalmente, una vez que se termina la escritura hacia el archivo, éste se cierra con la función **close()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from string import ascii_letters , digits\n",
    "from itertools import product\n",
    "\n",
    "#Concatenar letas y dígitos en una sola cadena\n",
    "caracteres = ascii_letters+digits\n",
    "\n",
    "def buscador(con):\n",
    "    \n",
    "    #Archivo con todas las combinaciones generadas\n",
    "    archivo = open(\"combinaciones.txt\", \"w\")\n",
    "    \n",
    "    if 3<= len(con) <= 4:\n",
    "        for i in range(3,5):\n",
    "            for comb in product(caracteres, repeat = i):\n",
    "                #Se utiliza join() para concatenar los caracteres regresado por la función product().\n",
    "                #Como join necesita una cadena inicial para hacer la concatenación, se pone una cadena vacía\n",
    "                #al principio\n",
    "                prueba = \"\".join(comb)\n",
    "                #Escribiendo al archivo cada combinación generada\n",
    "                archivo.write( prueba + \"\\n\"  )\n",
    "                if  prueba == con:\n",
    "                    print('Tu contraseña es {}'.format(prueba))\n",
    "                    #Cerrando el archivo\n",
    "                    archivo.close()\n",
    "                    break\n",
    "    else:\n",
    "        print('Ingresa una contraseña que contenga de 3 a 4 caracteres')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tu contraseña es H0l4\n",
      "Tiempos de ejecución 3.217832\n"
     ]
    }
   ],
   "source": [
    "from time import time\n",
    "t0 = time() \n",
    "con = 'H0l4'\n",
    "buscador(con)\n",
    "print(\"Tiempos de ejecución {}\".format(round(time()-t0, 6)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algoritmos ávidos (greedy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta estrategia se diferencía de fuerza bruta porque va tomando una serie de deciciones en un orden específico, una vez que se ha ejecutado esa decisión, ya no se vuelve a considerar. En comparación con fuerza bruta, ésta puede ser más rápidá; aunque una desventaja es que la solución que se obtiene, no siempre es la más óptima."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tip:** En el siguiente ejemplo se va a realizar una división entre enteros, para esto se va a ocupar el operando **//**. La diferencia entre utilizar **/** y **//** es que el primer operador realiza una operación de números flotantes y el segundo una operación de números enteros.\n",
    "```\n",
    "5/2 = 2.5\n",
    "5//2 = 2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A continuación se muestra la implementación del problema de cambio de monedas. El problema consiste en regresar el cambio de monedas, de cierta denominación,  usando el menor número de éstas. Este problema se resuelve escogiendo sucesivamente las monedas de mayor valor hasta que ya no se pueda seguir usándolas y cuando esto pasa, se utiliza la siguiente de mayor valor. La desventaje en esta solución es que si no se da la denominación de monedas en orden de mayor a menor, se resuelve el problema, pero no de una manera óptima."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def cambio(cantidad, denominaciones):\n",
    "    resultado = []\n",
    "    while (cantidad > 0):\n",
    "        if (cantidad >= denominaciones[0]):\n",
    "            \n",
    "            num = cantidad // denominaciones[0]\n",
    "            cantidad = cantidad - (num * denominaciones[0])\n",
    "            resultado.append([denominaciones[0], num])\n",
    "        denominaciones = denominaciones[1:]  #Se va consumiendo la lista de denominaciones\n",
    "    return resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[500, 2]]\n",
      "[[500, 1]]\n",
      "[[50, 6]]\n",
      "[[5, 40]]\n",
      "[[50, 1], [20, 2], [5, 1], [1, 3]]\n"
     ]
    }
   ],
   "source": [
    "#Pruebas del algoritmo\n",
    "print (cambio(1000, [500, 200, 100, 50, 20, 5, 1]))\n",
    "\n",
    "print (cambio(500, [500, 200, 100, 50, 20, 5, 1]))\n",
    "\n",
    "print (cambio(300, [50, 20, 5, 1]))\n",
    "\n",
    "print (cambio(200, [5]))\n",
    "\n",
    "print (cambio(98, [50, 20, 5, 1]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el siguiente ejemplo no regresa la solución óptima, además, si no existiera la moneda de valor 1, la solución fallaría."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5, 19], [1, 3]]\n"
     ]
    }
   ],
   "source": [
    "print (cambio(98, [5, 20, 1, 50]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bottom-up (programación dinámica)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El objetivo de esta estrategia es resolver un problema a partir de subproblemas que ya han sido resueltos. La solución final se forma a partir de la combinación de una o más soluciones que se guardan en una tabla, ésta previene que se vuelvan a calcular las soluciones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como ejemplo, se va a calcular el número *n* de la sucesión de Fibonacci.  La sucesión de Fibonacci es una sucesión infinita de números enteros cuyos primeros dos elementos son 0 y 1, los siguientes números son calculados por la suma de los dos anteriores.\n",
    "\n",
    "```\n",
    "0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A continuación se presenta la implementación iterativa para calcular la sucesión de Fibonacci."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fibonacci_iterativo_v1(numero):\n",
    "    f1=0\n",
    "    f2=1\n",
    "    tmp=0\n",
    "    for i in range(1,numero-1):\n",
    "        tmp = f1+f2\n",
    "        f1=f2\n",
    "        f2=tmp\n",
    "    return f2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci_iterativo_v1(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tip:** En Python se puede hacer una *asignación paralela*, esto va a servir para evitar tener la variable auxiliar *tmp*, tal y como se muestra a continuación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fibonacci_iterativo_v2(numero):\n",
    "    f1=0\n",
    "    f2=1\n",
    "    for i in range(1, numero-1):\n",
    "        f1,f2=f2,f1+f2    #Asignación paralela\n",
    "    return f2     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci_iterativo_v2(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una vez que conocemos como calcular la sucesión de Fibonacci, ahora vamos a aplicar la estrategia **bottom-up**. Partimos del hecho de que ya tenemos las soluciones para: \n",
    "```\n",
    "f(0) = 0\n",
    "f(1) = 1\n",
    "f(2) = 1\n",
    "```\n",
    "\n",
    "Estas soluciones previas son almacenadas en la tabla de soluciones *f_parciales*.\n",
    "```\n",
    "f_parciales = [0, 1, 1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fibonacci_bottom_up(numero):\n",
    "    f_parciales = [0, 1, 1]  #Esta es la lista que mantiene las soluciones previamente calculadas\n",
    "    while len(f_parciales) < numero:\n",
    "        f_parciales.append(f_parciales[-1] + f_parciales[-2])\n",
    "        print(f_parciales)\n",
    "    return f_parciales[numero-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 2]\n",
      "[0, 1, 1, 2, 3]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci_bottom_up(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se observa en el resultado anterior, no se hace el cálculo de los primeros números, si no que se toman las soluciones ya existentes. La solución se encuentra calculando los resultaods desde los primeros números (casos base), hasta llegar a *n*, de abajo hacia arriba.\n",
    "\n",
    "```\n",
    "[0, 1, 1]         Datos iniciales\n",
    "[0, 1, 1, 2]      Primera iteración, se calcula n-1 = 1, y n - 2 = 1;\n",
    "[0, 1, 1, 2, 3]   Segunda iteración, se calcula n-1 = 2, y n - 2 = 1;\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Top-down"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A diferencia de bottom-up, aquí se empiezan a hacer los cálculos de *n* hacia abajo. Además, se aplica una técnica llamada *memorización* la cual consiste en guardar los resultados previamente calculados, de tal manera que no se tengan que repetir operaciones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para aplicar la estrategia **top-down**, se utiliza un diccionario (*memoria*) el cual va a almacenar valores previamente calculados. Una vez que se realice el cálculo de algún elemento de la sucesión de Fibonacci, éste se va a almacenar ahí."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Memoria inicial\n",
    "memoria = {1:0, 2:1, 3:1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fibonacci_top_down(numero):\n",
    "    if numero in memoria:      #Si el número ya se encuentra calculado, se regresa el valor ya ya no se hacen más cálculos\n",
    "        return memoria[numero]\n",
    "    f = fibonacci_iterativo_v2(numero-1) + fibonacci_iterativo_v2(numero-2)\n",
    "    memoria[numero] = f\n",
    "    return memoria[numero]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se muestra en el código anterior, para obtener *n*, se calculan *n-1* y *n-2* usando la versión iterativa. La deficiencia de este algoritmo es que hay cálculos que es están repitiendo. La ventaja, es que una vez que ya se calcularon, se guardan en\n",
    "una memoria, que en este caso es un diccionario; en dado caso de que se necesite un valor que ya ha sido calculado, sólo regresa y ya no se realizan los cálculos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "89"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci_top_down(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 0, 2: 1, 3: 1, 12: 89}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Memoria después de obtener el elemento 12 de la sucesión de Fibonacci\n",
    "memoria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Memoria después de obtener el elemento 8 de la sucesión de Fibonacci\n",
    "fibonacci_top_down(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 0, 2: 1, 3: 1, 8: 13, 12: 89}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "memoria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se muestra en  la impresión de la variable *memoria*, que contiene los resultados previamente calculados, los nuevos valores obtenidos se agregaron a ésta. El problema con esta versión es que se siguen haciendo cálculos de más, ya que la función *fibonacci_iterativo_v2()* no tiene acceso a la variable memoria, lo que implica que tenemos que hacer modificaciones a la implementación. Por ejemplo, si se quiere calcular el elemento 5, se tiene que calcular (n-2) y (n-1), aunque algunos valores ya existen en la variable *memoria* no hay una manera de acceder a ellos.\n",
    "\n",
    "```\n",
    "f(5) = \n",
    "    (n-1) = f(4)+f(3)+f(2)+f(1)\n",
    "    (n-2) = f(3)+f(2)+f(1)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora, se requiere que los valores ya calculados sean guardados en un archivo, de tal manera que se puedan utilizar en otro instante de tiempo. Para esto se va a hacer uso de la biblioteca pickle (https://docs.python.org/3.5/library/pickle.html). Los archivos que se generan con pickle están en binario, por lo que no se puede leer a simple vista la información que contienen, como se haría desde un archivo de texto plano."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Se carga la biblioteca\n",
    "import pickle\n",
    "\n",
    "#Guardar variable\n",
    "#No hay restricción en lo que se pone como extensión del archivo, \n",
    "#generalmente se usa .p o .pickle como estandar.\n",
    "archivo = open('memoria.p', 'wb')   #Se abre el archivo para escribir en modo binario\n",
    "pickle.dump(memoria, archivo)       #Se guarda la variable memoria que es un diccionario\n",
    "archivo.close()                     #Se cierra el archivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Leer variable\n",
    "archivo = open('memoria.p', 'rb')          #Se abre el archivo para leer en modo binario\n",
    "memoria_de_archivo = pickle.load(archivo)  #Se lee la variable\n",
    "archivo.close()                            #Se cierra el archivo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si no se realizó un cambio en *memoria*, ésta variable y *memoria_de_archivo* deben contener los mismos datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 0, 2: 1, 3: 1, 8: 13, 12: 89}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "memoria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 0, 2: 1, 3: 1, 8: 13, 12: 89}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "memoria_de_archivo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Incremental"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es una estrategia que consiste en implementar y probar que sea correcto de manera paulatina, ya que en cada iteración se va agregando información hasta completar la tarea."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Insertion sort**\n",
    "\n",
    "Insertion sort ordena los elementos manteniendo una sublista de números ordenados empezando por las primeras localidades de la lista. Al principio se considera que el elemento en la primera posición de la lista está ordenado. Después cada uno de los elementos de la lista se compara con la sublista ordenada para encontrar la posición adecuada. La Figura 1 muestra la secuencia de cómo se ordena un elemento de la lista."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tip:** Las imágenes pueden ser agregadas usando etiquetas de HTML."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/Figura1.png\" height=\"800\" width=\"600\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def insertionSort(n_lista):\n",
    "    for index in range(1,len(n_lista)):\n",
    "        actual = n_lista[index]\n",
    "        posicion = index\n",
    "        print(\"valor a ordenar = {}\".format(actual))\n",
    "        while posicion>0 and n_lista[posicion-1]>actual:\n",
    "            n_lista[posicion]=n_lista[posicion-1]\n",
    "            posicion = posicion-1           \n",
    "        n_lista[posicion]=actual\n",
    "        print(n_lista)\n",
    "        print() \n",
    "    return n_lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lista desordenada [21, 10, 0, 11, 9, 24, 20, 14, 1]\n",
      "valor a ordenar = 10\n",
      "[10, 21, 0, 11, 9, 24, 20, 14, 1]\n",
      "\n",
      "valor a ordenar = 0\n",
      "[0, 10, 21, 11, 9, 24, 20, 14, 1]\n",
      "\n",
      "valor a ordenar = 11\n",
      "[0, 10, 11, 21, 9, 24, 20, 14, 1]\n",
      "\n",
      "valor a ordenar = 9\n",
      "[0, 9, 10, 11, 21, 24, 20, 14, 1]\n",
      "\n",
      "valor a ordenar = 24\n",
      "[0, 9, 10, 11, 21, 24, 20, 14, 1]\n",
      "\n",
      "valor a ordenar = 20\n",
      "[0, 9, 10, 11, 20, 21, 24, 14, 1]\n",
      "\n",
      "valor a ordenar = 14\n",
      "[0, 9, 10, 11, 14, 20, 21, 24, 1]\n",
      "\n",
      "valor a ordenar = 1\n",
      "[0, 1, 9, 10, 11, 14, 20, 21, 24]\n",
      "\n",
      "lista ordenada [0, 1, 9, 10, 11, 14, 20, 21, 24]\n"
     ]
    }
   ],
   "source": [
    "# Datos de entrada\n",
    "lista = [21, 10, 0, 11, 9, 24, 20, 14, 1]\n",
    "print(\"lista desordenada {}\".format(lista))\n",
    "insertionSort(lista)\n",
    "print(\"lista ordenada {}\".format(lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Divide y vencerás"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es una estrategia que consiste en:\n",
    "\n",
    "- Dividir el problema en subproblemas hasta que son suficientemente simples que se pueden resolver directamente.\n",
    "- Después las soluciones son combinadas para generar la solución general del problema."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick sort**\n",
    "\n",
    "Quicksort es un ejemplo de resolver un problema por medio de la estrategia divide y vencerás. En Quicksort se divide en dos el arreglo que va a ser ordenado y se llama recursivamente para ordenar las divisiones. La parte más importante en Quicksort es la partición de los datos. Lo primero que se necesita es escoger un valor de pivote el cual está encargado de ayudar con la partición de los datos. El objetivo de dividir los datos es mover los que se encuentran en una posición incorrecta con respecto al pivote. La siguiente figura muestra un ejemplo de cómo se ordena una lista."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/Figura2.png\" height=\"800\" width=\"600\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def quicksort(lista):\n",
    "    quicksort_aux(lista,0,len(lista)-1)\n",
    "\n",
    "def quicksort_aux(lista,inicio, fin):\n",
    "    if inicio < fin:\n",
    "\n",
    "        pivote = particion(lista,inicio,fin)\n",
    "\n",
    "        quicksort_aux(lista, inicio, pivote-1)\n",
    "        quicksort_aux(lista, pivote+1, fin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def particion(lista, inicio, fin):\n",
    "    #Se asigna como pivote en número de la primera localidad\n",
    "    pivote = lista[inicio]\n",
    "    print(\"Valor del pivote {}\".format(pivote))\n",
    "    #Se crean dos marcadores \n",
    "    izquierda = inicio+1\n",
    "    derecha = fin\n",
    "    print(\"Índice izquierdo {}\".format(izquierda))\n",
    "    print(\"Índice derecho {}\".format(derecha))\n",
    "\n",
    "    \n",
    "    bandera = False\n",
    "    while not bandera:\n",
    "        while izquierda <= derecha and lista[izquierda] <= pivote:\n",
    "            izquierda = izquierda + 1\n",
    "        while lista[derecha] >= pivote and derecha >=izquierda:\n",
    "            derecha = derecha -1\n",
    "        if derecha < izquierda:\n",
    "            bandera= True\n",
    "        else:\n",
    "            temp=lista[izquierda]\n",
    "            lista[izquierda]=lista[derecha]\n",
    "            lista[derecha]=temp\n",
    "            \n",
    "    print(lista)\n",
    "\n",
    "\n",
    "    temp=lista[inicio]\n",
    "    lista[inicio]=lista[derecha]\n",
    "    lista[derecha]=temp\n",
    "    return derecha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lista desordenada [21, 10, 0, 11, 9, 24, 20, 14, 1]\n",
      "Valor del pivote 21\n",
      "Índice izquierdo 1\n",
      "Índice derecho 8\n",
      "[21, 10, 0, 11, 9, 1, 20, 14, 24]\n",
      "Valor del pivote 14\n",
      "Índice izquierdo 1\n",
      "Índice derecho 6\n",
      "[14, 10, 0, 11, 9, 1, 20, 21, 24]\n",
      "Valor del pivote 1\n",
      "Índice izquierdo 1\n",
      "Índice derecho 4\n",
      "[1, 0, 10, 11, 9, 14, 20, 21, 24]\n",
      "Valor del pivote 10\n",
      "Índice izquierdo 3\n",
      "Índice derecho 4\n",
      "[0, 1, 10, 9, 11, 14, 20, 21, 24]\n",
      "lista ordenada [0, 1, 9, 10, 11, 14, 20, 21, 24]\n"
     ]
    }
   ],
   "source": [
    "lista = [21, 10, 0, 11, 9, 24, 20, 14, 1]\n",
    "print(\"lista desordenada {}\".format(lista))\n",
    "quicksort(lista)\n",
    "print(\"lista ordenada {}\".format(lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Medición y gráficas de los tiempos de ejecución"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jrg_sln/anaconda3/lib/python3.6/site-packages/IPython/core/magics/pylab.py:160: UserWarning: pylab import has clobbered these variables: ['product']\n",
      "`%matplotlib` prevents importing * from pylab and numpy\n",
      "  \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n"
     ]
    }
   ],
   "source": [
    "# Importando bibliotecas\n",
    "%pylab inline\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tip:** Las funciones en Python pueden ser guardadas en archivos individuales (*insertionSort.py*) o varias en un sólo archivo (*quickSort.py*). En el siguiente ejemplo, se agrego **_time** al nombre de la función en los archivos.\n",
    "\n",
    "**Tip:** En dado caso de que se quiera llamar más funciones que estén en un mismo archivo se pueden escribir los nombres de las funciones separados por nombres: *from file_name import función1, función2, función3*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Cargando módulos\n",
    "import random\n",
    "from time import time\n",
    "\n",
    "#Cargando las funciones guardadas en los archivo\n",
    "from insertionSort import insertionSort_time\n",
    "#Sólo se necesita llamar a la función principal\n",
    "from quickSort import quicksort_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Tamaños de la lista de números aleatorios a generar\n",
    "datos = [ii*100 for ii in range(1,21)] \n",
    "\n",
    "tiempo_is = []  #Lista para guardar el tiempo de ejecución de insert sort\n",
    "tiempo_qs = []  #Lista para guardar el tiempo de ejecución de quick sort\n",
    "\n",
    "for ii in datos:\n",
    "    lista_is = random.sample(range(0, 10000000), ii)\n",
    "    #Se hace una copia de la lista para que se ejecute el algoritmo con los mismo números\n",
    "    lista_qs = lista_is.copy() \n",
    "    \n",
    "    t0 = time()  #Se guarda el tiempo inicial\n",
    "    insertionSort_time(lista_is)\n",
    "    tiempo_is.append(round(time()-t0, 6))   #Se le resta al tiempo actual, el tiempo inicial\n",
    "    \n",
    "    t0 = time()    \n",
    "    quicksort_time(lista_qs)\n",
    "    tiempo_qs.append(round(time()-t0, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTA:** La función *time()* regresa el tiemo en segundos (https://docs.python.org/3/library/time.html#time.time)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tiempos parciales de ejecución en INSERT SORT [0.000454, 0.002072, 0.004049, 0.007109, 0.010946, 0.01551, 0.020094, 0.029021, 0.035898, 0.045617, 0.054019, 0.069195, 0.077898, 0.090723, 0.106664, 0.130038, 0.156966, 0.150643, 0.171415, 0.18271] [s] \n",
      "\n",
      "Tiempos parciales de ejecución en QUICK SORT [0.000125, 0.000279, 0.000438, 0.00067, 0.000941, 0.000939, 0.001097, 0.001339, 0.00152, 0.002072, 0.002319, 0.002242, 0.002362, 0.002759, 0.00294, 0.003293, 0.003307, 0.003523, 0.003468, 0.003722] [s]\n"
     ]
    }
   ],
   "source": [
    "# Se imprimen los tiempos parciales de ejecución\n",
    "print(\"Tiempos parciales de ejecución en INSERT SORT {} [s] \\n\".format(tiempo_is))\n",
    "print(\"Tiempos parciales de ejecución en QUICK SORT {} [s]\".format(tiempo_qs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tiempo total de ejecución en insert sort 1.3610410000000002 [s]\n",
      "Tiempo total de ejecución en quick sort 0.039355 [s]\n"
     ]
    }
   ],
   "source": [
    "# Se imprimen los tiempos totales de ejecución\n",
    "# Para calcular el tiempo total se aplica la función sum() a las listas de tiempo\n",
    "print(\"Tiempo total de ejecución en insert sort {} [s]\".format(sum(tiempo_is)))\n",
    "print(\"Tiempo total de ejecución en quick sort {} [s]\".format(sum(tiempo_qs)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEWCAYAAABMoxE0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzs3Xl4FFXWwOHfIQHCJioqg6KAAuMg\nYGR3GRBcQGVgUBAUwQ0ZRMdtcNBPBxkQx11HRVxQcUGD4sYoioLgDgKKsogawhaIyCYQ9iTn++NW\nk0rTnXTS6XQnOe/z1JOu5VafriR1+t6quldUFWOMMaakqsQ7AGOMMeWbJRJjjDFRsURijDEmKpZI\njDHGRMUSiTHGmKhYIjHGGBMVSyTljIj8n4hMjHccxSUiKiJNY7DfbBE5vrT3G+F7PyUi/wqx/GIR\nmSEi1Uu430kisk9EVkWw7dneMcgTkbML2e5vIvKo9/o4r0xSSeKrTERkoIh8FMF2o0XklTDrbhCR\ne0s/usQh9hxJYhGRbN9sTWAvkOvN/01VJ5d9VNETEQWaqWp6vGOJJRE5BbgX6KOqu0q4j0lApqre\nWYwyq4AhqjozxLpqwAqgk6quK0lMpUFErsDFeEa8YogVERkNNFXVy0KsSwHSgTaq+ltZx1YWrEaS\nYFS1dmAC1gB/8S0rl0mkMlHV71S1e0mTSIz0BpbHOYkkx+u9401V9wAfAIPjHUusWCIpZ4Kr0CLS\nSUS+EpHfReR7ETnTt26OiNztrc8Wkf+JSD0RmSwi20Vkvog09m2vXjU8Q0Q2icgDIlLFW1dFRO4U\nkdUi8puIvCQidQuJ81YRyRKR9SJyVdC66iLyoIisEZENXhNRjUL2dZWI/CgiW70mo0ZBMTeNZL8i\n0ltEFnmffYWI9PCWr/I3C4U4xmf4jvFa75t1oAnqbt9214hIuohsEZFpInJ0UJzDROQX73OMFxEJ\n95lDHIMrvN/LDhFZKSIDIy0LnAd86ttXYy+eZG9+joiMFZEvvf1/JCJHeOtSROQVEdnsff75IlLf\nW1dXRJ7zfs/rvL+1JF+8X4rIIyKyBZgCPAWc6v0t/h7iMw4QkQVBy24WkWne6/NFZJkX4zoRGRHh\nsavn/T62i8g33mf9ItSx8B2PIb7P8YVv3Uki8rH3O94gIv8X4v2qishrIvKmuNogwBzggkjiLY8s\nkZRjInIM8D5wN3A4MAJ4U0SO9G02ABgEHAOcAHwNvOBt/yNwV9Bu+wDtgDa4b7KBJHCFN3UFjgdq\nA0+EiauHF8s5QDMguO3+PqA5kAo09WIbFWZffwX+D7gQOBL4HHgt1LaF7VdEOgAvAbcChwKdgVVh\n9uN//+Nw3yYf994/FVgUYrtuwH+Ai4EGwGogLWiznkB74GRvu+5Fvb+371rAY8B5qloHOC1UDIVo\nBfxUxDaXAlcCRwHVcL8/gMuBusCxQD1gGLDbW/cikIM71qcA5wJDfPvsCGR4+7zMK/u1V7s+NEQM\n04A/ikizoLhe9V4/h2verQO0BD4p4jMFjAf24H4vV5H/N10sIlIHmAl8CByN+9yzgrapAbyDa5K+\nWFX3eat+xP3eKyRLJOXbZcB0VZ2uqnmq+jGwADjft80LqrpCVbfhTogrVHWmquYAb+BOAH73qeoW\nVV0DPApc4i0fCDysqhmqmg3cDgyQ0E0WF3vvu0RVdwKjAyu8b+HXADd777MDuAeX8EL5G/AfVf3R\ni/keINVfK4lwv1cDz6vqx96xWqeqy8O8p99AYKaqvqaq+1V1s6qGOokP9Pb/raru9Y7PqeKr8QH3\nqurv3rGdjUtKkcoDWopIDVXNUtWlxSh7KLCjiG1eUNWfVXU38Lovtv24BNJUVXNVdaGqbvdqJecB\nN6nqTq/t/xEK/h7Xq+rjqprj7bdQXnPgu3h/c15CORGXYAKxtBCRQ1R1q6p+W9Q+vRrSRcAoL84l\nuARYEj2BX1X1IVXdo6o7VHWeb/0huCSzArhSVXN963bgEnKFZImkfGsE9POaHH73mgvOwH3zCtjg\ne707xHztoH2u9b1ejfvmhfdzddC6ZKB+iLiODrGfgCNxNxEs9MX8obc8lEbAf33bbgEEV9vwK2q/\nx+L+wYsr0nIFjo+XbDcHxfmr7/UuDj72IXnJuD/uG32WiLwvIidGUtazFahTxDbhYnsZmAGkiWum\nvF9EquJ+L1W9eALH+2lc7SPA/zcQqVfJ//JyKfCO73rTRbgvSatF5FMROTWC/R2J+zsN9/dYHEX9\nLXQCWuO+MATfxVQH2FbC9014lkjKt7XAy6p6qG+qparR3Gp4rO/1ccB67/V63MnDvy6HgokpICvE\nfgI24RLYSb6Y63o3F4SyFtec4f+MNVT1q6DtitrvWlzTXig7cUko4A9B7x+unF+B4+M1R9UDSuUC\nt6rOUNVzcF8SlgPPFqP4D7gmv5K8735V/beqtsA1qfXEXTRei2u+OcJ3vA9R1ZP8xYN3F8FbfgQc\nISKpuIQSaNZCVeeram9csnoHV3Mqykbc32m4v8ed3s9wv3+/ov4WPsI1b84KXEfy+RPwfZHRllOW\nSMq3V4C/iEh3EUnyLoyeKSINo9jnrSJymIgcC9yIu0gK7rrEzSLSRERq45qNpnjNTcFeB64QkRYi\nUhPfdRhVzcOdBB8RkaPAXesRkXDXC54CbheRk7xt64pIv+CNItjvc8CVInKWuBsHjvF9q1+Ea6ar\nKiLtgL6+XU8Gzhb3bEiyd+E2VJPUq97+U8U9P3IPME9VV4X5XBETkfoi0stLTnuBbPJvCY/EdKBL\nCd+7q4i08pqItuOal3JVNQt34nxIRA7xjukJIlLY+2wAGvouQB/E+3uaCjyAu473sRdHNXHPdNRV\n1f1eLEUeA6956S1gtIjUFJEWuOs+gfUbccn+Mu9/6CrCJ4v3gD+IyE3ibuyoIyIdg97vftzfwizx\nbljwdME1LVdIlkjKMVVdi7sg/n+4b15rcReTo/m9vgssxJ1c38edgAGexzVzfAasxF28/HuYuD7A\nXV/5BHf/fPBF0ZHe8rkish13AfOPYfb1Nu4iepq37RJc23woYferqt/gLiY/gmti+JT8GsS/cCeP\nrcC/KfgteA2uOeUfuGa1RYS4aKqqs7z9vImrkZ1A+Os+xVXFe//1XgxdgOHFKP8/4ETx3UVWDH/A\nndi34y4Yf4r7AgOuZlINWIY7dlMp2Kwa7BNgKfCriGwqZLtXcTdovBH0RWUQsMr73Q7DXSP0P2B5\n3MG7AuB6XFPdr8Ak3M0mftfg/m82AycBwbVdALzrbucAf/H29Qvu5pPg7cbiakwzReRwcc+RnE/J\nr80kPHsg0Rwg5eyhQXG3JucCjbwTfoUgIs/imnU2qGqhzWoichYueVUHzlfV2WG2Gwq0UNWbSjve\n8kbK+MFIEfk7cKyq/rMs3i8eLJGYA8phImkNzAPq+m6zNKZQZZ1IKgNr2jLlkohchLuFdqQlEWPi\ny2okxhhjomI1EmOMMVGpFB2pHXHEEdq4ceN4hxHSzp07qVWrVrzDCMvii47FFx2LLzrRxrdw4cJN\nqhruYeF8qlrhp7Zt22qimj17drxDKJTFFx2LLzoWX3SijQ9YoBGcY61pyxhjTFQskRhjjImKJRJj\njDFRqRQX20PZv38/mZmZ7NmzJ65x1K1blx9//DGuMRSmuPGlpKTQsGFDqlatGsOojDGJpNImkszM\nTOrUqUPjxo2RyAeqK3U7duygTp2ieviOn+LEp6ps3ryZzMxMmjRpEuPIjDGJotI2be3Zs4d69erF\nNYlUNCJCvXr14l7LM8YAWVmk3ngj/Ppr0dtGqdImEsCSSAzYMTUmQYwdS93Fi2HMmJi/VaVOJMYY\nU+HUqAEiMGECogoTJrj5GjVi9paWSOLotNNOi+n+Fy1axPTp02Oy73vuuScm+zXGRCkjA7p1y5+v\nXh0GDoSVK2P2lpZIiiMrC7p0KbU2x6++Cjl+TqnIycmJSSJRVfLy8iyRGJOI8vLguefgEzeWXF7V\nqrB/PxxyCPwh3AjC0bNEUhxjx8IXX5Ram2Pt2m448Tlz5nDmmWfSt29fTjzxRAYOHIh6vTLfdttt\ntGjRgtatWzNixAgANm7cyEUXXUT79u1p3749X375JQCjR49m6NChnHvuuQwePJhRo0YxZcoUUlNT\nmTJlSoH3Xrp0KR06dCA1NZXWrVvzyy+/APDwww/TsmVLWrZsyaOPPgrAqlWr+NOf/sTw4cNp06YN\nV199Nbt37yY1NZWBAweWyrEwxkRp0ya44AL417+gYUO45hoWPvkkDBsW8wvulfb23wJuugkWLQq/\n/vPPXaYPmDDBTVWqwJ//HLpMaip4J+JIfPfddyxdupSjjz6a008/nS+//JIWLVrw9ttvs3z5ckSE\n33//HYAbb7yRm2++mTPOOIM1a9bQvXv3A896LFy4kC+++IIaNWowadIkFixYwBNPPHHQ+z311FPc\neOONDBw4kH379pGbm8vChQt54YUXmDdvHqpKx44dadeuHQ0bNuSnn37ihRde4MknnwTgjTfeYFFh\nx8wYU3bmzoV+/eC33+Cpp2DoUBBh55w5MGRIzN/eEkkkOnRw7Y6bNrmEUqUKHHEEnFDoKKjFfIsO\nNGzYEIDU1FRWrVpFp06dSElJYciQIVxwwQX07NkTgJkzZ7Js2bIDZbdv386OHTsA6NWrFzUiuKh2\n6qmnMm7cODIzM7nwwgtp1qwZX3zxBX369DnQW+iFF17IV199xcUXX0yjRo3o1KlTqX1eY0wpUIXH\nHoMRI+DYY+Grr6Bt2zIPI6aJRER6AP8FkoCJqnpv0PrOwKNAa2CAqk71lncFHvFteqK3/h0RmQR0\nAbZ5665Q1ei+GkdSc7j2WnjmGUhJgX374KKLwPt2XhqqV69+4HVSUhI5OTkkJyfzzTffMGvWLNLS\n0njiiSf45JNPyMvL4+uvvw6ZMCLtMvrSSy+lY8eOvP/++3Tv3p2JEyceaE4LJZG7yjamUtq+Ha6+\nGqZOhV69YNIkOOywuIQSs2skIpIEjAfOA1oAl4hIi6DN1gBXAK/6F6rqbFVNVdVUoBuwC/jIt8mt\ngfVRJ5FIbdjg2hrnzi2TNkeA7Oxstm3bxvnnn8+jjz56oCnp3HPPLdBcFa6JqU6dOgdqKsEyMjI4\n/vjjueGGG+jVqxc//PADnTt35p133mHXrl3s3LmTt99+O+ydZVWrVmX//v1RfkJjTIn88AO0awdv\nvw333w/vvBO3JAKxvdjeAUhX1Qx1Y2qnAb39G6jqKlX9AcgLtQNPX+ADVd0Vu1Aj8NZbMH48nHyy\n+/nWWzF/yx07dtCzZ09at25Nly5deOQRV0l77LHHWLBgAa1bt6ZFixY89dRTIct37dqVZcuWhbzY\nPmXKFFq2bElqairLly9n8ODBtGnThiuuuIIOHTrQsWNHhgwZwsknnxxy30OHDqV169Z2sd2YsvbC\nC9CxI2Rnw+zZcOut7jmReIpk0JKSTLgEMNE3Pwh4Isy2k4C+YdZ9AvQM2vYn4Adc81f1omIJNbDV\nsmXLIh7cJZa2b98e7xAKVZL4yvLYVvSBhWLN4otOmca3a5fqVVepgmq3bqq//lpkkbIa2Eq0kHbx\naIhIP6C7qg7x5gcBHVT17yG2nQS8p941Et/yBl7COFpV9/uW/QpUA54BVqjqQffjishQYChA/fr1\n26alpRVYX7duXZo2bRrtx4xabm4uSUlJ8Q4jrJLEl56ezrZt24resBRkZ2cfuI06EVl80anM8VXb\nvJkWY8aw7K67SNq1i5PuuovaGRmsGjSIVZdfDhH8X0YbX9euXReqarsiN4wk25RkAk4FZvjmbwdu\nD7PtJELUSIAbgWcKeY8zcQnIaiQxYjWS6Fh80anU8V17rWqVKqrnnqtap47q4YerTp9erF2UVY0k\nlndtzQeaiUgTYB0wALi0mPu4BJeADhCRBqqaJa53wL8CS0ojWGOMSQg1aoC/B+2PvPuMqleH886L\nT0xFiNnFdlXNAa4HZgA/Aq+r6lIRGSMivQBEpL2IZAL9gKdFZGmgvIg0Bo4FPg3a9WQRWQwsBo4A\n7o7VZzDGmDKXkQGXXgrJ3vf85GQYMABWrYprWIWJ6XMkqjodmB60bJTv9XygYZiyq4BjQizvdvDW\nxhhTQTRoANu2QU6Ouw6Sl+du7Y1hX1nRsr62jDEmkWzcCDNnuuTx5Zdl9txaNCyRlCMLFizghhtu\nKHSbWN/hMmnSJNavXx/T9zCm0lJ1fWOpwpw57nmRMnpuLRqWSCI0eTI0buy62Wrc2M2XtXbt2vHY\nY4+V/Rt7cnNzLZEYE0tPPw3TpsF990Hr1vGOJmKWSCIwebLrTHP1avdFYfVqNx9tMhk3bhxt2rTh\n7LPP5pJLLuHBBx8E4Mwzz2TBggUAbNq0icaNGwOuu/lAx43Z2dlceeWVtGrVitatW/Pmm28W2Pem\nTZs49dRTef/99wss37lzJxdccAEnn3wyLVu2PPDE+6xZszjllFNo1aoVV111FXv37gWgZcuWjBkz\nhjPOOIPXXnuNBQsWMHDgQFJTU9m9e3d0B8AYk+/HH+GWW+Dcc6GIlodEY73/UnQv8nPngndePWDX\nLtdf2rPPhi5TVC/yCxcuJC0t7UCX723atKFtMXrtHDt2LHXr1mXx4sUAbN269cC6DRs20KtXL+6+\n+27OOeecAuU+/PBDjj766AMJZtu2bezZs4crrriCWbNm0bx5cwYPHsyECRO46aabAEhJSeGLL74A\nYOLEiTz44IO0a1f0M0rGmAjt3evu1KpVy3W+WKV8fccvX9HGSXASKWp5JD7//HP69OlDzZo1OeSQ\nQ+jVq1exys+cOZPrrrvuwPxhXodt+/fv56yzzuL+++8/KIkAtGrVipkzZzJy5Eg+//xz6taty08/\n/USTJk1o3rw5AJdffjmfffbZgTL9+/cvyUc0xkTqzjvdt9nnnnN3bZUzViOh6F7kGzd2zVnBGjVy\n18NKSsJ0tJacnEyeN5DWHv+DST6qGrJ8cnIybdu2ZcaMGXTp0uWg9c2bN2fhwoVMnz6d22+/nXPP\nPbfIJGZdyBsTQzNnwoMPuruzivmFMlFYjSQC48ZBzZoFl9Ws6ZaXVOfOnXn77bfZvXs3O3bs4H//\n+9+BdY0bN2bhwoUATJ06NWT54K7kA01bIsLzzz/P8uXLuffeew8qt379emrWrMlll13GiBEj+Pbb\nbznxxBNZtWoV6enpALz88sshkxAU3jW9MaaYNm+Gyy+HE0+Ehx6KdzQlZokkAgMHujGtGjVyvTU3\nauTmo+lBvU2bNvTv35/TTz+diy66iD/7huwdMWIEEyZM4LTTTmPTpk0hy995551s3bqVli1bcvLJ\nJzN79uwD65KSkkhLS2P27NkHhsYNWLx48YGx2seNG8edd95JSkoKL7zwAv369aNVq1ZUqVKFYcOG\nhXzfK664gmHDhtnFdmOipQrXXOOeG3n11YO/rZYnkXTIVd6n8tBp41133aUPPPBAnKM5mHXaGB2L\nLzoVOr5nn1UF1Rj+35dVp41WIzHGmLL2889w441w1lnult9yzi62J4jRo0fHOwRjjF9WlussccqU\n0u3nat8+d6tvSgq8+GK5u9U3lPL/CaLgam6mNNkxNRXG2LHwxRcw5qBx86Jz112wcCFMnAjHHNQv\nbblUaRNJSkoKmzdvthNfKVJVNm/eTEpKSrxDMabkatRwd9VMmOB63p0wwc3XqBH9vufMcd2fXHMN\n9OkT/f4SRKVt2mrYsCGZmZls3LgxrnHs2bMnoU+8xY0vJSWFhg1DjgxgTPmQkQEjRkBamkskAPXq\nwb//7ZqlqlUr2X63boVBg6BZM3jkkdKLNwFU2kRStWpVmjRpEu8wmDNnDqecckq8wwgr0eMzptQF\nxgPJy3ODSuXmurFBrr/eNXcNGwZ/+1vxnkBXdWV+/RW+/tp1hVKBVNqmLWOMCSk3110bqVMHvvoK\nrr0WunaFDz+Edu3cNZNGjWDgQA5ZtswliaK8+CK88QbcfbfbRwVTaWskxhgT0iuvuBrJa69B+/Zu\nCujeHdLT3Rghzz9Pm1dfhRdecL31XnyxG1c9WHo6/P3vcOaZrsmsAoppjUREeojITyKSLiK3hVjf\nWUS+FZEcEekbtC5XRBZ50zTf8iYiMk9EfhGRKSJSwgZLY4wJsnu360CxfXuXGEJp2tRd41i3jp9v\nugl27oTBg+G442DUKAiM15OVBZ07Q79+ULUqvPSSGzq3AopZIhGRJGA8cB7QArhERFoEbbYGuAJ4\nNcQudqtqqjf5ezK7D3hEVZsBW4GrSz14Y0zl9N//QmYmPPBA0c931K7N+t69YelS+PhjN5rh3Xe7\nZq9LLoHrrnNNZIsWuQGrjj22bD5DHMSyRtIBSFfVDFXdB6QBvf0bqOoqVf0ByItkh+K6u+0GBHoy\nfBH4a+mFbIyptDZuhP/8B/7yFwjTaWlIInD22W5kw/R0d80kLQ3efjv/+snFF5fO7cMJKpaJ5Bhg\nrW8+01sWqRQRWSAic0UkkCzqAb+rak4J92mMMaHdfTdkZ7vnPErq+ONh7VqXOKpWdctq1HA9vK5c\nWTpxJqBYXmwPNdhGcZ7+O05V14vI8cAnIrIY2B7pPkVkKDAUoH79+syJZuCQGMrOzk7Y2MDii5bF\nF52yiq/GunW0Hz+eX88/n583bIANGyIqFy6+Znv2cHRODnnVqlFlzx7W79jBL8uXw/LlpRx5yeIr\ndZH07FiSCTgVmOGbvx24Pcy2k4C+hexrEtAXl5w2Acmh3iPcFKr330RRoXs3LQMWX3QsPk/fvqq1\naqlmZRWrWNj4+vRRHT5cddEi97NPn+hjLIGy6v03ljWS+UAzEWkCrAMGAJdGUlBEDgN2qepeETkC\nOB24X1VVRGbjkkoacDnwbkyiN8ZUDnPnwtSpMHp06XXO+NZb+a/Hjy+dfSawmF0jUXcd43pgBvAj\n8LqqLhWRMSLSC0BE2otIJtAPeFpElnrF/wQsEJHvgdnAvaq6zFs3ErhFRNJx10yei9VnMMZUcKru\n2Y4//AH+8Y94R1NuxfSBRFWdDkwPWjbK93o+cFDHTKr6FdAqzD4zcHeEGWNMdN55B7780t2eW7t2\nvKMpt6yLFGNM5bR/P9x2G/zpT3DVVfGOplyzLlKMMZXTs8+6kQqnTXOdM5oSsxqJMaby2b7dXVzv\n0gV69ox3NOWeJRJjTOXzwAPuSfYHHnBPppuoWCIxxlQu69bBQw+58dj9PfuaErNEYoypXEaNcmOO\n3HNPvCOpMCyRGGMqj8WLYdIkN9phAoyQWlFYIjHGVB4jR8Ihh8Add8Q7kgrF7nkzxlQOs2bBBx+4\nC+yHHx7vaCoUq5EYYyq+vDy49VY36NT118c7mgrHaiTGmIrv1Vfhu+/ceOwpKfGOpsKxGokxpmLb\ns8ddE2nTxg2Ba0qd1UiMMRXb44/DmjXubq2ixmE3JWKJxBhTMWVlwUUXwZIlcP750LVrvCOqsCyR\nGGMqprFj4euv3ev7749vLBWcJRJjTMVSo4a7LuLXsqW7yL57d3xiquCswdAYU7FkZLiL6oHrITVq\nwMCBsHJlfOOqwCyRGGMqlgYNXM++eXlunJG9e93T7KU1Hrs5iCUSY0zFsnUrfPYZHHkkzJsHw4bB\nr7/GO6oKLaaJRER6iMhPIpIuIreFWN9ZRL4VkRwR6etbnioiX4vIUhH5QUT6+9ZNEpGVIrLIm1Jj\n+RmMMeXMP//pevf96CP37Mj48fDWW/GOqkKL2cV2EUkCxgPnAJnAfBGZpqrLfJutAa4ARgQV3wUM\nVtVfRORoYKGIzFDV3731t6rq1FjFbowppz79FCZOdMkk1b5jlpVY3rXVAUhX1QwAEUkDegMHEomq\nrvLW5fkLqurPvtfrReQ34Ejgd4wxJpQ9e+Bvf3Pdw991V7yjqVREVWOzY9dU1UNVh3jzg4COqnpQ\nj2kiMgl4L1QtQ0Q6AC8CJ6lqnrftqcBeYBZwm6ruDVFuKDAUoH79+m3T0tJK66OVquzsbGrXrh3v\nMMKy+KJj8UWnOPE1fuEFGr/0Et/ffz9by2jkw4p0/ELp2rXrQlVtV+SGqhqTCegHTPTNDwIeD7Pt\nJKBviOUNgJ+ATkHLBKiOSzCjioqlbdu2mqhmz54d7xAKZfFFx+KLTsTxLV2qWrWq6mWXxTSeYBXm\n+IUBLNAIzvexvNieCRzrm28IrI+0sIgcArwP3KmqcwPLVTXL+4x7gRdwTWjGmMoqLw+GDoU6deDh\nh+MdTaUUy0QyH2gmIk1EpBowAJgWSUFv+7eBl1T1jaB1DbyfAvwVWFKqURtjypdnn4Uvv3RJ5Mgj\n4x1NpRSzRKKqOcD1wAzgR+B1VV0qImNEpBeAiLQXkUxcM9jTIrLUK34x0Bm4IsRtvpNFZDGwGDgC\nuDtWn8EYk+DWr3d3aHXrBoMHxzuaSiumfW2p6nRgetCyUb7X83FNXsHlXgFeCbPPbqUcpjGmvLrx\nRti3D55+GkTiHU2lZZ02GmPKp2nTYOpUuOceaNo03tFUatZFijGm/Nm+HYYPd736jgh+ntmUNauR\nGGPKnzvvdNdHpk6FqlXjHU2lZzUSY0z5Mm8ePPEEXHcddOoU72gMlkiMMeXJ/v1wzTVw9NEwbly8\nozEea9oyxpQfDz0EixfDO++4MUZMQrAaiTGmfEhPh3//Gy68EHr3jnc0xscSiTEm8am6AaqqVYPH\nHot3NCaINW0ZYxLfyy/DrFnw5JNwzDHxjsYEsRqJMSaxbdwIt9wCp53mxhsxCccSiTEmsf3jH+4B\nxGeegSp2ykpE1rRljElMWVm0u+oqWLnSPYB40knxjsiEYendGJOYRo2i1sqV7jbfO+6IdzSmEBHV\nSESkPhAYu/IbVf0tdiEZYyq1GjXc+Ou4oVDZvt0tS0mB3bvjGpoJrcgaiYhcDHyDGzPkYmCeNx67\nMcaUvhUroHnz/PmaNWHgQNfEZRJSJDWSO4D2gVqIiBwJzASmxjIwY0wl9fTT8PPPAORWq0bSnj2u\neesPf4hzYCacSBJJlaCmrM3YtRVjTCz8978wZgw0agTnn8+3bdrQ/rvvICsr3pGZQkSSSD4UkRnA\na958f4JGPTTGmKi99BLcdJMReiF7AAAgAElEQVTrAmXKFEhOZuecOTBkSLwjM0UosmahqrcCTwOt\ngZOBZ1R1ZCQ7F5EeIvKTiKSLyG0h1ncWkW9FJCf4uouIXC4iv3jT5b7lbUVksbfPx0RsfE1jyr1p\n0+Cqq+Css+DVVyHZnkwoTyJtovoK+BT4BPg6kgIikgSMB84DWgCXiEiLoM3WAFcArwaVPRy4C+gI\ndADuEpHDvNUTgKFAM2/qEeFnMMYkojlz4OKLoW1b16tv9erxjsgUUyR3bQ3B3bXVB+gLzBWRqyLY\ndwcgXVUzVHUfkAYU6LJTVVep6g9AXlDZ7sDHqrpFVbcCHwM9RKQBcIiqfq2qCrwE/DWCWIwxiWjh\nQujVC044AaZPh9q14x2RKYFI6o+3Aqeo6mYAEamHq6E8X0S5Y4C1vvlMXA0jEqHKHuNNmSGWH0RE\nhuJqLtSvX585c+ZE+NZlKzs7O2FjA4svWhZfeDXXrCH1hhvIrVWL70aPZt/ixQdtY8cvOmUVXySJ\nJBPY4ZvfQcGTfDihrl1oJEEVUjbifarqM8AzAO3atdMzzzwzwrcuW3PmzCFRYwOLL1oWXxhr1sCg\nQe4hw88/57SmTUNuZscvOmUVXySJZB3uIcR3cSft3sA3InILgKo+HKZcJnCsb74hsD7CuDKBM4PK\nzvGWNyzhPo0xieC33+Ccc2DHDvj0UwiTREz5EcnF9hXAO+R/838XyALqeFM484FmItJERKoBA4Bp\nEcY1AzhXRA7zLrKfC8xQ1Sxgh4h08u7WGuzFY4wpD7Ztgx49YO1aeP99OPnkeEdkSkGRNRJV/XdJ\ndqyqOSJyPS4pJAHPq+pSERkDLFDVaSLSHngbOAz4i4j8W1VPUtUtIjIWl4wAxqjqFu/1tcAkoAbw\ngTcZYxLd7t3uwvrixe5239NPj3dEppQUmUhEpB2um5RG/u1VtXVRZVV1OkEPL6rqKN/r+RRsqvJv\n9zwhLuir6gKgZVHvbYxJIPv3Q//+8Pnn7jmR886Ld0SmFEVyjWQy7s6txRx8m64xxhQuL889bPi/\n/8GECTBgQLwjMqUskkSyUVUjvbZhjDFOVpZLGk2bwiuvwLhxMGxYvKMyMRBJIrlLRCYCs4C9gYWq\n+lbMojLGlH9jx7qmrM8+c2Ou3357vCMyMRJJIrkSOBGoSn7TlgKWSIwxB/MNTHXAww/Dk0/awFQV\nVCSJ5GRVbRXzSIwxFcNPP0HXrpCR4eZr1HA9+j74YHzjMjETyXMkc0N0tmiMMQfbts11+56RASLu\nyfW9e21gqgoukhrJGcDlIrISd41EAI3k9l9jTCWydi1ccAH8+CO0aQOdOsHQofDMMzYwVQUXSSKx\nbtqNMYX79lvo2RN27oQPPoCzz85fN358/OIyZSKSga1W4/rM6ua93hVJOWNMJfH++9C5sxuM6ssv\nCyYRUylEMh7JXcBIIHDvXlXglVgGZYwpJ5580nV78sc/wty50NI6naiMIqlZ9AF6ATsBVHU9hXfW\naIyp6PLy4NZb4brrXHcnn34KRx8d76hMnERyjWSfqqqIKICI1IpxTMaYRLZ7txtL5M03Yfhw+O9/\nbYz1Si6SGsnrIvI0cKiIXAPMBJ6NbVjGmIS0cSN06wZvvQUPPQRPPGFJxETUjfyDInIOsB34IzBK\nVT+OeWTGmMTy009w/vmwfj1MneoeMjSGyJq28BKHJQ9jKqvPPoO//tXVPmbPds+IGOMJ27QlIl94\nP3eIyHbftENEtpddiMaYuMjKgi5d3J1Z55wDRx3l7syyJGKCFFYjqQWgqnaHljGV0Zgx+b33du4M\nb78Nhx8e76hMAioskWgh64wxFVWo3ns/+wyOOcZ67zUhFZZIjhKRW8KtVNWHi9q5iPQA/osbs32i\nqt4btL468BLQFtgM9FfVVSIyEDcqY0BroI2qLhKROUADIPAXfa6q/lZULMaYCGRnu04Xx48H9b5L\n1qwJffpY770mrMISSRJQG9dJY7GJSBIwHjgHyATmi8g0VV3m2+xqYKuqNhWRAcB9uGQyGTfELyLS\nCnhXVRf5yg30xm43xpQGVXjtNfeQ4fr10Lw5/PILVK/uaifWe68pRGGJJEtVx0Sx7w5AuqpmAIhI\nGtAb8CeS3sBo7/VU4AkREVX1N6tdArwWRRzGmMJ8/z38/e/uekjbtu7W3gcecH1mWe+9JgJS8Jzt\nWyHynaqeUuIdi/QFeqjqEG9+ENBRVa/3bbPE2ybTm1/hbbPJt80KoLeqLvHm5wD1gFzgTeBuDfEh\nRGQoMBSgfv36bdPS0kr6UWIqOzub2rVrxzuMsCy+6CRyfMnbttHw6adpNGMG++vUYeU115DVowck\nJcU7tAMS+fhBxY+va9euC1W1XZEbqmrICTg83LpIJqAf7rpIYH4Q8HjQNkuBhr75FUA933xHYHFQ\nmWO8n3WAj4DBRcXStm1bTVSzZ8+OdwiFsviik5Dx5eSoPvmk6uGHa16VKqo33KC6ZUu8owopIY+f\nT0WPD1igEZzvwz5HoqpbSpTC8mXiup8PaAisD7eNiCQDdQH/+w4gqFlLVdd5P3cAr+Ka0IwxkQg0\nXw0fDq1bs+DZZ11fWYcdFu/ITDkWy3FF5gPNRKSJiFTDJYVpQdtMAy73XvcFPvGyICJSBVerOdAm\nJSLJInKE97oq0BNYEsPPYEz5FXig8NdfYd06GDjQPQ+yZQu8/jp88gk7jz8+3lGaCiBmva2pao6I\nXA/MwN0B9ryqLhWRMbjq0jTgOeBlEUnH1UQG+HbRGchU72K9pzoww0siSVgHksaEN3YsfPGF69pk\nyRLIyYF//QtGjoRa1om3KT0x7bZTVacD04OWjfK93oOrdYQqOwfoFLRsJ+6ZE2NMOMEPFM6b535W\nr+6eVjemlNmQucZUNBkZ0L17/nz16q5Za9WquIVkKjZLJMZUNFlZrodecElk/357oNDElCUSYyqS\nH35wPfUmJcFll7lmrWHD3AV3Y2LEhjYzpqJYtsw9jV6jBsyfD4E7ssaPj29cpsKzGokxFcHPP8NZ\nZ7mayCef5CcRY8qA1UiMKe9WrHDjqOfmwpw5rsNFY8qQJRJjyrPVq10S2bPHXWBv0SLeEZlKyBKJ\nMeVVZiZ07Qrbt7vmrFat4h2RqaQskRhTHmVluZrI5s0wcyacUuKOuo2JmiUSY8qbDRtcElm/Hj76\nCNq3j3dEppKzRGJMebJpk7vFd/Vq+PBDOO20eEdkjCUSY8qNLVvcw4bp6fDee64nX2MSgCUSY8qD\nbdtc/1nLlsG0ae6ZEWMShCUSYxLdjh3Qo4cbW/2ttwp2yGhMArBEYkyiysqCfv3cOCILFsAbb0DP\nnvGOypiDWCIxJlHddRd8+aV7nZYGffrENx5jwrC+toxJNDVqgAg86xv8c8AAt9yYBGSJxJhEsmhR\n/sOFIu5nzZpuYKqVK+MXlzGFiGkiEZEeIvKTiKSLyG0h1lcXkSne+nki0thb3lhEdovIIm96ylem\nrYgs9so8JhL4bzOmHPv1VxgyBNq0cT35nnGGSyQpKa4fLRuYyiSwmCUSEUkCxgPnAS2AS0QkuEe5\nq4GtqtoUeAS4z7duhaqmetMw3/IJwFCgmTf1iNVnMCbm9uyB//wHmjWDl16Cm2+GX36BI490A1LN\nnWsDU5mEF8uL7R2AdFXNABCRNKA3sMy3TW9gtPd6KvBEYTUMEWkAHKKqX3vzLwF/BT4o9eiNiSVV\neP11GDnSPaXeuzc88IBLKOBu8w2wgalMghNVjc2ORfoCPVR1iDc/COioqtf7tlnibZPpza8AOgK1\ngaXAz8B24E5V/VxE2gH3qurZ3vZ/Bkaq6kH3RIrIUFzNhfr167dNS0uLyeeMVnZ2NrVr1453GGFZ\nfNEJFV+d5ctpOn48dZcsIfuEE0gfPpzf27RJmPgSicUXnWjj69q160JVbVfkhqoakwnoB0z0zQ8C\nHg/aZinQ0De/AqgHVAfqecvaAmuBQ4D2wEzf9n8G/ldULG3bttVENXv27HiHUCiLLzoF4lu7VvWy\ny1RBtX591WefVc3JiVtsquXs+CWgih4fsEAjON/H8mJ7JnCsb74hsD7cNiKSDNQFtqjqXlXdDKCq\nC3EJprm3fcMi9mlMYsjKIvXGGyEjA0aPdiMXvvEG3H67uw4yZIgbGteYci6W10jmA81EpAmwDhgA\nXBq0zTTgcuBroC/wiaqqiByJSyi5InI87qJ6hqpuEZEdItIJmAcMBh6P4WcwpuTGjKHu4sXQujXs\n3AkXXwz33QeNG8c7MmNKVcwSiarmiMj1wAwgCXheVZeKyBhcdWka8BzwsoikA1twyQagMzBGRHKA\nXGCYqm7x1l0LTAJq4C6y24V2k1hq1HB3YwECLomA62xxypS4hWVMrMS0ixRVnQ5MD1o2yvd6D+5a\nSnC5N4E3w+xzAdCydCM1ppTk5sKtt8K4cZCX55bVrOm6N3nwwfjGZkyM2JPtxpSWpUvdQFNjx8Jx\nx4EIudWq2QOFpsKzThuNidb+/XD//TBmjEsYaWmuCev88/n2lFNo/913ridfYyooSyTGRGPRIrjy\nSvezf394/HH3VHr//gDsnDPH3Z1lTAVmTVvGlMTevTBqFLRv72obb73laiJHHhnvyIwpc1YjMaa4\nvvkGrrrKXRO5/HJ4+GE4/PB4R2VM3FiNxJhI7d4N//wnnHqqG0N9+nSYNMmSiKn0LJEYE05WFnTp\n4nre/eILOPlk17HikCGwZAmcd168IzQmIVjTljHhjB3rEsg557hmrEaNYOZMOOuseEdmTEKxRGJM\nMN+T6YCrfYCroVgSMeYg1rRljN/eva4mUqdO/rLq1d1Qt6tWxS0sYxKZ1UiMAXfx/Omn4dFHXc3j\niCMgO9slkX377Ml0YwphNRJTuWVlwW23uS5NRo6Ek06Cjz+GP/8Zrr3Whro1JgJWIzGV088/u04U\nX3wRcnKgb193a2/btm792Wfnb2tD3RpTKEskpnKZP9+NCfLWW1Ctmnuw8B//gKZN4x2ZMeWWNW2Z\niivwHEhWFsyYAd26QYcOMGuWG6Vw9WqYMMGSiDFRshqJqbj+/W/4/HNo1Qo2b4ajj3bNWUOHFrwr\nyxgTFUskpuIJfg5k82b3c8sW14xljClV1rRlKpYNG6BnT/daxP2sWdM9B7JyZfziMqYCi2kiEZEe\nIvKTiKSLyG0h1lcXkSne+nki0thbfo6ILBSRxd7Pbr4yc7x9LvKmo2L5GUw5kZPjxgJp3hzefRdO\nOcUlkpQUG6HQmBiLWSIRkSRgPHAe0AK4RERaBG12NbBVVZsCjwD3ecs3AX9R1VbA5cDLQeUGqmqq\nN/0Wq89gyomvv3bjgtxwA3TsCIsXQ+PG7vkPew7EmJiL5TWSDkC6qmYAiEga0BtY5tumNzDaez0V\neEJERFW/822zFEgRkeqqujeG8ZryZuNG/nj//fDBB3DMMfDGG3DRRa4m8tZb+dvZcyDGxJSoamx2\nLNIX6KGqQ7z5QUBHVb3et80Sb5tMb36Ft82moP0MU9Wzvfk5QD0gF3gTuFtDfAgRGQoMBahfv37b\ntLS0mHzOaGVnZ1O7du14hxFWQsaXm8vR771Hk4kTSdq9m8x+/Vg9eDC5NWrEO7KDJOTx87H4olPR\n4+vatetCVW1X5IaqGpMJ6AdM9M0PAh4P2mYp0NA3vwKo55s/yVt2gm/ZMd7POsBHwOCiYmnbtq0m\nqtmzZ8c7hEIlXHzffKParp0qqHbtqvMmTYp3RIVKuOMXxOKLTkWPD1igEZzvY3mxPRM41jffEFgf\nbhsRSQbqAlu8+YbA216iWBEooKrrvJ87gFdxTWimIvIPLLV5M/ztb+4ayLp18NprMGsWuxo1ineU\nxlR6sbxGMh9oJiJNgHXAAODSoG2m4S6mfw30BT5RVRWRQ4H3gdtV9cvAxl6yOVRVN4lIVaAnMDOG\nn8HEU2BgqQED3Jggv/8ON98Md93l7sIyxiSEmCUSVc0RkeuBGUAS8LyqLhWRMbjq0jTgOeBlEUnH\n1UQGeMWvB5oC/xKRf3nLzgV2AjO8JJKESyLPxuozmDgJfqDw00/dz2rV4KGH4hOTMSasmD7ZrqrT\ngelBy0b5Xu/BXUsJLnc3cHeY3bYtzRhNAtm6Fd5/341COGOGezYEXALp29eSiDEJyrpIMfG1erV7\ngPDdd13NIzcXGjSAZs1g+fL8gaXq1rUHCo1JUNZFiokd/8XyAFX47jsYPdo9fd64Mdx4o9vmn/+E\nefMgMxNOPNEGljKmnLAaiYmdwMXy0aOhX7/8mseaNe6hwdNPhwcegN69XQ3Ezx4oNKbcsERiSl/w\nxfKnn3YTQK9e7q6rnj3hKOsmzZiKwBKJKT3r18O0adCpk7veEehwICnJ1T5eeAGOPz6+MRpjSp0l\nElNyqrB0aX6T1fz5bvkJJ7jBpBYvzr9YftJJlkSMqaDsYrsJLyuL1MCF8ICcHFfbuOUWN0Rtq1Zw\n551QpQqMG+ceHPzlF5dM7GK5MZWC1UhMeGPHUnfxYpcozj/f1Tree8+NNFi9unveY+RI+Mtf3C27\nfnax3JhKwxKJOZjvYrkAPPecmwAGDXJ3WXXvDgnc66kxpuxYIjHOmjUwaxZ88ol7+M9/11VyMpx5\nprtY3rBh3EI0xiQmSyQVWVaW6/BwypSDnwr/7TeYPTs/eazwOlg+6ijo1s3dgfX55+RWrUpSTo57\nzsOSiDEmBEskFVnggcAxY+A//3EXyT/5xCWPJUvcNocc4mobN9zgEshJJ7mHBS+8EK69lm9POYX2\n333nkpIxxoRgiaQiCn4gcMIENwXWnXEGDBzoLpafcoprugrmXSzfOWcODBkS+5iNMeWWJZKKYNs2\n+PZb9xzH/PlQr54b/CmgShVX0xg9Gi64wN1xZYwxpcSeI0lkoTo93L0bvv4aHnvM3UF14olw6KGu\nWWrkSJdQzjgDTj3VNVGlpLhyZ5zhmqssiZhKYPJk1x9olSru5+TJlbN8t25dSlS+2CIZj7e8T+V2\nzPahQ1VFVLt0Ub3mGtXUVNXkZDdeOag2aKDaq5fq2LGqH36oumlTftk+fVSHD1ddtMj97NOn9ONL\nABZfdMLF98orqo0auT+/Ro3cfHGUXvm8Ypd/5RXVmjXz/03AzUe6j+KUD3X8yvL9Y1HejwjHbLem\nrVgq7K4pAFWqbtsG33wDGRluWrECJk2CvLz87T791E1VqsBtt0H79m465pjw720PBEZl8mS44w53\nV/Rxx7mH9gcOLEn5LlGWj/b9i19+8mQYOhR27XLzq1e7eYhsH6VbXg4qn5fnet0JN40Ykf/eAbt2\nuc4YgvsJDXQH55+/5ZbQ5W+6yV1OzMlxU24uLF3agGXL8udzcuCee0KXv+461+mDSOgJ3M/77w9f\nfskS9x779xf86X/93nuu4SK4/B13FO9vqDhEg49kBdSuXTtdsGBB2b/x8OGu19v+/eHyy/OTRSBh\nZGTAjh0Fy/zhD3DssbBxoxuXIyfHNU9deKEbITDCwZ1K70SkHHecJOyJcM6cOZx55pml+v7BJ0KA\nmjXhmWdKdiL1l+/f/+B//OD5d95xHST775dISXEdDFxwQf6Jp0qV0K/fe8999uDyY8e68nl5+dO8\neQto06ZdgWUXXggbNhz8uY44Ah58EPbuLTjt21dw/qWXYOfOg8unpMBpp+WfdIOnwPL09PzBMf0C\nnzM3t+jfQUVVtaqbkpPzf/pfV60KP/4YuqxIwe+nkRCRhararsjtYplIRKQH8F/c+OoTVfXeoPXV\ngZdww+duBvqr6ipv3e3A1UAucIOqzohkn6GUJJFMngx3jMxhzboqHNcwj3H3Jh98Etm3z9U6MjML\nTo89xuS8/tzBPazhOI5jDeP4PwbymrtGcfzxB6b0vDyadu/u5hs3hlq13Puf/Tx3zDqLNRzLcaxl\n3FmzGDjzqohjj9WJMJHK5+XBzJmfcvrpXQqckN94w42R5f9WFjgRd+8e/kQWmK6+2uXxYIceCn//\nu4tr9+7wPxcvDn0irMiqVXN/2tWrw6ZN4bc7/XR3wktKKjj5l73xRvjyd9zh3quwafjw0L+/+vVh\n6tT8b/8BwfPhEmmDBu7O+UCsycnwzTdf0bnzaQfmk5OhRQv3BSZYo0awcqW/wSl/gvzXzZvD2rWh\ny69aFf7YBDRu7GqBJS3vF/dEIiJJwM/AOUAmMB+4RFWX+bYZDrRW1WEiMgDoo6r9RaQF8BrQATga\nmAk094oVus9QiptIQp7Iqu7nmTMnM7DWu/kJY8OGg+vGtWoxudY1DP1tHLuomV++yh6e+Nev9L35\nOHK1Crm57kT4+edf0bHjaQfmc3PdN9I7/7mXPXn5F8ZTquxj5L+q0a1bwW+xoaZbboHNmw/+XHXr\nusdF/NXiwOSfnzbt4KoxuJNxly5FH79PPy34bTigenVo144CnzUw+edXrgz/jTQlJf9zxqsyXbOm\nu4va/9P/+n//C192zJiC3ySDv1kmJ7t7KEJ9NhHXYpmXl3/SCfX6sstCv7cIvPaa+1YfmJYuXUxq\naqsCywYNcs+rBmvQwD2WFEgY1avnn7z9J+NoT2TRli/LL0KhasTl5YtYJBIhkZwKjFbV7t787QCq\n+h/fNjO8bb4WkWTgV+BI4Db/toHtvGKF7jOU4iaSxrKa1TQ6aHkS+zm66iZyq1Qlr0oyuVKVXEki\nT5JcctAq5OXBnj0SYq+Jw18NDq4qV60KP/8cvmzHjkXvf9688Ou6dcv/5lmlSsFvpYH5tLTw5W+9\nteBJd82aDJo3P77AyXj48NBlRVySDP42HDz16hX6+ctjj3UnuOBvsMHifSItTvmKeiIsz02rpVu+\nZE3TAYmQSPoCPVR1iDc/COioqtf7tlnibZPpza8AOuKSxlxVfcVb/hzwgVes0H369j0UGApQv379\ntmmFnZ2CdOvWBdVQZwulR49fvfZoJSlJvW9x6k3udVrasXjdHR5UftiwDN/2yv79e6lRoxpVqihJ\nSW6/9957YtjyDz30PUlJWuh0442pbNqUclDpo47aQ1ra3CJPhAMGdGLDhoPL16/vyhelLMtnZ2dT\nO6jzyGjff+bMo3jwwT+yd2/SgWXVq+cyYsRPnH12iK/q5bh8qOMX2MfEicfz22/VOeqovQwZkhHR\neydK+bIS7vglimjj69q1a0SJJGa33AL9cNcwAvODgMeDtlkKNPTNrwDqAeOBy3zLnwMuimSfoabi\n3v7bqFGoVky3vLTLh7p9MNr3j/ftg+X99svAPuJ1+2rpvn/h5cvr7cmJoqLHR4S3/8YykZwKzPDN\n3w7cHrTNDOBU73UysAn3VbzAtoHtItlnqKm4ieSVV1RrJu0ueCJK2m0nwhKVj8+JMNr3Ly0V/UQT\naxZfdCpCIkkGMoAmQDXge+CkoG2uA57yXg8AXvden+RtX90rn4G7S6vIfYaaSvJAop0InYr+jxJr\nFl90LL7olFUiidkDiaqaIyLXe7WJJOB5VV0qImO84KbhmqxeFpF0YIuXTPC2ex1YBuQA16lqLkCo\nfcYi/oEDo3t4J97ljTGmrMT0yXZVnQ5MD1o2yvd6D+66R6iy44BxkezTGGNM/FinjcYYY6JiicQY\nY0xULJEYY4yJiiUSY4wxUakUvf+KyEYgRKcRCeEI3PMzicrii47FFx2LLzrRxtdIVY8saqNKkUgS\nmYgs0Ei6IIgTiy86Fl90LL7olFV81rRljDEmKpZIjDHGRMUSSfw9E+8AimDxRcfii47FF50yic+u\nkRhjjImK1UiMMcZExRKJMcaYqFgiiSEROVZEZovIjyKyVERu9JaPFpF1IrLIm873lbldRNJF5CcR\n6V4GMa4SkcVeHAu8ZYeLyMci8ov38zBvuYjIY158P4hImxjH9kffMVokIttF5KZ4Hz8ReV5EfvNG\n+AwsK/YxE5HLve1/EZHLYxzfAyKy3IvhbRE51FveWER2+47lU74ybb2/jXTvM5TKGNJh4iv271RE\nenjL0kXkttKIrZD4pvhiWyUii7zl8Th+4c4r8fsbjKSveZtKPCZLA6CN97oO8DPQAjeU8IgQ27eg\n4DgsK4CkGMe4CjgiaNn9wG3e69uA+7zX5+OGPBagEzCvDI9lEvAr0Cjexw/oDLQBlpT0mAGH48bW\nORw4zHt9WAzjOxdI9l7f54uvsX+7oP18gxtMTrzPcF4M4yvW79SbVgDHkz82UYtYxRe0/iFgVByP\nX7jzStz+Bq1GEkOqmqWq33qvdwA/AscUUqQ3kKaqe1V1JZAOdIh9pCHjeNF7/SLwV9/yl9SZCxwq\nIg3KKKazgBWqWlgPBWVy/FT1M9z4OcHvXZxj1h34WFW3qOpW4GOgR6ziU9WPVDXHm50LNCxsH16M\nh6jq1+rOOi/5PlOpx1eIcL/TDkC6qmao6j4gzds2pvF5tYqLgdcK20eMj1+480rc/gYtkZQREWkM\nnALM8xZd71Uznw9UQXF/DGt9xTIpPPGUBgU+EpGFIjLUW1ZfVbPA/dECR8UxvoABFPznTZTjF1Dc\nYxbPWK/CfUMNaCIi34nIpyLyZ2/ZMV5MZRlfcX6n8Tp+fwY2qOovvmVxO35B55W4/Q1aIikDIlIb\neBO4SVW3AxOAE4BUIAtXVQZX9QwW6/uzT1fVNsB5wHUi0rmQbeMRHyJSDegFvOEtSqTjV5RwMcXr\nWN6BG3V0srcoCzhOVU8BbgFeFZFD4hBfcX+n8fpdX0LBLzRxO34hzithNw0TS6nFaIkkxkSkKu6X\nPVlV3wJQ1Q2qmquqecCz5De/ZALH+oo3BNbHMj5VXe/9/A1424tlQ6DJyvv5W7zi85wHfKuqG7xY\nE+b4+RT3mJV5rN7F1J7AQK+5Ba/JaLP3eiHuukNzLz5/81dM4yvB7zQexy8ZuBCY4os7Lscv1HmF\nOP4NWiKJIa899TngR1V92Lfcf12hDxC4O2QaMEBEqotIE6AZ7oJdrOKrJSJ1Aq9xF2SXeHEE7uC4\nHHjXF99g7y6QTsC2QKrcjcMAAAMFSURBVFU6xgp8C0yU4xekuMdsBnCuiBzmNeOc6y2LCRHpAYwE\neqnqLt/yI0UkyXt9PO6YZXgx7hCRTt7f8WDfZ4pFfMX9nc4HmolIE6/GOsDbNpbOBpar6oEmq3gc\nv3DnFeL5N1gadxHYFPbuijNwVcUfgEXedD7wMrDYWz4NaOArcwfuW81PlNJdHoXEdzzubpfvgaXA\nHd7yesAs4Bfv5+HecgHGe/EtBtqVwTGsCWwG6vqWxfX44ZJaFrAf963u6pIcM9y1inRvujLG8aXj\n2sMDf4dPedte5P3uvwe+Bf7i20873Al9BfAEXk8YMYqv2L9T73/pZ2/dHbE8ft7yScCwoG3jcfzC\nnVfi9jdoXaQYY4yJijVtGWOMiYolEmOMMVGxRGKMMSYqlkiMMcZExRKJMcaYqFgiMaaUiEiuuB5g\nl4rI9yJyi4gU+j8mrvfYS8sqRmNiwRKJMaVnt6qmqupJwDm4e/vvKqJMY8ASiSnXLJEYEwPqupwZ\niuuIULyax+ci8q03neZtei/wZ68mc7OIpIjIC+LGsfhORLoCiMhJIvKNt90PItIsXp/NmGD2QKIx\npUREslW1dtCyrcCJwA4gT1X3eEngNVVtJyJn4sbh6Olt/w+gpapeKSInAh/h+m56AJirqpO9LkGS\nVHV32X06Y8JLjncAxlRwgR5WqwJPiEgqkItLDqGcATwOoKrLRWS1t+3XwB0i0hB4Swt2Y25MXFnT\nljEx4nXil4vrhfVmYANwMq4PpmrhioVaqKqv4rrS3w3MEJFupR6wMSVkicSYGBCRI4GngCfUtR/X\nBbLUdZM+CDdULLgmrzq+op8BA719NAeOA37yklKGqj6G69SwdZl8EGMiYE1bxpSeGiKyCNeMlYPr\n0TbQzfeTwJsi0g+YDez0lv8A5IjI97jeZZ8EnhKRxd4+rlDVvSLSH/j/9u7QBmAYBoBgvGemydol\nBR0g4KWiuw2MXrKB98w86/tdf36aCa4c2wFIrLYASIQEgERIAEiEBIBESABIhASAREgASF4pKYIx\nTzsMHQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x106c96e48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Generando la gráfica\n",
    "fig, ax = subplots()\n",
    "ax.plot(datos, tiempo_is, label=\"insert sort\", marker=\"*\",color=\"r\")\n",
    "ax.plot(datos, tiempo_qs, label=\"quick sort\", marker=\"o\",color=\"b\")\n",
    "ax.set_xlabel('Datos') \n",
    "ax.set_ylabel('Tiempo') \n",
    "ax.grid(True)\n",
    "ax.legend(loc=2); \n",
    "\n",
    "plt.title('Tiempo de ejecución [s] (insert vs. quick)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modelo RAM\n",
    "\n",
    "Cuando se realiza un análisis de complejidad utilzando el modelo RAM, se debe contabilizar las veces que se ejecuta una función o un ciclo, en lugar de medir el tiempo de ejecución."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "times = 0\n",
    "\n",
    "def insertionSort_graph(n_lista):\n",
    "    global times\n",
    "    for index in range(1,len(n_lista)):\n",
    "        times += 1\n",
    "        actual = n_lista[index]\n",
    "        posicion = index\n",
    "        while posicion>0 and n_lista[posicion-1]>actual:\n",
    "            times += 1\n",
    "            n_lista[posicion]=n_lista[posicion-1]\n",
    "            posicion = posicion-1           \n",
    "        n_lista[posicion]=actual\n",
    "    return n_lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "TAM = 101\n",
    "eje_x = list(range(1,TAM,1))\n",
    "eje_y = []\n",
    "lista_variable = []\n",
    "\n",
    "for num in eje_x:\n",
    "    lista_variable = random.sample(range(0, 1000), num)\n",
    "    times = 0\n",
    "    lista_variable = insertionSort_graph(lista_variable)\n",
    "    eje_y.append(times)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEWCAYAAABxMXBSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIkkYOIiISBIGDiIikoSBg4iIJPn/F0Qj8OL+hLUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10efec3c8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(facecolor='w', edgecolor='k')\n",
    "ax.plot(eje_x, eje_y, marker=\"o\",color=\"b\", linestyle='None')\n",
    "\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.grid(True)\n",
    "ax.legend([\"Insertion sort\"])\n",
    "\n",
    "plt.title('Insertion sort')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bibliografía"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1] *Design and analysis of algorithms*; Prabhakar Gupta y Manish Varshney; PHI Learning, 2012, segunda edición.<br>\n",
    "[2] *Introduction to Algorithms*, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest y Clifford Stein; The MIT Press; 2009, tercera edicion.<br>\n",
    "[3] *Problem Solving with Algorithms and Data Structures using Python*; Bradley N. Miller y David L. Ranum, Franklin, Beedle & Associates; 2011, segunda edition.<br>\n",
    "[4] https://docs.python.org/3/library/itertools.html#<br>\n",
    "[5] https://docs.python.org/3/library/itertools.html#itertools.product<br>\n",
    "[6] https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files<br>\n",
    "[7] https://docs.python.org/3.5/library/pickle.html"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}