HW1_pds_2023_RodrigoSilva_PedroCatarro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:brown\"> Start Here </span> \n",
    "\n",
    "[Please Complete the following form with your details]\n",
    "\n",
    "Student Name - Rodrigo Silva<br>\n",
    "Student id - 20230536<br>\n",
    "Contact e-mail - 20230536@novaims.unl.pt<br>\n",
    "\n",
    "\n",
    "Student Name - Pedro Catarro<br>\n",
    "Student id - 20230463<br>\n",
    "Contact e-mail - 20230463@novaims.unl.pt<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:brown\"> Part 1 -  Variable Declaration and Manipulation </span> \n",
    "\n",
    "## Exercise I - of Lists and Random numbers\n",
    "\n",
    "**1**: Declare a variable X that stores a list of 100 integers randomly sampled between -100 and 100.<br>\n",
    "Note: You are not allowed to use third party libraries -- such as Numpy, Pandas, or Scipy -- in this exercise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "# radom.randint -> Returns a random integer within the range [start, end]\n",
    "# _ -> used when you don´t need to use the variable (we just want to loop 100 times)\n",
    "\n",
    "X = [random.randint(-100,100) for _ in range(100)] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2**: How many odd numbers are in the list X?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 47 odd numbers.\n"
     ]
    }
   ],
   "source": [
    "# Filter(function, iterable), in our case we defined a lambda function that investigate the odds integers in our list\n",
    "# lambda function are used when a function like, filter, map, etc. can take a funtion as a parameter\n",
    "Odds_count = len(list((filter(lambda i: i%2 != 0, X))))\n",
    "\n",
    "print(f\"There are {Odds_count} odd numbers.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.1** Check if there are as many even numbers as there are odd numbers, else discard the list and generate a new one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For our list of 100 elements, to have as many even numbers as there are odd numbers, X needs to have 50 even and 50 odd numbers\n",
    "\n",
    "if Odds_count == 50:\n",
    "    print(\"There are as many even numbers as there are odd numbers.\")\n",
    "else:\n",
    "    new_list = [random.randint(-100,100) for _ in range(100)] # We choosed to generate another random list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.2** Create a pipeline to automatically perform the tasks above such that you avoid having to run the cells multiple times to reach the desired outcome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Odds in X: 49\n",
      "Exercise 2.1 result: [93, 31, 99, -83, 83, -57, -30, -87, 23, -83, 11, 52, -91, 81, -7, 79, -76, -72, -21, -12, 72, -81, -20, 13, -78, -61, 23, 26, -21, -63, -100, -23, -28, -68, 37, -33, -45, 39, -19, -15, 75, -99, 32, -87, 1, -70, 39, -91, -67, 100, -99, -41, -97, 95, -58, 68, 28, -75, -75, -50, -88, 87, 92, -40, 33, 60, -12, -15, 56, -46, 82, -92, -26, 86, -91, -21, -7, 16, -5, 8, 62, -94, -86, 67, -4, -30, -32, 43, 45, -95, 52, -35, 85, 55, -81, 15, -63, 24, 52, 93]\n"
     ]
    }
   ],
   "source": [
    "# Exercise 1\n",
    "X = [random.randint(-100,100) for _ in range(100)] \n",
    "# Exercise 2\n",
    "Odds_count = len(list(filter(lambda i: i%2 != 0, X)))\n",
    "# Exercise 2.1\n",
    "if Odds_count == 50:\n",
    "    result = \"There are as many even numbers as there are odd numbers\"\n",
    "else:\n",
    "    result = [random.randint(-100,100) for _ in range(100)] \n",
    "\n",
    "print(f\"Number of Odds in X: {Odds_count}\\nExercise 2.1 result: {result}\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3**: Print the number of digits that the 5th and 100th element of the list have. <br>\n",
    "*Note: For instance, the number 1 contains one digit, the number 10 contains two digits, the number -2 contains one digit.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 5th element is -9 and it contains 1 digit(s).\n",
      "The 100th element is 10 and it contains 2 digit(s).\n"
     ]
    }
   ],
   "source": [
    "# We used abs so the len dont count with the minus (-)\n",
    "number_of_digits_5th = len(str(abs(X[4])))\n",
    "number_of_digits_100th = len(str(abs(X[-1]))) # [-1] results here because we know that X has 100 elements\n",
    "\n",
    "print(f\"The 5th element is {X[4]} and it contains {number_of_digits_5th} digit(s).\\nThe 100th element is {X[-1]} and it contains {number_of_digits_100th} digit(s).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4**: Is the sum total of all the numbers in the list even or odd?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total sum = -61. The Total sum is odd.\n"
     ]
    }
   ],
   "source": [
    "if sum(X) % 2 == 0:\n",
    "    print(f\"Total sum = {sum(X)}. The Total sum is even.\")\n",
    "else:\n",
    "    print(f\"Total sum = {sum(X)}. The Total sum is odd.\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5**: What is the average of the list X?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The avarage of the list X is -0.61.\n"
     ]
    }
   ],
   "source": [
    "Xavarage = sum(X) / len(X)\n",
    "\n",
    "print(f\"The avarage of the list X is {Xavarage}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5.1.** What is the population standard deviation? <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The population standard deviation is 56.75947409904359.\n"
     ]
    }
   ],
   "source": [
    "# We created a list of squared differences between each element and the mean of X\n",
    "list_of_diff_nums_vs_mean_squared = list(map(lambda x: (x - Xavarage)**2, X))\n",
    "# Calculating the population standard deviation\n",
    "population_standart_dev = pow(sum(list_of_diff_nums_vs_mean_squared)/len(X), 0.5)\n",
    "\n",
    "print(f\"The population standard deviation is {population_standart_dev}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**6**: Sort list X in descending order and store the result in variable Xsort. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xsort = sorted(X, reverse = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**6.1** Then replace each value in Xsort with index i as the sum of the values with index i-1 and i. <br> \n",
    "\n",
    "*Note: Consider that Xsort[-1] = 0.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 200, 299, 396, 489, 582, 675, 761, 846, 921, 995, 1068, 1140, 1212, 1284, 1355, 1421, 1483, 1545, 1605, 1664, 1722, 1779, 1831, 1880, 1928, 1973, 2017, 2057, 2092, 2122, 2149, 2174, 2195, 2215, 2234, 2251, 2267, 2282, 2297, 2311, 2325, 2335, 2344, 2352, 2357, 2357, 2356, 2354, 2351, 2347, 2342, 2335, 2327, 2318, 2308, 2297, 2285, 2271, 2257, 2242, 2225, 2207, 2185, 2160, 2131, 2102, 2070, 2036, 2001, 1964, 1924, 1881, 1836, 1788, 1740, 1691, 1637, 1583, 1527, 1471, 1411, 1345, 1278, 1211, 1144, 1073, 999, 925, 849, 772, 685, 597, 508, 417, 325, 231, 134, 37, -61]\n"
     ]
    }
   ],
   "source": [
    "for i in range(100):\n",
    "    if i > 0: # i > 0 so the fisrt element in Xsort stays the same, because by definition Xsort[-1] = 0\n",
    "        Xsort[i] = Xsort[i-1] + Xsort[i]\n",
    "print(Xsort)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise II - we have a gamer in the room\n",
    "\n",
    "**7**: Consider the dictionaries  *purchases* and *clients* that are declared in the cell below. <br>\n",
    "Create a list with the names of the clients who bought more than one videogame. Print the List. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "purchases = {\n",
    "    \n",
    "    \"1539\":\"Red dead redemption II\",\n",
    "    \"9843\":\"GTA V,FarCry 5, watchdogs II\",\n",
    "    \"8472\":\"Canis Canem Edit\",\n",
    "    \"3874\":\"Watchdogs II,South Park: The Stick of Truth\",\n",
    "    \"5783\":\"AC: The Ezio Collection, watchdogs ii\",\n",
    "    \"9823\":\"For Honor,The Forest,South Park: The Fractured but whole\"\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Morty Smith', 'Mildred Ratched', 'Alex Vause', 'Sheldon Cooper']\n"
     ]
    }
   ],
   "source": [
    "clients = {\n",
    "    \n",
    "    \"1539\":\"Rick Sanchez\",\n",
    "    \"9843\":\"Morty Smith\",\n",
    "    \"8472\":\"Eve Polastri\",\n",
    "    \"3874\":\"Mildred Ratched\",\n",
    "    \"5783\":\"Alex Vause\",\n",
    "    \"9823\":\"Sheldon Cooper\"\n",
    "    \n",
    "}\n",
    "\n",
    "# games.split(\",\") -> Splits games strings into a list of individual games\n",
    "clients_purchases = {clients.get(purchases_id): games.split(\",\") for purchases_id, games in purchases.items()}\n",
    "\n",
    "# Update the dictionary:\n",
    "    # [game.lower().strip() for game in games] -> updates each string (lower case & get rid of the space on the left and right) \n",
    "clients_purchases = {client: [game.lower().strip() for game in games] for client, games in clients_purchases.items()}\n",
    "\n",
    "# len(games) > 1 -> games list as more than one video game\n",
    "result = [client for client, games in clients_purchases.items() if len(games) > 1]\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**7.1** What is the name of the client that bought more videogames?\n",
    "\n",
    "*Tip: You will want to check the methods associated with string manipulation. See the link: <br>\n",
    "https://python-reference.readthedocs.io/en/latest/docs/unicode/index.html*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The client that bought more videogames is Morty Smith.\n",
      "The client that bought more videogames is Sheldon Cooper.\n"
     ]
    }
   ],
   "source": [
    "client_games_counter = {client: len(games) for client, games in clients_purchases.items()}\n",
    "\n",
    "# This part of the code is used because we have two players with the same number of games purchased\n",
    "max_games = max(client_games_counter.values())\n",
    "result = [client for client, games_count in client_games_counter.items() if games_count == max_games]\n",
    "\n",
    "for name in result:\n",
    "    print(f\"The client that bought more videogames is {name}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**7.2** What is the name of the most popular videogame?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The most popular videogame is watchdogs ii.\n"
     ]
    }
   ],
   "source": [
    "list_of_games = [game for games in clients_purchases.values() for game in games]\n",
    "\n",
    "games_counter = {game: list_of_games.count(game) for game in list_of_games}\n",
    "\n",
    "# Although the max counter is not repeating here, we decided to go with the same strategy, because in other examples the problem could append\n",
    "max_value = max(games_counter.values())\n",
    "result = [game for game, counter in games_counter.items() if counter == max_value]\n",
    "\n",
    "for game in result:\n",
    "    print(f\"The most popular videogame is {game}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:brown\"> Part 2 -  Data loading and analysis  </span>\n",
    "\n",
    "## Exercise I - Alice what do you have to say?\n",
    "\n",
    "**8**: Load the Alice text file into a variable called Alice. <br>\n",
    "\n",
    "*Note: Use a relative filepath in relation to the location of your notebook.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"alice.txt\", \"r\") as file:\n",
    "    Alice = file.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**9**: Create a list in which each element is a word from the file *Alice*. Store that list in a variable called *wAlice*. <br>\n",
    "\n",
    "*Note: You will need to do some text parsing here. In particular to split the sentences into words. It is also a good practice to normalize words so that words \"Hello\" and \"hello\" become identical, by making all letters lower case. <br>*\n",
    "\n",
    "*Tip: check the following links for a discussion on regular expressions. Also consult the methods available for string manipulation.*\n",
    "\n",
    "https://docs.python.org/3/library/re.html\n",
    "\n",
    "https://stackoverflow.com/questions/1276764/stripping-everything-but-alphanumeric-chars-from-a-string-in-python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# re module in Python is used to work with text data. \"re\" means Regular Expressions = Patterns, that are used to make our job easy\n",
    "import re\n",
    "\n",
    "# The Alice text has a lot of problems that are contaminating our path to the final target (Create a list in which each element is a word from the file Alice)\n",
    "\n",
    "wAlice = []\n",
    "text = Alice.lower().split() # text is a list with splited words in \" \" and with all letters lower case\n",
    "\n",
    "for words in text:\n",
    "    pattern = re.compile(\"[\\W_]+\") # Here we defined our pattern: \"[]\" -> Used to indicate a set of characters; \"\\W\" -> Matches any character which is not a word character(not including underscore); \"_\"-> So we include underscore in our pattern; \"+\" -> Causes the resulting RE to match 1 or more repetitions of the preceding RE\n",
    "    modified_words = pattern.sub(\"\", words) # Here we used our pattern to substitute (in this case remove) all occurrences of the pattern in words \n",
    "    wAlice.append(modified_words)\n",
    "    \n",
    "# Now wAlice is a list in which each element is a word from the file Alice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Using the list *wAlice* answer the following questions:<br>\n",
    "**10**: How many words are in the file Alice.txt? <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 57 words in Alice.txt.\n"
     ]
    }
   ],
   "source": [
    "number_of_words_in_Alice = len(wAlice)\n",
    "\n",
    "print(f\"There are {number_of_words_in_Alice} words in Alice.txt.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**11**: What is the longest and smallest word in the text file?\n",
    "\n",
    "*Note: Length in this case is measured in terms of the number of characters.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longest word: conversations\n",
      "Smallest word: a\n"
     ]
    }
   ],
   "source": [
    "# key = len -> We are comparing the elements by the len\n",
    "smallest = min(wAlice, key = len)\n",
    "longest = max(wAlice, key = len)\n",
    "\n",
    "print(f\"Longest word: {longest}\\nSmallest word: {smallest}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**12**: Delete all the repeated words from *wAlice*. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# non_repeated_words is a list with no repeated words from wAlice\n",
    "non_repeated_words = list(set(wAlice))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**12.1**:How many different words does the text contain?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 41 different words.\n"
     ]
    }
   ],
   "source": [
    "diff_words = len(non_repeated_words)\n",
    "\n",
    "print(f\"There are {diff_words} different words.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise II - of Countries I Love\n",
    "\n",
    "Consider the list countries in the cell below. <br>\n",
    "It consists of a list of the 3-digit ISO codes of a set of countries of interest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "countries = [\n",
    "\n",
    "('PRT','Portugal','Europe'),\n",
    "('ISL','Israel','Asia'),\n",
    "('COL','Colombia','South America'),\n",
    "('NEV','Nevada','North America'),\n",
    "('JPN','Japan','Asia'),\n",
    "('RUS','Russia','well... which part?'),\n",
    "('DEN','Denmark','Europe'),\n",
    "('NOR','Norway','Europe')\n",
    "    \n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Now consider the file *cdata.csv* that you should download.** <br>\n",
    "\n",
    "The file contains several information about countries, and is organized as follows:\n",
    "1. Column 1 is the 3-digit **ISO Code**\n",
    "2. Column 2 is the **Full Name** of the country\n",
    "3. Column 3 is the **Continent** of the country\n",
    "4. Column 4 is the **Population Size** in 2010\n",
    "5. Column 5 is the **GDP per capita** in 2010"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**13**: Using the Library CSV from Python STL, load the file *cdata.csv* into an object called *raw*. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "with open('cdata.csv', 'r') as file:\n",
    "    raw = list(csv.reader(file))\n",
    "\n",
    "# raw is a list of lists, where each list represents a row in the CSV file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**13.1**: Create a dictionary called *cData* in which the key corresponds to the 3-digit ISO Code and the value is a tuple with the information contained in the 2nd to the 5th of column of the cdata file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "cData = {row[0]: (row[1], row[2], row[3], row[4]) for row in raw[1:]} # iterate from the first row so we don´t get the features names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**14**: Using *cData*, identify what is the most common Continent among the nations in the list *countries*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The most common Continent among the nations in the list countries is Europe.\n",
      "The most common Continent among the nations in the list countries is Asia.\n"
     ]
    }
   ],
   "source": [
    "# Although Nevada and Colombia were not in cData we decided to maintain them in our coutries list\n",
    "\n",
    "# We decided to transform countries in a list of lists so we can make assignments\n",
    "countries = [list(tuples) for tuples in countries] \n",
    "\n",
    "# Here we are correcting all continents in countries according to cData\n",
    "for cData_tuples in cData.values():\n",
    "    for i in range(len(countries)):\n",
    "        if countries[i][1] in cData_tuples:\n",
    "            countries[i][2] = cData_tuples[1]\n",
    "            break # We used break so when the loop finds the country in cData it stops searching in countries list\n",
    "    \n",
    "\n",
    "# Know that countries have all continents correct according to cData\n",
    "            \n",
    "\n",
    "# We created a list with all the continents and a dict to count the continents in countries\n",
    "list_of_continents = [lists[2] for lists in countries]\n",
    "dict_count_continents = {continent: list_of_continents.count(continent) for continent in list_of_continents}\n",
    "\n",
    "# We used this method again so any continent escape \n",
    "max_value = max(dict_count_continents.values())\n",
    "result = [continent for continent, counter in dict_count_continents.items() if counter == max_value]\n",
    "\n",
    "\n",
    "for continent in result:\n",
    "    print(f\"The most common Continent among the nations in the list countries is {continent}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**15**: Using *cData*, identify what is the the most populated nation in the list *countries*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The the most populated nation in the list countries is Russia.\n"
     ]
    }
   ],
   "source": [
    "# Already with countries as a list of list modified by exericse 14\n",
    "\n",
    "dict_population = {}\n",
    "\n",
    "for cData_tuples in cData.values(): # Same strategy  here\n",
    "    for i in range(len(countries)):\n",
    "        if countries[i][1] in cData_tuples:\n",
    "            countries[i][2] = cData_tuples[2]\n",
    "            dict_population.setdefault(countries[i][1], countries[i][2]) \n",
    "            break\n",
    "\n",
    "# We used a key to change the dict values to floats so max() function can compare dict_population by numbers \n",
    "# If we hadn't put this key=lambda... here, max() had analyzed the key (country name) that comes last in the lexicographic order\n",
    "max_pop_country = max(dict_population, key = lambda x: float(dict_population[x]))\n",
    "\n",
    "print(f\"The the most populated nation in the list countries is {max_pop_country}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**16**: Compare the average GDP per capita of the nations in the list *countries* with the average GDP of the countries in cdata file. What can you conclude?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average GDP of the countries is 38242.63072863724 and is greater than 18014.65454394603, which corresponds to the average GDP of the cData.\n"
     ]
    }
   ],
   "source": [
    "# Already with countries as a list of list modified by exericse 15\n",
    "\n",
    "list_GDP_cData = [] # Stores cData GDP\n",
    "list_GDP_countries = [] # Stores countries GDP\n",
    "\n",
    "for cData_tuples in cData.values(): # Same strategy  here, \n",
    "    list_GDP_cData.append(float(cData_tuples[-1])) # Here we are appending each one of the GDP values in cData so we can do the avarage later / We transformed the strings to float so we could calculate the avarage\n",
    "    for i in range(len(countries)): \n",
    "        if countries[i][1] in cData_tuples:\n",
    "            countries[i][2] = cData_tuples[-1]\n",
    "            list_GDP_countries.append(float(cData_tuples[-1])) # Here we are appending each one of the GDP values in countries (cData values) so we can do the avarage later\n",
    "            break\n",
    "\n",
    "avarage_GDP_cData = sum(list_GDP_cData) / len(list_GDP_cData)\n",
    "avarage_GDP_countries = sum(list_GDP_countries) / len(list_GDP_countries)\n",
    "\n",
    "print(f\"The average GDP of the countries is {avarage_GDP_countries} and is greater than {avarage_GDP_cData}, which corresponds to the average GDP of the cData.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:brown\"> Part 3 - Functions hurt nobody </span>\n",
    "\n",
    "## Exercise I - I hate math\n",
    "\n",
    "##### Consider the following equation:\n",
    "\n",
    "\\begin{equation}\n",
    "    y = 6x^2 + 3x + 2\n",
    "\\end{equation}\n",
    "\n",
    "**17**: Write a function called *f* that takes one argument, x, and returns y according to the equation above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    \"\"\"\n",
    "    Solves the equation:  $ y = 6x^2 + 3x + 2 $\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    \n",
    "    x: integer or float\n",
    "        The number used to solve our equation\n",
    "        \n",
    "    Returns\n",
    "    ----------\n",
    "    \n",
    "    y: integer or float\n",
    "        The result of our equation\n",
    "    \"\"\"\n",
    "    \n",
    "    y = 6*x**2 + 3*x + 2\n",
    "    \n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**17.1**: Call the function for x = 2 and print the answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "answer = f(2) # Calling the function for x = 2\n",
    "\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Consider the following sequence of numbers:\n",
    "\n",
    "\\begin{equation}\n",
    "    x_0 = 0; ~~~ ~~~ ~~~ ~~ ~~~ ~~~ ~~~ ~~~ ~~~ ~~~ ~~~ ~~ ~~~ ~~~ ~~~ ~~ ~~~ ~~~ ~~~ ~~ ~ ~~~ ~~~ ~~~ ~~ ~~~ ~~~ ~~~ ~~ ~~~ ~~~ ~~~ ~~ ~~~ ~~~ ~~~ ~~ \\\\\n",
    "    x_{n} = x_{n-1} - n; ~~~ \\textit{ if} ~~~ x_{n-1}-n > 0 ~~~ \\textit{ and is not already in the sequence}\\\\\n",
    "    x_{n} = x_{n-1} + n; ~~~ \\textit{ otherwise} ~~~ ~~~ ~~~ ~~~ ~~ ~~~ ~~~ ~~~ ~~~ ~~~ ~ ~~~ ~~~ ~~~ ~~~ ~~~ ~~~ ~ ~~~ ~~~ ~~~~ ~~~ ~~~ ~~~ ~ \\\\\n",
    "\\end{equation}\n",
    "\n",
    "**17.2**: Write a function that returns the nth digit of the above defined sequence. <br>\n",
    "\n",
    "*Note: the above sequence is also known as the Recamán's sequence, and it was invnted by Bernardo Recamán Santos (Bogotá, Colombia)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Recamans(n):\n",
    "    \"\"\"\n",
    "    Returns the nth digit of a Recamán's sequence\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    \n",
    "    n: integer\n",
    "        The used to know what is the nth element of the Recamán's sequence\n",
    "        \n",
    "    Returns\n",
    "    ----------\n",
    "    \n",
    "    nth_digit: integer\n",
    "        The nth digit of the Recamán's sequence\n",
    "    \"\"\"\n",
    "    Recamans_list = [0] # We started with a list with zero inside because we know that the first element of recamans list is zero\n",
    "\n",
    "    for i in range(1,n): \n",
    "        if Recamans_list[i-1] - i > 0 and Recamans_list[i-1] - i not in Recamans_list:\n",
    "            Xn = Recamans_list[i-1] - i\n",
    "            Recamans_list.append(Xn)\n",
    "        else:\n",
    "            Xn = Recamans_list[i-1] + i\n",
    "            Recamans_list.append(Xn)\n",
    "            \n",
    "    nth_digit = Recamans_list[n-1] # or Recamans_list[-1]\n",
    "    \n",
    "    return nth_digit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**17.3** Write a function named isPrime that takes an integer as input and outputs True if the number is prime and False if the number if not prime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isPrime(x):\n",
    "    \"\"\"\n",
    "    Identify if an integer is prime or not\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    \n",
    "    x: positive integer -> only natural numbers\n",
    "        Integer that we want to test\n",
    "        \n",
    "    Returns\n",
    "    ----------\n",
    "    \n",
    "    True or False: boolean\n",
    "        True if the integer is prime\n",
    "        False if the integer is not prime\n",
    "    \"\"\"\n",
    "    if x==0 or x==1:\n",
    "        return(False)\n",
    "    elif (x!= 2 and x % 2 == 0) or (x!=3 and x % 3 == 0) or (x!=5 and x % 5 == 0) or (x!=7 and x % 7 == 0):\n",
    "        return(False)\n",
    "    else:\n",
    "        return(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**17.4** Test your function against some examples to show that it works as expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 is prime? True\n",
      "2 is prime? True\n",
      "1 is prime ? False\n",
      "11 is prime ? True\n",
      "279 is prime? False\n"
     ]
    }
   ],
   "source": [
    "print(f\"3 is prime? {isPrime(3)}\\n2 is prime? {isPrime(2)}\\n1 is prime ? {isPrime(1)}\\n11 is prime ? {isPrime(11)}\\n279 is prime? {isPrime(279)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise II - Monty Hall Problem\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**18**: The Monty Hall Problem is a probability puzzle loosely based on the American television game show \"Let's Make a Deal\" and named after its original host, Monty Hall. The puzzle can be stated as follows\n",
    "\n",
    "> Suppose you're on a game show, and you're given the choice of three doors: Behind one door is a car; behind the others, goats. You pick a door, say No. 1, and the host, who knows what's behind the doors, opens another door, say No. 3, which has a goat. He then says to you, \"Do you want to pick door No. 2?\" Is it to your advantage to switch your choice? <br>\n",
    "+info: https://en.wikipedia.org/wiki/Monty_Hall_problem\n",
    "\n",
    "While intuitively your guess might be that the chances of winning the car is 1/3 independently of the choice to switch doors or not. Howewver, the odds of winning if you switch doors are 2/3 and greater than if you decide not to switch. While there are theoretical solutions to this problem that allow us to estimate the correct odds of winning in each scenario -- switching or not doors -- an alternative way to proof such outcome is through computer simulations. That is the goal of this exercise, to write the necessary components to simulate the Monty Hall problem and validate the theoretical results through simulations.\n",
    "\n",
    "In this exercise, start by implementing a function that simulates one instance of the Monty Hall problem. \n",
    "In that sense, write a function called MontyHall that accepts **one argument**:\n",
    "- A boolean (True/False, or 1/0) that specifies if the player switches doors or not (after the host has opened his door, which contains a goat).\n",
    "The function should return True if the player wins the car or False if not.\n",
    "\n",
    "Naturally, for the function to reproduce the contest it needs to consider and perform some actions, such as:\n",
    "- Set up the game, that is, create the necessary variables to store the information about three doors and what they have behind, as well as an indicator to track the choice of the player.\n",
    "- Given the initial choice of the player, simulate the opening of one of the two remaining doors that contains a goat.\n",
    "- Given the last two doors left, simulate if the player wants to switch or not his/her choice given their strategy (defined by the input boolean argument of the function).\n",
    "- Output the result, if the contestant correctly guesses which door hides the car or if not.\n",
    "\n",
    "The function MontyHall should simulate one instance of the contest given the choice of the player (to switch or not).\n",
    "\n",
    "**The goal is to understand, statistically, which action leads to the highest probability of winning.** <br>\n",
    "*Note: You should use the library random to solve this exercise.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def MontyHall(switch):\n",
    "    \"\"\"\n",
    "    Solves the MontyHall problem \n",
    "    \n",
    "    The problem was resolved thinking about the player (us) passing towards the show different events\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    \n",
    "    switch: boolean\n",
    "        True if player switches door\n",
    "        False if player not switches door\n",
    "        \n",
    "    Returns\n",
    "    ----------\n",
    "    \n",
    "    True or False: string\n",
    "        True if player wins the car\n",
    "        False if player loses the car\n",
    "    \"\"\"\n",
    "    \n",
    "    doors = [\"goat\", \"goat\", \"car\"]\n",
    "    random.shuffle(doors) # We chosed to shuffle the things behind the doors\n",
    "    door_chosen_by_me = random.randint(0,2) # Our door choice \n",
    "    \n",
    "    # This part of the code gives us the host door choice\n",
    "    \n",
    "    # For each door\n",
    "    for i in range(3): \n",
    "        # If the door is not my choice and there is no car behind it\n",
    "        if i!= door_chosen_by_me and doors[i]!= \"car\":\n",
    "            door_chosen_by_monty = i\n",
    "            break # loop breaks when the host when it finds the first door without car\n",
    "    \n",
    "    # Here we are simulating our final choice\n",
    "    # We decided to pop the doors decisions that were not our final coice\n",
    "    if switch == True:\n",
    "        if door_chosen_by_me > door_chosen_by_monty:\n",
    "            doors.pop(door_chosen_by_me)\n",
    "            doors.pop(door_chosen_by_monty)\n",
    "        \n",
    "        else:\n",
    "            doors.pop(door_chosen_by_monty)\n",
    "            doors.pop(door_chosen_by_me)\n",
    "            \n",
    "        result = doors[0] # index 0 because at this time doors only have 1 item left, our final result\n",
    "    else:\n",
    "        result = doors[door_chosen_by_me]\n",
    "        \n",
    "    # We decided to return True or False in strings and not in booleans, because professors does not specify \n",
    "    if result == \"car\":\n",
    "        return(\"True\")\n",
    "    else:\n",
    "        return(\"False\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**18.1** Now that you have a function that simulates an instance of the Monty Hall problem, implement an experiment where you repeat many times (thousands of times) for each of the two possible scenarios: player switching the door, and player not switcing the door. Keep track of the results and estimate the frequencies of wins for each scenario and discuss if the results are inline with the theoretical odds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frequency of winning if you switch: 0.66618.\n",
      "Frequency of winning if you do not switch: 0.33177.\n"
     ]
    }
   ],
   "source": [
    "switch_win = 0\n",
    "dont_switch_win = 0\n",
    "\n",
    "for _ in range(100000):\n",
    "    if MontyHall(True) == \"True\": # switching door and winning\n",
    "        switch_win += 1\n",
    "    if MontyHall(False) == \"True\": # not switching door and winning\n",
    "        dont_switch_win += 1\n",
    "\n",
    "print(f\"Frequency of winning if you switch: {switch_win/100000}.\\nFrequency of winning if you do not switch: {dont_switch_win/100000}.\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise III\n",
    "\n",
    "**19**: Consider the list *A*, declared below. <br>\n",
    "Use the function map() to change the values of A by adding 1 to each value if it is even and subtracting 1 to it otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [460,3347,3044,490,699,1258,1804,973,2223,3416,2879,1058,2915,2422,351,1543,1020,208,643,795,3337,2585,471,2623,1077]\n",
    "A = list(map(lambda x: x+1 if x%2==0 else x-1, A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**20**: Create a list B with the same size of A, where each element is True if the associated value in list A is greater than 700, else is False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We are using list A modified because of the exercise 19\n",
    "B = list(map(lambda x: x > 700, A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**21**: Create a list L that contains the Logarithm of base 10 of each value in A. <br>\n",
    "\n",
    "*Note: You should use the module math to solve this exercise.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We are using list A modified because of the exercise 19\n",
    "import math\n",
    "\n",
    "L = list(map(lambda x: math.log10(x), A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**22**: How many numbers in A are greater than 1000? <br>\n",
    "\n",
    "*Note: You should use the function filter().*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 16 numbers greater than 1000 in A.\n"
     ]
    }
   ],
   "source": [
    "# We are using list A modified because of the exercise 19\n",
    "list22 = list(filter(lambda x: x > 1000, A))\n",
    "number_of_items = len(list22)\n",
    "\n",
    "print(f\"There are {number_of_items} numbers greater than 1000 in A.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**23** Use the function isPrime, that you declared in 17.3, to identify which numbers from A are prime. Note that depending on your implementation of isPrime this task can take more or less time. Use filter to achieve this task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list of numbers from A  that are prime is [461, 491, 1259, 2423, 1021, 209].\n"
     ]
    }
   ],
   "source": [
    "# We are using list A modified because of the exercise 19\n",
    "print(f\"The list of numbers from A  that are prime is {list(filter(isPrime, A))}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Congratulations, it is done!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![LEO_GOOD_JOB](https://www.idlememe.com/wp-content/uploads/2022/01/good-job-meme-idlememe-3.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}