{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "16ae3669",
   "metadata": {},
   "source": [
    "1. Hacer un programa en Python que resuelva la siguiente expresión aritmética\n",
    "del área de un Triángulo, donde el usuario ingresa la base y la altura."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "094fdbdc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El área del triángulo es: 1.5\n"
     ]
    }
   ],
   "source": [
    "def getTriangleArea(base, height):\n",
    "    area = (base * height) / 2\n",
    "    return area\n",
    "\n",
    "base = float(input(\"Ingrese la base del triángulo: \"))\n",
    "height = float(input(\"Ingrese la altura del triángulo: \"))\n",
    "\n",
    "area = getTriangleArea(base, height)\n",
    "\n",
    "print(\"El área del triángulo es:\", area)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d84a2e61",
   "metadata": {},
   "source": [
    "2. Hacer un programa en Python que resuelva la siguiente ecuación de 2o grado.\n",
    "El usuario ingresa los valores de a, b y c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7aca06e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hay dos soluciones reales: -1.4379807976820196 y -9.56201920231798\n"
     ]
    }
   ],
   "source": [
    "def getSecondGradeEcuationSolver(a, b, c):\n",
    "    discriminant = b**2 - 4*a*c\n",
    "    \n",
    "    if discriminant < 0:\n",
    "        return \"No hay soluciones reales\"\n",
    "    elif discriminant == 0:\n",
    "        solution = -b / (2*a)\n",
    "        return f\"Hay una solución real: {solution}\"\n",
    "    else:\n",
    "        solution1 = (-b + discriminant**0.5) / (2*a)\n",
    "        solution2 = (-b - discriminant**0.5) / (2*a)\n",
    "        return f\"Hay dos soluciones reales: {solution1} y {solution2}\"\n",
    "\n",
    "a = float(input(\"Ingrese el coeficiente a: \"))\n",
    "b = float(input(\"Ingrese el coeficiente b: \"))\n",
    "c = float(input(\"Ingrese el coeficiente c: \"))\n",
    "\n",
    "\n",
    "result = getSecondGradeEcuationSolver(a, b, c)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "227a94c7",
   "metadata": {},
   "source": [
    "3. Hacer un programa en Python que calcule el salario semanal de un obrero,\n",
    "según los siguientes criterios:\n",
    "○ Si trabajó 40 horas o menos, sele paga $16 por hora.\n",
    "○ Si trabajó más de 40 horas, se le paga $16 por las primeras 40 horas, y $20\n",
    "por cada hora extra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5cb648c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El salario semanal es: 660.0\n"
     ]
    }
   ],
   "source": [
    "def getWeeklySalary(hoursWorked):\n",
    "    baseRate = 16\n",
    "    overtimeRate = 20\n",
    "\n",
    "    if hoursWorked < 0:\n",
    "        return \"El número de horas trabajadas no puede ser negativo.\"\n",
    "\n",
    "    if hoursWorked <= 40:\n",
    "        salary = hoursWorked * baseRate\n",
    "    else:\n",
    "        overtimeHours = hoursWorked - 40\n",
    "        salary = (40 * baseRate) + (overtimeHours * overtimeRate)\n",
    "\n",
    "    return salary\n",
    "\n",
    "\n",
    "hoursWorked = float(input(\"Ingrese el número de horas trabajadas: \"))\n",
    "\n",
    "weeklySalary = getWeeklySalary(hoursWorked)\n",
    "\n",
    "print(\"El salario semanal es:\", weeklySalary)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a680fec4",
   "metadata": {},
   "source": [
    "4. Hacer un programa en Python que clasifique el tipo de triángulo a partir de sus\n",
    "lados ingresados:\n",
    "Triángulo Medidas de los lados\n",
    "Equilátero Los 3 son iguales\n",
    "Isósceles Tiene 2 lagos iguales y un lado distinto\n",
    "Escaleno Los 3 lados son distintos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "45fd184f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El triángulo es: Escaleno\n"
     ]
    }
   ],
   "source": [
    "def getTriangleClassification(side1, side2, side3):\n",
    "    if side1 == side2 == side3:\n",
    "        return \"Equilátero\"\n",
    "    elif side1 == side2 or side1 == side3 or side2 == side3:\n",
    "        return \"Isósceles\"\n",
    "    else:\n",
    "        return \"Escaleno\"\n",
    "\n",
    "side1 = float(input(\"Ingrese el primer lado del triángulo: \"))\n",
    "side2 = float(input(\"Ingrese el segundo lado del triángulo: \"))\n",
    "side3 = float(input(\"Ingrese el tercer lado del triángulo: \"))\n",
    "\n",
    "classification = getTriangleClassification(side1, side2, side3)\n",
    "\n",
    "print(\"El triángulo es:\", classification)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc8905b0",
   "metadata": {},
   "source": [
    "5. Hacer un programa en Python que calcule el Índice de Masa Corporal de una\n",
    "persona (IMC = peso[kg] / altura\n",
    "2\n",
    "[m]) e indique el estado en el que se encuentra\n",
    "esa persona en función del valor de IMC.\n",
    "Valor de IMC Diagnóstico\n",
    "< 16 Criterio de ingreso en hospital\n",
    "de 16 a 17 Infrapeso\n",
    "de 17 a 18 Bajo peso\n",
    "de 18 a 25 peso normal (saludable)\n",
    "de 25 a 30 Sobrepeso (obesidad de grado I)\n",
    "de 30 a 35 Sobrepeso crónico (obesidad de grado II)\n",
    "de 35 a 40 Obesidad premórbida (obesidad de grado III)\n",
    "\\> 40 Obesidad mórbida (obesidad de grado IV)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6af05555",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Su IMC es: 30.86\n",
      "Su clasificación de IMC es: Sobrepeso crónico (obesidad de grado II)\n"
     ]
    }
   ],
   "source": [
    "def getIMC(weight, height): \n",
    "    imc = weight / (height ** 2)\n",
    "    return imc\n",
    "\n",
    "def getIMCClassification(imc):\n",
    "    if imc < 16:\n",
    "        return \"Criterio de ingreso en hospital\"\n",
    "    elif imc < 17:\n",
    "        return \"Infrapeso\"\n",
    "    elif imc < 18:\n",
    "        return \"Bajo peso\"\n",
    "    elif imc < 25:\n",
    "        return \"Peso normal (saludable)\"\n",
    "    elif imc < 30:\n",
    "        return \"Sobrepeso (obesidad de grado I)\"\n",
    "    elif imc < 35:\n",
    "        return \"Sobrepeso crónico (obesidad de grado II)\"\n",
    "    elif imc < 40:\n",
    "        return \"Obesidad premórbida (obesidad de grado III)\"\n",
    "    else:\n",
    "        return \"Obesidad mórbida (obesidad de grado IV)\"\n",
    "\n",
    "weight = float(input(\"Ingrese su peso en kg: \"))\n",
    "height = float(input(\"Ingrese su altura en metros: \"))\n",
    "\n",
    "if weight <= 0 or height <= 0:\n",
    "    print(\"Peso y altura deben ser mayores a 0\")\n",
    "else:\n",
    "    imc = getIMC(weight, height)\n",
    "    classification = getIMCClassification(imc)\n",
    "\n",
    "    print(f\"Su IMC es: {imc:.2f}\")\n",
    "    print(f\"Su clasificación de IMC es: {classification}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a30840b9",
   "metadata": {},
   "source": [
    "6. Hacer un programa en Python que, por un número entero dado por el usuario,\n",
    "muestre la lista de números pares inferiores a él."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c906f952",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Los números pares menores que 6 son: [2, 4]\n"
     ]
    }
   ],
   "source": [
    "def getEvenNumbersBelow(n):\n",
    "    return [i for i in range(2, n, 2)]\n",
    "\n",
    "\n",
    "number = int(input(\"Ingrese un número entero: \"))\n",
    "\n",
    "if number < 2:\n",
    "    print(\"No hay números pares menores que\", number)\n",
    "else:\n",
    "    evenNumbers = getEvenNumbersBelow(number)\n",
    "    print(\"Los números pares menores que\", number, \"son:\", evenNumbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be62a60c",
   "metadata": {},
   "source": [
    "7. Hacer un programa en Python que muestre los productos del 1 al 10 de la tabla\n",
    "de multiplicar del número 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3fe1fa53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 x 1 = 5\n",
      "5 x 2 = 10\n",
      "5 x 3 = 15\n",
      "5 x 4 = 20\n",
      "5 x 5 = 25\n",
      "5 x 6 = 30\n",
      "5 x 7 = 35\n",
      "5 x 8 = 40\n",
      "5 x 9 = 45\n",
      "5 x 10 = 50\n"
     ]
    }
   ],
   "source": [
    "number = 5\n",
    "\n",
    "multiplicationTable = [number * i for i in range(1, 11)]\n",
    "\n",
    "for i in range(1, 11):\n",
    "    print(f\"{number} x {i} = {multiplicationTable[i-1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "587f271a",
   "metadata": {},
   "source": [
    "8. Hacer un programa en Python que imprima la serie de la sumatoria Σ , donde 1\n",
    "𝑛\n",
    "n es ingresado por el usuario.\n",
    "a. Ejemplo de salida: 1/1, 1/2, 1/3, … , 1/n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ed389ad6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La serie de la sumatoria es: 1/1, 1/2, 1/3, 1/4, 1/5, 1/6\n"
     ]
    }
   ],
   "source": [
    "def printSummationSeries(n):\n",
    "    if n < 1:\n",
    "        print(\"El número debe ser mayor o igual a 1.\")\n",
    "        return\n",
    "\n",
    "    series = [f\"1/{i}\" for i in range(1, n + 1)]\n",
    "    print(\"La serie de la sumatoria es:\", \", \".join(series))\n",
    "\n",
    "number = int(input(\"Ingrese un número entero: \"))\n",
    "printSummationSeries(number)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecb9882c",
   "metadata": {},
   "source": [
    "9. Hacer un programa en Python que imprima el valor obtenido de la sumatoria\n",
    "Σ , donde n es ingresado por el usuario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4aac6ba6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor de la sumatoria es: 2.283333333333333\n"
     ]
    }
   ],
   "source": [
    "def getSummatorySerieValue(n):\n",
    "    summatory = 0\n",
    "    for i in range(1, n + 1):\n",
    "        summatory += 1 / i\n",
    "    return summatory\n",
    "\n",
    "\n",
    "inputNumber = input(\"Ingrese un número entero: \")\n",
    "\n",
    "try:\n",
    "    numberFloat = float(inputNumber)\n",
    "\n",
    "    if not numberFloat.is_integer():\n",
    "        print(\"Advertencia: Se ingresó un decimal, se redondeará.\")\n",
    "\n",
    "    number = round(numberFloat)\n",
    "\n",
    "    if number < 1:\n",
    "        print(\"El número debe ser mayor o igual a 1.\")\n",
    "    else:\n",
    "        summatoryValue = getSummatorySerieValue(number)\n",
    "        print(\"El valor de la sumatoria es:\", summatoryValue)\n",
    "\n",
    "except ValueError:\n",
    "    print(\"Entrada inválida. Debe ingresar un número.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "939c6d0b",
   "metadata": {},
   "source": [
    "10. Hacer un programa en Python que imprima la serie y además el valor obtenido\n",
    "de la sumatoria n\n",
    "2 Σ , donde n es ingresado por el usuario (n no debe ser mayor\n",
    "de 5)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a420c070",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor de la sumatoria es: 55\n"
     ]
    }
   ],
   "source": [
    "def getSummarySerieValue(n):\n",
    "  summatory = 0\n",
    "  for i in range(1, n + 1):\n",
    "    summatory += i**2\n",
    "  return summatory\n",
    "\n",
    "inputNumber = input(\"Ingrese un número entero: \")\n",
    "\n",
    "if inputNumber.isdigit() and int(inputNumber) <= 5:\n",
    "  number = int(inputNumber)\n",
    "  summaryValue = getSummarySerieValue(number)\n",
    "  print(\"El valor de la sumatoria es:\", summaryValue)\n",
    "else:\n",
    "  print(\" El número debe ser un numero entero menor o igual a 5.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ef74faf",
   "metadata": {},
   "source": [
    "11. Hacer un programa en Python que permita registrar las calificaciones de varios\n",
    "estudiantes. Cada estudiante tiene un nombre y una lista de calificaciones,\n",
    "implementa funciones para:\n",
    "a. Agregar un estudiante\n",
    "b. Agregar una calificación\n",
    "c. Calcular el promedio de cada estudiante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fc02f0a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estructura de datos: {'Pedro': [8.5, 6.5], 'Maria': [10.0, 6.5, 8.5]}\n",
      "El promedio de notas para Pedro es: 7.5\n",
      "El promedio de notas para Maria es: 8.333333333333334\n"
     ]
    }
   ],
   "source": [
    "students = {}\n",
    "\n",
    "def addStudent(name):\n",
    "    if name not in students:\n",
    "        students[name] = []\n",
    "\n",
    "def addGrade(studentName, grade):\n",
    "    if studentName in students:\n",
    "        students[studentName].append(grade)\n",
    "    else:\n",
    "        print(\"Student not found.\")\n",
    "\n",
    "def getAverageGradeByStudent(studentName):\n",
    "    if studentName in students:\n",
    "        grades = students[studentName]\n",
    "        if len(grades) == 0:\n",
    "            return None\n",
    "        return sum(grades) / len(grades)\n",
    "    else:\n",
    "        print(\"Student not found.\")\n",
    "        return None\n",
    "\n",
    "\n",
    "addStudent(\"Pedro\")\n",
    "addGrade(\"Pedro\", 8.5)\n",
    "addGrade(\"Pedro\", 6.5)\n",
    "\n",
    "addStudent(\"Maria\")\n",
    "addGrade(\"Maria\", 10.0)\n",
    "addGrade(\"Maria\", 6.5)\n",
    "addGrade(\"Maria\", 8.5)\n",
    "\n",
    "\n",
    "print(\"Estructura de datos:\", students)\n",
    "\n",
    "averageGradePedro = getAverageGradeByStudent(\"Pedro\")\n",
    "averageGradeMaria = getAverageGradeByStudent(\"Maria\") \n",
    "\n",
    "\n",
    "if averageGradePedro is not None:\n",
    "    print(f\"El promedio de notas para Pedro es: {averageGradePedro}\")\n",
    "\n",
    "if averageGradeMaria is not None:\n",
    "    print(f\"El promedio de notas para Maria es: {averageGradeMaria}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "289ac4e7",
   "metadata": {},
   "source": [
    "12. Crea un programa en Python para gestionar un pequeño catálogo de\n",
    "productos. Cada producto tendrá:\n",
    "a. un código clave\n",
    "b. una tupla con nombre, precio y cantidad disponible\n",
    "Implementa funciones para:\n",
    "a. Agregar productos,\n",
    "b. Consultar un producto por código,\n",
    "c. Calcular el valor total del inventario\n",
    "\n",
    "Ejemplo:\n",
    "productos = {\n",
    " \"A001\": (\"Camisa\", 250.0, 10),\n",
    " \"B002\": (\"Pantalón\", 400.0, 5)\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7b68838b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estructura de datos: {'A001': ('Laptop', 1500.0, 10), 'A002': ('Smartphone', 800.0, 20), 'A003': ('Headphones', 200.0, 50)}\n",
      "Product A003: Headphones, Price: 200.0, Quantity: 50\n",
      "Valor total del inventario: 41000.0\n"
     ]
    }
   ],
   "source": [
    "products = {}\n",
    "\n",
    "def addProduct(code, name, price, quantity):\n",
    "    if code not in products:\n",
    "        products[code] = (name, price, quantity)\n",
    "    else:\n",
    "        print(\"Product already exists.\")\n",
    "\n",
    "def getProductByCode(code):\n",
    "    if code in products:\n",
    "        return products[code]\n",
    "    else:\n",
    "        print(\"Product not found.\")\n",
    "        return None\n",
    "\n",
    "def getTotalInventoryValue():\n",
    "    return sum(price * quantity for name, price, quantity in products.values())\n",
    "\n",
    "\n",
    "addProduct(\"A001\", \"Laptop\", 1500.00, 10)\n",
    "addProduct(\"A002\", \"Smartphone\", 800.00, 20)\n",
    "addProduct(\"A003\", \"Headphones\", 200.00, 50)\n",
    "\n",
    "print(\"Estructura de datos:\", products)\n",
    "\n",
    "product = getProductByCode(\"A003\")\n",
    "if product is not None:\n",
    "    name, price, quantity = product\n",
    "    print(f\"Product A003: {name}, Price: {price}, Quantity: {quantity}\")\n",
    "\n",
    "totalInventoryValue = getTotalInventoryValue()\n",
    "print(f\"Valor total del inventario: {totalInventoryValue}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb2d5c8c",
   "metadata": {},
   "source": [
    "13. Escribe una función en Python que reciba una frase y devuelva un diccionario\n",
    "con la cantidad de veces que aparece cada palabra. Ignora mayúsculas y\n",
    "signos de puntuación\n",
    "Ejemplo:\n",
    "Entrada: \"Hola mundo hola mundo hola\"\n",
    "Salida: {'hola': 3, 'mundo': 2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "7948a1b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tipo de dato: <class 'dict'>\n",
      "El diccionario de palabras es: {'hola': 3, 'mundo': 2}\n"
     ]
    }
   ],
   "source": [
    "def getDictionaryWords(text):\n",
    "    lowerText = text.lower()\n",
    "    words = lowerText.split()\n",
    "    return { word: words.count(word) for word in set(words) }\n",
    "\n",
    "inputText = \"Hola mundo hola mundo hola\"\n",
    "wordDictionary = getDictionaryWords(inputText)\n",
    "\n",
    "print(\"Tipo de dato:\", type(wordDictionary))\n",
    "print(\"El diccionario de palabras es:\", wordDictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "868def8b",
   "metadata": {},
   "source": [
    "14. Crea un programa en Python para gestionar una agenda donde cada contacto\n",
    "tiene:\n",
    "a. un nombre (clave del diccionario)\n",
    "b. una tupla con teléfono y correo\n",
    "Implementa funciones para:\n",
    "a. Agregar un contacto,\n",
    "b. Buscar un contacto por nombre,\n",
    "c. Actualizar datos de un contacto\n",
    "Ejemplo:\n",
    "agenda = {\n",
    " \"María\": (\"555-1234\", \"maria@gmail.com\"),\n",
    " \"Luis\": (\"555-5678\", \"luis@hotmail.com\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "0f6d6166",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estructura de datos: {'Maria': ('555-1234', 'maria@gmail.com'), 'Luis': ('555-5678', 'luis@gmail.com')}\n",
      "Contact Maria: Phone: 555-1234, Email: maria@gmail.com\n",
      "Estructura de datos después de la actualización: {'Maria': ('555-1234', 'maria@gmail.com'), 'Luis': ('555-8765', 'updated@hotmail.com')}\n",
      "Updated Contact Luis: Phone: 555-8765, Email: updated@hotmail.com\n"
     ]
    }
   ],
   "source": [
    "contacts = {}\n",
    "def addContact(name, phone, email):\n",
    "  if name not in contacts:\n",
    "    contacts[name] = (phone, email)\n",
    "  else: \n",
    "    print(\"Contact already exists.\")\n",
    "\n",
    "def getContactByName(name):\n",
    "  if name in contacts:\n",
    "    return contacts[name]\n",
    "  else:\n",
    "    print(\"Contact not found.\")\n",
    "    return None\n",
    "  \n",
    "def updateContact(name, phone=None, email=None):\n",
    "  if name in contacts:\n",
    "    currentPhone, currentEmail = contacts[name]\n",
    "    newPhone = phone if phone is not None else currentPhone\n",
    "    newEmail = email if email is not None else currentEmail\n",
    "    contacts[name] = (newPhone, newEmail)\n",
    "  else:\n",
    "    print(\"Contact not found.\")\n",
    "\n",
    "addContact(\"Maria\", \"555-1234\", \"maria@gmail.com\")\n",
    "addContact(\"Luis\", \"555-5678\", \"luis@gmail.com\")\n",
    "\n",
    "print(\"Estructura de datos:\", contacts)\n",
    "\n",
    "contact = getContactByName(\"Maria\")\n",
    "if contact is not None:\n",
    "  phone, email = contact\n",
    "  print(f\"Contact Maria: Phone: {phone}, Email: {email}\")\n",
    "\n",
    "updateContact(\"Luis\", phone=\"555-8765\", email=\"updated@hotmail.com\")\n",
    "updatedContact = getContactByName(\"Luis\")\n",
    "\n",
    "print (\"Estructura de datos después de la actualización:\", contacts)\n",
    "\n",
    "if updatedContact is not None:\n",
    "  phone, email = updatedContact\n",
    "  print(f\"Updated Contact Luis: Phone: {phone}, Email: {email}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dafc21b",
   "metadata": {},
   "source": [
    "15. Crea una función en Python que reciba una lista de números y devuelva una\n",
    "tupla con los siguientes datos:\n",
    "a. número mayor,\n",
    "b. número menor,\n",
    "c. promedio,\n",
    "d. cantidad de números pares,\n",
    "e. cantidad de números impares\n",
    "Ejemplo:\n",
    "Entrada: [2, 5, 8, 3, 10]\n",
    "Salida: (10, 2, 5.6, 3, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cc93578e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tipo de dato: <class 'tuple'>\n",
      "Resultado: (10, 2, 5.6, 3, 2)\n"
     ]
    }
   ],
   "source": [
    "def getNumberCommonDataTuple(listNumbers):\n",
    "    \n",
    "    minValue = min(listNumbers)\n",
    "    maxValue = max(listNumbers)\n",
    "    averageValue = sum(listNumbers) / len(listNumbers)\n",
    "    parNumbersCount = len([num for num in listNumbers if num % 2 == 0])\n",
    "    imparNumbersCount = len([num for num in listNumbers if num % 2 != 0])\n",
    "\n",
    "    return (maxValue, minValue, averageValue, parNumbersCount, imparNumbersCount)\n",
    "\n",
    "inputNumbers = [2, 5, 8, 3, 10]\n",
    "\n",
    "result = getNumberCommonDataTuple(inputNumbers)\n",
    "\n",
    "print(\"Tipo de dato:\", type(result))\n",
    "print(\"Resultado:\", result)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.14.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}