SummerCamp_Python2023_MILMadrid_PabloSanchezArias_aka_Paulos_SOLUCIONES_ARCHIVOS.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Autor: Pablo Sánchez Arias (also known as Paûlos/Pa_u_los/Paulitos/...)\n",
        "\n",
        "Linkedin: www.linkedin.com/in/paulitos\n",
        "\n",
        "Fecha de finalización: 01/07/2023"
      ],
      "metadata": {
        "id": "Q7atqUXRaP_X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Summer_Camp_Python MIL Madrid ~ Créditos a Carmen Becker Pombo por el repositorio: https://github.com/carmenbecker/Summer_Camp_Python."
      ],
      "metadata": {
        "id": "vAmO9KQuzkoG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Resolución del archivo Summer_Camp_Python.pdf.\n",
        "\n",
        "Todos los *challenges* resueltos de https://pythonprinciples.com/challenges/."
      ],
      "metadata": {
        "id": "0y5j_WZNzzxt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**1. Capital Indexes**"
      ],
      "metadata": {
        "id": "xfdcSRbR3NyC"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "i4__tgkSzehW"
      },
      "outputs": [],
      "source": [
        "def capital_indexes(string):\n",
        "    indexes = []\n",
        "\n",
        "    # Iterate through the characters and their indices in the string\n",
        "    for index, char in enumerate(string):\n",
        "        if char.isupper():\n",
        "            # If the character is uppercase, add its index to the list\n",
        "            indexes.append(index)\n",
        "\n",
        "    return indexes\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**2. Middle letter**"
      ],
      "metadata": {
        "id": "hmmj_ivP3m-A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def mid(string):\n",
        "    length = len(string)\n",
        "\n",
        "    if length % 2 == 0:\n",
        "        return \"\"\n",
        "    else:\n",
        "        middle_index = length // 2\n",
        "        return string[middle_index]"
      ],
      "metadata": {
        "id": "MXouSNMN3suo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**3. Online status**"
      ],
      "metadata": {
        "id": "ipWqvFmf40xs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def online_count(statuses):\n",
        "    count = 0\n",
        "    for status in statuses.values():\n",
        "        if status == \"online\":\n",
        "            count += 1\n",
        "    return count\n"
      ],
      "metadata": {
        "id": "83hlvKaI45Lb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**4. Randomness**"
      ],
      "metadata": {
        "id": "UgijJQiY6rsl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "def random_number():\n",
        "    return random.randint(1, 100)"
      ],
      "metadata": {
        "id": "6Zy4Gc7K6x34"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**5. Type check**"
      ],
      "metadata": {
        "id": "Nq3IVMc47Ddz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def only_ints(a, b):\n",
        "    if (type(a) == int and type(b) == int):\n",
        "        return True\n",
        "    else:\n",
        "        return False"
      ],
      "metadata": {
        "id": "D8rODWwb7Ge8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**6. Double letters**"
      ],
      "metadata": {
        "id": "9XKgeZoY7j91"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def double_letters(string):\n",
        "    for i in range(len(string) - 1):\n",
        "        if string[i] == string[i + 1]:\n",
        "            return True\n",
        "    return False\n"
      ],
      "metadata": {
        "id": "uKRJ9Sfo7nX8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**7. Adding and removing dots**"
      ],
      "metadata": {
        "id": "vE6JzK1M8ldC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def add_dots(string):\n",
        "    return '.'.join(string)\n",
        "\n",
        "def remove_dots(string):\n",
        "    return string.replace('.', '')"
      ],
      "metadata": {
        "id": "0w_MgdyL8oja"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**8. Counting syllables**"
      ],
      "metadata": {
        "id": "nHYPXLqz9OWa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def count(word):\n",
        "    syllables = word.split(\"-\")\n",
        "    return len(syllables)"
      ],
      "metadata": {
        "id": "hAGxnbFy9SDI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**9. Anagrams**"
      ],
      "metadata": {
        "id": "EQLEsREu99iH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def is_anagram(str1, str2):\n",
        "    return sorted(str1.lower()) == sorted(str2.lower())"
      ],
      "metadata": {
        "id": "Gr45X526-Bxt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**10. Flatten a list**"
      ],
      "metadata": {
        "id": "2XP-aBGg-kXQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Uso de list comprehension\n",
        "def flatten(lst):\n",
        "    return [item for sublist in lst for item in sublist]"
      ],
      "metadata": {
        "id": "Amhi6hlU-nmN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**11. Min-maxing**"
      ],
      "metadata": {
        "id": "10Fvn5UU_LvZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def largest_difference(numbers):\n",
        "    return max(numbers) - min(numbers)"
      ],
      "metadata": {
        "id": "ZUWBJIck_PQI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**12. Divisible by 3**"
      ],
      "metadata": {
        "id": "95MY8z1DAhYt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def div_3(str1):\n",
        "    return str1 % 3 == 0"
      ],
      "metadata": {
        "id": "vdreYzKRAl4o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**13. Tic tac toe input**"
      ],
      "metadata": {
        "id": "88LECeptBGxT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# The ord() function returns the numberrepresenting the unicode code of a specified character\n",
        "def get_row_col(cell):\n",
        "    column = ord(cell[0]) - ord('A')\n",
        "    row = int(cell[1]) - 1\n",
        "    return (row, column)\n"
      ],
      "metadata": {
        "id": "uyuKUwV6BKed"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**14. Palindrome**"
      ],
      "metadata": {
        "id": "3J6oFxAadGiR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def palindrome(str):\n",
        "    return (str[::1] == str[::-1])"
      ],
      "metadata": {
        "id": "xszLIxGadKYd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**15. Up and down**"
      ],
      "metadata": {
        "id": "JwrDfg9zdaFW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def up_down(numba):\n",
        "    lista = [numba-1, numba+1]\n",
        "    return tuple(lista)"
      ],
      "metadata": {
        "id": "mmOVCgqjdeFW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**16. Consecutive zeros**"
      ],
      "metadata": {
        "id": "iClWhzaceTj5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def consecutive_zeros(string):\n",
        "    max_zeros = 0  # Variable to store the maximum consecutive zeros\n",
        "    count = 0  # Variable to keep track of the current consecutive zeros\n",
        "\n",
        "    for char in string:\n",
        "        if char == '0':\n",
        "            count += 1\n",
        "            max_zeros = max(max_zeros, count)\n",
        "        else:\n",
        "            count = 0\n",
        "\n",
        "    return max_zeros"
      ],
      "metadata": {
        "id": "aa2KDcoxeaXE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**17. All Equal**"
      ],
      "metadata": {
        "id": "J9W-xj9ifbl8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def all_equal(lst):\n",
        "    for i in lst:\n",
        "        if i != lst[0]:\n",
        "            return False\n",
        "    return True"
      ],
      "metadata": {
        "id": "qTBa_Ua8ftWD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**18. Boolean and**"
      ],
      "metadata": {
        "id": "I4HAoV2wgXhf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def triple_and(a, b, c):\n",
        "    return (a & b & c)"
      ],
      "metadata": {
        "id": "wapAO3NWgcFQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**19. Writing short code**"
      ],
      "metadata": {
        "id": "JsNXu_7WgqkD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def convert(lst):\n",
        "    return list(map(str, lst))"
      ],
      "metadata": {
        "id": "euUhkVN0gufA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**20. Custom zip**"
      ],
      "metadata": {
        "id": "dTLSA9GUhVqy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def zap(a, b):\n",
        "    min_len = min(len(a), len(b))\n",
        "    result = []\n",
        "    for i in range(min_len):\n",
        "        result.append((a[i], b[i]))\n",
        "    return result\n",
        "# asume que a y b son listas del mismo tamaño"
      ],
      "metadata": {
        "id": "x6x59jiGhaVi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**21. Solution validation**"
      ],
      "metadata": {
        "id": "jpE2KVH4ishY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "\n",
        "def validate(code):\n",
        "    if \"def\" not in code:\n",
        "        return \"missing def\"\n",
        "    if \":\" not in code:\n",
        "        return \"missing :\"\n",
        "    if \"(\" not in code or \")\" not in code:\n",
        "        return \"missing paren\"\n",
        "    if re.search(r\"\\(\\s*\\)\", code): # we need to detect the presence of () as an empty parameter list in the code.\n",
        "        return \"missing param\"\n",
        "    if \"    \" not in code:\n",
        "        return \"missing indent\"\n",
        "    if \"validate\" not in code:\n",
        "        return \"wrong name\"\n",
        "    if \"return\" not in code:\n",
        "        return \"missing return\"\n",
        "    return True\n"
      ],
      "metadata": {
        "id": "DdIgRRw5iweu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**22. List xor**"
      ],
      "metadata": {
        "id": "rd17anKVmC2y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def list_xor(n, list1, list2):\n",
        "    if (n in list1 and n in list2) or (n not in list1 and n not in list2):\n",
        "        return False\n",
        "    else:\n",
        "        return True"
      ],
      "metadata": {
        "id": "Bpz7YGBzmHdx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**23. Counting parameters**"
      ],
      "metadata": {
        "id": "NQSqW9SFnFBv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def param_count(*args):\n",
        "    return len(args)"
      ],
      "metadata": {
        "id": "RCXzHeZPnJm9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**24. Thousands separator**"
      ],
      "metadata": {
        "id": "MnbU1VWcnsIZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def format_number(number):\n",
        "    return '{:,.0f}'.format(number)"
      ],
      "metadata": {
        "id": "uquISAGLqU5p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Hasta aquí todos los problemas ofrecidos de manera gratuita con las soluciones correctas."
      ],
      "metadata": {
        "id": "ZqFbpinCqo__"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A continuación la resolución de los ejercicios del archivo **list1.py**"
      ],
      "metadata": {
        "id": "AKMsb2_rJdnA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.\n",
        "def match_ends(words):\n",
        "    count = 0\n",
        "    for word in words:\n",
        "        if len(word) >= 2 and word[0] == word[-1]:\n",
        "            count += 1\n",
        "    return count\n",
        "\n",
        "# 2.\n",
        "def front_x(words):\n",
        "    x_words = []\n",
        "    other_words = []\n",
        "    for word in words:\n",
        "        if word.startswith('x'):\n",
        "            x_words.append(word)\n",
        "        else:\n",
        "            other_words.append(word)\n",
        "    return sorted(x_words) + sorted(other_words)\n",
        "\n",
        "# 3.\n",
        "def sort_last(tuples):\n",
        "    return sorted(tuples, key=lambda x: x[-1])\n",
        "\n",
        "'''\n",
        "Equivalente a hacer esto\n",
        "\n",
        "  def get_last_element(tuple):\n",
        "      return tuple[-1]\n",
        "\n",
        "  def sort_last(tuples):\n",
        "      return sorted(tuples, key=get_last_element)\n",
        "'''\n",
        "\n",
        "def test(got, expected):\n",
        "    if got == expected:\n",
        "        prefix = ' OK '\n",
        "    else:\n",
        "        prefix = '  X '\n",
        "    print(f'{prefix} got: {repr(got)} expected: {repr(expected)}')\n",
        "\n",
        "def main():\n",
        "    test(match_ends(['aba', 'xyz', 'aa', 'x', 'bbb']), 3)\n",
        "    test(match_ends(['', 'x', 'xy', 'xyx', 'xx']), 2)\n",
        "    test(match_ends(['aaa', 'be', 'abc', 'hello']), 1)\n",
        "\n",
        "    test(front_x(['bbb', 'ccc', 'axx', 'xzz', 'xaa']),\n",
        "       ['xaa', 'xzz', 'axx', 'bbb', 'ccc'])\n",
        "    test(front_x(['ccc', 'bbb', 'aaa', 'xcc', 'xaa']),\n",
        "       ['xaa', 'xcc', 'aaa', 'bbb', 'ccc'])\n",
        "    test(front_x(['mix', 'xyz', 'apple', 'xanadu', 'aardvark']),\n",
        "       ['xanadu', 'xyz', 'aardvark', 'apple', 'mix'])\n",
        "\n",
        "    test(sort_last([(1, 3), (3, 2), (2, 1)]),\n",
        "       [(2, 1), (3, 2), (1, 3)])\n",
        "    test(sort_last([(2, 3), (1, 2), (3, 1)]),\n",
        "       [(3, 1), (1, 2), (2, 3)])\n",
        "    test(sort_last([(1, 7), (1, 3), (3, 4, 5), (2, 2)]),\n",
        "       [(2, 2), (1, 3), (3, 4, 5), (1, 7)])\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    main()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W1pl3sfxJh6l",
        "outputId": "a8e77dec-4bcc-4760-dd73-ca8f7ee94032"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " OK  got: 3 expected: 3\n",
            " OK  got: 2 expected: 2\n",
            " OK  got: 1 expected: 1\n",
            " OK  got: ['xaa', 'xzz', 'axx', 'bbb', 'ccc'] expected: ['xaa', 'xzz', 'axx', 'bbb', 'ccc']\n",
            " OK  got: ['xaa', 'xcc', 'aaa', 'bbb', 'ccc'] expected: ['xaa', 'xcc', 'aaa', 'bbb', 'ccc']\n",
            " OK  got: ['xanadu', 'xyz', 'aardvark', 'apple', 'mix'] expected: ['xanadu', 'xyz', 'aardvark', 'apple', 'mix']\n",
            " OK  got: [(2, 1), (3, 2), (1, 3)] expected: [(2, 1), (3, 2), (1, 3)]\n",
            " OK  got: [(3, 1), (1, 2), (2, 3)] expected: [(3, 1), (1, 2), (2, 3)]\n",
            " OK  got: [(2, 2), (1, 3), (3, 4, 5), (1, 7)] expected: [(2, 2), (1, 3), (3, 4, 5), (1, 7)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Resolución de los ejercicios del archivo **string1.py**"
      ],
      "metadata": {
        "id": "I5KzTP1jL71X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# A. donuts\n",
        "# Given an int count of a number of donuts, return a string\n",
        "# of the form 'Number of donuts: <count>', where <count> is the number\n",
        "# passed in. However, if the count is 10 or more, then use the word 'many'\n",
        "# instead of the actual count.\n",
        "# So donuts(5) returns 'Number of donuts: 5'\n",
        "# and donuts(23) returns 'Number of donuts: many'\n",
        "def donuts(count):\n",
        "  if count >= 10:\n",
        "    return \"Number of donuts: many\"\n",
        "  return \"Number of donuts: \" + str(count)\n",
        "\n",
        "\n",
        "# B. both_ends\n",
        "# Given a string s, return a string made of the first 2\n",
        "# and the last 2 chars of the original string,\n",
        "# so 'spring' yields 'spng'. However, if the string length\n",
        "# is less than 2, return instead the empty string.\n",
        "def both_ends(s):\n",
        "  # +++your code here+++\n",
        "  if len(s) < 2:\n",
        "    return ''\n",
        "  else:\n",
        "    return s[:2] + s[-2:]\n",
        "\n",
        "def fix_start(s):\n",
        "    first_char = s[0]\n",
        "    modified_string = s.replace(first_char, '*')\n",
        "    return first_char + modified_string[1:]\n",
        "\n",
        "def mix_up(a, b):\n",
        "    modified_a = b[:2] + a[2:]\n",
        "    modified_b = a[:2] + b[2:]\n",
        "    return modified_a + ' ' + modified_b\n",
        "\n",
        "def test_donuts():\n",
        "  print(donuts)\n",
        "  # Each line calls donuts, compares its result to the expected for that call.\n",
        "  test(donuts(4), 'Number of donuts: 4')\n",
        "  test(donuts(9), 'Number of donuts: 9')\n",
        "  test(donuts(10), 'Number of donuts: many')\n",
        "  test(donuts(99), 'Number of donuts: many')\n",
        "\n",
        "def test_both_ends():\n",
        "  print (both_ends)\n",
        "  test(both_ends('spring'), 'spng')\n",
        "  test(both_ends('Hello'), 'Helo')\n",
        "  test(both_ends('a'), '')\n",
        "  test(both_ends('xyz'), 'xyyz')\n",
        "\n",
        "def test_fix_start():\n",
        "  print (fix_start)\n",
        "  test(fix_start('babble'), 'ba**le')\n",
        "  test(fix_start('aardvark'), 'a*rdv*rk')\n",
        "  test(fix_start('google'), 'goo*le')\n",
        "  test(fix_start('donut'), 'donut')\n",
        "\n",
        "def test_mix_up():\n",
        "  print (mix_up)\n",
        "  test(mix_up('mix', 'pod'), 'pox mid')\n",
        "  test(mix_up('dog', 'dinner'), 'dig donner')\n",
        "  test(mix_up('gnash', 'sport'), 'spash gnort')\n",
        "  test(mix_up('pezzy', 'firm'), 'fizzy perm')\n",
        "\n",
        "\n",
        "# Standard boilerplate to call the main() function.\n",
        "if __name__ == '__main__':\n",
        "  test_donuts()\n",
        "  test_both_ends()\n",
        "  test_fix_start()\n",
        "  test_mix_up()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YfHljfxoRQDy",
        "outputId": "b3b724c8-d982-4d2c-9a2f-ddf631e0441a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<function donuts at 0x7f792aaf91b0>\n",
            " OK  got: 'Number of donuts: 4' expected: 'Number of donuts: 4'\n",
            " OK  got: 'Number of donuts: 9' expected: 'Number of donuts: 9'\n",
            " OK  got: 'Number of donuts: many' expected: 'Number of donuts: many'\n",
            " OK  got: 'Number of donuts: many' expected: 'Number of donuts: many'\n",
            "<function both_ends at 0x7f792aaf9000>\n",
            " OK  got: 'spng' expected: 'spng'\n",
            " OK  got: 'Helo' expected: 'Helo'\n",
            " OK  got: '' expected: ''\n",
            " OK  got: 'xyyz' expected: 'xyyz'\n",
            "<function fix_start at 0x7f792aaf9870>\n",
            " OK  got: 'ba**le' expected: 'ba**le'\n",
            " OK  got: 'a*rdv*rk' expected: 'a*rdv*rk'\n",
            " OK  got: 'goo*le' expected: 'goo*le'\n",
            " OK  got: 'donut' expected: 'donut'\n",
            "<function mix_up at 0x7f7929dca5f0>\n",
            " OK  got: 'pox mid' expected: 'pox mid'\n",
            " OK  got: 'dig donner' expected: 'dig donner'\n",
            " OK  got: 'spash gnort' expected: 'spash gnort'\n",
            " OK  got: 'fizzy perm' expected: 'fizzy perm'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Solución a los ejercicios del archivo **wordcount1.py**."
      ],
      "metadata": {
        "id": "FwiQRGjPWu7E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import sys\n",
        "\n",
        "def word_count_dict(filename):\n",
        "    \"\"\"Returns a word/count dict for this filename.\"\"\"\n",
        "    word_count = {}\n",
        "    with open(filename, 'r') as file:\n",
        "        for line in file:\n",
        "            words = line.lower().split()\n",
        "            for word in words:\n",
        "                if word in word_count:\n",
        "                    word_count[word] += 1\n",
        "                else:\n",
        "                    word_count[word] = 1\n",
        "    return word_count\n",
        "\n",
        "\n",
        "def print_words(filename):\n",
        "    \"\"\"Prints one per line '<word> <count>' sorted by word\"\"\"\n",
        "    word_count = word_count_dict(filename)\n",
        "    sorted_words = sorted(word_count.items(), key=lambda x: x[0])\n",
        "    for word, count in sorted_words:\n",
        "        print(word, count)\n",
        "\n",
        "\n",
        "def print_top(filename):\n",
        "    \"\"\"Prints the top count listing for the given file.\"\"\"\n",
        "    word_count = word_count_dict(filename)\n",
        "    sorted_words = sorted(word_count.items(), key=lambda x: x[1], reverse=True)\n",
        "    for word, count in sorted_words[:20]:\n",
        "        print(word, count)\n",
        "\n",
        "\n",
        "# calls the print_words() and print_top() functions which you must define.\n",
        "def main():\n",
        "  print(\"testing functions\\n\")\n",
        "  filename = \"small.txt\"\n",
        "  print(\"print_words function\")\n",
        "  print_words(filename)\n",
        "  print(\"\\nprint_top function\")\n",
        "  print_top(filename)\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  main()"
      ],
      "metadata": {
        "id": "4AySNY2dWzNu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bb56324d-dcef-4fd3-9705-35609d602b11"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "testing functions\n",
            "\n",
            "print_words function\n",
            "-- 1\n",
            "are 3\n",
            "at 1\n",
            "be 3\n",
            "but 1\n",
            "coach 1\n",
            "football 1\n",
            "least 1\n",
            "need 1\n",
            "not 3\n",
            "should 1\n",
            "to 2\n",
            "used 1\n",
            "we 6\n",
            "what 3\n",
            "\n",
            "print_top function\n",
            "we 6\n",
            "are 3\n",
            "not 3\n",
            "what 3\n",
            "be 3\n",
            "to 2\n",
            "should 1\n",
            "need 1\n",
            "but 1\n",
            "at 1\n",
            "least 1\n",
            "used 1\n",
            "-- 1\n",
            "football 1\n",
            "coach 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Se prueba con el archivo *small.txt* de manera exitosa.\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "Mcl4DALeY9GG"
      }
    }
  ]
}