Desafios.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Desafio 1 💩\n",
    "\n",
    "Un vector es sinónimo lista, sólo que un vector tiene siempre datos del mismo tipo. Por ejemplo: un vector de números, sólo puede tener números, no palabras.\n",
    "\n",
    "Crear un vector de 10 valores al azar entre 1 y 99\n",
    "\n",
    "Por ejemplo: \n",
    "\n",
    "```python\n",
    "vector = [1, 20, 23, 12, 7, 25, 9, 8, 31, 16]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tu código aquí\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "\n",
    "<summary> 🤪 TIPS</summary>\n",
    "\n",
    "  - Crear un vector vacío.\n",
    "  - Agregarle item usando `append`\n",
    "  - Usar `for` para evitar repetir cosas manualmente\n",
    "  - Se puede usar `randint` para generar números al azar (random)\n",
    "\n",
    "</details>\n",
    "\n",
    "<br/>\n",
    "\n",
    "<details>\n",
    "\n",
    "<summary> 🤨 RESPUESTA</summary>\n",
    "\n",
    "Esta es una forma de creación de un vector con números al azar:\n",
    "\n",
    "\n",
    "```python\n",
    "from random import randint\n",
    "\n",
    "vector = []\n",
    "for i in range(1, 11):\n",
    "  vector.append(randint(1, 99))\n",
    "\n",
    "print(vector)\n",
    "\n",
    "```\n",
    "\n",
    "Esta es otra forma, preferida por los programadores mas avanzados de python. Usa 'list comprehension', un método para crear listas de diversas maneras con poco código. Para saber más sobre cómo usar list comprehensions: https://realpython.com/list-comprehension-python/\n",
    "\n",
    "```python\n",
    "from random import randint\n",
    "\n",
    "print([ randint(1, 100) for i in range(10) ])\n",
    "```\n",
    "</details>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Desafío 2 💩\n",
    "\n",
    "Crear una matriz de 100 valores (10 fila y 10 columnas) con números generados al azar entre 1 y 99.\n",
    "Recuerda: una matriz no es mas de que una colección de vectores.\n",
    "\n",
    "Por ejemplo:\n",
    "\n",
    "```python\n",
    "matrix = [\n",
    "  [85,  6, 76, 75, 80, 13, 43,  8, 98, 68], \n",
    "  [47, 41, 19, 26, 77, 81, 55,  8, 77, 77], \n",
    "  [10, 78, 93, 87, 37, 81, 39,  9, 29, 45], \n",
    "  [45, 43, 64, 30, 60, 92,  5, 94, 46, 78], \n",
    "  [60, 22, 27, 81, 57, 16, 35, 96, 87, 68], \n",
    "  [ 3, 37, 59, 78, 84, 82, 25, 21, 99, 89], \n",
    "  [78, 45, 39, 46, 32, 66, 95, 45, 76, 89], \n",
    "  [19, 37, 86, 44, 98, 56, 73, 78,  2, 65], \n",
    "  [99, 29, 81, 27, 82, 50, 94, 60, 15, 19], \n",
    "  [65, 92,  1, 38, 59, 52, 43, 71,  7, 37]\n",
    "]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tu código aqui\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "\n",
    "<summary> 🤪 TIPS</summary>\n",
    "  \n",
    "  - Una matriz es una colección de vectores (una lista de listas)\n",
    "  - `for` es uno de tus mejores amigos para trabajar con listas de forma simple (aunque no siempre es la mejor opción)\n",
    "\n",
    "</details>\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>\n",
    "\n",
    "<summary> 🤨 RESPUESTA</summary>\n",
    "\n",
    "Esta es una forma ineficiente de creación de una matrix:\n",
    "\n",
    "```python\n",
    "from random import randint\n",
    "\n",
    "matrix = []\n",
    "\n",
    "for x in range(1,11):\n",
    "  vector = []\n",
    "  for y in range(1,11):\n",
    "    vector.append(randint(1,99))\n",
    "  matrix.append(vector)\n",
    "\n",
    "print(matrix)\n",
    "\n",
    "```\n",
    "\n",
    "También se puede obtener el mismo resultado utilizando list comprehension como vimos en el desafío anterior:\n",
    "\n",
    "```python\n",
    "from random import randint\n",
    "\n",
    "[ [ randint(1,100) for i in range(10)] for i in range(10) ]\n",
    "```\n",
    "</details>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Desafío 3 💩\n",
    "\n",
    "Crear un vector con los numeros de cada diagonal de la matriz generada anteriormente.\n",
    "Las diagonales se obtienen de arriba hacia abajo (top-bottom).\n",
    "\n",
    "Por ejemplo:\n",
    "\n",
    "```python\n",
    "matrix = [\n",
    "  [85,  6, 76, 75, 80, 13, 43,  8, 98, 68], \n",
    "  [47, 41, 19, 26, 77, 81, 55,  8, 77, 77], \n",
    "  [10, 78, 93, 87, 37, 81, 39,  9, 29, 45], \n",
    "  [45, 43, 64, 30, 60, 92,  5, 94, 46, 78], \n",
    "  [60, 22, 27, 81, 57, 16, 35, 96, 87, 68], \n",
    "  [ 3, 37, 59, 78, 84, 82, 25, 21, 99, 89], \n",
    "  [78, 45, 39, 46, 32, 66, 95, 45, 76, 89], \n",
    "  [19, 37, 86, 44, 98, 56, 73, 78,  2, 65], \n",
    "  [99, 29, 81, 27, 82, 50, 94, 60, 15, 19], \n",
    "  [65, 92,  1, 38, 59, 52, 43, 71,  7, 37]\n",
    "]\n",
    "\n",
    "diagonal1 = [85, 41, 93, 30, 57, 82, 95, 78, 15, 37]\n",
    "diagonal2 = [68, 77, 9, 5, 16, 84, 46, 86, 29, 65]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tu código aquí\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "\n",
    "<summary> 🤪 TIPS</summary>\n",
    "\n",
    "  - Una forma de recorrer una matriz por sus filas y columnas es usando `for`, aunque no es la única forma.\n",
    "  - Siempre se pueden hacer operaciones aritméticas con cualquier variable, aunque éstas sean los índices de una lista.\n",
    "\n",
    "</details>\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>\n",
    "\n",
    "<summary> 🤨 RESPUESTA</summary>\n",
    "\n",
    "\n",
    "```python\n",
    "diagonal1 = [] # \\\n",
    "diagonal2 = [] # /\n",
    "\n",
    "matrix = [ [ randint(1,100) for i in range(10)] for i in range(10) ]\n",
    "\n",
    "for i in range(0, len(matrix)):\n",
    "  diagonal1.append(matrix[i][i])\n",
    "  diagonal2.append(matrix[i][len(matrix)-i-1])\n",
    "\n",
    "print(diagonal1)\n",
    "print(diagonal2)\n",
    "\n",
    "```\n",
    "\n",
    "De nuevo, se pueden usar lists comprehensions para obtener el mismo resultado:\n",
    "\n",
    "```python\n",
    "\n",
    "# Se ha omitido aquí la definición de matrix para no hacer tan largo el código\n",
    "\n",
    "rows = len(matrix)\n",
    "\n",
    "diagonal1 = [matrix[i][i] for i in range(rows)]\n",
    "diagonal2 = [matrix[i][rows-i-1] for i in range(rows)]\n",
    "print(diagonal1) \n",
    "print(diagonal2) \n",
    "```\n",
    "\n",
    "</details>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Desafío 4 💩💩💩\n",
    "\n",
    "Desde un proceso misterioso de asignaciones de turnos, se ha generado una lista de números aleatorios desordenados. No se saben cuántos números pueden venir en esa lista, pero se sabe que no pueden ser más de 1000 y que al menos siempre habrá 10 números.\n",
    "\n",
    "Esa lista de números representan los DNI de personas que se encuentran en lista de espera para ser atendidas en un centro de salud público. Se le quiere dar prioridad a las personas de mayor edad, por lo que se debe ordenar la lista de modo que aquellas personas sean las primeras en ser atendidas. _Se sabe que cuanto mas grande el DNI, más joven es la persona_.\n",
    "\n",
    "Luego, en base a la lista ordenada, sebe generar una nueva lista que tenga el DNI de cada persona y una fecha **a partir del día de hoy** en adelante que será la fecha en que será atendida. Tener en cuenta que **no se puede atender a las personas ni sábados ni domingos**. En cada fecha se pueden atender **hasta 10 personas**. También, por cada persona, se le debe **asignar un médico de forma aleatoria** (Hay 10 médicos: Dr Strange, Dr Malito, Dr Charles Xavier, Dr Zhivago, Dr Frankenstein, Dr Constantine, Dr Jekyll, Dr Who, Dr Indiana jones, Dr House). Un médico no puede atender a más de 1 personas por día.\n",
    "\n",
    "Crear una función que tome la lista original de DNI y retorne la lista final de turnos con las fechas y doctores asignados dando priodidad a las personas mayores.\n",
    "\n",
    "\n",
    "Por ejemplo:\n",
    "  \n",
    "  ```python\n",
    "  def asignar_turnos(lista_DNIs):\n",
    "    # Código aquí\n",
    "    return lista_final\n",
    "\n",
    "print(asignar_turnos())\n",
    "\n",
    "# Resultado esperado:\n",
    "[\n",
    "  {\n",
    "    'dni': 12345678,\n",
    "    'fecha': '2021-05-03',\n",
    "    'doctor': 'Dr Strange'\n",
    "  },\n",
    "  {\n",
    "    'dni': 12345679,\n",
    "    'fecha': '2021-05-03',\n",
    "    'doctor': 'Dr Malito'\n",
    "  },\n",
    "  ...\n",
    "]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "\n",
    "<summary> 🤪 TIPS</summary>\n",
    "\n",
    "  - Para resolver un problema mediante programación hay que crear un algoritmo. Un algoritmo es una serie de pasos que se deben seguir para resolver un problema. Un problema puede ser resuelto por varios algoritmos diferentes. Para este caso, un algoritmo podría ser el siguiente:\n",
    "  \n",
    "  1. Ordenar la lista de DNI de menor a mayor.\n",
    "  2. Crear una lista de médicos.\n",
    "  3. Crear una lista de turnos vacía.\n",
    "  4. Crear una lista de fechas a partir de hoy en adelante, excluyendo los fines de semana. Hasta cubrir la lista de personas.\n",
    "  5. Recorrer la lista de fechas y para cada fecha:\n",
    "    1. Recorrer la lista de DNI y para cada DNI:\n",
    "      1. Crear un turno con el DNI, la fecha y un médico aleatorio.\n",
    "      2. Agregar el turno a la lista de turnos.\n",
    "      3. Si esta fecha tiene 10 turnos, salir del bucle.\n",
    "  6. Retornar la lista de turnos.\n",
    "\n",
    "\n",
    "  - `datetime.datetime.now()` nos devuelve la fecha y hora actual en formato ISO 8601.\n",
    "  - `datetime.timedelta(days=1)` nos devuelve un objeto de tipo `datetime.timedelta` que representa un día. Se puede usar para sumar o restar días a una fecha.\n",
    "  - `una_fecha.weekday()` nos devuelve el día de la semana de una fecha. El lunes es 0, martes es 1... y el domingo es 6.\n",
    "  - `random.choice(lista)` nos devuelve un elemento aleatorio de una lista.\n",
    "\n",
    "</details>\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>\n",
    "\n",
    "<summary> 🤨 RESPUESTA</summary>\n",
    "\n",
    "\n",
    "```python\n",
    "# Tu código aquí\n",
    "from random import randint, shuffle\n",
    "from datetime import datetime, timedelta\n",
    "from pprint import pprint\n",
    "\n",
    "# Metodo 3\n",
    "# defino una funcion generadora que devuelva grupos de pacientes\n",
    "def getPatientsGroups(patients, patients_by_day):\n",
    "    for i in range(0, len(patients), patients_by_day):\n",
    "        yield patients[i:i+patients_by_day]\n",
    "\n",
    "\n",
    "doctors = [\"Dr Strange\", \"Dr Malito\", \"Dr Charles Xavier\", \"Dr Zhivago\", \"Dr Frankenstein\", \"Dr Constantine\", \"Dr Jekyll\", \"Dr Who\", \"Dr Indiana jones\", \"Dr House\"]\n",
    "dnis = [ randint(20000000, 60000000) for x in range(randint(10, 1_000)) ]\n",
    "today = datetime.now()\n",
    "agenda = []\n",
    "\n",
    "# me aseguro que hoy no sea sabado ni domingo\n",
    "while today.weekday() > 4:\n",
    "    today += timedelta(days=1)\n",
    "\n",
    "# Metodo 1\n",
    "# Usando list comprehension\n",
    "# for patient_group in [dnis[i:i+10] for i in range(0, len(dnis), 10)]:\n",
    "#   pprint(patient_group)\n",
    "\n",
    "# Metodo 2\n",
    "# Usando for para agrupar pacientes sin usar getPatientsGroups\n",
    "# for i in range(0, len(dnis), 10):\n",
    "#    pprint(dnis[i:i+10])\n",
    "\n",
    "\n",
    "# Metodo 3\n",
    "# Usando una funcion generadora\n",
    "for patient_group in getPatientsGroups(dnis, 10):\n",
    "\n",
    "  shuffle(doctors)\n",
    "\n",
    "  for index, doctor in enumerate(doctors[0:len(patient_group)]):\n",
    "      \n",
    "    appointment = {\n",
    "        \"dni\": patient_group[index],\n",
    "        \"doctor\": doctor,\n",
    "        \"date\": today.strftime(\"%d/%m/%Y %A\"),\n",
    "    }\n",
    "\n",
    "    agenda.append(appointment)\n",
    "  \n",
    "  tomorrow = today + timedelta(days=1)\n",
    "  while tomorrow.weekday() > 4:\n",
    "    tomorrow +=  timedelta(days=1)\n",
    "  \n",
    "  # print(today, tomorrow, tomorrow.weekday() )\n",
    "  today = tomorrow\n",
    "    \n",
    "pprint(agenda)\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Desafío 5 💩💩\n",
    "\n",
    "De una matriz de 10x10 (100 en total), con números enteros generados al azar entre 1 y 100, se necesita conocer cuántas veces aparece cada número en la matriz y qué números aparecen mas de 2 veces.\n",
    "\n",
    "Por ejemplo:\n",
    "\n",
    "```python\n",
    "matrix = [\n",
    "  [85,  6, 76, 75, 80, 13, 43,  8, 98, 68], \n",
    "  [47, 41, 19, 26, 77, 81, 55,  8, 77, 77], \n",
    "  [10, 78, 93, 87, 37, 81, 39,  9, 29, 45], \n",
    "  [45, 43, 64, 30, 60, 92,  5, 94, 46, 78], \n",
    "  [60, 22, 27, 81, 57, 16, 35, 96, 87, 68], \n",
    "  [ 3, 37, 59, 78, 84, 82, 25, 21, 99, 89], \n",
    "  [78, 45, 39, 46, 32, 66, 95, 45, 76, 89], \n",
    "  [19, 37, 86, 44, 98, 56, 73, 78,  2, 65], \n",
    "  [99, 29, 81, 27, 82, 50, 94, 60, 15, 19], \n",
    "  [65, 92,  1, 38, 59, 52, 43, 71,  7, 37]\n",
    "]\n",
    "\n",
    "Repeticiones de cada número:  {85: 1, 6: 1, 76: 2, 75: 1, 80: 1, 13: 1, 43: 3, 8: 2, 98: 2, 68: 2, 47: 1, 41: 1, 19: 3, 26: 1, 77: 3, 81: 4, 55: 1, 10: 1, 78: 5, 93: 1, 87: 2, 37: 4, 39: 2, 9: 1, 29: 2, 45: 4, 64: 1, 30: 1, 60: 3, 92: 2, 5: 1, 94: 2, 46: 2, 22: 1, 27: 2, 57: 1, 16: 1, 35: 1, 96: 1, 3: 1, 59: 2, 84: 1, 82: 2, 25: 1, 21: 1, 99: 2, 89: 2, 32: 1, 66: 1, 95: 1, 86: 1, 44: 1, 56: 1, 73: 1, 2: 1, 65: 2, 50: 1, 15: 1, 1: 1, 38: 1, 52: 1, 71: 1, 7: 1}\n",
    "\n",
    "Números que aparecen mas de 3 veces:  {81: 4, 78: 5, 37: 4, 45: 4}\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tu código aquí\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "\n",
    "<summary> 🤪 TIPS</summary>\n",
    "\n",
    "  - Una forma simple de recorrer una matriz por sus filas y columnas es usando `for`\n",
    "  - La diferencia entre un programador senior($$$$$$) y un junior($) es que el senior conoce en profundidad todas las herramientas que brinda el lenguaje y el junior solo conoce las que le han enseñado. Por eso es importante estudiar siempre mejores formas de hacer las cosas. Para este ejercicio, es de programador pro poder usar `collections.Counter` para contar las repeticiones de cada número, o `dictionary comprehension` para obtener los números que aparecen mas de 3 veces.\n",
    "\n",
    "</details>\n",
    "\n",
    "<br>\n",
    "\n",
    "<details>\n",
    "\n",
    "<summary> 🤨 RESPUESTA</summary>\n",
    "\n",
    "\n",
    "```python\n",
    "from random import randint\n",
    "from typing import Counter\n",
    "\n",
    "matrix = [ [ randint(1,100) for i in range(10)] for i in range(10) ]\n",
    "\n",
    "ocurrencias = {}\n",
    "\n",
    "for row in range(10):\n",
    "   for column in range(10):\n",
    "    ocurrencias[matrix[row][column]] = (ocurrencias[matrix[row][column]]+1) if matrix[row][column] in ocurrencias else 1\n",
    "\n",
    "print(\"Repeticiones de cada número: \", ocurrencias)\n",
    "\n",
    "# convertir la matriz matrix en un arreglo unidimensional para poder usar Counter\n",
    "numeros = [ matrix[row][column] for row in range(10) for column in range(10) ]\n",
    "ocurrencias_2 = Counter(numeros)\n",
    "\n",
    "print(\"Repeticiones de cada número MEJORADA: \", ocurrencias_2)\n",
    "\n",
    "print(\"Números que aparecen mas de 3 veces: \", {k:v for k,v in ocurrencias.items() if v > 3} )\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Desafío 4000 💩💩💩💩💩\n",
    "\n",
    "Hay una escalera de `n` escalones. Para llegar a la parte superior se requieren `n` pasos.\n",
    "Para lograr llegar arriba, se pueden hacer movimientos de 1 o 2 pasos.\n",
    "\n",
    "¿Cuántas maneras hay de subir la escalera y alcanzar la parte superior?\n",
    "\n",
    "Ejemplos:\n",
    "\n",
    "<table>\n",
    "<tr>\n",
    "<td>\n",
    "  <img src=\"img/stair1s.svg\" alt=\"drawing\" width=\"200\"/>\n",
    "</td>\n",
    "<td>\n",
    "  <img src=\"img/stair3s.svg\" alt=\"drawing\" width=\"200\"/>\n",
    "</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>\n",
    "<b>Escalera de n=2</b>\n",
    "\n",
    "Soluciones: 2\n",
    "\n",
    "  1. 1 paso + 1 paso\n",
    "  2. 2 pasos\n",
    "</td>\n",
    "<td>\n",
    "<b>Escalera de n=3</b>\n",
    "\n",
    "Soluciones: 3\n",
    "\n",
    "  1. 1 paso + 1 paso + 1 paso\n",
    "  2. 1 pasos + 2 pasos\n",
    "  3. 2 pasos + 1 paso\n",
    "</td>\n",
    "</tr>\n",
    "</table>\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.0 64-bit",
   "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.10.0"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "e4238f632384955c51958c1cbeb17132fdc8a9a602388a6d4ca4d7449a346567"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}