diff --git a/bus/bus.ipynb b/bus/bus.ipynb index 81779ce..7bde852 100644 --- a/bus/bus.ipynb +++ b/bus/bus.ipynb @@ -32,60 +32,117 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# variables\n", - "\n" + "got_in = (2,5,4,6)\n", + "got_out = (1,3,3,6)\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(2, 1), (5, 3), (4, 3), (6, 6)]\n", + "The number of stops is 4\n" + ] + } + ], "source": [ "# 1. Calculate the number of stops.\n", - "\n" + "\n", + "stops=[]\n", + "\n", + "for i in range(len(got_in)):\n", + " stops.append((got_in[i],got_out[i]))\n", + "\n", + "print(stops)\n", + "print(\"The number of stops is\", len(stops))\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 1, 0]\n" + ] + } + ], "source": [ - "# 2. Assign a variable a list whose elements are the number of passengers in each stop: \n", + "# 2. Assign to a variable a list whose elements are the number of passengers at each stop (in-out),\n", "# Each item depends on the previous item in the list + in - out.\n", - "\n" + "\n", + "pasg_by_stop = []\n", + "\n", + "for i in range(len(got_in)):\n", + " pasg_by_stop.append(stops[i][0]-stops[i][1])\n", + " \n", + "print(pasg_by_stop)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], "source": [ "# 3. Find the maximum occupation of the bus.\n", - "\n" + "max_pasg = max(pasg_by_stop)\n", + "\n", + "print(max_pasg)\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard Deviation of the occupation of bus is 0.816496580927726\n", + "The average occupation of the bus is 1.0\n" + ] + } + ], "source": [ "# 4. Calculate the average occupation. And the standard deviation.\n", - "\n" + "\n", + "pasg_mean = sum(pasg_by_stop)/len(pasg_by_stop)\n", + "\n", + "import statistics \n", + "from statistics import stdev \n", + "\n", + "pasg_stdev = stdev(pasg_by_stop)\n", + "\n", + "print(\"Standard Deviation of the occupation of bus is\", pasg_stdev )\n", + "print(\"The average occupation of the bus is\", pasg_mean)\n" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [] } ], @@ -105,7 +162,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.2" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/bus/bus_exercise.py b/bus/bus_exercise.py new file mode 100644 index 0000000..61f11f7 --- /dev/null +++ b/bus/bus_exercise.py @@ -0,0 +1,69 @@ +#%% Change working directory from the workspace root to the ipynb file location. Turn this addition off with the DataScience.changeDirOnImportExport setting +# ms-python.python added +import os + +try: + os.chdir(os.path.join(os.getcwd(), "bus/.ipynb_checkpoints")) + print(os.getcwd()) +except: + pass +#%% [markdown] +# # Bus +# +# 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. +# +# At each stop the entry and exit of passengers is represented by a tuple consisting of two integer numbers. +# ``` +# bus_stop = (in, out) +# ``` +# The succession of stops is represented by a list of these tuples. +# ``` +# stops = [(in1, out1), (in2, out2), (in3, out3), (in4, out4)] +# ``` +# +# ## Goals: +# * lists, tuples +# * while/for loops +# * minimum, maximum, length +# * average, standard deviation +# +# ## Tasks +# 1. Calculate the number of stops. +# 2. Assign to a variable a list whose elements are the number of passengers at each stop (in-out), +# 3. Find the maximum occupation of the bus. +# 4. Calculate the average occupation. And the standard deviation. +# + +#%% +# variables +##def bus_stop (in,out) + +# Each item depends on the previous item in the list + in - out. +pass_in = [2, 3, 5, 7] +pass_out = (1, 5, 7, 8) +max_pass = max(len(pass_in), len(pass_out)) +print(max_pass) +print("hello") + +#%% +# 1. Calculate the number of stops. +stops = [] +i = 0 +print(stops) + +while i < max_pass: + stops.append((pass_in[i], pass_out[i])) + +print(stops) +print("hello") +#%% +# 2. Assign a variable a list whose elements are the number of passengers in each stop: + + +#%% +# 3. Find the maximum occupation of the bus. + + +#%% +# 4. Calculate the average occupation. And the standard deviation. + diff --git a/duel/duel.ipynb b/duel/duel.ipynb index 4398d88..7be3fad 100644 --- a/duel/duel.ipynb +++ b/duel/duel.ipynb @@ -40,7 +40,7 @@ "# 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]" + "saruman = [23, 66, 12, 43, 12, 10, 44, 23, 12, 16]" ] }, { @@ -49,7 +49,9 @@ "metadata": {}, "outputs": [], "source": [ - "# Assign 0 to each variable that stores the victories\n" + "# Assign 0 to each variable that stores the victories\n", + "gandalf_victories= 0\n", + "saruman_victories = 0 " ] }, { @@ -58,18 +60,37 @@ "metadata": {}, "outputs": [], "source": [ - "# Execution of spell clashes\n" + "# Execution of spell clashes\n", + "for i in range(len(gandalf)):\n", + " if gandalf[i] > saruman[i]:\n", + " gandalf_victories += 1\n", + " elif gandalf[i] < saruman[i]:\n", + " saruman_victories += 1\n", + "\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gandalf wins 6 - 4\n" + ] + } + ], "source": [ "# We check who has won, do not forget the possibility of a draw.\n", "# Print the result based on the winner.\n", - "\n" + "if gandalf_victories > saruman_victories:\n", + " print (\"Gandalf wins\", gandalf_victories, \"-\", saruman_victories)\n", + "elif gandalf_victories < saruman_victories:\n", + " print (\"Saruman wins\", saruman_victories, \"-\", gandalf_victories)\n", + "else:\n", + " print (\"It's a tie!\")\n" ] }, { @@ -116,7 +137,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -139,51 +160,145 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "gandalf power [50, 40, 40, 10, 50, 10, 40, 50, 10, 50]\n", + "saruman power [45, 45, 25, 50, 25, 40, 10, 45, 10, 10]\n" + ] + } + ], "source": [ "# Assign spell power lists to variables\n", - "\n" + "power_gandalf = []\n", + "power_saruman = []\n", + "\n", + "for i in range(len(gandalf)):\n", + " power_gandalf.append(POWER.get(gandalf[i]))\n", + " power_saruman.append(POWER.get(saruman[i]))\n", + " \n", + "print(\"gandalf power\" , power_gandalf)\n", + "print(\"saruman power\" , power_saruman)\n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 25, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 0, 1, 0, 1, 0, 1, 1, 1]\n", + "Gandalf Wins\n" + ] + } + ], "source": [ "# 2. A sorcerer wins if he succeeds in winning 3 spell clashes in a row.\n", "\n", "\n", "# Execution of spell clashes\n", + "gandalf_victories = []\n", "\n", - "\n", + " \n", + "for i in range(len(gandalf)):\n", + " if power_gandalf[i] > power_saruman[i]:\n", + " gandalf_victories.append(1)\n", + " elif power_gandalf[i] < power_saruman[i]:\n", + " gandalf_victories.append(0)\n", + "print (gandalf_victories)\n", "\n", "# check for 3 wins in a row\n", + "three_sauroman = 0\n", "\n", + "for i in range (len(gandalf_victories)):\n", "\n", - "# check the winner\n" + " if gandalf_victories[i] + gandalf_victories[i-1] == 0 and gandalf_victories[i] + gandalf_victories[i+1] == 0:\n", + " three_sauroman = three_sauroman + 1\n", + " else:\n", + " three_sauroman= 0\n", + "\n", + " \n", + "# check the winner\n", + "if three_sauroman == 1:\n", + " print (\"Sauroman Wins\")\n", + "else:\n", + " print (\"Gandalf Wins\")" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "35.0\n", + "30.5\n", + "35.0\n", + "30.5\n", + "35\n", + "30.5\n" + ] + } + ], "source": [ "# 3. Average of each of the spell lists.\n", - "\n" + "\n", + "# Method 1\n", + "avg_gandalf = sum(power_gandalf)/len(power_gandalf)\n", + "avg_saruman = sum(power_saruman)/len(power_gandalf)\n", + "\n", + "print (avg_gandalf)\n", + "print (avg_saruman)\n", + "\n", + "# Method 2: Reduce & Lambda\n", + "from functools import reduce\n", + " \n", + "redu_gand = reduce(lambda a, b: a + b, power_gandalf) / len(power_gandalf) \n", + "\n", + "redu_saru = reduce(lambda a, b: a + b, power_saruman) / len(power_gandalf) \n", + "\n", + "print (redu_gand)\n", + "print (redu_saru)\n", + "#Method 3: Using mean from statistics\n", + "\n", + "from statistics import mean \n", + " \n", + "me_gand = mean(power_gandalf)\n", + "me_saru = mean(power_saruman)\n", + "print (me_gand)\n", + "print (me_saru)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard Deviation = 17.795130420052185\n" + ] + } + ], "source": [ "# 4. Standard deviation of each of the spell lists.\n", - "\n" + "\n", + "import statistics \n", + " \n", + "# Prints standard deviation \n", + "print(\"Standard Deviation =\", statistics.stdev(power_gandalf)) \n" ] }, { @@ -210,7 +325,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/robin-hood/robin-hood.ipynb b/robin-hood/robin-hood.ipynb index b1af06b..a009ffa 100644 --- a/robin-hood/robin-hood.ipynb +++ b/robin-hood/robin-hood.ipynb @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -57,44 +57,128 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There were 4 arrows that hit another arrow. The coordinates are: {(4, 5), (5, 7), (-3, 2), (2, 2)}\n" + ] + } + ], "source": [ "# 1. Robin Hood is famous for hitting an arrow with another arrow. Did you get it?\n", + "\n", + "norm_arrow = set(points)\n", + "#print(norm_arrow)\n", + "arrow_arrow = {x for x in points if points.count(x)>1}\n", + "\n", + "print (\"There were\", len (arrow_arrow), \"arrows that hit another arrow. The coordinates are:\",arrow_arrow)\n", "\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1st quadrant 11 2nd quandrant 6 3rd quadrant 3 4th quadrant 2\n" + ] + } + ], "source": [ "# 2. Calculate how many arrows have fallen in each quadrant.\n", - "\n" + "bullseye = []\n", + "first_q = []\n", + "second_q = []\n", + "third_q = []\n", + "fourth_q = []\n", + "\n", + "xcoord = []\n", + "ycoord = []\n", + "\n", + "for i in points:\n", + " xcoord.append(i[0])\n", + " ycoord.append(i[1])\n", + "\n", + "for i in range(len(xcoord)):\n", + " if xcoord[i] >= 0 and ycoord[i] >= 0:\n", + " first_q.append(i)\n", + " elif xcoord[i] <= 0 and ycoord[i] <= 0:\n", + " third_q.append(i)\n", + " elif xcoord[i] >= 0 and ycoord[i] <= 0:\n", + " fourth_q.append(i)\n", + " elif xcoord[i] <= 0 and ycoord[i] >= 0:\n", + " second_q.append(i)\n", + " else: \n", + " bullseye.append(i)\n", + " \n", + "print(\"1st quadrant\",len(first_q),\"2nd quandrant\",len(second_q),\"3rd quadrant\",len(third_q),\"4th quadrant\",len(fourth_q))\n" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The closest points to the center are: [(0, 2), (0, -2), (2, 2), (2, 2)]\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", - "\n" + "import math\n", + "\n", + "def sClosest(shots, N): \n", + " \n", + " shots.sort(key = lambda N: math.sqrt(N[0]**2 + N[1]**2)) \n", + " \n", + " return shots[:N] \n", + " \n", + "shots = points \n", + "\n", + "N = 4\n", + "\n", + "print(\"The closest points to the center are:\",sClosest(shots, N)) \n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The number of arrows in 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", - "\n" + "inside = []\n", + "outside = [] \n", + "\n", + "for i in range(len(xcoord)):\n", + " if ((xcoord[i] - 0)**2 + \n", + " (ycoord[i] - 0)**2 <= 9**2): \n", + " inside.append(i)\n", + " else: \n", + " outside.append(i)\n", + "print (\"The number of arrows in the forest is\",len(outside))" ] }, { @@ -121,7 +205,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.2" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/robot.md b/robot.md new file mode 100644 index 0000000..e69de29 diff --git "a/rock\342\200\223paper\342\200\223scissors/rock-paper-scissors.ipynb" "b/rock\342\200\223paper\342\200\223scissors/rock-paper-scissors.ipynb" index f13735d..42b7556 100644 --- "a/rock\342\200\223paper\342\200\223scissors/rock-paper-scissors.ipynb" +++ "b/rock\342\200\223paper\342\200\223scissors/rock-paper-scissors.ipynb" @@ -171,7 +171,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/snail-and-well/snail-and-well.ipynb b/snail-and-well/snail-and-well.ipynb index c8055f7..23214a9 100644 --- a/snail-and-well/snail-and-well.ipynb +++ b/snail-and-well/snail-and-well.ipynb @@ -20,19 +20,48 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "On day 1 the snail is 10 from the ground\n", + "On day 2 the snail is 20 from the ground\n", + "On day 3 the snail is 30 from the ground\n", + "On day 4 the snail is 40 from the ground\n", + "On day 5 the snail is 50 from the ground\n", + "On day 6 the snail is 60 from the ground\n", + "On day 7 the snail is 70 from the ground\n", + "On day 8 the snail is 80 from the ground\n", + "On day 9 the snail is 90 from the ground\n", + "On day 10 the snail is 100 from the ground\n", + "On day 11 the snail is 110 from the ground\n", + "On day 12 the snail is 120 from the ground\n", + "On day 13 the snail is 130 from the ground\n" + ] + } + ], "source": [ "# Assign problem data to variables with representative names\n", "# well height, daily advance, night retreat, accumulated distance\n", "\n", + "well_height = 125\n", + "day_rise = 30\n", + "night_fall = -20\n", + "accumulated_distance = 0\n", "\n", "# Assign 0 to the variable that represents the solution\n", "\n", + "days = 0\n", "\n", "# Write the code that solves the problem\n", "\n", + "while accumulated_distance < well_height:\n", + " accumulated_distance += (day_rise + night_fall)\n", + " days += 1\n", + " print(\"On day\", days , \"the snail is\", accumulated_distance,\"from the ground\")\n", "\n", "# Print the result with print('Days =', days)\n" ] @@ -69,33 +98,62 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "On day 1 the snake is 30 from the ground\n", + "On day 2 the snake is 51 from the ground\n", + "On day 3 the snake is 84 from the ground\n", + "On day 4 the snake is 161 from the ground\n", + "77 12 38.09090909090909 17.996969441850734\n" + ] + } + ], "source": [ "# Assign problem data to variables with representative names\n", "# well height, daily advance, night retreat, accumulated distance\n", - "\n", + "advance_cm = [30, 21, 33, 77, 44, 45, 23, 45, 12, 34, 55]\n", + "accumulated_distance = 0\n", "\n", "# Assign 0 to the variable that represents the solution\n", "\n", + "days = 0\n", "\n", "# Write the code that solves the problem\n", "\n", + "displacement = []\n", + "while accumulated_distance < well_height:\n", + " accumulated_distance += advance_cm[days]\n", + " days += 1\n", "\n", "\n", "# Print the result with print('Days =', days)\n", "\n", - "\n", - "# What is its maximum displacement in a day? And its minimum?\n", + " \n", + " print(\"On day\", days ,\"the snake is\", accumulated_distance, \"from the ground\")\n", + " \n", + " \n", "\n", "\n", + "# What is its maximum displacement in a day? And its minimum?\n", + "max_displacement = max(advance_cm)\n", + "min_displacement = min(advance_cm)\n", "\n", "# What is its average progress?\n", "\n", + "average_prog = sum(advance_cm)/len(advance_cm)\n", "\n", "# What is the standard deviation of your displacement during the day?\n", - "\n" + "\n", + "from statistics import stdev\n", + "\n", + "std_advance = stdev(advance_cm)\n", + "\n", + "print(max_displacement, min_displacement, average_prog, std_advance)\n" ] }, { @@ -122,7 +180,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/temperature/temperature.ipynb b/temperature/temperature.ipynb index 048d15a..5a88341 100644 --- a/temperature/temperature.ipynb +++ b/temperature/temperature.ipynb @@ -35,7 +35,9 @@ { "cell_type": "code", "execution_count": 1, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { @@ -49,7 +51,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -101,34 +103,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "# assign a variable to the list of temperatures\n", - "\n", - "# 1. Calculate the minimum of the list and print the value using print()\n", - "\n", - "\n", - "# 2. Calculate the maximum of the list and print the value using print()\n", - "\n", - "\n", - "# 3. Items in the list that are greater than 70ºC and print the result\n", - "\n", - "\n", - "# 4. Calculate the mean temperature throughout the day and print the result\n", - "\n", - "\n", - "# 5.1 Solve the fault in the sensor by estimating a value\n", - "\n", - "\n", - "# 5.2 Update of the estimated value at 03:00 on the list\n", - "\n", - "\n", - "\n", - "# Bonus: convert the list of ºC to ºFarenheit\n", - "\n" - ] + "source": [] }, { "cell_type": "markdown", @@ -144,13 +122,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "# Print True or False depending on whether you would change the cooling system or not\n", - "\n" - ] + "source": [] }, { "cell_type": "markdown", @@ -227,7 +202,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.3" } }, "nbformat": 4,