diff --git a/bus/bus.ipynb b/bus/bus.ipynb index 81779ce..cd84e98 100644 --- a/bus/bus.ipynb +++ b/bus/bus.ipynb @@ -32,52 +32,154 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# variables\n", - "\n" + "\n", + "entrada = 0\n", + "saida = 0\n", + "\n", + "bus_stop = int()\n", + "limite = 50\n", + "paradas = []\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*** '99' na variável 'entrada' para parar ***\n", + "\n", + "\n", + "entrada = 2\n", + "saida = 2\n", + "\n", + "entrada = 1\n", + "saida = 1\n", + "\n", + "entrada = 99\n", + "\n", + "Quantidade de paradas = 2 \n", + "Paradas [(2, 2), (1, 1)]\n" + ] + } + ], "source": [ - "# 1. Calculate the number of stops.\n", - "\n" + "# Número de passageiros ENTRADA e SAÍDA\n", + "\n", + "print(\"*** '99' na variável 'entrada' para parar ***\\n\")\n", + "\n", + "while entrada != '99':\n", + " entrada = input(\"\\nentrada = \")\n", + " if entrada == '99':\n", + " break\n", + " else:\n", + " saida = input(\"saida = \")\n", + " bus_stop = (int(entrada), int(saida))\n", + " paradas.append (bus_stop)\n", + "\n", + "\n", + "print(\"\\nQuantidade de paradas = \", len(paradas), \"\\nParadas\", (paradas))" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quantidade de paradas = 2\n" + ] + } + ], "source": [ - "# 2. Assign a variable a list whose elements are the number of passengers in each stop: \n", - "# Each item depends on the previous item in the list + in - out.\n", + "# 1. Calculate the number of stops.\n", + "\n", + "qtd_paradas = 0\n", + "\n", + "for t in paradas:\n", + "\tqtd_paradas +=1\n", + "\n", + "print(\"Quantidade de paradas = \", qtd_paradas)\n", "\n" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Histórico de ocupantes no ônibus = [0, 0]\n", + "Quantidade de passageiros no ônibus (final) = 0\n", + "Máximo de ocupantes = 0\n", + "Média de passageiros = 0.0\n" + ] + } + ], "source": [ + "# 2. Assign a variable a list whose elements are the number of passengers in each stop: \n", + "\n", + "\n", + "# Each item depends on the previous item in the list + in - out.\n", + "# Number passengers in the bus \n", "# 3. Find the maximum occupation of the bus.\n", + "# 4. Calculate the average occupation. And the standard deviation.\n", + "\n", + "\n", + "##Number passengers in the bus##\n", + "##Max of passengers##\n", + "\n", + "number_pas = 0\n", + "total_pas = 0\n", + "hist_ocup = []\n", + "\n", + "for tupla in paradas:\n", + "\tnumber_pas = tupla[0]-tupla[1]\n", + "\ttotal_pas+=number_pas\n", + "\thist_ocup.append(total_pas)\n", + "\n", + "soma = sum(hist_ocup)\n", + "\t\n", + "print('Histórico de ocupantes no ônibus = ', hist_ocup)\n", + "print('Quantidade de passageiros no ônibus (final) = ',total_pas)\n", + "print('Máximo de ocupantes = ', max(hist_ocup))\n", + "print('Média de passageiros = ', soma/len(hist_ocup))\n", "\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Desvio Padrão do histórico de passageiros = 0.00\n" + ] + } + ], "source": [ - "# 4. Calculate the average occupation. And the standard deviation.\n", + "##Desvio padrão##\n", + "\n", + "import statistics\n", + "print( \"Desvio Padrão do histórico de passageiros = \", \"%.2f\" %(statistics.stdev(hist_ocup)))\n", + "\n", "\n" ] }, @@ -105,7 +207,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.2" + "version": "3.7.6" } }, "nbformat": 4, diff --git a/duel/duel.ipynb b/duel/duel.ipynb index 4398d88..b91f13a 100644 --- a/duel/duel.ipynb +++ b/duel/duel.ipynb @@ -33,43 +33,85 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, "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]" + "saruman = [23, 66, 12, 43, 12, 10, 44, 23, 12, 17]\n", + "tie=[]" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 48, "metadata": {}, "outputs": [], "source": [ - "# Assign 0 to each variable that stores the victories\n" + "# Assign 0 to each variable that stores the victories\n", + "gandalf_results=int(0)\n", + "saruman_results=int(0)\n", + "draw=int(0)" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 49, "metadata": {}, "outputs": [], "source": [ - "# Execution of spell clashes\n" + "# Execution of spell clashes\n", + "\n", + "for i in range(10):\n", + " if gandalf[i] < saruman[i]:\n", + " saruman_results+=1\n", + " elif gandalf[i] > saruman[i]:\n", + " gandalf_results+=1\n", + " else:\n", + " draw+=1\n", + "\n", + "for i in range(10):\n", + " tie.append(int(gandalf[i] + saruman[i]))\n", + " " ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 50, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "**SCORE** \n", + " Saruman = 4 \n", + " Gandalf = 6 \n", + " Draw = 0 \n", + "**THE SUM OF POWER** \n", + " [33, 77, 25, 73, 34, 21, 54, 56, 34, 39] = 446 of 10 clashes\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" + "print(\"**SCORE** \\n\",\n", + " \"Saruman =\", saruman_results,\"\\n\",\n", + " \"Gandalf =\", gandalf_results,\"\\n\",\n", + " \"Draw =\", draw,\"\\n\"\n", + " \"**THE SUM OF POWER** \\n\", tie, \"=\", sum(tie), \"of\", len(tie), \"clashes\" )\n" ] }, { @@ -116,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -134,56 +176,140 @@ "gandalf = ['Fireball', 'Lightning bolt', 'Lightning bolt', 'Magic arrow', 'Fireball', \n", " 'Magic arrow', 'Lightning bolt', 'Fireball', 'Magic arrow', 'Fireball']\n", "saruman = ['Contagion', 'Contagion', 'Black Tentacles', 'Fireball', 'Black Tentacles', \n", - " 'Lightning bolt', 'Magic arrow', 'Contagion', 'Magic arrow', 'Magic arrow']" + " 'Lightning bolt', 'Magic arrow', 'Contagion', 'Magic arrow', 'Magic arrow']\n", + "\n", + "gandalf_power=[]\n", + "saruman_power=[]\n", + "\n", + "gandalf_results1=[]\n", + "saruman_results1=[]" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Power Gandalf= [50, 40, 40, 10, 50, 10, 40, 50, 10, 50] \n", + " Power Saruman= [45, 45, 25, 50, 25, 40, 10, 45, 10, 10]\n" + ] + } + ], "source": [ "# Assign spell power lists to variables\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# 2. A sorcerer wins if he succeeds in winning 3 spell clashes in a row.\n", - "\n", - "\n", - "# Execution of spell clashes\n", - "\n", - "\n", "\n", - "# check for 3 wins in a row\n", + "for gandalf_magic, saruman_magic in zip(gandalf, saruman):\n", + " gandalf_power.append(POWER[gandalf_magic])\n", + " saruman_power.append(POWER[saruman_magic])\n", "\n", - "\n", - "# check the winner\n" + "print(\"Power Gandalf=\", gandalf_power,\"\\n\",\"Power Saruman=\", saruman_power)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rodadas: 10\n", + "Ganfald ganha 1\n", + "Saruman ganha 1\n", + "Ganfald ganha 1\n", + "Saruman ganha 1\n", + "Ganfald ganha 1\n", + "Saruman ganha 1\n", + "Ganfald ganha 1\n", + "Ganfald ganha 1\n", + "Empate\n", + "Ganfald ganha 1\n", + "Fim do Jogo: Gandalf Ganhou\n" + ] + } + ], "source": [ - "# 3. Average of each of the spell lists.\n", - "\n" + "gandalf_ganhou = int(0)\n", + "saruman_ganhou = int(0)\n", + "print(\"Rodadas:\", len(saruman_power))\n", + "\n", + "# 2. A sorcerer wins if he succeeds in winning 3 spell clashes in a row.#\n", + "# Execution of spell clashes#\n", + "# check the winner#\n", + "for i in range (1):\n", + " for i in range (len(saruman_power)):\n", + " if gandalf_power[i] > saruman_power[i]:\n", + " gandalf_ganhou+=1\n", + " print(\"Ganfald ganha 1\")\n", + " elif saruman_power[i] > gandalf_power[i]:\n", + " saruman_ganhou+=1\n", + " print(\"Saruman ganha 1\")\n", + " else:\n", + " print(\"Empate\")\n", + " if gandalf_ganhou > 3:\n", + " print(\"Fim do Jogo: Gandalf Ganhou\")\n", + " elif saruman_ganhou > 3:\n", + " print(\"Fim do Jogo: Saruman Ganhou\")\n", + " else:\n", + " print(\"Fim do Jogo: ninguém ganhou\")\n" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Desvio Padrão Saruman = 15.56\n", + "Desvio Padrão Gandalf = 17.80\n" + ] + } + ], "source": [ "# 4. Standard deviation of each of the spell lists.\n", - "\n" + "\n", + "\n", + "#COM MATH#\n", + "\n", + "import math\n", + "\n", + "##Variaveis##\n", + "\n", + "soma_saruman=int(0)\n", + "\n", + "##Soma##\n", + "for i in saruman_power:\n", + " soma_saruman+=i\n", + "\n", + " \n", + "## Média ##\n", + "\n", + "media_saruman = soma_saruman/len(saruman_power)\n", + "\n", + "\n", + "##Variancia##\n", + "variancia_calc = 0\n", + "for i in saruman_power:\n", + " variancia_calc += (((i) - media_saruman)**2)\n", + " \n", + "\n", + "##Desvio Padrão##\n", + "\n", + "desvio = math.sqrt(variancia_calc/len(saruman_power))\n", + "print ('Desvio Padrão Saruman = ', \"%.2f\" %(desvio))\n", + "\n", + "#COM STATISTICS#\n", + "\n", + "import statistics\n", + "print( \"Desvio Padrão Gandalf = \", \"%.2f\" %(statistics.stdev(gandalf_power)))" ] }, { @@ -210,7 +336,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.6" } }, "nbformat": 4, diff --git a/robin-hood/robin-hood.ipynb b/robin-hood/robin-hood.ipynb index b1af06b..32932b1 100644 --- a/robin-hood/robin-hood.ipynb +++ b/robin-hood/robin-hood.ipynb @@ -52,16 +52,44 @@ "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)]" + " (5, 7), (5, 7), (2, 2), (9, 9), (-8, -9)]\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Robin Hood acertou 2 vezes nas coordenadas = (4, 5)\n", + "Robin Hood acertou 3 vezes nas coordenadas = (5, 7)\n", + "Robin Hood acertou 2 vezes nas coordenadas = (2, 2)\n", + "Robin Hood acertou 2 vezes nas coordenadas = (-3, 2)\n" + ] + } + ], "source": [ "# 1. Robin Hood is famous for hitting an arrow with another arrow. Did you get it?\n", + "\n", + "val_count = 0\n", + "hit_dict = {}\n", + "\n", + "\n", + "# Verificando repetição e criando dicionário dos resultados\n", + "\n", + "for valor in points:\n", + " val_count = points.count(valor)\n", + " \n", + " if val_count>1:\n", + " hit_dict.update( {valor : val_count} )\n", + "\n", + "# Mostrando valores \n", + "\n", + "for k, v in hit_dict.items():\n", + " print(\"Robin Hood acertou\", v,\" vezes nas coordenadas = \", k)\n", "\n" ] }, @@ -69,40 +97,168 @@ "cell_type": "code", "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "**RESULTADO FINAL**\n", + " \n", + " Q1 = 10 \n", + " Q2 = 6 \n", + " Q3 = 2 \n", + " Q4 = 6 \n", + " Eixo X = 0 \n", + " Eixo y = 2 \n", + " Origem = 0 \n", + "\n" + ] + } + ], "source": [ "# 2. Calculate how many arrows have fallen in each quadrant.\n", + "\n", + "quadrante_1=0\n", + "quadrante_2=0\n", + "quadrante_3=0\n", + "quadrante_4=0\n", + "x=''\n", + "y=''\n", + "eixo_x = 0\n", + "eixo_y = 0\n", + "origem = 0\n", + "\n", + "# Determinando X e Y de cada tupla\n", + "\n", + "for conjunto in points:\n", + " coord = conjunto\n", + " for index, valor in enumerate(coord):\n", + " if index == 0:\n", + " x = valor\n", + " else:\n", + " y = valor\n", + " \n", + "# Verificando Quadrantes\n", + " \n", + "\n", + " if x>0:\n", + " if y>0:\n", + " quadrante_1+=1\n", + " elif y<0:\n", + " quadrante_4+=1\n", + " else:\n", + " eixo_x += 1 \n", + "\n", + " elif x<0:\n", + " if y<0:\n", + " quadrante_3+=1\n", + " elif y>0:\n", + " quadrante_2+=1\n", + " else:\n", + " eixo_y += 1\n", + " \n", + " elif x==0:\n", + " if y !=0:\n", + " eixo_y += 1\n", + " else:\n", + " origem += 1\n", + " else:\n", + " (\"valor inesperado\")\n", + " \n", + "# Mostrando resultados\n", + "\n", + "print( \"**RESULTADO FINAL**\" \"\\n\", \"\\n\",\n", + " \"Q1 = \", quadrante_1, \"\\n\",\n", + " \"Q2 = \", quadrante_2, \"\\n\",\n", + " \"Q3 = \", quadrante_3, \"\\n\",\n", + " \"Q4 = \", quadrante_2, \"\\n\",\n", + " \"Eixo X = \", eixo_x, \"\\n\",\n", + " \"Eixo y = \", eixo_y, \"\\n\",\n", + " \"Origem = \", origem,\"\\n\")\n", "\n" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A menor distância é 2.0 das coordenadas (0, 2)\n", + "A menor distância é 2.0 das coordenadas (0, -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", + "# Definindo a formula: d²=(x_1-x_2)²+(y_1-y_2)²\n", + "\n", + "from math import sqrt\n", + "\n", + "# Variavéis das coordenadas e origem (0,0) ##\n", + "\n", + "x_1 = ''\n", + "y_1 = ''\n", + "\n", + "x_2 = 0\n", + "y_2 = 0\n", + "\n", + "dist_list=[]\n", + "dist_origem = {}\n", + "\n", + "# Definindo x_1 e y_1 e aplicando a fórmula \n", + "\n", + "for conjunto1 in points:\n", + " coord1 = conjunto1\n", + " for index1, valor1 in enumerate(coord1):\n", + " if index1 == 0:\n", + " x_1 = valor1\n", + " else:\n", + " y_1 = valor1\n", + " dist = ((x_1-x_2)**2) + ((y_1-y_2)**2)\n", + " dist = sqrt(dist)\n", + " dist_list.append(dist)\n", + " hit_dict.update( {coord1 : dist} )\n", + " \n", + "# Mostrando o resultado\n", + " \n", + "for k, v in hit_dict.items():\n", + " if v == min(dist_list):\n", + " print (\"A menor distância é\", v, \"das coordenadas\", k )\n", + "\n", "\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Temos 0 flechas com o raio maior que 9\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" + "# 4. If the target has a radius of 9, calculate the number of arrows that - must be picked up in the forest.\n", + "hit_out = 0\n", + "\n", + "# Distância maiores que 9 \n", + "for k, v in hit_dict.items():\n", + " if v > 9:\n", + " hit_out +=1\n", + " \n", + "\n", + "print(\"Temos\", hit_out, \"flechas com o raio maior que 9\")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -121,7 +277,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.2" + "version": "3.7.6" } }, "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..ed90fcd 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" @@ -25,49 +25,121 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "metadata": {}, "outputs": [], "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", "\n", - "# Assign to a list the 3 possible options: 'stone', 'paper' or 'scissors'.\n", + "import random\n", "\n", + "# Assign to a list the 3 possible options: 'stone', 'paper' or 'scissors'.\n", "# Assign a variable to the maximum number of games: 1, 3, 5, etc ...\n", "\n", + "qtd_max = 3\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", + "para_ganhar = 3\n", + "\n", + "# Preferably the value will be based on the number of maximum games\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", "\n", + "game_machine=[]\n", + "game_user=[]\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", + "opcoes = {'pedra':1, 'papel':2, 'tesoura':3}\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", "\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 jogada():\n", + " return random.choice(list(opcoes.keys()))\n", + " \n", "\n", + "def pergunta():\n", + " escolha = int(input(\"\\nEscolha uma opção = 1 - pedra, 2 - papel, 3 - tesoura = \\n\"))\n", + " while escolha != opcoes.values():\n", + " if escolha == 1:\n", + " escolha = \"pedra\"\n", + " break\n", + " elif escolha == 2:\n", + " escolha = \"papel\"\n", + " break\n", + " elif escolha == 3:\n", + " escolha = \"tesoura\"\n", + " break\n", + " else:\n", + " escolha = int(input(\"\\n Você só pode escolher entre = 1 - pedra, 2 - papel, 3 - tesoura = \\n\"))\n", + " \n", + " return escolha\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Escolha uma opção = 1 - pedra, 2 - papel, 3 - tesoura = \n", + "1\n", + "\n", + "A máquina escolheu = papel \n", + "Você escolheu = pedra\n", + "\n", + "A máquina ganhou essa rodada\n", + "\n", + "Escolha uma opção = 1 - pedra, 2 - papel, 3 - tesoura = \n", + "1\n", + "\n", + "A máquina escolheu = tesoura \n", + "Você escolheu = pedra\n", + "\n", + "Você ganhou essa rodada\n", + "\n", + "Escolha uma opção = 1 - pedra, 2 - papel, 3 - tesoura = \n", + "2\n", + "\n", + "A máquina escolheu = pedra \n", + "Você escolheu = papel\n", + "\n", + "Você ganhou essa rodada\n" + ] + } + ], + "source": [ + "for i in range(qtd_max):\n", + " user = pergunta()\n", + " machine = jogada()\n", " \n", - "# Create two variables that accumulate the wins of each participant\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", - "\n", - "\n", + " print(\"\\nA máquina escolheu = \", machine, \"\\nVocê escolheu = \", user)\n", " \n", - "# Print by console the winner of the game based on who has more accumulated wins\n", - " " + " if user == 'papel':\n", + " if machine == 'papel':\n", + " print(\"\\nDeu empate\")\n", + " elif machine == 'tesoura':\n", + " print(\"\\nA máquina ganhou essa rodada\")\n", + " else:\n", + " print(\"\\nVocê ganhou essa rodada\")\n", + " elif user == 'pedra':\n", + " if machine == 'papel':\n", + " print(\"\\nA máquina ganhou essa rodada\")\n", + " elif machine == 'tesoura':\n", + " print(\"\\nVocê ganhou essa rodada\")\n", + " else:\n", + " print(\"\\nDeu empate\")\n", + " elif user == 'tesoura':\n", + " if machine == 'papel':\n", + " print(\"\\nVocê ganhou essa rodada\")\n", + " elif machine == 'tesoura':\n", + " print(\"\\nDeu empate\")\n", + " else:\n", + " print(\"\\nA máquina ganhou essa rodada\")\n", + " else:\n", + " print(\"\\nerrado\")\n", + " \n" ] }, { @@ -93,19 +165,77 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quantidade máxima de jogo = 3\n", + "\n", + " INICIANDO RODADA = 1 \n", + "\n", + "\n", + "Escolha uma opção = 1 - pedra, 2 - papel, 3 - tesoura , 4 - lagarto, 5 - spok = \n", + "1\n", + "Usuário escolheu 1 e máquina escolheu 5\n", + "Resultado = 1\n", + "\n", + " INICIANDO RODADA = 2 \n", + "\n", + "\n", + "Escolha uma opção = 1 - pedra, 2 - papel, 3 - tesoura , 4 - lagarto, 5 - spok = \n", + "1\n", + "Usuário escolheu 1 e máquina escolheu 1\n", + "Resultado = 0\n", + "\n", + " INICIANDO RODADA = 3 \n", + "\n", + "\n", + "Escolha uma opção = 1 - pedra, 2 - papel, 3 - tesoura , 4 - lagarto, 5 - spok = \n", + "1\n", + "Usuário escolheu 1 e máquina escolheu 4\n", + "Resultado = 2\n", + "\n", + " Pontos para o usuário = 1 Pontos para a máquina = 1 Empate = 1 \n", + "\n", + "DEU EMPATE\n" + ] + } + ], "source": [ - "# Import the choice function of the random module\n", + "# # Import the choice function of the random module\n", + "\n", + "import random\n", + "\n", + "\n", + "game_machine=[]\n", + "game_user=[]\n", + "\n", "\n", "\n", "# Define a function that asks for an odd number on the keyboard, until it is not valid\n", "# will keep asking\n", "\n", + "def pergunta():\n", + " valor= int(input(\"Insira um valor ímpar\"))\n", + " validacao = valor % 2\n", + " while validacao == 0:\n", + " valor = int(input(\"Insira APENAS um valor ímpar\"))\n", + " validacao = valor % 2\n", + " return (\"Valor é impar\")\n", + " \n", + "\n", "\n", "# Assign a list of 5 possible options.\n", "\n", + "opcoes = {1:'pedra', 2: 'papel', 3 :'tesoura', 4 :'lagarto', 5: 'spock' }\n", + "\n", + "combinacoes = {1:[4,3], 2:[1,5], 3 :[4,2], 4 :[2,5], 5:[1,3]}\n", + "\n", + "\n", + "\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", @@ -115,32 +245,91 @@ "# Preferably the value will be based on the number of maximum games\n", "\n", "\n", + "qtd_max = int(input(\"Quantidade máxima de jogo = \"))\n", + "\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", "\n", + "def jogada():\n", + " return random.choice(list(opcoes.keys()))\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", "\n", + "def pergunta():\n", + " escolha = int(input(\"\\nEscolha uma opção = 1 - pedra, 2 - papel, 3 - tesoura , 4 - lagarto, 5 - spok = \\n\"))\n", + " while escolha not in opcoes:\n", + " escolha = int(input(\"\\nEscolha APENAS uma opção = 1 - pedra, 2 - papel, 3 - tesoura , 4 - lagarto, 5 - spok = \\n\"))\n", + " return escolha\n", + "\n", "\n", "# Define a function that resolves a combat.\n", + "\n", + "\n", + "def combate(user, machine):\n", + " if user in combinacoes:\n", + " if user != machine:\n", + " if machine in combinacoes[user]:\n", + " user = 2\n", + " elif machine not in combinacoes[user]:\n", + " user = 1\n", + " else:\n", + " user = 0\n", + " return user\n", + " \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", " \n", "\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", "\n", - " \n", + "def show():\n", + " lista_resultado = []\n", + " for i in range(qtd_max):\n", + " print('\\n INICIANDO RODADA = ', i + 1, '\\n' )\n", + " resposta = pergunta()\n", + " resultado = jogada()\n", + " print (\"Usuário escolheu\", resposta, \"e máquina escolheu\", resultado)\n", + " print(\"Resultado =\", combate(resposta, resultado))\n", + " lista_resultado.append(combate(resposta, resultado))\n", + " return lista_resultado\n", + " \n", + " \n", + " \n", "# Create two variables that accumulate the wins of each participant\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", "\n", + "user_game = 0\n", + "machine_game = 0\n", + "tie = 0\n", + "\n", + "final = show()\n", + "\n", + "for i in final:\n", + " if i == 2:\n", + " user_game += 1\n", + " elif i == 1:\n", + " machine_game += 1\n", + " else:\n", + " tie += 1\n", + " \n", + "print(\"\\n Pontos para o usuário = \", user_game,\"Pontos para a máquina = \", machine_game, \"Empate = \", tie, \"\\n\")\n", + "\n", + "\n", + "if user_game > machine_game:\n", + " print('O USUÁRIO GANHOU')\n", + "elif user_game < machine_game:\n", + " print('A MÁQUINA GANHOU')\n", + "else:\n", + " print('DEU EMPATE') \n", + "\n", " \n", " \n", "# Print by console the winner of the game based on who has more accumulated wins\n", @@ -171,7 +360,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.6" } }, "nbformat": 4, diff --git a/snail-and-well/snail-and-well.ipynb b/snail-and-well/snail-and-well.ipynb index c8055f7..984d9ab 100644 --- a/snail-and-well/snail-and-well.ipynb +++ b/snail-and-well/snail-and-well.ipynb @@ -20,21 +20,47 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, - "outputs": [], + "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", + "# Assign 0 to the variable that represents the solution\n", + "# Write the code that solves the problem\n", "\n", "\n", - "# Assign 0 to the variable that represents the solution\n", + "botton= int(0)\n", + "snail_day= int(30)\n", + "snail_night= int(20)\n", + "path=[]\n", + "days=int(0)\n", "\n", "\n", - "# Write the code that solves the problem\n", + "while botton < 125:\n", + "\tbotton+=snail_day\n", + "\tpath.append(botton)\n", + "\tif botton > 125:\n", + "\t\tbreak\n", + "\telse:\n", + "\t\tbotton= botton - snail_night\n", + "\t\tpath.append(botton)\n", + "\n", + "\n", + "for i in path:\n", + "\tdays+=0.5\n", "\n", + "# Print the result with print('Days =', days)\n", "\n", - "# Print the result with print('Days =', days)\n" + "print('Days=', days)\n" ] }, { @@ -69,41 +95,47 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Path = [30, 10, 40, 20, 50, 30, 60, 40, 70, 50, 80, 60, 90, 70, 100, 80, 110, 90, 120, 100, 125]\n", + "Minimun = 10 Maximum = 125 Média = 67.86\n", + "Desvio Padrão = 33.11\n" + ] + } + ], "source": [ "# Assign problem data to variables with representative names\n", "# well height, daily advance, night retreat, accumulated distance\n", - "\n", - "\n", "# Assign 0 to the variable that represents the solution\n", - "\n", - "\n", "# Write the code that solves the problem\n", - "\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", + "# What is its average progress?\n", "\n", + "for index, item in enumerate(path):\n", + " if item > 125:\n", + " path[index] = 125\n", + " else:\n", + " pass\n", + " \n", + "print(\"Path = \", path)\n", "\n", + "average = sum(path)/ len(path)\n", "\n", - "# What is its average progress?\n", + "print(\"Minimun =\", min(path), \"Maximum =\", max(path), \"Média =\", \"%.2f\"%(average))\n", "\n", "\n", "# What is the standard deviation of your displacement during the day?\n", - "\n" + "import statistics\n", + "\n", + "\n", + "print( \"Desvio Padrão = \", \"%.2f\" %(statistics.stdev(path)))\n" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -122,7 +154,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.6" } }, "nbformat": 4, diff --git a/temperature/temperature.ipynb b/temperature/temperature.ipynb index 048d15a..a669f0d 100644 --- a/temperature/temperature.ipynb +++ b/temperature/temperature.ipynb @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -43,13 +43,13 @@ "Text(0.5, 1.0, 'Temperatures of our server throughout the day')" ] }, - "execution_count": 1, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -101,32 +101,59 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Minímo = 0\n", + "Máximo = 90\n", + "Temperaturas maiores que 70 [76, 80, 81, 80, 83, 90, 79]\n", + "A média é 60\n" + ] + } + ], "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", + "minimo = min(y)\n", + "print(\"Minímo = \", minimo)\n", "\n", - "# 2. Calculate the maximum of the list and print the value using print()\n", "\n", + "# 2. Calculate the maximum of the list and print the value using print()\n", + "maximo = max(y)\n", + "print(\"Máximo = \", maximo)\n", "\n", "# 3. Items in the list that are greater than 70ºC and print the result\n", "\n", + "temp_70up = []\n", + "for i in y:\n", + " if i > 70:\n", + " temp_70up.append(i)\n", + " \n", + "\n", + "print(\"Temperaturas maiores que 70\", temp_70up)\n", "\n", "# 4. Calculate the mean temperature throughout the day and print the result\n", "\n", + "soma = 0\n", + "for i in y:\n", + " soma += i\n", "\n", - "# 5.1 Solve the fault in the sensor by estimating a value\n", + "media = soma/len(y)\n", + "print(\"A média é\", \"{:.0f}\".format(media))\n", "\n", + "# 5.1 Solve the fault in the sensor by estimating a value\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", + "for count, item in enumerate(y):\n", + " if item == 0:\n", + " y[count] = media\n", + " \n", "\n" ] }, @@ -144,12 +171,68 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fahrenheit = [91, 151, 149, 140, 138, 140, 144, 147, 158, 169, 176, 178, 176, 181, 194, 174, 142, 127, 122, 120, 127, 118, 113, 102]\n" + ] + } + ], "source": [ "# Print True or False depending on whether you would change the cooling system or not\n", - "\n" + "\n", + "regular=[]\n", + "media_live = int()\n", + "soma_live = int()\n", + "up70 = int()\n", + "up80 = int()\n", + "\n", + "#more than 4 hours with temperatures greater than or equal to 70ºC\n", + "\n", + "for index, valor in enumerate(y, start=1):\n", + " if valor > 70:\n", + " up70 += 1\n", + " if up70 > 4:\n", + " regular.append(index)\n", + " up70 = 0\n", + " \n", + "#some temperature higher than 80ºC\n", + " \n", + "for index, valor in enumerate(y, start=1):\n", + " if valor > 80:\n", + " regular.append(index)\n", + " \n", + "#average was higher than 65ºC throughout the day If any of these three is met, the cooling system must be changed.\n", + "\n", + "for index, valor in enumerate(y, start=1):\n", + " soma_live += valor\n", + " media_live = (soma_live/index)\n", + " if media_live > media:\n", + " regular.append(index)\n", + "# print(\"{:.2f}\".format(media_live))\n", + " \n", + "\n", + "# Bonus: convert the list of ºC to ºFarenheit\n", + "\n", + "fahrenheit = []\n", + "\n", + "for count, celsius in enumerate(y):\n", + " f = 1.8* celsius +32\n", + " f = int(\"{:.0f}\".format(f))\n", + " fahrenheit.append(f)\n", + "\n", + " \n", + "print(\"Fahrenheit = \", fahrenheit)\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " " ] }, { @@ -165,12 +248,25 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hours = [12, 13, 14, 14, 15, 16, 16, 16, 17, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]\n" + ] + } + ], "source": [ "# 1. We want the hours (not the temperatures) whose temperature exceeds 70ºC\n", - "\n" + "\n", + "#Alterando para horas, como tive que iniciar em 1 no #\n", + "for index, valor in enumerate(regular):\n", + " regular[index] = valor + 1\n", + " \n", + "print(\"Hours =\", sorted(regular))" ] }, { @@ -180,17 +276,42 @@ "outputs": [], "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", - "\n" + "\n", + "Sim\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Média Celsius = 60.25\n", + "Média Fahrenheit = 144.875\n" + ] + } + ], "source": [ "# 3. Average of each of the lists (ºC and ºF). How they relate?\n", - "\n" + "# 4. Standard deviation of each of the lists. How they relate?\n", + "\n", + "\n", + "print (\"Média Celsius = \", media)\n", + "\n", + "## Média Fahrenheit\n", + "\n", + "soma_f= 0\n", + "for i in fahrenheit:\n", + " soma_f+=i\n", + " media_f= soma_f/len(fahrenheit)\n", + "print(\"Média Fahrenheit = \", media_f) \n", + "\n", + "\n", + "\n", + "## Sofre um efeito de deslocamento na mutiplicação" ] }, { @@ -199,7 +320,6 @@ "metadata": {}, "outputs": [], "source": [ - "# 4. Standard deviation of each of the lists. How they relate?\n", "\n" ] }, @@ -227,7 +347,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.6" } }, "nbformat": 4,