Auxiliares/Auxiliar_11/PautaAuxiliar11.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Pauta_Auxiliar_11.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/bpoblete/CC1002/blob/master/Auxiliares/Auxiliar_11/PautaAuxiliar11.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rZqTOiY_AbYq"
      },
      "source": [
        "# Pauta Auxiliar 11\n",
        "\n",
        "### Estructuras Indexadas, String\n",
        "\n",
        "Auxiliares: Nadia Decar, Nelson Marambio, Albani Olvieri, Monserrat Prado, Lucas Torrealba, Ricardo Valdivia"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tfvjMLNMIZwM"
      },
      "source": [
        "### Pregunta 1. Sopa de letras\n",
        "\n",
        "Esta pregunta onsiste en modelar una sopa de letras como una lista de strings, como la siguiente:\n",
        "\n",
        "```python\n",
        "L = ['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n",
        "```\n",
        "\n",
        "Es para esto que se le pide crear las siguientes funciones, que operan con listas de letras:\n",
        "\n",
        "a)  Escriba la función contarLetras(L, letra) que cuenta la cantidad de veces que se repite la 'letra' entregada dentro de la lista L. En el ejemplo, contarLetras(L, 'a') entregaría 5\n",
        "\n",
        "b) Escriba la función invertir(L) que toma una lista de letras como la del ejemplo, y entrega una **nueva lista**, con los elementos invertidos de esa lista. Ejemplo:\n",
        "```python\n",
        "invertir(L) entrega ['a', 'r', 'b', 'a', 'd', 'a', 'c', 'a', 'r', 'b', 'a']\n",
        "```\n",
        "\n",
        "c) Escriba una función mezclarSopas(L1,L2), que toma dos listras de letras de distintos tamaños, y retorna una lista con los string concatenados uo por uno. En el caso que una lista sea más corta que la cotra, debe concatenarse con un guión bajo. Ejemplo:\n",
        "```python\n",
        "L1 = ['a', 'b', 'r', 'a']\n",
        "L2 = ['c', 'a']\n",
        "mezclarSopas(L1,L2) entrega ['ac', 'ba', 'r_', 'a_']\n",
        "```\n",
        "\n",
        "d) Escriba una funci´on sinRepeticiones(L) que recibe una lista de letras, y\n",
        "retorna una lista, sin letras repetidas.\n",
        "\n",
        "```python\n",
        "sinRepeticiones(L) entrega ['a', 'b', 'r', 'c', 'd']\n",
        "```\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mzTW4bjBPWsN"
      },
      "source": [
        "# listas para usar en los ejemplos y test\n",
        "Lejemplo = ['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']\n",
        "Lcorta1 = ['a', 'b', 'r', 'a']\n",
        "Lcorta2 = ['c','a']\n",
        "Lcorta3 = ['c', 'a', 'r', 'z']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gPOmyJOcNj-Q"
      },
      "source": [
        "# a)\n",
        "# contarLetras: list(str) str -> int\n",
        "# cuenta la cantidad de una letra en una lista de letras\n",
        "# Ej: contarLetras(Lejemplo,'a') entrega 5\n",
        "def contarLetras(L,letra):\n",
        "  assert type(L) == list\n",
        "  assert type(letra) == str\n",
        "  contador = 0\n",
        "  # En este caso, usaremos un for, que recorre 'automaticamente' cada\n",
        "  # elemento e de la lista L en cada ciclo.\n",
        "  for e in L:\n",
        "    if e == letra:\n",
        "      contador = contador + 1\n",
        "    # Si no son iguales, no aumentamos el contador, asi que ignoramos\n",
        "    # ese caso, no hay else\n",
        "  return contador\n",
        "# Test\n",
        "assert contarLetras(Lejemplo,'a') == 5\n",
        "assert contarLetras(Lejemplo,'z') == 0\n",
        "assert contarLetras([],'a') == 0\n",
        "'''\n",
        "En algunos casos, podemos usar las funciones nativas de python, para operar\n",
        "con listas o strings. Si es aplicable, puede facilitar mucho la resolución\n",
        "de los problemas.\n",
        "'''\n",
        "# contarLetras: list(str) str -> int\n",
        "# cuenta la cantidad de una letra en una lista de letras\n",
        "# Ej: contarLetras(Lejemplo,'a') entrega 5\n",
        "def contarLetras2(L,letra):\n",
        "  assert type(L) == list\n",
        "  assert type(letra) == str\n",
        "  return L.count(letra)\n",
        "\n",
        "assert contarLetras2(Lejemplo,'a') == 5\n",
        "assert contarLetras2(Lejemplo,'z') == 0\n",
        "assert contarLetras2([],'a') == 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O6NX417bPTLp"
      },
      "source": [
        "# b)\n",
        "# invertir: list(str) -> list(str)\n",
        "# crea una nueva lista, con los elementos en orden inverso de la lista entregada\n",
        "# Ej: invertir(Lcorta1) entrega ['a', 'r', 'b', 'a']\n",
        "def invertir(L):\n",
        "  assert type(L) == list\n",
        "  # En este caso, no podemos usar el metodo list.reverse() de python\n",
        "  # ya que estariamos editando la lista original, y no es la idea del problema\n",
        "  # que nos pide una nueva lista invertida.\n",
        "  nuevaL = []\n",
        "  i = len(L) - 1 # Los elementos se cuentan desde 0 hasta Total-1\n",
        "  while i >= 0:\n",
        "  # Tomamos el elemento, y lo agregamos a la otra lista,\n",
        "  # usando lista.append(elemento), que lo agrega al final de la lista.\n",
        "    letra = L[i]\n",
        "    nuevaL.append(letra)\n",
        "  # para que en algun momento se termine el while debemos ir modificando la \n",
        "  # variable que se verifica como condicion.\n",
        "    i= i-1\n",
        "  return nuevaL\n",
        "assert invertir(Lejemplo) == ['a', 'r', 'b', 'a', 'd', 'a', 'c', 'a', 'r', 'b', 'a']\n",
        "assert invertir(Lcorta1) == ['a', 'r', 'b', 'a']\n",
        "assert invertir([]) == []"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Do5W3sVbP0ll"
      },
      "source": [
        "# c)\n",
        "# mezclarSopas: list(str) list(str) -> list(str)\n",
        "# toma dos listas de letras, y mezcla sus elementos uno a uno\n",
        "# Ej: mezclarSopas(Lcorta1, Lcorta3) entrega ['ac', 'ba', 'r_', 'a_']\n",
        "def mezclarSopas(L1,L2):\n",
        "  assert type(L1) == list and type(L2) == list\n",
        "  # Obtenemos el largo de ambas listas\n",
        "  largo1 = len(L1)\n",
        "  largo2 = len(L2)\n",
        "  i = 0\n",
        "  nuevaL = []\n",
        "  while i < min(largo1,largo2):\n",
        "  # Se juntan las letras, y se agregan a la nueva lista.\n",
        "    e = L1[i] + L2[i]\n",
        "    nuevaL.append(e)\n",
        "    i = i + 1\n",
        "  # Notar que la variable i indica en que punto quedamos de la lista mas larga, lo que\n",
        "  # nos permite continuar leyendo elementos a partir de ese punto.\n",
        "  if largo1 > largo2:\n",
        "    while i < largo1:\n",
        "      e = L1[i] + '_'\n",
        "      nuevaL.append(e)\n",
        "      i = i + 1\n",
        "  elif largo1 < largo2:\n",
        "    while i < largo2:\n",
        "      e = '_' + L2[i]\n",
        "      nuevaL.append(e)\n",
        "      i = i + 1\n",
        "  return nuevaL\n",
        "# test\n",
        "assert mezclarSopas(Lcorta1, Lcorta2) == ['ac', 'ba', 'r_', 'a_']\n",
        "assert mezclarSopas(Lcorta1, Lcorta3) == ['ac', 'ba', 'rr', 'az']\n",
        "assert mezclarSopas([],Lcorta2) == ['_c','_a']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PG2uyoe-Qeb0"
      },
      "source": [
        "# d)\n",
        "# sinRepeticiones: list(str) -> list(str)\n",
        "# toma una lista de letras, y genera una nueva lista con solo 1 aparicion\n",
        "# de las letras de la lista original\n",
        "# ej: sinRepeticiones(Lprueba) entrega ['a', 'b', 'r', 'c', 'd']\n",
        "def sinRepeticiones(L):\n",
        "  assert type(L) == list\n",
        "  # Creamos una lista vacia, y le vamos agregando letras, siempre y cuando\n",
        "  # no existan en esa lista previamente \n",
        "  nuevaL = []\n",
        "  for e in L:\n",
        "    if contarLetras(nuevaL,e) == 0:\n",
        "      nuevaL.append(e)\n",
        "  return nuevaL\n",
        "# Test\n",
        "assert sinRepeticiones(Lejemplo) == ['a', 'b', 'r', 'c', 'd']\n",
        "assert sinRepeticiones([]) == []\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zB1USbC8AU9h"
      },
      "source": [
        "### Pregunta 2. A rotar!\n",
        "\n",
        "Escriba la función de encabezamiento def rotacionParcial(L) que modifique y la lista L de N elementos de modo que\n",
        "L[0] queda fijo, L[1] pasa a L[2], L[2] a L[3], ..., L[N-2] a L[N-1] y finalmente L[N-1] pasa a L[1]. Por ejemplo, si\n",
        "L=['A','B','C','D','E','F'], entonces rotacionParcial(L) debe dejar L= ['A','F,'B','C','D','E'].\n",
        "\n",
        "**Como Restriccion especifica, esta pregunta solo se puede realizar ocupando While(recursion y for no estan permitidos)** "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jmXPd9XQAUWl"
      },
      "source": [
        "# rotacionParcial: lista -> lista\n",
        "# realiza una rotacion desde el indice 1 hasta el N-1\n",
        "# Ejemplo de uso rotacionParcial(['A', 'B', 'C', 'D', 'E', 'F'])\n",
        "# nos entrega ['A', 'F', 'B', 'C', 'D', 'E']\n",
        "def rotacionParcial(L):\n",
        "  n=len(L)-1 \n",
        "  ultimo=L[n] \n",
        "  while n>1:\n",
        "    L[n]=L[n-1] \n",
        "    n-=1\n",
        "  L[1]=ultimo\n",
        "  return L\n",
        "\n",
        "L=['A', 'B', 'C', 'D', 'E', 'F']\n",
        "assert rotacionParcial(L) == ['A', 'F', 'B', 'C', 'D', 'E']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xou-2kU4Q98U"
      },
      "source": [
        "### Pregunta 3. A medir!\n",
        "\n",
        "Se le pide registrar las mediciones de residuos tóxicos de un lago en una lista de listas (Matriz), en donde cada lista representa las mediciones en un sector especifico del lago, se sabe que el mayor valor de concentración es de 100, y que \"F\" representa una medición fallida.\n",
        "\n",
        "```python\n",
        "[ [20.1, 30.5, 25.4, 24, 23, 'F'],\n",
        "[ 'F', 'F', 18.3, 25.2, 30.1, 30],\n",
        "... ,\n",
        "[11.1, 22, 24, 26.6, 28.8, 30] ]\n",
        "\n",
        "```\n",
        "\n",
        "Se desea obtener las concetracione spromedio de cada zona de un registro como el anterior,  y entregarlas en una lista. Para esto, cree la funcion promedioConcentracion(M), que recive una matriz como la antes descrita, y le retorna una lista, en donde cada elemento representa la concentración de toxico promedio en cada sector. Para los casos con mediciones fallidas (letra \"F\"), entonces se calcula el promedio de ese día con menos datos. En caso de que todos los registros en un sector sean fallidos, entonces el promedio será \"F\".\n",
        "\n",
        "\n",
        "Además se le pide programar las funciones, minConcentracion(M) y maxConcentracion(M), de manera análoga a la anterior, pero que entrega los mínimos y máximos por zona respectivamente.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "feuQBq7OVk5m"
      },
      "source": [
        "# matrices (listas de listas) de ejemplo para los test\n",
        "matrizTox =[[20.1, 30.5, 25.4, 24, 23, 'F'],\n",
        "['F', 'F', 18.3, 25.2, 30.1, 30] ,\n",
        "[30, 29, 23, 'F', 'F', 11.1],\n",
        "[11.1, 22, 24, 26.6, 28.8, 30] ]\n",
        "# una matriz que tiene una fila solo con 'E'\n",
        "matrizE =[[20.1, 30.5, 25.4, 24, 23, 'F'],\n",
        "['F','F','F','F','F','F'],\n",
        "['F', 'F', 18, 25.3, 30.1, 30] ]\n",
        "\n",
        "\n",
        "\n",
        "# parte 1\n",
        "# promedioConcentracion: list(list(num|str)) -> list(num|str)\n",
        "# revisa una matriz de mediciones, y calcula los promedios por cada fila\n",
        "# Ej: promedioConcentracion(MatrizTox) entrega [24.6, 25.9, 23.275, 23.75]\n",
        "def promedioConcentracion(M):\n",
        "  assert type(M) == list\n",
        "  # creamos una lista vacia, donde iremos agregando el promedio de cada zona\n",
        "  listaC = []\n",
        "  # para cada zona\n",
        "  for zona in M:\n",
        "    totalcorrecto = 0\n",
        "    sumaC = 0\n",
        "  # para cada medición en una zona en particular\n",
        "    for med in zona:\n",
        "    # si la medicion no es incorrecta, la acumulamos en las variables.\n",
        "      if med != 'F':\n",
        "        totalcorrecto = totalcorrecto + 1\n",
        "        sumaC = sumaC + med\n",
        "  # Finalmente para esa zona, dependiendo si hay al menos una medición\n",
        "  # correcta o no, calculamos el promedio o colocamos una 'E'\n",
        "    if totalcorrecto != 0:\n",
        "      listaC.append(1.0*sumaC/totalcorrecto)\n",
        "    else:\n",
        "      listaC.append('F')\n",
        "  return listaC\n",
        "# Test\n",
        "assert promedioConcentracion(matrizTox) == [24.6, 25.9, 23.275, 23.75]\n",
        "assert promedioConcentracion(matrizE) == [24.6, 'F', 25.85]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QG0nTm-GXRSn"
      },
      "source": [
        "# parte 2\n",
        "# minConcentracion: list(list(num|str)) -> list(num|str)\n",
        "# revisa una matriz de mediciones, y calcula el valor minimo en cada fila\n",
        "# Ej: minConcentracion(MatrizTox) entrega [20.1, 18.3, 11.1, 11.1]\n",
        "def minConcentracion(M):\n",
        "  assert type(M) == list\n",
        "  # creamos una lista vacia, donde iremos agregando el minimo de cada zona\n",
        "  listaC = []\n",
        "  for zona in M:\n",
        "    # vamos a obtener la menor medición. \n",
        "    menor = 101\n",
        "    # para cada medición en la zona\n",
        "    for med in zona:\n",
        "    # si no es erronea\n",
        "      if med != 'F':\n",
        "        if med < menor:\n",
        "          menor = med\n",
        "    if menor != 101:\n",
        "      listaC.append(menor)\n",
        "    else:\n",
        "      listaC.append('F')\n",
        "  return listaC\n",
        "# Test\n",
        "assert minConcentracion(matrizTox) == [20.1, 18.3, 11.1, 11.1]\n",
        "assert minConcentracion(matrizE) == [20.1, 'F', 18]\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DO8amSt4WEAy"
      },
      "source": [
        "# parte 3\n",
        "# maxConcentracion: list(list(num|str)) -> list(num|str)\n",
        "# revisa una matriz de mediciones, y calcula el valor maximo en cada fila\n",
        "# Ej: maxConcentracion(MatrizTox) entrega [30.5, 30.1, 30, 30]\n",
        "def maxConcentracion(M):\n",
        "  assert type(M) == list\n",
        "  listaC = []\n",
        "  for zona in M:\n",
        "    # vamos a obtener la mayor medición. Partimos con una medición \"mayor\", tal\n",
        "    # que sea siempre menor a cualquier dato de la matriz, con tal de que sea\n",
        "    # reemplazada facilmente\n",
        "    mayor = -1\n",
        "    # para cada medición en la zona\n",
        "    for med in zona:\n",
        "    # si no es erronea\n",
        "      if med != 'F':\n",
        "        if med > mayor:\n",
        "          mayor = med\n",
        "    if mayor != -1:\n",
        "      listaC.append(mayor)\n",
        "    else:\n",
        "      listaC.append('F')\n",
        "  return listaC\n",
        "# Test\n",
        "assert maxConcentracion(matrizTox) == [30.5, 30.1, 30, 30]\n",
        "assert maxConcentracion(matrizE) == [30.5, 'F', 30.1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dwCWotuDcgWv"
      },
      "source": [
        "### Pregunta 4, strings contenidos\n",
        "\n",
        "Se le pide crear una función contieneString(s1, s2), que recibe una frase y un string corto, donde debe decirnos si es que el string s2 esta contenido en s1, para esto debe ignorar los espacios que puedan estar en la frase s1. Además se asume que, solo importara que los caracteres coincidan, sin importar si son mayusculas o minusculas.\n",
        "Por ejemplo: \n",
        "```python\n",
        "contieneString(\"hola como estas\", \"laco\") retorna True\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0wFbPOZfcHCW"
      },
      "source": [
        "# contieneString: str str -> Bool\n",
        "# Nos dice si el segundo string entregado esta contenido en alguna parte del\n",
        "# primer string\n",
        "# Ejemplo de uso: contieneString(\"hola como estas\", \"laco\") entrega True\n",
        "\n",
        "def contieneString(s1, s2):\n",
        "  # Como debemos ignorar los espacios lo primero que haremos sera, quitar\n",
        "  # todos los posibles espacios existentes en ambos strings\n",
        "  s1_sin_espacios = s1.replace(\" \", \"\")\n",
        "  s2_sin_espacios = s2.replace(\" \", \"\")\n",
        "  # Además nos dicen que solo importan los caracteres por lo que\n",
        "  # en caso de existir mayusculas debemos comparar por el mismo tipo\n",
        "  # asi que pasaremos todo el texto a minuscula\n",
        "  s1_minus = s1_sin_espacios.lower()\n",
        "  s2_minus = s2_sin_espacios.lower()\n",
        "  # ahora que tenemos los tring sin espacios y en minusculas\n",
        "  # podemos preguntar directamente si uno esta en el otro\n",
        "  return s2_minus in s1_minus\n",
        "\n",
        "assert contieneString(\"Hola Como Estas\", \"laco\")\n",
        "assert contieneString(\"Hola Como Estas\", \"LaCo\")\n",
        "assert not contieneString(\"Hola Como Estas\", \"lace\")\n",
        "assert contieneString(\"Hola Como Estas\", \"la co\")"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}