diff --git a/ejercicio2.ipynb b/ejercicio2.ipynb
index 1b2b3d2ded35035711fabcbbe9662fe2ebf00d66..1c5d45a7e35a140eff7aafe00acedd98431e3471 100644
--- a/ejercicio2.ipynb
+++ b/ejercicio2.ipynb
@@ -44,7 +44,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -52,7 +52,7 @@
     "    \"\"\"\n",
     "    Esta función recibe un argumento de tipo entero\n",
     "    \n",
-    "    Retorna una lista con los numeros de la fila n del triangulo de Pascal\n",
+    "    Retorna una lista con los numeros tipo int de la fila n del triangulo de Pascal \n",
     "   \"\"\"\n",
     "    lista=[]\n",
     "    \n",
@@ -78,12 +78,22 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Falta explicacion"
+    "La función `triangulo_pascal(n)` recibe una variable de tipo _string_ y comprueba que sea de caracter numerico usando el metodo `.isdecimal()`. Se escogio este metodo pues retorna `True` cuando los caracteres de `n` \"representan\" un numero entero; y retorna `False` cuando los caracteres \"representan\" un numero decimal o un numero complejo.\n",
+    "\n",
+    "Si la parte anterior de la funcion comprueba que `n` \"representa\" un entero, este se convierte a una variable de tipo _entero_ usando la funcion `int` de Python. Se invoca la función `corazon_pascal` y se devuelve el resultado de esta.\n",
+    "\n",
+    "En caso contrario, se imprime en pantalla un mensaje que le indica al usuario que el numero que ingresó **NO** es de tipo _entero_.\n",
+    "\n",
+    "La linea final: \n",
+    "```python\n",
+    "return \"\"\n",
+    "```\n",
+    "se coloco para evitar que se imprima `None` en pantalla cuando se llama a esta función."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -100,7 +110,7 @@
     "    if es_entero:\n",
     "        return corazon_pascal(int(n))\n",
     "    else:\n",
-    "        print(\"\"\"El numero introducido NO es un numero entero, \n",
+    "        return print(\"\"\"El numero introducido NO es un numero entero, \n",
     "        por favor introduzca un numero ENTERO\"\"\")\n",
     "    \n",
     "    return \"\"        "
@@ -108,7 +118,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -116,10 +126,10 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "Introduzca un numero entero mayor que cero,\n",
+      "Introduzca un numero entero mayor que cero;\n",
       "se retornará la fila n del triangulo de Pascal\n",
       "\n",
-      " 3\n"
+      " 8\n"
      ]
     },
     {
@@ -127,34 +137,50 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "[1, 2, 1]\n"
+      "[1, 7, 21, 35, 35, 21, 7, 1]\n"
      ]
     }
    ],
    "source": [
     "numero_usuario=input(\"\"\"\n",
-    "Introduzca un numero entero mayor que cero,\n",
+    "Introduzca un numero entero mayor que cero;\n",
     "se retornará la fila n del triangulo de Pascal\n",
     "\n",
     "\"\"\")\n",
     "print(\"\")\n",
-    "print(triangulo_pascal(numero_usuario))\n"
+    "print(triangulo_pascal(numero_usuario))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## La segunda parte del ejercicio lo lamé Triangulo de Pascal modificado, y consiste en...\n",
+    "\n",
+    "Modifique la rutina anterior para que reciba un número variable de argumentos: n1, n2, n3,... y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila n1 del triángulo de Pascal, el segundo elemento una lista con los números en la fila n2, y así sucesivamente.\n",
+    "___"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# --> Falta explicacion\n",
+    "Para trabajar este problema, empezamos solicitando al usuario una secuencia de numeros separados por comas; para ello usamos la función `input()`. Esta secuencia queda guardada en una variable de tipo _string_ que llamamos `varios_numeros`.\n",
     "\n",
-    "## Triangulo de Pascal modificado\n",
+    "Usando el metodo `varios_numeros.split(\",\")`, Python divide el contenido de la variable `varios_numeros` donde encuentra una coma. Cada una de estas \"palabras\" las guarda en una lista. En nuestro caso llamamos a esta lista `lista_de_numeros_string`.\n",
     "\n",
-    "Modifique la rutina anterior para que reciba un número variable de argumentos: n1, n2, n3,... y retorne una lista cuyo primer elemento es una lista conteniendo los números en la fila n1 del triángulo de Pascal, el segundo elemento una lista con los números en la fila n2, y así sucesivamente."
+    "Finalmente, se crea una lista llamada `filas_del_tri_pascal` cuyos elementos serán las filas del triangulo de Pascal que el usuario solicitó. Para ello usamos _list comprehension_ llamando a la función `triangulo_pascal(n)` para cada elemento de la lista `lista_de_numeros_string`.\n",
+    "\n",
+    "Es importante mencionar que la función `triangulo_pascal(n)` recibe como argumento una variable de tipo _string_.\n",
+    "\n",
+    "Usando un ciclo `for` imprimimos el contenido de la lista `filas_del_tri_pascal` de manera comprensible."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 79,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -166,7 +192,7 @@
       "e.g. n1,n2,n3\n",
       "Se retornará una lista que contiene las filas n1,n2 y n3 del\n",
       "triangulo de Pascal\n",
-      " 2,4,6\n"
+      " 10,20,33\n"
      ]
     },
     {
@@ -176,9 +202,9 @@
       "\n",
       "\n",
       "[\n",
-      "[1, 1]\n",
-      "[1, 3, 3, 1]\n",
-      "[1, 5, 10, 10, 5, 1]\n",
+      "[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]\n",
+      "[1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1]\n",
+      "[1, 32, 496, 4960, 35960, 201376, 906192, 3365856, 10518300, 28048800, 64512240, 129024480, 225792840, 347373600, 471435600, 565722720, 601080390, 565722720, 471435600, 347373600, 225792840, 129024480, 64512240, 28048800, 10518300, 3365856, 906192, 201376, 35960, 4960, 496, 32, 1]\n",
       "]\n"
      ]
     }
@@ -193,40 +219,150 @@
     "\n",
     "lista_de_numeros_string=varios_numeros.split(\",\")\n",
     "\n",
-    "# lista_de_numeros_int=[int(x) for x in lista_de_numeros_string]\n",
-    "\n",
-    "# print(lista_con_numeros_int)\n",
-    "\n",
-    "# Comprobamos que los numeros en la lista lista_con_numeros_int sean de tipo int\n",
-    "#for i in lista_con_numeros_int:\n",
-    "#    print(type(i))\n",
-    "\n",
     "filas_del_tri_pascal=[triangulo_pascal(h) for h in lista_de_numeros_string]\n",
     "print(\"\")\n",
     "print(\"\")\n",
     "print(\"[\")\n",
     "for s in filas_del_tri_pascal:\n",
     "    print(s)\n",
-    "print(\"]\")    \n",
-    "      \n"
+    "print(\"]\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "Bibliografia utilizada:\n",
+    "\n",
+    "+ https://stackoverflow.com/questions/44891070/whats-the-difference-between-str-isdigit-isnumeric-and-isdecimal-in-python\n",
+    "\n",
+    "+ https://www.w3schools.com/python/ref_string_split.asp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A continuacion hice una pequeña prueba.\n",
+    "\n",
+    "Quise ver como se comportan las filas del triangulo de Pascal si consideraramos cada una de sus filas como un numero.\n",
+    "\n",
+    "Es decir, como se vería la grafica de una función $f(n)$ que cumple\n",
+    "\n",
+    "$$\n",
+    "f(1)=1\\\\\n",
+    "f(2)=11\\\\\n",
+    "f(3)=121\\\\\n",
+    "f(4)=1331\\\\\n",
+    "f(5)=14641\\\\\n",
+    "f(6)=15101051\\\\\n",
+    ".\\\\\n",
+    ".\\\\\n",
+    ".\n",
+    "$$"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "# Prueba\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "121\n",
+      "<class 'int'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "def cachipai(l):\n",
+    "    \"\"\"\n",
+    "    Esta funcion recibe una lista con los numeros de una fila del triangulo de Pascal\n",
+    "    \n",
+    "    Retorna el numero (tipo int) que se construiría si pegaramos todos los elementos de la lista.\n",
+    "    \n",
+    "    Ejemplo: cachipai([1,2,1])          retorna 121.\n",
+    "             cachipai([1,5,10,10,5,1])  retorna 15101051\n",
+    "    \"\"\"\n",
+    "    aux=\"\"\n",
+    "    for f in l:\n",
+    "        aux=aux+str(f)\n",
+    "    return int(aux)    \n",
+    "\n",
+    "\n",
+    "prueba=cachipai([1,2,1])\n",
+    "print(prueba)\n",
+    "print(type(prueba))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "range(1, 5)\n",
+      "[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]]\n",
+      "\n",
+      "[1, 11, 121, 1331]\n"
+     ]
+    }
+   ],
    "source": [
-    "Bibliografia utilizada:\n",
+    "x=range(1,5)\n",
     "\n",
-    "+ https://stackoverflow.com/questions/44891070/whats-the-difference-between-str-isdigit-isnumeric-and-isdecimal-in-python\n",
+    "print(x)\n",
     "\n",
-    "+ https://www.w3schools.com/python/ref_string_split.asp"
+    "prueba=[triangulo_pascal(str(i)) for i in x]\n",
+    "\n",
+    "print(prueba)\n",
+    "\n",
+    "y=[cachipai(j) for j in prueba]\n",
+    "\n",
+    "print(\"\")\n",
+    "print(y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plt.plot(x,y,\"b-*\")\n",
+    "#plt.show()\n",
+    "plt.loglog(x,y)\n",
+    "plt.show()"
    ]
   },
   {