{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial de Ruby "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Laura P. Cerón Martinez y Camilo A. Dajer Piñerez**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Universidad Nacional de Colombia**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lenguajes de programación 2017-II**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/logo.gif\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Introducción**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<div style=\"text-align: justify\">Ruby es un lenguaje interpretado, case sensitive y de código abierto, creado por Yukihiro Matsumoto. Es un lenguaje de alto nivel que permite la aplicación de los principios de la programación orientada a objetos de una manera intuitiva. Ruby es un lenguaje muy sencillo de implementar pero que posee un desarrollo complejo y completo, diseñado con un énfasis en las necesidades humanas por encima de las del computador.\n",
    "\n",
    "Toda su documentación puede ser encontrada  <a href=\"https://www.ruby-lang.org/es/\"> aquí </a> \n",
    "</div>\n",
    "\n",
    "Todo en Ruby es considerado un objeto, inclusive **nil**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instalación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: justify\">La instalación de Ruby se encuentra explicada detalladamente en el siguiente <a href=\"https://www.ruby-lang.org/es/documentation/installation/\"> enlace</a>. Solo se debe realizar la selección del sistema operativo que posee el usuario. En caso de ser Windows se recomienda usar el paquete de instalación *RubyInstaller*.  </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creación "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: justify\">Una vez realizado el proceso de instalación, todo se encuentra listo para poder empezar a programar en Ruby. Para esto crearemos un archivo con extensión ***.rb***, el proceso se realizara por el terminal usando el comando ***echo. 2>MyProgram.rb*** , el cual creara un archivo vacío en la carpeta donde se encuentra actualmente:</div> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"screen/creacion.PNG\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<div style=\"text-align: justify\">Ya que creamos el archivo, colocaremos el famoso *Hola Mundo!* para ver la correcta ejecución de Ruby, para esto abriremos nuestro archivo y colocaremos *puts 'Hola Mundo'*. De esta manera se realiza el proceso de impresion en el lenguaje.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejecución de un programa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: justify\">Para la ejecución de un archivo, se coloca el comando *ruby* y a continuación el nombre del archivo a ejecutar. Para este ejemplo se coloca ***ruby MyProgram.rb***.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<img src=\"screen/HolaMundo.PNG\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: justify\">Listo, ya que sabemos como crear archivos y ejecutarlos a través del terminal, podemos empezar a aprender el lenguaje.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Primeros pasos con Ruby"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comentarios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los comentarios en Ruby se realizan de dos maneras:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol>\n",
    "   <li>**Lineas**: Se hace mediante el caracter ***#***.</li>\n",
    "   <li>**Bloques**: El interprete ignora cualquier cosa comprendida entre **=begin** y **=end**.</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operados básicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol>\n",
    "   <li>**Aritmeticos**: +,-,/,*******,********,%</li>\n",
    "   <li>**Relacionales**: ==,!=,<,>,<=,>=</li>\n",
    "   <li>**Lógicos**: and, or, !</li>\n",
    "   <li>Ruby no posee operadores pre/post incremento/decremento</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "puts 2**(5%3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Impresión"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Ruby se poseen dos metodos para la impresión en consola.\n",
    "<ul>\n",
    "    <li>**puts**: Permite la impresión con un salto de linea.</li>\n",
    "    <li>**print**: Permite la impresión sin salto de linea.</li>\n",
    "<ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cadenas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ruby permite el manejo de Strings de manera sencilla, estas pueden estar entre comillas dobles ***\"Cadena\"*** o en comillas sencillas ***'Cadena'***. Sin embargo su uso es diferente:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las cadenas que se encuentren entre comillas dobles permiten *de la presencia embebida de caracteres de escape precedidos por un backslash y la expresión de evaluación #{ }*, por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lenguajes\n",
      "de\n",
      "programación\n"
     ]
    }
   ],
   "source": [
    "puts \"Lenguajes\\nde\\nprogramación\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "ejemplo\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "a = 'ejemplo'\n",
    "puts \"a\\n#{a}\\nb\\nc\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo si se declarara en comillas simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\\n#{a}\\nb\\nc\n"
     ]
    }
   ],
   "source": [
    "a = 'ejemplo'\n",
    "puts 'a\\n#{a}\\nb\\nc'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La concatenación en Ruby es muy sencilla, se realiza a través del operador **+**. Adicionalmente se puede concatenar una palabra consigo mismo una cantidad de veces determinada de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HolaMundoHolaMundoHolaMundoHolaMundoHolaMundo\n"
     ]
    }
   ],
   "source": [
    "puts 'HolaMundo' * 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extracción de caracteres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se realiza de la misma manera que en python, sin embargo si se poseen indices negativos empezara desde el final de la cadena."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "es\n"
     ]
    }
   ],
   "source": [
    "palabra = \"Lenguajes\"\n",
    "puts palabra[-2,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Debido a que todo en Ruby es tratado como un objeto, el casting se realizar mediante el llamado del objeto como veremos a continuación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String\n",
      "Fixnum\n"
     ]
    }
   ],
   "source": [
    "ejemplo1 = 1.to_s\n",
    "puts ejemplo1.class  #String\n",
    "ejemplo2 = \"10000\".to_i\n",
    "puts ejemplo2.class  #Numero => Fixnum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los tipos de casting son:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol>\n",
    "   <li>**to_i**: Nos permite hacer casting a un entero.</li>\n",
    "   <li>**to_f**: Nos permite hacer casting a un decimal.</li>\n",
    "   <li>**to_a**: Nos permite hacer casting a un arreglo, su uso es en rangos debido a que su uso en cadenas se hace mediante el método **split**.</li>\n",
    "   <li>**to_s**: Nos permite hacer casting a un cadena de caracteres.</li>\n",
    "   <li>**to_h**: Nos permite hacer casting de dos arreglos a un diccionario.</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{:llave1=>:llave2, \"valor1\"=>\"valor2\"}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[[:llave1, :llave2], [\"valor1\", \"valor2\"]].to_h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Colecciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas se pueden crear listando elementos entre corchetes y separando cada elemento por comas. Estas listas pueden almacenar objetos de distintas clases sin restricción."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La manera de concatenar listas es igual a como se realiza con cadenas, usando el operador **+**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para adicionar elementos a una lista se puede\n",
    "hacer uso de la función **.push** o haciendo uso del operador ***<<*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"Brasil\", \"Italia\", \"Egipto\", \"Turquia\"]\n",
      "[\"Brasil\", \"Italia\", \"Egipto\", \"Turquia\", \"Japon\"]\n"
     ]
    }
   ],
   "source": [
    "visitar = [\"Brasil\", \"Italia\", \"Egipto\" ]\n",
    "visitar.push(\"Turquia\")\n",
    "puts visitar\n",
    "visitar << \"Japon\"\n",
    "puts visitar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas se pueden convertir a y obtener de cadenas con los métodos **join** y **split** respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, \"4\", \"5\", \"6\"]\n"
     ]
    }
   ],
   "source": [
    "array_1 = [1,2,3]\n",
    "array_2 = \"456\"\n",
    "puts array_1 + array_2.split('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola mundo\n"
     ]
    }
   ],
   "source": [
    "array_3 = ['H','o','l','a']\n",
    "puts array_3.join + \" mundo\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El operador **map** nos permite recorrer cada elemento de la lista y realizar una operación en él, es parecido a un iterador pero eso lo estudiaremos mas adelante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "arreglo = [1, 2, 3]\n",
    "puts arreglo.map { |n| n * n } #=> [1, 4, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diccionarios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Ruby a los diccionarios se les denomina *hash*. Al igual que en Python, estan compuestos por llaves y valores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La manera de declarar un hash y acceder a un valor con su llave es la siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1=>\"Lunes\", \"6\"=>\"Sabado\", 7=>\"Sabado y Domingo\", 3=>\"Miercoles\"}\n"
     ]
    }
   ],
   "source": [
    "dict = {1 => \"Lunes\", \"6\" => \"Sabado\", 7 => \" \"}\n",
    "dict[7] = dict[\"6\"] + \" y Domingo\" \n",
    "dict[3] = \"Miercoles\"   # agregamos una nueva llave\n",
    "puts dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rangos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ruby permite implementar rangos de una manera muy sencilla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65]\n"
     ]
    }
   ],
   "source": [
    "range = (46..65).to_a\n",
    "puts range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si no se desea incluir el ultimo numero se deben colocar **...**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]\n"
     ]
    }
   ],
   "source": [
    "range = (46...65).to_a\n",
    "puts range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simbolos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los símbolos son el objeto mas básico de Ruby, estos son útiles por que dado un símbolo, se refiere al mismo objeto en todo el programa. Por esta razón son más eficientes que las cadenas: dos strings con el mismo nombre, son dos objetos distintos. Esto implica un ahorro de tiempo y memoria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40163604\n",
      "40162272\n",
      "2151764\n",
      "2151764\n"
     ]
    }
   ],
   "source": [
    "puts \"cadena\".object_id\n",
    "puts \"cadena\".object_id\n",
    "puts :cadena.object_id\n",
    "puts :cadena.object_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿Y el operador ! ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los métodos que terminan en **!** son aquellos que modificaran de manera definitiva al objeto, una manera sencilla de ver su comportamiento es el siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[4, 3, 2, 1]\n",
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "arreglo = [4,3,2,1]\n",
    "\n",
    "puts arreglo.sort\n",
    "puts arreglo #El arreglo no fue modificado e imprimira [4,3,2,1]\n",
    "puts arreglo.sort!\n",
    "puts arreglo #El arreglo fue modificado e imprimira [1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Estructuras de control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Su funcionamiento y declaración es la misma que la de python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No es ninguna de las anteriores\n"
     ]
    }
   ],
   "source": [
    "i = 30**(2%4)\n",
    "\n",
    "if i < 10\n",
    "    puts \"Es menor a 10\"\n",
    "elsif i == 20\n",
    "    puts \"Es 20\"\n",
    "else\n",
    "   puts \"No es ninguna de las anteriores\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La manera de implementar un **while** es muy similar a C, como se puede observar a continuación. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while( i < 3 )\n",
    "   puts i\n",
    "   i += 1\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo se poseen 4 palabras reservadas para hacer \n",
    "operaciones especiales en el bucle:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol>\n",
    "   <li>**break**: Interrupe la ejecución del while totalmente, similarmente como ocurre en C.</li>\n",
    "   <li>**next**: Permite terminar la ejecución del bucle actual pero continua con la verificación de la condición de la siguiente iteración.</li>\n",
    "   <li>**redo**: Permite reiniciar la iteración actual</li>\n",
    "   <li>**return**: Permite retornar un valor en el método que se encuentre actualmente, por lo cual interrupe la ejecución del ciclo y del método actual.</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "Iteracion # 25\n",
      "24\n",
      "Iteracion # 24\n",
      "Ejecute un next\n",
      "22\n",
      "Iteracion # 22\n",
      "21\n",
      "Iteracion # 21\n",
      "Ejecute un break\n"
     ]
    }
   ],
   "source": [
    "k = 26\n",
    "while( k > 10 )\n",
    "  if (k % 12 == 0)\n",
    "    k-=1\n",
    "    puts \"Ejecute un next\"\n",
    "    next\n",
    "  elsif (k% 7 == 0 )\n",
    "    k-= 1 \n",
    "    puts \"Ejecute un break\"\n",
    "    break\n",
    "  else \n",
    "    k-=1\n",
    "    puts k\n",
    "  end \n",
    "   puts \"Iteracion # \"+ k.to_s\n",
    "end  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tambien Ruby posee la estructura de control **until**, que funciona de manera similar a la negación de la condición del **while**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Case"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La sentencia **case** es usada para comprobar un valor, su funcionamiento es similar a un **switch** de Java. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 - 10, o puede ser 30\n"
     ]
    }
   ],
   "source": [
    "valor = 30\n",
    "case valor\n",
    "  when 30, (1..10)\n",
    "    puts \"1 - 10\" + \", o puede ser 30\"\n",
    "  when 11..20\n",
    "    puts \"11 - 20\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### For"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### En colecciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden recorrer colecciones de manera compacta y sencilla, ejecutandose una vez por cada de elemento de la colección:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola 2 soy el 5"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[\"Hola \", \"2 \", \"soy \", \"el \", \"5\"]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_string = [\"Hola \",\"2 \",\"soy \",\"el \",\"5\"]\n",
    "for r in random_string\n",
    "  print r\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### En rangos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De manera similar se puede realizar un **for** en un rango determinado de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "1\n",
      "0\n",
      "2\n",
      "1\n",
      "0\n",
      "2\n",
      "1\n",
      "0\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0..10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in (0..10)\n",
    "  puts (i*7 + i) % 3\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteradores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los iteradores nos permiten una accion repetidas veces, parecido a un ciclo, sin embargo su codificación es diferente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cadenas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las cadenas en Ruby tienen iteradores que puede ser útiles, entre los cuales encontramos:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### each_byte"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Permite iterar a través de cada letra de la cadena."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c\n",
      "a\n",
      "d\n",
      "e\n",
      "n\n",
      "a\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"cadena\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"cadena\".each_byte{|letra| puts letra.chr}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### each_line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Permite iterar a través de cada linea de la cadena."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esto\n",
      "es\n",
      "una\n",
      "frase"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"Esto\\nes\\nuna\\nfrase\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Esto\\nes\\nuna\\nfrase\".each_line{|linea| print linea}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### En colecciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### each"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funciona de manera similar al **for** para recorrer elementos de una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3,4].each do |f| \n",
    "  puts f\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### collect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40, 50]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3,4,5]\n",
    "b = a.collect{|x| 10*x}\n",
    "puts b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clone"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Este comando crea una copia nueva de un arreglo la cual sera guardada en un espacio de memoria diferente con lo cual se evita sobreescribir el arreglo original"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meses[\"Enero\", \"Febrero\", \"Marzo\"]\n",
      "Mismos meses[\"Enero\", \"Febrero\", \"Marzo\"]\n",
      "Otros meses[\"Enero\", \"Febrero\", \"Marzo\", \"Abril\"]\n"
     ]
    }
   ],
   "source": [
    "mes = [\"Enero\",\"Febrero\",\"Marzo\"]\n",
    "los_mismos_meses = mes \n",
    "otros_meses = mes.clone\n",
    "otros_meses.push(\"Abril\")\n",
    "puts \"Meses\" + mes.to_s\n",
    "puts \"Mismos meses\" + los_mismos_meses.to_s\n",
    "puts \"Otros meses\" + otros_meses.to_s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Orientado a objetos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ruby es un lenguaje orientado a objetos, como pudimos observar en las explicación anterior, todo en ruby es un objeto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Métodos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un método de un objeto en Ruby es muy sencillo de usar, solo se debe colocar la instancia de la clase con un **.** y el nombre del método del objeto a llamar, con sus respectivos parametros que deben ir en paréntesis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunos métodos predefinidos de los objetos en Ruby son:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol>\n",
    "   <li>**length**: Retorna el tamaño de la lista, tambien puede ser llamado sobre cadenas, donde retornara el número de caracteres.</li>\n",
    "   <li>**class**: Retorna la clase del objeto, este método esta sobrecargado</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La manera de definir un método es la siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def nombreDelMetodo\n",
    "  #Comandos\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, en caso de recibir paramétros estos deben ir entre paréntesis, separados por comas sin especificar el tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def nombreDelMetodo(a,b)\n",
    "  #Comandos\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sobrecarga de métodos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ruby **no permite una manera convencional de realizar polimorfismo**, para poder realizarlo se debe realizar de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modulo: 8 de la suma de 2 numeros: 1\n"
     ]
    }
   ],
   "source": [
    "def operaciones(*args) # * implica número variable de argumentos\n",
    "  num_args = args.size\n",
    "  if args.size > 4\n",
    "    puts 'ERROR: Numero excesivo de argumentos'\n",
    "  else\n",
    "    case num_args\n",
    "      when 2\n",
    "        puts \"Multiplique 2 numeros: \" + (args[0]*args[1]).to_s\n",
    "      when 3\n",
    "        puts \"Modulo: \"+ args[2].to_s + \" de la suma de 2 numeros: \" +((args[0]+args[1]) % args[2]).to_s\n",
    "      when 1\n",
    "        puts\"Solo entro el numero: \" + args[0].to_s\n",
    "      \n",
    "    end\n",
    "  end\n",
    "end\n",
    "\n",
    "operaciones(9,24,8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Método **defined**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este método nos permite saber si una variable a sido declarado y en dado nos devuelve una descripción de la variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "local-variable\n",
      "constant\n"
     ]
    }
   ],
   "source": [
    "var1 = 1\n",
    "@var2 = 1\n",
    "$var3 = 1\n",
    "Var4 = 1\n",
    "puts defined? var1\n",
    "puts defined? Var4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Clases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las clases en Ruby son muy fáciles de declarar, su estructura es muy similar a la de Python, por lo cual nos permite declarar atributos y metodos a una clase de manera intuitiva e interactuar con ellos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La estructura de una clase en Ruby es la siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola! mi nombre es Colombia y me encuentro en América\n",
      "En Colombia se habla Español \n"
     ]
    }
   ],
   "source": [
    "# Definimos la clase Persona\n",
    "class Pais \n",
    " \n",
    "  # Constructor de la clase\n",
    "  def initialize(nombre,continente,idioma)  \n",
    "    # atributos   \n",
    "    @nombre = nombre \n",
    "    @continente = continente\n",
    "    @idioma = idioma\n",
    "  end  \n",
    " \n",
    "  # método saludar\n",
    "  def ubicacion\n",
    "    puts \"Hola! mi nombre es #{@nombre} y me encuentro en #{@continente}\"   \n",
    "  end\n",
    "  def lenguaje\n",
    "    puts \"En #{@nombre} se habla #{ @idioma} \"\n",
    "  end\n",
    " \n",
    "end \n",
    "\n",
    "colombia = Pais.new(\"Colombia\",\"América\", \"Español\")\n",
    "colombia.ubicacion\n",
    "colombia.lenguaje"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las variables definidas con @ son consideradas como los atributos de la clases y estos pueden accedidos desde cualquier método de la clase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Herencia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para poder implementar herencia en nuestro código solo debemos hacer uso del caracter **<** en la definición de la clase, de esta manera *extenderemos* de la clase declarada a la derecha del operador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Los aviones volamos\n"
     ]
    }
   ],
   "source": [
    "class Vehiculo\n",
    "  def transportar\n",
    "    puts \"Me movilizo\"\n",
    "  end\n",
    "end\n",
    "\n",
    "class Avion<Vehiculo\n",
    "  def volar\n",
    "    puts \"Los aviones volamos\"\n",
    "  end\n",
    "  def aterrizar \n",
    "    puts \"Los aviones aterrizamos\"\n",
    "  end\n",
    "end\n",
    "\n",
    "Avion.new.volar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo hay casos en los que una subclase no deberia heredar el comportamiento de la clase padre por lo que es posible reescribir el método en la subclase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tengo 22 neumaticos\n"
     ]
    }
   ],
   "source": [
    "class VehiculoTerrestre\n",
    "  def neumaticos\n",
    "    puts \"Tengo 4 neumaticos\"\n",
    "  end\n",
    "end\n",
    "\n",
    "class Tractomula<VehiculoTerrestre\n",
    "  def neumaticos\n",
    "    puts \"Tengo 22 neumaticos\"\n",
    "  end\n",
    "end\n",
    "Tractomula.new.neumaticos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ruby permite hacer uso de la palabra reservada **super**, que permite ejecutar el código del método definido en el padre y adicionalmente ejecutar el método definido en la subclase. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encapsulamiento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ruby nos permite aplicar encapsulamiento a métodos de nuestra clase declarando la palabra **private** y el nombre de la clase como simbolo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n"
     ]
    }
   ],
   "source": [
    "class Cuenta\n",
    "  \n",
    "  def initialize(ahorro,clave)\n",
    "    @ahorro = ahorro\n",
    "    @clave = clave\n",
    "  end\n",
    "  \n",
    "  \n",
    "  def balance(clave)\n",
    "    if clave == @clave\n",
    "      return getAhorro\n",
    "    else\n",
    "      return \"No autorizado\"\n",
    "    end\n",
    "  end\n",
    "  \n",
    "  \n",
    "  def getAhorro\n",
    "    return @ahorro\n",
    "  end\n",
    "  \n",
    "  private :getAhorro\n",
    "end\n",
    "a = Cuenta.new(1000,1234)\n",
    "puts a.balance(1234)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Métodos singleton"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunas veces es necesario modificar el comportamiento de un método de algun objeto en particular, lo que nos implicaria tener que crear una nueva clase para ese objeto. Ruby nos permite modificar el comportamiento de los objetos de manera individual."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Regular\n",
      "Regular\n",
      "Regular\n",
      "PEAMA\n"
     ]
    }
   ],
   "source": [
    "class Estudiante\n",
    "  \n",
    "  def admision\n",
    "    #Operaciones\n",
    "    return \"Regular\"\n",
    "  end\n",
    "  \n",
    "end\n",
    "\n",
    "estudiante_1 = Estudiante.new\n",
    "estudiante_2 = Estudiante.new\n",
    "estudiante_3 = Estudiante.new\n",
    "estudiante_4 = Estudiante.new\n",
    "\n",
    "def estudiante_4.admision\n",
    "  #Nuevas operaciones\n",
    "  return \"PEAMA\"\n",
    "end\n",
    "puts estudiante_1.admision\n",
    "puts estudiante_2.admision\n",
    "puts estudiante_3.admision\n",
    "puts estudiante_4.admision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos de variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ruby distintas clases de variables, las cuales se especifican de la siguiente manera:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol>\n",
    "   <li>**$*nombre***: Variable global, puede ser accedida desde cualquier parte del código</li>\n",
    "   <li>**@*nombre***: Variable de instancia</li>\n",
    "   <li>[a-z]+[a-zA-Z0-9]*: Variable local</li>\n",
    "   <li>[A-Z]+[a-zA-Z0-9]*: Constante</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Accesores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Ruby no se permite el acceso a los atributos de una instanacia  de manera directa como lo permite Java, este proceso se debe realizar mediante métodos definidos en la clase. Sin embargo Ruby no permite definir un método para acoplarnos a esa sintaxis: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20000\n"
     ]
    }
   ],
   "source": [
    "class Factura\n",
    "  \n",
    "  def initialize(valor)\n",
    "    @valor = valor\n",
    "  end\n",
    "  \n",
    "  def valor=(valor)\n",
    "    @valor = valor\n",
    "  end\n",
    "  \n",
    "  def valor\n",
    "    return @valor\n",
    "  end\n",
    "  \n",
    "end \n",
    "\n",
    "f1 = Factura.new(10000)\n",
    "#Modificación del atributo valor\n",
    "f1.valor = 20000\n",
    "puts f1.valor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo Ruby sabe que esto lo hacen la mayoria de programadores, para no tener que repitir los getters y setters por cada atributo podemos hacer lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30000\n"
     ]
    }
   ],
   "source": [
    "class Factura\n",
    "  \n",
    "  attr_accessor :valor #, mas atributos \n",
    "\n",
    "  \n",
    "  def initialize(valor)\n",
    "    @valor = valor\n",
    "  end\n",
    "  \n",
    "  \n",
    "end \n",
    "\n",
    "f2 = Factura.new(10000)\n",
    "#Modificación del atributo valor\n",
    "f2.valor = 30000\n",
    "puts f2.valor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### OpenStruct"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es una estructura de datos muy interesante, permite a su instancia la declaracion arbitraria de atributos. Su uso es parecido a un *hash*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre\n",
      "50\n",
      "\n"
     ]
    }
   ],
   "source": [
    "require \"ostruct\"\n",
    "\n",
    "person = OpenStruct.new\n",
    "person.name = \"Nombre\"\n",
    "person.age  = 50\n",
    "\n",
    "puts person.name      # => \"John Smith\"\n",
    "puts person.age       # => 70\n",
    "puts person.address   # => nil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplo del uso de clases en Ruby"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre: Producto1\n",
      "Caracteristicas:\n",
      "\tGrande\n",
      "\tPesado\n",
      "\tElegante\n",
      "Valor: $2000\n",
      "Fabricante: X"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"Valor: $2000\\nFabricante: X\""
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Producto\n",
    "  attr_accessor :nombre\n",
    "  attr_accessor :caract\n",
    "  attr_accessor :valor\n",
    "  attr_accessor :fabricante\n",
    "  \n",
    "  def initialize(nombre,caract,valor, fabricante)\n",
    "    @nombre= nombre\n",
    "    @caract = caract \n",
    "    @valor = valor\n",
    "    @fabricante = fabricante \n",
    "  end\n",
    "  \n",
    "  def descripcion \n",
    "    print \"Nombre: #{@nombre}\"\n",
    "    print \"\\nCaracteristicas:\\n\"\n",
    "    @caract.each do |c|\n",
    "      puts \"\\t\" + c.to_s\n",
    "    end \n",
    "    \"Valor: $#{@valor}\\nFabricante: #{@fabricante}\"\n",
    "    .each_line{|l| print l}\n",
    "  end  \n",
    "end\n",
    "p = Producto.new(\"Producto1\",[\"Grande\",\"Pesado\",\"Elegante\"],2000,\"X\")\n",
    "\n",
    "p.descripcion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre: Portátil ASUS ROGGL552 i5 15\n",
      "Caracteristicas:\n",
      "\tProcesador: Intel® Core i5\n",
      "\tSistema Operativo:Windows 10\n",
      "\tMemoria: 8GB\n",
      "\tDisco Duro: 1TB\n",
      "\tPantalla: 15.6\n",
      "Valor: $2899000\n",
      "Fabricante: ASUS\n",
      "Garantia: 1 año"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"Valor: $2899000\\nFabricante: ASUS\\nGarantia: 1 año\""
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Electrodomestico<Producto\n",
    "  attr_accessor :garantia \n",
    "  \n",
    "  def initialize(nombre,caract,valor,fabricante,garantia)\n",
    "    super(nombre,caract,valor,fabricante)\n",
    "    @garantia = garantia\n",
    "  end\n",
    "  \n",
    "  def descripcion\n",
    "    print \"Nombre: #{@nombre}\"\n",
    "    print \"\\nCaracteristicas:\\n\"\n",
    "    @caract.each do |c|\n",
    "      puts \"\\t\" + c.to_s\n",
    "    end \n",
    "    \"Valor: $#{@valor}\\nFabricante: #{@fabricante}\\nGarantia: #{@garantia}\"\n",
    "    .each_line{|l| print l}   \n",
    "  end  \n",
    "end\n",
    "e = Electrodomestico.new(\"Portátil ASUS ROGGL552 i5 15\",\n",
    "  [\"Procesador: Intel® Core i5\",\"Sistema Operativo:Windows 10\",\"Memoria: 8GB\",\"Disco Duro: 1TB\",\"Pantalla: 15.6\"],\n",
    "  2899000,\"ASUS\",\"1 año\")\n",
    "\n",
    "e.descripcion\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7000.0\n"
     ]
    }
   ],
   "source": [
    "class Pago \n",
    "    \n",
    "  def pagar(*args)\n",
    "    num_args = args.size\n",
    "    if args.size == 0\n",
    "      puts 'ERROR: FALTAN PRODUCTOS '\n",
    "    elsif num_args == 1\n",
    "      return args[0].valor\n",
    "    elsif num_args >1 and num_args <4\n",
    "      b = 0 \n",
    "      args.each do |a| \n",
    "        b+= a.valor\n",
    "      end  \n",
    "      return b * 0.70\n",
    "    else\n",
    "      b = 0\n",
    "      args.each do |a|\n",
    "        b+= a.valor\n",
    "      end  \n",
    "      return b * 0.50\n",
    "    end\n",
    "  end     \n",
    "end\n",
    "\n",
    "p = Producto.new(\"Producto1\",[\"Grande\",\"Pesado\",\"Elegante\"],2000,\"X\")\n",
    "p1 = Producto.new(\"Producto2\",[\"Grande\",\"Pesado\",\"Elegante\"],3000,\"X\")\n",
    "p2 = Producto.new(\"Producto3\",[\"Grande\",\"Pesado\",\"Elegante\"],4000,\"X\")\n",
    "p3= Producto.new(\"Producto4\",[\"Grande\",\"Pesado\",\"Elegante\"],5000,\"X\")\n",
    "\n",
    "checkout = Pago.new\n",
    "puts checkout.descuento(p1,p2,p3,p)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cibergrafia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol>\n",
    "  <li>http://www.ubiqum.com/blog/las-mejores-aplicaciones-hechas-con-ruby-on-rails/</li>\n",
    "  <li>https://skillcrush.com/2015/02/02/37-rails-sites/</li>\n",
    "  <li>https://builtwith.com/github.com</li>\n",
    "  <li>https://www.tutorialspoint.com/ruby/ruby_iterators.htm</li>\n",
    "  <li>http://rubytutorial.wikidot.com/clases-modificar</li>\n",
    "  <li>http://rubytutorial.wikidot.com/simbolos</li>\n",
    "  <li>https://www.uco.es/aulasoftwarelibre/wiki/images/3/35/Curso_ruby_i.pdf</li>\n",
    "  <li>https://www.ruby-lang.org/es/</li>\n",
    "  <li>https://codesolt.com/rails/poo-ruby/</li>\n",
    "  <li>http://ruby-doc.org/core-2.4.1/String.html</li>\n",
    "  <li>http://stackoverflow.com/questions/525957/using-tuples-in-ruby</li>\n",
    "  <li>http://www.rubyist.net/~slagell/ruby/</li>\n",
    "  <li>https://www.howtogeek.com/howto/programming/ruby/ruby-if-else-if-command-syntax/#</li>\n",
    "</ol>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 2.4.1",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "2.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}