diff --git a/bus/poad_solution_bus.ipynb b/bus/poad_solution_bus.ipynb new file mode 100644 index 0000000..6660225 --- /dev/null +++ b/bus/poad_solution_bus.ipynb @@ -0,0 +1,172 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bus\n", + "\n", + "This bus has a passenger entry and exit control system to monitor the number of occupants it carries and thus detect when there is too high a capacity.\n", + "\n", + "At each stop the entry and exit of passengers is represented by a tuple consisting of two integer numbers.\n", + "```\n", + "bus_stop = (in, out)\n", + "```\n", + "The succession of stops is represented by a list of these tuples.\n", + "```\n", + "stops = [(in1, out1), (in2, out2), (in3, out3), (in4, out4)]\n", + "```\n", + "\n", + "## Goals:\n", + "* lists, tuples\n", + "* while/for loops\n", + "* minimum, maximum, length\n", + "* average, standard deviation\n", + "\n", + "## Tasks\n", + "1. Calculate the number of stops.\n", + "2. Assign to a variable a list whose elements are the number of passengers at each stop (in-out),\n", + "3. Find the maximum occupation of the bus.\n", + "4. Calculate the average occupation. And the standard deviation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# variables\n", + "#stops = [(on1, off1), (on2, off2), (on3, off3), (on4, off4)]\n", + "stops = [(2,0), (1,2), (5,3), (4,2)]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n" + ] + } + ], + "source": [ + "# 1. Calculate the number of stops.\n", + "print(len(stops))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Passengers entering [2, 1, 5, 4]\n", + "Passengers exiting [0, 2, 3, 2]\n", + "Number of passengers at each stop is [2, 1, 3, 5]\n" + ] + } + ], + "source": [ + "stop_list_on = []\n", + "stop_list_off = []\n", + "for i in stops:\n", + " stop_list_on.append(i[0])\n", + " stop_list_off.append(i[1])\n", + "print(\"Passengers entering \", stop_list_on)\n", + "print(\"Passengers exiting \", stop_list_off)\n", + "\n", + "# 2. Assign a variable a list whose elements are the number of passengers in each stop:\n", + "bus_occupancy = []\n", + "stop_occupancy = 0\n", + "for i in range(len(stop_list_on)):\n", + " stop_occupancy += (stop_list_on[i] - stop_list_off[i])\n", + " bus_occupancy.append(int(stop_occupancy)) \n", + "print(\"Number of passengers at each stop is\", bus_occupancy)\n", + "# Each item depends on the previous item in the list + in - out.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "# 3. Find the maximum occupation of the bus.\n", + "print(max(bus_occupancy))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average occupancy 2.75\n", + "Standard deviation of the occupancy is 1.479019945774904\n" + ] + } + ], + "source": [ + "# 4. Calculate the average occupation. And the standard deviation.\n", + "avg_occupancy = (sum(bus_occupancy) / len(bus_occupancy))\n", + "print(\"Average occupancy\", avg_occupancy)\n", + "\n", + "summation = 0\n", + "for i in bus_occupancy:\n", + " summation += (i - avg_occupancy) ** 2\n", + "std_dev = (summation / len(bus_occupancy)) ** 0.5\n", + "print(\"Standard deviation of the occupancy is\", std_dev)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/duel/poad_solution.ipynb b/duel/poad_solution.ipynb new file mode 100644 index 0000000..4ee5f6a --- /dev/null +++ b/duel/poad_solution.ipynb @@ -0,0 +1,309 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Duel of sorcerers\n", + "You are witnessing an epic battle between two powerful sorcerers: Gandalf and Saruman. Each sorcerer has 10 spells of variable power in their mind and they are going to throw them one after the other. The winner of the duel will be the one who wins more of those clashes between spells. Spells are represented as a list of 10 integers whose value equals the power of the spell.\n", + "```\n", + "gandalf = [10, 11, 13, 30, 22, 11, 10, 33, 22, 22]\n", + "saruman = [23, 66, 12, 43, 12, 10, 44, 23, 12, 17]\n", + "```\n", + "For example:\n", + "1. The first clash is won by Saruman: 10 against 23, wins 23\n", + "2. The second clash wins Saruman: 11 against 66, wins 66\n", + "3. etc.\n", + "\n", + "\n", + "You will create two variables, one for each sorcerer, where the sum of clashes won will be stored. Depending on which variable is greater at the end of the duel, you will show one of the following three results on the screen:\n", + "* Gandalf wins\n", + "* Saruman wins\n", + "* Tie\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Assign spell power lists to variables\n", + "\n", + "gandalf = [10, 11, 13, 30, 22, 11, 10, 33, 22, 22]\n", + "saruman = [23, 66, 12, 43, 12, 10, 44, 23, 12, 17]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Assign 0 to each variable that stores the victories\n", + "g_wins = 0\n", + "s_wins = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Execution of spell clashes\n", + "for i in range(len(gandalf)):\n", + " if gandalf[i] > saruman [i]:\n", + " g_wins += 1\n", + " else:\n", + " s_wins += 1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gandalf wins\n" + ] + } + ], + "source": [ + "# We check who has won, do not forget the possibility of a draw.\n", + "# Print the result based on the winner.\n", + "if g_wins > s_wins:\n", + " print(\"Gandalf wins\")\n", + "elif g_wins < s_wins:\n", + " print(\"Saruman wins\")\n", + "else:\n", + " print(\"Tie\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Goals\n", + "\n", + "1. Treatment of lists\n", + "2. Use of **for loop**\n", + "3. Use of conditional **if-elif-else**\n", + "4. Use of the functions **range(), len()**\n", + "5. Print" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bonus\n", + "\n", + "1. Spells now have a name and there is a dictionary that relates that name to a power.\n", + "2. A sorcerer wins if he succeeds in winning 3 spell clashes in a row.\n", + "3. Average of each of the spell lists.\n", + "4. Standard deviation of each of the spell lists.\n", + "\n", + "```\n", + "POWER = {\n", + " 'Fireball': 50, \n", + " 'Lightning bolt': 40, \n", + " 'Magic arrow': 10, \n", + " 'Black Tentacles': 25, \n", + " 'Contagion': 45\n", + "}\n", + "\n", + "gandalf = ['Fireball', 'Lightning bolt', 'Lightning bolt', 'Magic arrow', 'Fireball', \n", + " 'Magic arrow', 'Lightning bolt', 'Fireball', 'Fireball', 'Fireball']\n", + "saruman = ['Contagion', 'Contagion', 'Black Tentacles', 'Fireball', 'Black Tentacles', \n", + " 'Lightning bolt', 'Magic arrow', 'Contagion', 'Magic arrow', 'Magic arrow']\n", + "```\n", + "\n", + "Good luck!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# 1. Spells now have a name and there is a dictionary that relates that name to a power.\n", + "# variables\n", + "\n", + "POWER = {\n", + " 'Fireball': 50, \n", + " 'Lightning bolt': 40, \n", + " 'Magic arrow': 10, \n", + " 'Black Tentacles': 25, \n", + " 'Contagion': 45\n", + "}\n", + "\n", + "gandalf = ['Fireball', 'Lightning bolt', 'Lightning bolt', 'Magic arrow', 'Fireball', \n", + " 'Magic arrow', 'Lightning bolt', 'Fireball', 'Fireball', 'Fireball']\n", + "saruman = ['Contagion', 'Contagion', 'Black Tentacles', 'Fireball', 'Black Tentacles', \n", + " 'Lightning bolt', 'Magic arrow', 'Contagion', 'Magic arrow', 'Magic arrow']" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Assign spell power lists to variables\n", + "g_spell_power = []\n", + "s_spell_power = []\n", + "\n", + "for i in gandalf:\n", + " g_spell_power.append(POWER[i])\n", + "for i in saruman:\n", + " s_spell_power.append(POWER[i])\n", + " \n", + "#print(g_spell_power)\n", + "#print(s_spell_power)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gandalf wins\n" + ] + } + ], + "source": [ + "# 2. A sorcerer wins if he succeeds in winning 3 spell clashes in a row.\n", + "g_wins = 0\n", + "s_wins = 0\n", + "\n", + "# Execution of spell clashes\n", + "for i in range(len(g_spell_power)):\n", + " if g_spell_power[i] > s_spell_power[i]:\n", + " g_wins += 1\n", + " s_wins = 0\n", + " if g_wins == 3:\n", + " print(\"Gandalf wins\")\n", + " else:\n", + " g_wins = 0\n", + " s_wins += 1\n", + " if s_wins == 3:\n", + " print(\"Saruman wins\")\n", + "\n", + "# check for 3 wins in a row \n", + "# check the winner\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of Gandalf's spell list is 39.0\n", + "Mean of Saruman's spell list is 30.5\n" + ] + } + ], + "source": [ + "# 3. Average of each of the spell lists.\n", + "g_avg = sum(g_spell_power) / len(g_spell_power)\n", + "print(\"Mean of Gandalf's spell list is\", g_avg)\n", + "\n", + "s_avg = sum(s_spell_power) / len(s_spell_power)\n", + "print(\"Mean of Saruman's spell list is\", s_avg)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Std Dev of Gandalf's spell list is 15.132745950421556\n", + "Std Dev of Saruman's spell list is 15.56438241627338\n" + ] + } + ], + "source": [ + "# 4. Standard deviation of each of the spell lists.\n", + "#Gandalf's list first\n", + "#we have the mean (g_avg)\n", + "#set the summation variables\n", + "g_summation = 0\n", + "s_summation = 0\n", + "#iterate through each item in the power list, subtracting the mean, squaring the difference, and adding that back to the variable\n", + "for i in g_spell_power:\n", + " g_summation += (i - g_avg) ** 2\n", + "g_std_dev = (g_summation / len(g_spell_power)) ** 0.5\n", + "print(\"Std Dev of Gandalf's spell list is\", g_std_dev)\n", + "\n", + "for i in s_spell_power:\n", + " s_summation += (i - s_avg) ** 2\n", + "s_std_dev = (s_summation / len(s_spell_power)) ** 0.5\n", + "print(\"Std Dev of Saruman's spell list is\", s_std_dev)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/robin-hood/poad_solution_robinhood.ipynb b/robin-hood/poad_solution_robinhood.ipynb new file mode 100644 index 0000000..a14e968 --- /dev/null +++ b/robin-hood/poad_solution_robinhood.ipynb @@ -0,0 +1,226 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Robin Hood:\n", + "We are in a competition to win the archery contest in Sherwood. With our bow and arrows we shoot on a target and try to hit as close as possible to the center.\n", + "\n", + "The center of the target is represented by the values (0, 0) on the coordinate axes.\n", + "\n", + "![](images/arrows.jpg)\n", + "\n", + "## Goals:\n", + "* data structures: lists, sets, tuples\n", + "* logical operators: if-elif-else\n", + "* loop: while/for\n", + "* minimum (optional sorting)\n", + "\n", + "## Description:\n", + "In the 2-dimensional space, a point can be defined by a pair of values that correspond to the horizontal coordinate (x) and the vertical coordinate (y). The space can be divided into 4 zones (quadrants): Q1, Q2, Q3, Q4. Whose single point of union is the point (0, 0).\n", + "\n", + "If a point is in Q1 both its x coordinate and the y are positive. I leave a link to wikipedia to familiarize yourself with these quadrants.\n", + "\n", + "https://en.wikipedia.org/wiki/Cartesian_coordinate_system\n", + "\n", + "https://en.wikipedia.org/wiki/Euclidean_distance\n", + "\n", + "## Shots\n", + "```\n", + "points = [(4, 5), (-0, 2), (4, 7), (1, -3), (3, -2), (4, 5),\n", + " (3, 2), (5, 7), (-5, 7), (2, 2), (-4, 5), (0, -2),\n", + " (-4, 7), (-1, 3), (-3, 2), (-4, -5), (-3, 2),\n", + " (5, 7), (5, 7), (2, 2), (9, 9), (-8, -9)]\n", + "```\n", + "\n", + "## Tasks\n", + "1. Robin Hood is famous for hitting an arrow with another arrow. Did you get it?\n", + "2. Calculate how many arrows have fallen in each quadrant.\n", + "3. Find the point closest to the center. Calculate its distance to the center. \n", + "4. If the target has a radius of 9, calculate the number of arrows that must be picked up in the forest." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Variables\n", + "\n", + "points = [(4, 5), (-0, 2), (4, 7), (1, -3), (3, -2), (4, 5),\n", + " (3, 2), (5, 7), (-5, 7), (2, 2), (-4, 5), (0, -2),\n", + " (-4, 7), (-1, 3), (-3, 2), (-4, -5), (-3, 2),\n", + " (5, 7), (5, 7), (2, 2), (9, 9), (-8, -9)]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "We did hit an arrow with another arrow!\n" + ] + } + ], + "source": [ + "# 1. Robin Hood is famous for hitting an arrow with another arrow. Did you get it?\n", + "if len(points) > len(set(points)):\n", + " print(\"We did hit an arrow with another arrow!\")\n", + "else:\n", + " print(\"We did not hit an arrow with another arrow.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The number of arrows with an x-value of zero or greater, and a y-value of zero or greater is 11\n", + "The number of arrows with an x-value of zero or greater, and a y-value of below zero is 3\n", + "The number of arrows with an x-value of below zero, and a y-value of below zero is 2\n", + "The number of arrows with an x-value of below zero, and a y-value of zero or greater is 6\n" + ] + } + ], + "source": [ + "# 2. Calculate how many arrows have fallen in each quadrant.\n", + "\"\"\"\n", + "Q1 positive x, positive y\n", + "Q2 positive x, negative y\n", + "Q3 negative x, negative y\n", + "Q4 negative x, positive y\n", + "\"\"\"\n", + "q1 = 0\n", + "q2 = 0\n", + "q3 = 0\n", + "q4 = 0\n", + "\n", + "x_values = []\n", + "y_values = []\n", + "list_points = []\n", + "\n", + "for i in list(points):\n", + " list_points.append(list(i))\n", + "#print(list_points)\n", + "\n", + "for i in list_points:\n", + " x_values.append(i[0])\n", + " y_values.append(i[1])\n", + "#print(x_values)\n", + "#print(y_values)\n", + "\n", + "\n", + "for i in range(len(points)):\n", + " #print(x_values[i])\n", + " #print(y_values[i])\n", + " if x_values[i] >= 0 and y_values[i] >= 0:\n", + " q1 += 1\n", + " elif x_values[i] >= 0 and y_values[i] < 0:\n", + " q2 += 1\n", + " elif x_values[i] < 0 and y_values[i] >= 0:\n", + " q4 += 1\n", + " else:\n", + " q3 += 1\n", + " \n", + "print(\"The number of arrows with an x-value of zero or greater, and a y-value of zero or greater is \", q1)\n", + "print(\"The number of arrows with an x-value of zero or greater, and a y-value of below zero is \", q2)\n", + "print(\"The number of arrows with an x-value of below zero, and a y-value of below zero is \", q3)\n", + "print(\"The number of arrows with an x-value of below zero, and a y-value of zero or greater is \", q4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The shot closest to the center is index number 1\n", + "The distance of that shot to the center is 2.0\n" + ] + } + ], + "source": [ + "# 3. Find the point closest to the center. Calculate its distance to the center\n", + "# Defining a function that calculates the distance to the center can help.\n", + "# I should instead define a function that calculates the distance to the center, and returns the coordinate pair of the minimum-distance-value\n", + "\n", + "distance_from_center = []\n", + "summation = 0\n", + "for i in range(len(points)):\n", + " summation = ((x_values[i] ** 2) + (y_values[i] ** 2))\n", + " distance_from_center.append(summation ** 0.5)\n", + "\n", + "print(\"The shot closest to the center is index number\", distance_from_center.index(min(distance_from_center)))\n", + "print(\"The distance of that shot to the center is\", min(distance_from_center))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The number of arrows to retrive from the forest is 2\n" + ] + } + ], + "source": [ + "# 4. If the target has a radius of 9, calculate the number of arrows that \n", + "# must be picked up in the forest.\n", + "forest_pickup = 0\n", + "for i in distance_from_center:\n", + " if i > 9:\n", + " forest_pickup += 1\n", + "#distance_from_center.sort(reverse=True)\n", + "#print(distance_from_center)\n", + "print(\"The number of arrows to retrive from the forest is\", forest_pickup)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git "a/rock\342\200\223paper\342\200\223scissors/poad-rock-paper-scissors-final.ipynb" "b/rock\342\200\223paper\342\200\223scissors/poad-rock-paper-scissors-final.ipynb" new file mode 100644 index 0000000..846c06e --- /dev/null +++ "b/rock\342\200\223paper\342\200\223scissors/poad-rock-paper-scissors-final.ipynb" @@ -0,0 +1,442 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Rock Paper Scissors\n", + "\n", + "Let's play the famous game against our computer.\n", + "\n", + "https://en.wikipedia.org/wiki/Rock%E2%80%93paper%E2%80%93scissors\n", + "\n", + "The use of functions is recommended\n", + "\n", + "## Goals\n", + "1. Use of loop\n", + "2. Data capture by console\n", + "3. Use if-elif-else\n", + "4. Use of try-except\n", + "5. Definition of functions. Modular programming\n", + "6. Logical operators.\n", + "7. Print\n", + "8. Import modules" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Please select stone, paper, or scissorsstone\n", + "The computer picked stone\n", + "You picked stone\n", + "Tie!\n", + "The score is computer:0 to player:0.\n", + "Please select stone, paper, or scissorsPAPER\n", + "The computer picked stone\n", + "You picked paper\n", + "The player won\n", + "The score is computer:0 to player:1.\n", + "Please select stone, paper, or scissorsscissors\n", + "The computer picked scissors\n", + "You picked scissors\n", + "Tie!\n", + "The score is computer:0 to player:1.\n", + "Please select stone, paper, or scissorsstone\n", + "The computer picked stone\n", + "You picked stone\n", + "Tie!\n", + "The score is computer:0 to player:1.\n", + "Please select stone, paper, or scissorspaper\n", + "The computer picked paper\n", + "You picked paper\n", + "Tie!\n", + "The score is computer:0 to player:1.\n", + "Please select stone, paper, or scissorsscissors\n", + "The computer picked scissors\n", + "You picked scissors\n", + "Tie!\n", + "The score is computer:0 to player:1.\n", + "Please select stone, paper, or scissorsstone\n", + "The computer picked scissors\n", + "You picked stone\n", + "The player won\n", + "The score is computer:0 to player:2.\n", + "Please select stone, paper, or scissorsstone\n", + "The computer picked paper\n", + "You picked stone\n", + "The computer won\n", + "The score is computer:1 to player:2.\n", + "Please select stone, paper, or scissorsscissors\n", + "The computer picked scissors\n", + "You picked scissors\n", + "Tie!\n", + "The score is computer:1 to player:2.\n", + "Please select stone, paper, or scissorspaper\n", + "The computer picked paper\n", + "You picked paper\n", + "Tie!\n", + "The score is computer:1 to player:2.\n", + "Please select stone, paper, or scissorsstone\n", + "The computer picked stone\n", + "You picked stone\n", + "Tie!\n", + "The score is computer:1 to player:2.\n", + "Please select stone, paper, or scissorsstone\n", + "The computer picked scissors\n", + "You picked stone\n", + "The player won\n", + "The score is computer:1 to player:3.\n" + ] + } + ], + "source": [ + "# Import the choice function of the random module\n", + "# https://stackoverflow.com/questions/306400/how-to-randomly-select-an-item-from-a-list\n", + "import random\n", + "\n", + "\n", + "# Assign to a list the 3 possible options: 'stone', 'paper' or 'scissors'.\n", + "options = ['stone', 'paper', 'scissors']\n", + "\n", + "# Assign a variable to the maximum number of games: 1, 3, 5, etc ...\n", + "max_games = 5\n", + "\n", + "# Assign a variable to the number of games a player must win to win.\n", + "# Preferably the value will be based on the number of maximum games\n", + "\n", + "\n", + "\n", + "# Define a function that randomly returns one of the 3 options.\n", + "# This will correspond to the play of the machine. Totally random.\n", + "def computer_turn():\n", + " return random.choice(options)\n", + "#print(computer_turn())\n", + "\n", + "\n", + "# Define a function that asks your choice: 'stone', 'paper' or 'scissors'\n", + "# you should only allow one of the 3 options. This is defensive programming.\n", + "# If it is not stone, paper or scissors keep asking until it is.\n", + "def my_turn():\n", + " '''This is a while statement to force the user to select a valid input'''\n", + " while True:\n", + " my_pick = input(\"Please select stone, paper, or scissors\")\n", + " if my_pick.lower() not in options:\n", + " print(\"Sorry, I didn't catch that.\")\n", + " continue\n", + " else:\n", + " #print(\"I picked\", my_pick)\n", + " return my_pick.lower()\n", + "\n", + "\n", + "# Define a function that resolves a combat.\n", + "# Returns 0 if there is a tie, 1 if the machine wins, 2 if the human player wins\n", + "def resolve_combat():\n", + " '''call the functions for the choices, and use if-elif-else to find who wins the round'''\n", + " global computer_select\n", + " global my_select\n", + " computer_select = computer_turn()\n", + " my_select = my_turn()\n", + " # declare the variables as global\n", + " global computer_wins\n", + " global player_wins\n", + " # start the resolution of the combat\n", + " if computer_select == my_select:\n", + " return 0\n", + " if computer_select == 'stone' and my_select == 'paper':\n", + " player_wins += 1\n", + " return 2\n", + " elif computer_select == 'stone' and my_select == 'scissors':\n", + " computer_wins += 1\n", + " return 1\n", + " if computer_select == 'paper' and my_select == 'stone':\n", + " computer_wins += 1\n", + " return 1\n", + " elif computer_select == 'paper' and my_select == 'scissors':\n", + " player_wins += 1\n", + " return 2\n", + " if computer_select == 'scissors' and my_select == 'stone':\n", + " player_wins += 1\n", + " return 2\n", + " else:\n", + " computer_wins += 1\n", + " return 1\n", + "\n", + "# Define a function that shows the choice of each player and the state of the game\n", + "# This function should be used every time accumulated points are updated\n", + "def state_of_play(combat_victor):\n", + " print(\"The computer picked \", computer_select)\n", + " print(\"You picked \", my_select)\n", + " if combat_victor == 0:\n", + " print(\"Tie!\")\n", + " elif combat_victor == 1:\n", + " print(\"The computer won\")\n", + " else:\n", + " print(\"The player won\")\n", + " print(\"The score is computer:\" + str(computer_wins) + \" to player:\" + str(player_wins) + \".\")\n", + " \n", + "\n", + "# Create two variables that accumulate the wins of each participant\n", + "computer_wins = 0\n", + "player_wins = 0\n", + "\n", + "\n", + "# Create a loop that iterates while no player reaches the minimum of wins\n", + "# necessary to win. Inside the loop solves the play of the\n", + "# machine and ask the player's. Compare them and update the value of the variables\n", + "# that accumulate the wins of each participant.\n", + "while (computer_wins < games_to_win) and (player_wins < games_to_win):\n", + " state_of_play(resolve_combat())\n", + "else:\n", + " if computer_wins > player_wins:\n", + " print(\"The computer has won the game.\")\n", + " else:\n", + " print(\"The player has defeated the computer!\")\n", + "\n", + "\n", + " \n", + "# Print by console the winner of the game based on who has more accumulated wins" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bonus: Stone, paper, scissors, lizard, spock\n", + "\n", + "Now the improvement begins.\n", + "\n", + "![](images/rpsls.jpg)\n", + "\n", + "\n", + "http://www.samkass.com/theories/RPSSL.html\n", + "\n", + "You are asked to impliment some improvements with respect to the simple previous game. In addition, the number of games (which must be ODD) will be requested per console until a valid number is entered.\n", + "\n", + "Improvements:\n", + "* 5 options: stone, paper, scissors, lizard, spock\n", + "* The number of games is requested per console\n", + "Tip: Reuse code that you already use. If you have programmed intelligently, the bonus are simple modifications to the original game." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Maximum number of games you'd like to play?3\n", + "You'll need 2 points to win.\n", + "Please select stone, paper, scissors, lizard, or spockstone\n", + "The computer picked paper\n", + "You picked stone\n", + "The computer won\n", + "The score is computer:1 to player:0.\n", + "Please select stone, paper, scissors, lizard, or spockstone\n", + "The computer picked stone\n", + "You picked stone\n", + "Tie!\n", + "The score is computer:1 to player:0.\n", + "Please select stone, paper, scissors, lizard, or spockstone\n", + "The computer picked spock\n", + "You picked stone\n", + "The computer won\n", + "The score is computer:2 to player:0.\n", + "The computer has won the game.\n" + ] + } + ], + "source": [ + "# Import the choice function of the random module\n", + "import random\n", + "\n", + "# Define a function that asks for an odd number on the keyboard, until it is not valid\n", + "# will keep asking\n", + "def how_many_games():\n", + " '''This is a while statement to force the user to select a valid input'''\n", + " while True:\n", + " max_games = input(\"Maximum number of games you'd like to play?\")\n", + " if int(max_games) % 2 == 0:\n", + " print(\"It needs to be an odd number\")\n", + " continue\n", + " else:\n", + " return int(max_games)\n", + " \n", + "# Assign a list of 5 possible options.\n", + "options = ['stone', 'paper', 'scissors', 'lizard', 'spock']\n", + "\n", + "# Assign a variable to the maximum number of games: 1, 3, 5, etc ...\n", + "# This time the previously defined function is used\n", + "max_games = how_many_games()\n", + "\n", + "\n", + "# Assign a variable to the number of games a player must win to win.\n", + "# Preferably the value will be based on the number of maximum games\n", + "games_to_win = (max_games / 2) + 0.5\n", + "print(\"You'll need \" + str(int(games_to_win)) + \" points to win.\")\n", + "\n", + "\n", + "# Define a function that randomly returns one of the 5 options.\n", + "# This will correspond to the play of the machine. Totally random.\n", + "def computer_turn():\n", + " return random.choice(options)\n", + "\n", + "# Define a function that asks your choice between 5\n", + "# you should only allow one of the 5 options. This is defensive programming.\n", + "# If it is not valid, keep asking until it is valid.\n", + "def my_turn():\n", + " '''This is a while statement to force the user to select a valid input'''\n", + " while True:\n", + " my_pick = input(\"Please select stone, paper, scissors, lizard, or spock\")\n", + " if my_pick.lower() not in options:\n", + " print(\"Sorry, I didn't catch that.\")\n", + " continue\n", + " else:\n", + " #print(\"I picked\", my_pick)\n", + " return my_pick.lower()\n", + "\n", + "# Define a function that resolves a combat.\n", + "# Returns 0 if there is a tie, 1 if the machine wins, 2 if the human player wins\n", + "# Now there are more options\n", + "def resolve_combat():\n", + " '''call the functions for the choices, and use if-elif-else to find who wins the round'''\n", + " global computer_select\n", + " global my_select\n", + " computer_select = computer_turn()\n", + " my_select = my_turn()\n", + " # declare the variables as global\n", + " global computer_wins\n", + " global player_wins\n", + " # start the resolution of the combat\n", + " if computer_select == my_select:\n", + " return 0\n", + " if computer_select == 'stone' and my_select == 'paper':\n", + " player_wins += 1\n", + " return 2\n", + " elif computer_select == 'stone' and my_select == 'scissors':\n", + " computer_wins += 1\n", + " return 1\n", + " elif computer_select == 'stone' and my_select == 'lizard':\n", + " computer_wins += 1\n", + " return 1\n", + " elif computer_select == 'stone' and my_select == 'spock':\n", + " player_wins += 1\n", + " return 2\n", + " if computer_select == 'paper' and my_select == 'stone':\n", + " computer_wins += 1\n", + " return 1\n", + " elif computer_select == 'paper' and my_select == 'scissors':\n", + " player_wins += 1\n", + " return 2\n", + " elif computer_select == 'paper' and my_select == 'lizard':\n", + " player_wins += 1\n", + " return 2\n", + " elif computer_select == 'paper' and my_select == 'spock':\n", + " computer_wins += 1\n", + " return 1\n", + " if computer_select == 'scissors' and my_select == 'stone':\n", + " player_wins += 1\n", + " return 2\n", + " elif computer_select == 'scissors' and my_select == 'paper':\n", + " computer_wins += 1\n", + " return 1\n", + " elif computer_select == 'scissors' and my_select == 'lizard':\n", + " computer_wins += 1\n", + " return 1\n", + " elif computer_select == 'scissors' and my_selct == 'spock':\n", + " player_wins += 1\n", + " return 2\n", + " elif computer_select == 'lizard' and my_select == 'stone':\n", + " player_wins += 1\n", + " return 2\n", + " elif computer_select == 'lizard' and my_select == 'paper':\n", + " computer_wins += 1\n", + " return 1\n", + " elif computer_select == 'lizard' and my_select == 'scissors':\n", + " player_wins += 1\n", + " return 2\n", + " elif computer_select == 'lizard' and my_select == 'spock':\n", + " computer_wins += 1\n", + " return 1\n", + " elif computer_select == 'spock' and my_select == 'stone':\n", + " computer_wins += 1\n", + " return 1\n", + " elif computer_select == 'spock' and my_select == 'paper':\n", + " player_wins += 1\n", + " return 2\n", + " elif computer_select == 'spock' and my_select == 'scissors':\n", + " computer_wins += 1\n", + " return 1\n", + " elif computer_select == 'spock' and my_select == 'lizard':\n", + " player_wins += 1\n", + " return 2\n", + " \n", + "# Define a function that shows the choice of each player and the state of the game\n", + "# This function should be used every time accumulated points are updated\n", + "def state_of_play(combat_victor):\n", + " print(\"The computer picked \", computer_select)\n", + " print(\"You picked \", my_select)\n", + " if combat_victor == 0:\n", + " print(\"Tie!\")\n", + " elif combat_victor == 1:\n", + " print(\"The computer won\")\n", + " else:\n", + " print(\"The player won\")\n", + " print(\"The score is computer:\" + str(computer_wins) + \" to player:\" + str(player_wins) + \".\")\n", + " \n", + "# Create two variables that accumulate the wins of each participant\n", + "computer_wins = 0\n", + "player_wins = 0\n", + "# Create a loop that iterates while no player reaches the minimum of wins\n", + "# necessary to win. Inside the loop solves the play of the\n", + "# machine and ask the player's. Compare them and update the value of the variables\n", + "# that accumulate the wins of each participant.\n", + "while (computer_wins < games_to_win) and (player_wins < games_to_win):\n", + " state_of_play(resolve_combat())\n", + "else:\n", + " if computer_wins > player_wins:\n", + " print(\"The computer has won the game.\")\n", + " else:\n", + " print(\"The player has defeated the computer!\")\n", + " \n", + "# Print by console the winner of the game based on who has more accumulated wins\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/snail-and-well/poad_solution_snail.ipynb b/snail-and-well/poad_solution_snail.ipynb new file mode 100644 index 0000000..40177c0 --- /dev/null +++ b/snail-and-well/poad_solution_snail.ipynb @@ -0,0 +1,182 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Snail and well\n", + "\n", + "A snail falls at the bottom of a 125 cm well. Each day the snail rises 30 cm. But at night, while sleeping, slides 20 cm because the walls are wet. How many days does it take to escape from the well?\n", + "\n", + "TIP: http://puzzles.nigelcoldwell.co.uk/sixtytwo.htm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solución" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Days = 10.5\n" + ] + } + ], + "source": [ + "# Assign problem data to variables with representative names\n", + "# well height, daily advance, night retreat, accumulated distance\n", + "well_height = 125\n", + "daily_advance = 30\n", + "nightly_retreat = 20\n", + "accumulated_distance = 0\n", + "\n", + "# Assign 0 to the variable that represents the solution\n", + "days = 0\n", + "\n", + "# Write the code that solves the problem\n", + "while accumulated_distance < well_height:\n", + " accumulated_distance += daily_advance\n", + " days += 0.5\n", + " if accumulated_distance >= well_height:\n", + " break\n", + " else:\n", + " accumulated_distance -= nightly_retreat\n", + " days += 0.5\n", + "\n", + "# Print the result with print('Days =', days)\n", + "print('Days =', days)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Goals\n", + "\n", + "1. Treatment of variables\n", + "2. Use of loop **while**\n", + "3. Use of conditional **if-else**\n", + "4. Print in console" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bonus\n", + "The distance traveled by the snail is now defined by a list.\n", + "```\n", + "advance_cm = [30, 21, 33, 77, 44, 45, 23, 45, 12, 34, 55]\n", + "```\n", + "How long does it take to raise the well?\n", + "\n", + "What is its maximum displacement in one day? And its minimum?\n", + "\n", + "What is its average speed during the day?\n", + "\n", + "What is the standard deviation of its displacement during the day?" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Days = 4.5\n", + "The snail's maximum displacement in a single day is 57 cm.\n", + "The snail's minimum displacement in a single day is -8 cm.\n", + "The snail's average daily progress is 18.09090909090909 cm.\n", + "The standard deviation of the snail's daily displacement, in centimers, is 17.159437082600803\n" + ] + } + ], + "source": [ + "# Assign problem data to variables with representative names\n", + "# well height, daily advance, night retreat, accumulated distance\n", + "advance_cm = [30, 21, 33, 77, 44, 45, 23, 45, 12, 34, 55]\n", + "well_height = 125\n", + "daily_advance = 30\n", + "nightly_retreat = 20\n", + "accumulated_distance = 0\n", + "\n", + "# Assign 0 to the variable that represents the solution\n", + "days = 0\n", + "\n", + "# Write the code that solves the problem\n", + "while accumulated_distance < well_height:\n", + " for i in advance_cm:\n", + " accumulated_distance += i\n", + " days += 0.5\n", + " if accumulated_distance >= well_height:\n", + " break\n", + " else:\n", + " accumulated_distance -= nightly_retreat\n", + " days += 0.5\n", + "\n", + "\n", + "# Print the result with print('Days =', days)\n", + "print('Days =', days)\n", + "\n", + "# What is its maximum displacement in a day? And its minimum?\n", + "daily_displacement = []\n", + "for i in advance_cm:\n", + " daily_displacement.append(i - 20)\n", + "#print(daily_displacement)\n", + "print(\"The snail's maximum displacement in a single day is \" + str(max(daily_displacement)) + \" cm.\")\n", + "print(\"The snail's minimum displacement in a single day is \" + str(min(daily_displacement)) + \" cm.\")\n", + "\n", + "# What is its average progress?\n", + "print(\"The snail's average daily progress is \" + str(sum(daily_displacement)/len(daily_displacement)) + \" cm.\")\n", + "\n", + "# What is the standard deviation of the snail's displacement during the day?\n", + "mean_displacement = (sum(daily_displacement)/len(daily_displacement))\n", + "summation = 0\n", + "for i in daily_displacement:\n", + " summation += (i - mean_displacement) ** 2\n", + "std_dev = ((summation / len(daily_displacement)) ** 0.5)\n", + "print(\"The standard deviation of the snail's daily displacement, in centimers, is \", std_dev)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/temperature/poad_solution_temperature.ipynb b/temperature/poad_solution_temperature.ipynb new file mode 100644 index 0000000..345de82 --- /dev/null +++ b/temperature/poad_solution_temperature.ipynb @@ -0,0 +1,350 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Processor temperature\n", + "\n", + "We have a temperature sensor in the processor of our company's server. We want to analyze the data provided to determinate whether we should change the cooling system for a better one. It is expensive and as a data analyst we cannot make decisions without a basis.\n", + "\n", + "We provide the temperatures measured throughout the 24 hours of a day in a list-type data structure composed of 24 integers:\n", + "```\n", + "temperatures_C = [33,66,65,0,59,60,62,64,70,76,80,69,80,83,68,79,61,53,50,49,53,48,45,39]\n", + "```\n", + "\n", + "## Goals\n", + "\n", + "1. Treatment of lists\n", + "2. Use of loop or list comprenhention\n", + "3. Calculation of the mean, minimum and maximum.\n", + "4. Filtering of lists.\n", + "5. Interpolate an outlier.\n", + "6. Logical operators.\n", + "7. Print" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Temperature graph\n", + "To facilitate understanding, the temperature graph is shown below. You do not have to do anything in this section. The test starts in **Problem**." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Temperatures of our server throughout the day')" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# import\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "# axis x, axis y\n", + "y = [33,66,65,0,59,60,62,64,70,76,80,81,80,83,90,79,61,53,50,49,53,48,45,39]\n", + "x = list(range(len(y)))\n", + "\n", + "# plot\n", + "plt.plot(x, y)\n", + "plt.axhline(y=70, linewidth=1, color='r')\n", + "plt.xlabel('hours')\n", + "plt.ylabel('Temperature ºC')\n", + "plt.title('Temperatures of our server throughout the day')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Problem\n", + "\n", + "If the sensor detects more than 4 hours with temperatures greater than or equal to 70ºC or any temperature above 80ºC or the average exceeds 65ºC throughout the day, we must give the order to change the cooling system to avoid damaging the processor.\n", + "\n", + "We will guide you step by step so you can make the decision by calculating some intermediate steps:\n", + "\n", + "1. Minimum temperature\n", + "2. Maximum temperature\n", + "3. Temperatures equal to or greater than 70ºC\n", + "4. Average temperatures throughout the day.\n", + "5. If there was a sensor failure at 03:00 and we did not capture the data, how would you estimate the value that we lack? Correct that value in the list of temperatures.\n", + "6. Bonus: Our maintenance staff is from the United States and does not understand the international metric system. Pass temperatures to Degrees Fahrenheit.\n", + "\n", + "Formula: F = 1.8 * C + 32\n", + "\n", + "web: https://en.wikipedia.org/wiki/Conversion_of_units_of_temperature\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The minimum temperature recorded during the day is 0 Celsius.\n", + "The maximum temperature recorded during the day is 83 Celsius.\n", + "[76, 80, 80, 83, 79]\n", + "58.833333333333336\n", + "62.0\n", + "[33, 66, 65, 62.0, 59, 60, 62, 64, 70, 76, 80, 69, 80, 83, 68, 79, 61, 53, 50, 49, 53, 48, 45, 39]\n", + "[91.4, 150.8, 149.0, 143.60000000000002, 138.2, 140.0, 143.60000000000002, 147.2, 158.0, 168.8, 176.0, 156.2, 176.0, 181.4, 154.4, 174.20000000000002, 141.8, 127.4, 122.0, 120.2, 127.4, 118.4, 113.0, 102.2]\n" + ] + } + ], + "source": [ + "# assign a variable to the list of temperatures\n", + "temperatures_C = [33,66,65,0,59,60,62,64,70,76,80,69,80,83,68,79,61,53,50,49,53,48,45,39]\n", + "# 1. Calculate the minimum of the list and print the value using print()\n", + "print(\"The minimum temperature recorded during the day is \" + str(min(temperatures_C)) + \" Celsius.\")\n", + "\n", + "# 2. Calculate the maximum of the list and print the value using print()\n", + "print(\"The maximum temperature recorded during the day is \" + str(max(temperatures_C)) + \" Celsius.\")\n", + "\n", + "# 3. Items in the list that are greater than 70ºC and print the result\n", + "over_70 = []\n", + "for i in temperatures_C:\n", + " if i > 70:\n", + " over_70.append(i)\n", + "print(over_70)\n", + "\n", + "# 4. Calculate the mean temperature throughout the day and print the result\n", + "mean_temp = (sum(temperatures_C) / len(temperatures_C))\n", + "print(mean_temp)\n", + "\n", + "\n", + "# 5.1 Solve the fault in the sensor by estimating a value\n", + "zero_value = temperatures_C.index(0)\n", + "interpolate = ((temperatures_C[zero_value - 1] + temperatures_C[zero_value + 1]) / 2)\n", + "print(interpolate)\n", + "\n", + "\n", + "# 5.2 Update of the estimated value at 03:00 on the list\n", + "temperatures_C[zero_value] = interpolate\n", + "print(temperatures_C)\n", + "\n", + "# Bonus: convert the list of ºC to ºFarenheit\n", + "temperatures_F = []\n", + "for i in temperatures_C:\n", + " temperatures_F.append((1.8 * i) + 32)\n", + "print(temperatures_F)\n", + "#not sure why some of these values are returned with an extreme number of decimal places. rounding using format.() would require the string data type\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Take the decision\n", + "Remember that if the sensor detects more than 4 hours with temperatures greater than or equal to 70ºC or any temperature higher than 80ºC or the average was higher than 65ºC throughout the day, we must give the order to change the cooling system to avoid the danger of damaging the equipment:\n", + "* more than 4 hours with temperatures greater than or equal to 70ºC\n", + "* some temperature higher than 80ºC\n", + "* average was higher than 65ºC throughout the day\n", + "If any of these three is met, the cooling system must be changed.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "# Print True or False depending on whether you would change the cooling system or not\n", + "if max(temperatures_C) > 80 or mean_temp > 65 or len(over_70) >= 5:\n", + " print(\"True\")\n", + "else:\n", + " print(\"False\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Future improvements\n", + "1. We want the hours (not the temperatures) whose temperature exceeds 70ºC\n", + "2. Condition that those hours are more than 4 consecutive and consecutive, not simply the sum of the whole set. Is this condition met?\n", + "3. Average of each of the lists (ºC and ºF). How they relate?\n", + "4. Standard deviation of each of the lists. How they relate?\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[9, 10, 12, 13, 15]]\n" + ] + } + ], + "source": [ + "# 1. We want the hours (not the temperatures) whose temperature exceeds 70ºC\n", + "# essentially, give a list of the indexes where the value is > 70, the values from over_70\n", + "hours_over_70 = []\n", + "hours_over_70.append([i for i, j in enumerate(temperatures_C) if j > 70])\n", + "print(hours_over_70)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The consecutive condition has not been met.\n" + ] + } + ], + "source": [ + "# 2. Condition that those hours are more than 4 consecutive and consecutive, not simply the sum of the whole set. Is this condition met?\n", + "# Alter the condition, that the 4 hours with temperature greater than 70 degrees must be consecutive. is this new condition met?\n", + "# this new condition is not met, from a practical review of the list\n", + "#test temperatures_C = [100, 100, 100, 100, 100, 100]\n", + "#test temperatures_C = [10, 10, 10, 10, 10, 10]\n", + "consecutive = []\n", + "for i in range(len(temperatures_C)):\n", + " subset = temperatures_C[i:i+4]\n", + " if all(i > 70 for i in subset):\n", + " consecutive.append(i)\n", + " #print(\"The consecutive condition has been met!\")\n", + " #print(subset)\n", + " #else:\n", + " #print(\"The consecutive condition has not been met.\")\n", + " #print(subset)\n", + "if (len(consecutive) >= 5):\n", + " print(\"The consecutive condition has been met!\")\n", + "else:\n", + " print(\"The consecutive condition has not been met.\")\n", + "\n", + " \n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "58.833333333333336\n", + "142.54999999999998\n", + "The mean temperature of the Fahrenheit list is higher than expected since converting the mean height of the Celsius list to Fahrenheit results in 137.84\n" + ] + } + ], + "source": [ + "# 3. Average of each of the lists (ºC and ºF). How they relate?\n", + "mean_temp_F = (sum(temperatures_F) / len(temperatures_F))\n", + "print(mean_temp)\n", + "print(mean_temp_F)\n", + "print(\"The mean temperature of the Fahrenheit list is higher than expected since converting the mean height of the Celsius list to Fahrenheit results in 137.84\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The standard deviation of the Celsius list is 13.30413469565007\n", + "The standard deviation of the Fahrenheit list is 23.491647451807207\n", + "The Celsius list deviates less from its mean than the Fahrenheit list.\n" + ] + } + ], + "source": [ + "# 4. Standard deviation of each of the lists. How they relate?\n", + "#find standard deviation of Celsius list\n", + "summation_C = 0\n", + "for i in temperatures_C:\n", + " summation_C += (i - mean_temp) ** 2\n", + "std_dev_C = (summation_C / len(temperatures_C)) ** 0.5\n", + "print(\"The standard deviation of the Celsius list is\", std_dev_C)\n", + "\n", + "#find standard deviation of Fahrenheit list\n", + "summation_F = 0\n", + "for i in temperatures_F:\n", + " summation_F += (i - mean_temp_F) ** 2\n", + "std_dev_F = (summation_F / len(temperatures_F)) ** 0.5\n", + "print(\"The standard deviation of the Fahrenheit list is\", std_dev_F)\n", + "\n", + "print(\"The Celsius list deviates less from its mean than the Fahrenheit list.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/test.md b/test.md new file mode 100644 index 0000000..e69de29