{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Auxiliar 11.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rZqTOiY_AbYq"
      },
      "source": [
        "#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"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O6NX417bPTLp"
      },
      "source": [
        "# b)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Do5W3sVbP0ll"
      },
      "source": [
        "# c)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PG2uyoe-Qeb0"
      },
      "source": [
        "# d)\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": [
        ""
      ],
      "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",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QG0nTm-GXRSn"
      },
      "source": [
        "# parte 2\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DO8amSt4WEAy"
      },
      "source": [
        "# parte 3"
      ],
      "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": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}