yutsuo
/
jupyter-notebooks
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
21 Commits
1 Branch
0 Tags
12 MiB
 
Tree: 2bf0c96b8d
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2bf0c96b8d'
${ noResults }
jupyter-notebooks/Exercicios-Cap01/.ipynb_checkpoints/Exercicios01-checkpoint.ipynb

1519 lines
72 KiB
Raw Blame History

{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# <font color='blue'>Data Science Academy</font>\n",
"# <font color='blue'>Matemática Para Machine Learning</font>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Lista de Exercícios - Capítulo 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"O objetivo desta lista de exercícios é você praticar algumas operações matemáticas básicas, ao mesmo tempo que desenvolve suas habilidades em lógica de programação com a linguagem Python. \n",
"\n",
"Caso tenha dúvidas, isso é absolutamente normal e faça um trabalho de pesquisa a fim de relembrar o formato das operações matemáticas.\n",
"\n",
"Quando encontrar o formato de uma operação que resolva o exercício proposto, use a linguagem Python para representar esta operação. Em essência, é assim que aplicamos Matemática Para Machine Learning, construindo algoritmos e representando esses algoritmos em linguagem de programação.\n",
"\n",
"Divirta-se!!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Parte 1 - Operações Básicas"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 1 - Leia 2 números do terminal e imprima a soma, subtração, multiplicação e divisão.\n",
"\n",
"Dica: Crie funções em Python para formatar a saída das operações"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"will do math stuff with two integers:\n",
"5\n",
"6\n",
"sum result is 11\n",
"\n",
"subtraction result is -1\n",
"\n",
"multiply result is 30\n",
"\n",
"divide result is 0.8333333333333334\n",
"\n"
]
}
],
"source": [
"def mathStuff():\n",
" print(\"will do math stuff with two integers:\")\n",
" a = input()\n",
" b = input()\n",
" r_sum = int(a) + int(b)\n",
" r_sub = int(a) - int(b)\n",
" r_mul = int(a) * int(b)\n",
" r_div = int(a) / int(b)\n",
" print(\"sum result is \" + str(r_sum) + \"\\n\")\n",
" print(\"subtraction result is \" + str(r_sub) + \"\\n\")\n",
" print(\"multiply result is \" + str(r_mul) + \"\\n\")\n",
" print(\"divide result is \" + str(r_div) + \"\\n\")\n",
"\n",
"mathStuff()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercício 2 - Escreva um programa em Python para converter uma medida de graus em radianos.\n",
"\n",
"Nota: O radiano é a unidade padrão de medida angular, usada em muitas áreas da matemática. A medida de um ângulo em radianos é numericamente igual ao comprimento de um arco correspondente de um círculo unitário; um radiano é um pouco menos que 57,3 graus (quando o comprimento do arco é igual ao raio)."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"π: 3.141592653589793\n",
"Insert circumference degrees\n",
"720\n",
"720.0 degrees are equivalent to 12.566370614359172 (aproximately)\n"
]
}
],
"source": [
"def radians():\n",
" import math\n",
" print(\"π: \" + str(math.pi))\n",
" print(\"Insert circumference degrees\")\n",
" degree = float(input())\n",
" pi = math.pi\n",
" radians = (degree * pi) / 180\n",
" print(str(degree) + \" degrees are equivalent to ≈ \" + str(radians))\n",
"\n",
"radians()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 3 - Escreva um programa em Python para calcular a área de um paralelogramo.\n",
"\n",
"Nota: Um paralelogramo é um quadrilátero com lados opostos paralelos (e portanto ângulos opostos iguais). Um quadrilátero com lados iguais é chamado de losango, e um paralelogramo cujos ângulos são todos ângulos retos é chamado de retângulo."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"base:\n",
"3\n",
"height:\n",
"4\n",
"paralelogram area is: 12\n"
]
}
],
"source": [
"def paralelArea():\n",
" import math\n",
" print(\"base:\")\n",
" base = float(input())\n",
" print(\"height:\")\n",
" height = float(input())\n",
" area = base * height\n",
" print(\"paralelogram area is: \" + str(area))\n",
" \n",
"paralelArea()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 4 - Escreva um programa em Python para calcular o volume da superfície e a área de uma esfera.\n",
"\n",
"Nota: Uma esfera é um objeto geométrico perfeitamente redondo no espaço tridimensional que é a superfície de uma bola completamente redonda."
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"enter sphere radius value:\n",
"5\n",
"area of a sphere with radius 5.0 is ≈ 314.1592653589793\n",
"volume of a sphere with radius 5.0 is ≈ 523.5987755982989\n"
]
}
],
"source": [
"def sphereVolumeArea():\n",
" import math\n",
" print(\"enter sphere radius value:\")\n",
" radius = float(input())\n",
" PI = math.pi\n",
" area = (4 * PI) * (pow(radius, 2))\n",
" volume = (4/3) * PI * (pow(radius, 3))\n",
" print(\"area of a sphere with radius \" + str(radius) + \" is ≈ \" + str(area))\n",
" print(\"volume of a sphere with radius \" + str(radius) + \" is ≈ \" + str(volume))\n",
"\n",
"sphereVolumeArea()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 5 - Escreva um programa em Python para imprimir todas as permutações de uma determinada string (incluindo duplicatas). Por exemplo a string: ABCD.\n",
"\n",
"Na matemática, a noção de permutação refere-se ao ato de organizar todos os membros de um conjunto em alguma sequência ou ordem, ou se o conjunto já está ordenado, reorganizando (reordenando) seus elementos, um processo chamado de permutação. Estes diferem das combinações, que são seleções de alguns membros de um conjunto onde a ordem é desconsiderada.\n",
"\n",
"Na imagem a seguir, cada uma das seis linhas é uma permutação diferente de três bolas distintas"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAL8AAAEyCAIAAAAk0ZbjAAAACXBIWXMAAAsTAAALEwEAmpwYAAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUIIFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuja9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMBAPh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCdmCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgwABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88SuuEOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHgg/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgugdfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7iJIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKSKcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8//UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBCCmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHaiAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyGvEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPEbDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKggHCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmxpFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+IoUspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgXaPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1QwNzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnUlqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIpG6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acKpxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsMzhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZLTepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnutrxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFnYhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPjthPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/uNu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGLw34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8YuZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhOOJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCepkLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQrAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0dWOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWFfevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebeLZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ27tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHtxwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTradox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLTk2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/XfFt1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9DBY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAAKDlJREFUeNrsnWmQZNV5pt/v3P3mUtXQFBqLbsDIILSwCNTIf0YW2xhrsz1jq4UVHluW3MaaACRsDdLIEZ4Ix8RM2A7HjGOwjBctg7XZIyEhBhmEsLAWQGAWyUIg1gbL0Gro6qrKvMtZvvlxbmVVV2d3V2VmVeYh7xsZFbezsyrPOfe9Zz/fQ8yMWrUGkqiLoFbtnlq1e2rV7qk1JfI39Glm7nazTqeb54WU0hhTd7qdFhEJIYIgiOOo0UjTNCGiDfz6Om+/MebAgfn5+QX7NXEcBUEghNjQl9WaNDGzMUZKmeeFrRRmZ9vbts0KIUbmnsXFpX379s/OzszOtj3Pqwv9pSqt9fz8wvz8wbm57a1WcwTu2bfvx1qbubnttW+mx0P79u33PDE3d8JQ7vnRj55L03R2tl2X6bRpfn6h2+3+xE+8bED37Nu3PwyD2dmZuiin1UAHy1LOzW3f8Ih9cXFJa11bZ5o1OzujtV5cXNqYe4wx+/btP4rpak2J5ua279u33xizAfccODA/OztTd5NreZ43Oztz4MD8et3DzPPzC3VPudZy+9Wen1/o2z/u455uN4vjqK54avWqnziOut1sXe7pdLqNRlqXWq2eGo200+muyz1FUURRVBdZrZ6iKCqKYl3uKUsZhkFdZLV6CsOgLOXh7/t9h+vrXCR7iekZ+ex3snu/m3334eKRp8qnnlPPL+iFptd8mX/iznDnmeErz07O2pW+fmewY/xJ/Rd9z/3lQ9+TDz+mn9irn9+nDy5wq0knzolTTvLOPN0/5zXBBa8Ld540ms6rEKLvoL3PXPOjjz5++umnDf+V/J17zb3/xN/7Z/7hY9j7DL/4AgzTtm04eQe94hX02teI159Hu14/Cb75eufO2xZv/9rSHXvlMyvpBxvWDNYwhg0ADX1yuPPixkU/1/7Zi5oXjiWpd3yzuO2O4vZvFHufNauHydqAGVrD3mWt+eSd3qVvjH7u4viSN46gH9LXFZvgnv0vmK/8vbn1dnPHP0DJ1TMB0BrM0KbKohDi4ovEZZeKt74FJ4xnZvK+7J++cPDGLy7elJsCgIAAYGDsT8PGwChWmpWBYcCwUVApJe+Y/eXds7/8hvSCLUvqvQ+Wn78pv/EreV4wALs3xt4+Y8AGWkNpVhrGgBnGQClOU3rnLyTv/MXkp88PJ9095v9+wXz+Rv7mt2DbPhIAwMa2iMwG2kApKAXDvSyKC39GXL5bvPMdW2ydG+Y/9dn5zz1RPunD98kjCALZWodhFGsFZZglpGRpYIzRCkpWTuIzwtN/4/hf33Pce7cgqZ/8XPbpL2RPPK19D74PQdXGKmYYZqVgTaMUK8laQzMrBSlhDDNwxiv8976rccWvpRPqHn56r/nkDebTn4U28H34HgRhVRahNJSCMVCSlYSuHhabRfi+t+c9Ys976SdP3YKbcVAf/MsXP3bDgRsiEQcU+BT4EIK8nnsMawWjWEqWuclKVgqq4EKzvUFKQxsYMK7efuX7T7hym7dts5J60PzFDd1PfC6LQgpD+B58nzwBUNW+amsajbJEXnBZQhsuC5aKbelqzYYB4AN7mh/47cZxs2JU7vFHkkN+8CF9/V/z1+9EmiIM4AfwPXjeqixqKA0lUUrkBZUltOKyABGIICWU0n96HT+117vmqs3uDC3ohY++eP3nD97Y9mYiESUiiSjy4Xnk9VouzVpBF1xkJosoyjkvuPCMV6AggMEE0qwVqT/e/ycd7nxk7kObYaCDC+a6j2d/d1PeblEcURJTFFHgQXjkCQDQBkaz1CgKznKOCuQ5SglPQJREpWEGEWnNSuMPr1vqZPx71zQHM9C6xlyDWOfPrufv3IuZNuIYSYIopMCH8HBIFhWKElmGKEeeoyzJ81gUoBLMIILW5ks3odvxfu/Dm2qgjx/4Pzct3Nz0WiklDdFIRBRSHFEUUrBsdpQsCy5KzjNKOtTxOQhM4CMHQxvtwTCDiYmJQB994fqEkj942X8deVI/9pn8i1/J2k0kqWiklEQURYgiCvyVal0qKgouCsoK7nQ59E1WkOcBYK2Fpw0bsCAyTITrPtZJYvpv/6U1Ee7hvc/oT9zADzyIdgtJSo0USYIooihCEKzKokRRoCiQxdzpIgyQ5fB8AlhreAbM1kPmttuRpN5//4NNasI+e/Bv//bg3zVEoyHShmi2RLMh0ojiiMKAwl5XVHJZcFlw3qFuQEFg/A48ANpoFszaMLFhIyCIyMD8yf7/uSM8abR9oM/cmH32xm6rIdIEzSa1miJNKQ4pChGEJAgADEOWXJTIS+52OQxM4AnfB2C0BjMbJmY2DCFABGPwx3+2tOPl3jB9oJG5x3zmc/ytb6PVpLSBZkqtFtIUcYwoQhBiVRapKJDn6HYRBggC9n07sqz6zvanECAyN32Zdp7k/dH/GLl1Hsge/OLBLyWUNEWz5bVaotkUzZZopSKJKAoo6LVckmXBRddkPgUeeR55BMHMWmildSBCY4wBGzKate0qXf/CX54dnzWqUdj935NfuDlPE2o00G6KVouaDWo1RZpQFFK46sEsJYqSuxkHvvE84QkmYQyTNtCaQ0m8PHrUXP3KRz/ROec1/pCjsGHdY276srnxS2ik1Gii3aRWG80GWi2kKUURDs0iFwW6XQQBeT57HhGxMdCGtOIwBBsYD8ZAawD6z66n150rLt89WvfcvHjLv8rnZrwZa5qWaM56My3RSkUjFXGAVXUPyq7JI+r4VVeamFmzllqWVEgECtKQ1iw0NIEI9HDxg7+Z//So3PPlW4sfPW+2zVCrIdotajZpti3aTUpTSmJaU/dkOeIQvieIDAHMwhhTSpQlBQFLDc8jbaAN237mw4+qG/42G6t7Xjxgbv4KPI8aDbQa1G6j2cLsDNotSlMkCYKgGrcbAykpyziO4PsgQQRmJqO5lChLBBJSwmNoDa1BBKXMDZ8Sl1w8wnmgb3a/dfvS7ZEIIxE2RdoSzbZoNUWr7bUbIo0pCcj3yAOgWUtWAQU+eXaOB4BhlXMWcRhyVLIqhS+NtPMutgcN4DPzn317+60XNy8aMqnfuLu87etFFCIMqdFAsyFaTWo1qd0SjZTiGEGw0muWEmFAvscMo40As9I6KygKOQxJSvZLUmSniGz3EgA+9fns7ZfFl/7MUBOJg/e9ze1f4/vupyhCGFGjiWYLrSZaLWq3MTODdgv2YmYG7TbaLczMULuNVgutJpotajQRRhRFCEMKAvh+NT4jsp4zX/2a+dJNI6x4/rHzDQkVUBhRFIk4pjgVaSqShOKE0lQkDdFIKU0pbYhGKpKE0oTiVCSpSGOKIxFHFAUU+sL3yfPgUXU7Vk60dUz35oVbhk/qnd8ulOIwpChEHIk4RiOhNBFJQklCaSLS6md10Xu/kVAcI46EdV7gw/fI86pUrj571+nyzbflw65gDO6eO7+BwEcYIIoQR4gjNBqUJkgSJAnSBqUppQmlCaUp0oZ9n9IEjUb1edu6BT58H1UWaXUWzZdvGZV1fiR/dFf3bh9+QGFIoS3bUIQxxbGIYxHFFEcUxSKKRRRRFFMciygWcUxxKMKQghBhSGFAoQ/fgy9AgoRYtk7PQ7cu3bZ6uWOQpP6r/ta90vcR+oiW0xqGFMeIQ8QR4hhxTHG86iJCHCKOq0+GIaKQQn953k2ABIRYTupyAX/ljmLvs3oM7uEHHuS77ibfRxgiChEuv6qsRMsX8aqL5fd7H7YPyKFZxKosmltv47vvGU1/OX/oX+Vz1psE8skLlp9MW8g+2evAR+CR55NfFT55PnzbivV+3SNBJOzYnnHIdOuT5VN3d4dK8/3fU889p4nsN8D3KLDTZ4L8gGxC17588gPyBPkeggC+R3aen4iEqIYudlB7SFKf1nfdV47BPeaBh6pJGutk38dyFnv3AlX5H/pPT6DKoo9eUyy8/lmU0txz70jc88/595crCawyKGP53nNvbRS86p/L7xCt/fWjjuyGSer3HpGwSUNv6rt3sbKCu+aiSjUBTNUFCIzq4khO/a4cQ6+ZH/nBYe9R72dVjfOq8gcIxId+bF1f9NB3R+KeH5Y/1NXSGjNYQUsjFWnNRkIpKAOlmbgayFSrcRJKs1GspZEKuvfrGobZ2EwRaE318/3i4aGS+pjSy/NfqBZ4WCloTVLbC5Ag+5jZYblSLDXr6pOsdLVWVy1J80qXeU318/1H1Djc89gT1VQNM8CsFKmSlIbWkApKQgcgURmnWtKSkApak9KsSlZqVRaXNxYclkV+5NGRuOfpcq9doipZlizLarBX5pyHJvTJJ0MBGY8FAA0jucy5KEyRc16ilChLLu3v2iV3rlZ9zdo6AHiyfHKYpD75jNYKSnMpuSirLy4l5QUHIfkeiBBqFh4AGG3XfuyLewktSi4lK81awTCMgTHL1dUqAz3+tB6De/DMs9AKStm5KpRVLinPEYTs+0QCoV4ZsZeSqyzmXFafR1GilFAKq7KINVl8eu9I3POcep5ZK6iSy4Lz3OQZ5QEFPoKAAqGJBQekPPTcI3OTZZx1TdY13czkuckLzksu1fI+iF5VdPh3DZPU5/dpw1CKypKLgvICWc5BwIEPP2Bb6UgFTxAAbVhKZDlnOXcz7nY5yzkvUBQo7dKuZq0rdx9+LOL5feNwD7/4AvkBK0lliaJAXiDLEXQQBPADCGJmyAD2YIbWkBJZhixDN0O3gyzHShYl7Ip1ryo65IteHM1yozoYi8jnsuSyNGVHdHzjA7B9SiVUCRlS2OtflFxmJuua7pJZXNCLS2apw53SlCWXBZclS2W09Q3zWgMt6sVhkjq/wElM9nksJC912PMAMkIIgtGKpKQwIBIMgA1KyVnO3S4vLvHCklns8FKHC2mzahegq40Uh3ecF5Z4HHWP0sygskRZoCixtMSeRyAWHhGgFaREGK6aay6RZeh2eXERC0u8uISlJRQlygJlyVJCKRwpi6NQ4sWSS2XKHHmHAqGF7eMwWLEuuOyabkCBHYEbsGRp31w0ix3TWdALS2apw93c5MqUClJDG9a25VpTA7W8odYg04RKiVKavBBBlz1hqvEds1JclKIbchDQqiVELkp0umaxg6UOLyzyUsd0u5wXKG1/TUNrti3XmtJtN2kM7qFWmw8eRCk5zyno2NkaBhMbVgpFQd3umlVSLgp0ulhc5KUlLCxiqYNuh+1+guUsVi3XqizScceNxD3He8fvLZ/xhfQ4F8YTEMzQ0LaX2eVuhDAQ4Yp7TFmgLEzRMZ1Fs9jR3S53O6abc16yLM3yfizus9v3Zf6JwyT1uG1i77M68Ckv2BMQwm48tbu9qJvpKKTDVkk5L9Dp8mLHdDqwTVhesJQoS9aatd0ZeZhOnPPGUff8xL/Bj3/MgU95zp5HQoANtGGlSSp0u2zX2FetVNgGjjsdLC6hs4Rul7td5LnNIrRa2bG6WifvHIl7dgQ7Hi+fyFkQk2c8AJKUhJSsutyNdRSJKDBhb4eG5LIwRY4iN0XHdLomyzkvTJ5znnMhIe2WZ7v+uKblOjUcanfAySd5TzylspyI2C5HKGWkIlmabkZxhCii0Kfe1qlScVGw7VJ2Ms4yznPOC85zznIoVW15tr3KNdX6aSePwz102k/yffchy0EEz2MASpGUkCV3M8RRtUrak10lzQvkGTodzjLkOfK86jDZrYb9skhnnD4S97wyOuNrna8pVqUpIUgbpaiUKAsuEpNEIvRNIEj0es2GjYIsTJlx5ZuSy5zL0pSKlYE2YOubwzvOr4rOHCqpp3lfvRNKmaIUACsNqVhKKgtKYgojCnwWy3PHdvFcKpSFTSjnBRclioKLEkoZ+0jaAJOHdwpedYY/Dve8+lWw0wtFSYDdYFrVIklGYcR2d1iv7jEaUnFZIMsr36zKYtVmmeVZjtXuOeu1I3HPa+JXK6MhJDNrYwzpArLgsqQio8w3vkfVXlrbj9Ewy5tQy5yL0kgNVXApWSooZXRvZ6qA0Dhk5HJOcvYwSX3tqwOlQAQURmvS1ZZTJDF3c/I9u3RFRFU/Rmu2g0ApOcshJSuFoqwmfpRa2ZkqRLVE2tO5rw3G4B5x3rmaBJQEmFeyWCIp0O1yb2dqr9/T25kqJbICsrTOg7Jzdas6PauzGARi1/kjcc/r0/N3hCftLZ+BYGbW0B48afwCpSDhw/OFv3ZXvFEK2lZCdiOznZCTptoVj+XTF4c2W6dckO4aJqm7zg13nCT2PmM4qI7aeAKBj7KEIHg+fI/tVi9btMZAaTvpwVJCKrZ7OZe3jFfP4uGdglNP9t5wXjiOumfX68Wbfsb8/a22qmCt4XkUSJQFhLBZRP8sGlsRQ2sYDaUg1UprdWgWxaWX0AW7RuKencGOixsX/UX5V2TIkFFMBCGF70N67AkioQX6nMhhbee1jGIYBtt3jjRWB3Bp85IhjwvuPMm79I3Rn3+iS0TGgBQLAaW4VOQJFtUWhJWWq6rcGdpAq0NO5GhdWafvQPZn3xQNeVxw8GZPXHap+X+3gAiGQRJCsJIofdhOtB0S9FouAIbZbv6y04zGgFFtBzvCWF285bIRDtova/+7G+b/JuOcmDx4WD5hQyBPeHTY4gmDtbFdY20fYOsbA9PzzZr1p4ZI39weQZovuyj+5OeyLGeyG7s0tIanmQie6K2Sr16L63MakLEyodlbWu8VcCOlN18SD5nOIdzz1reIz99o7vi67ThDG2gDT4GIV05THHo71pwGXL0t9bAsiosvFG976wjdc1Hzwl+e/aWPHfiErVcIJFgAGoDQ4vC408wrDZNZvhFY3ix2+AIFgN2z7xh+axiAS94Y7f755K8+1bUPHQFCkFLV82h7PGuTupwo21QdXpWvqXsu/8VkyK1hQ7kHJ2wXl+82d36jOpBld3XZRbdem3XkLK44pm8Wg0C86/KRHzC9fHb3tzt3PVz8wLrHkLHLnLb/239WvWqbefVKN/Vb5T0zeuWvzL5zVEn9lf+QfPOe8uEfKlu0htnu8DpCDLiqLuqNOnqPYd9o7Gee7r/rl5LhEznUuR5x+W5vz3uqGlPrldGTPca45mVbq97Heous/WaWvSt+c+SbmgG8Ib3gPce/e8UWzIaNnUvr+9KsDa+0U73q5/CBOoF+8/j3jPBg8k+fH/7mrzawqtdijF0w7//S5pBHcs3F6jImwm/9x8bwm5oxPOVEXLGnal9WsqiPcC+W/+tYWRRvf5v47d/C5mjPce+9evuVvdu/PBtyhFfVH+XVr75/9v3brxr5keQrfi39wG81e198pEJd/eJD09pX11zRHMlxHADe7//+769564UXDhx//HrXB2jbNjp5J559lh9/or8hDn8BR1nJEpde7H34g/SaV2PTdG5yTsbZvdl9I7vNx++5du53E5GMPqlnBVmO79wvR/UH3/fuxoeuaibxhpe3+rpiWPcAoJe/nF5xGl44wD94ZNia7O1v8z78wc0+iZyIZFd6PoC7uncP+acI9IHtV18797ubdI49iWnX6wKAvn1vOWxSCb/z280PXTXgMeTNck9loPNfR0LwPz1wtH7dURQE3n+6wvvwf97UWme1gS5svmm7f/zecu9+vX+wP3Jm9MoPn3jtB0+4ZjNqndUGuujfRtuP855+Vu9/wQyY1NP9j3ygde2Vg9Q6m+4e24SJSy+hU0/B0hI/sbHNdeLiC72PfMi75v20bRu2UOcn552dnOWT/2jxqOQNtA4Nkf7qtnddO/fBn2+/bWuS+vpzgnNeEwQ+PfKYkhtpxxop/do70g9f3fyFnxtqdqevKzYh+tOP95sv3WS+fIu59TYcPaNBIC69RLzlMvG2t44r+pPVV5duv3nhlluXbnuyfOronzw1POXS5iVvbl82knmdAXTrPxQ335Z/5Y7iyWNtKj31ZO9n3xS9+ZJ4+HkdbF3ssN70w933mHvu5Ye+y488iqf32l2CdNxxOHknnXE6nfVasev8US1EjER75TN3d+95IHvw+8XDT5ZPPqeeX9SLLa/1Mv/EU8NTXxWdeU5y9gXprkmIW7j3WX3XfeX935Xff0Q9/rR+fp9eWOJ2k06c80472XvVGf65rw3ecN7I4haOwT21Xkrq64qaaltriDFyXQS1avfUqt1Tq3ZPrSmRXxdBT1scvn+opE4GFKEesQPjC98/gMYFRdjy2UIXOBXjDd+/IY0XilBzKtZq7OH716+xQxFqTsWKJiR8/7qSOhlQhE0kDWANp6LR7MupoL6cCmZzx9fNP37Te+DBreFUTHj4/tWacCjCNHIqJjx8/2pNOBRh6jgVkx++v6fJhyJMF6fCifD9Vk5AEaaLU+FE+H4rJ6AIU8SpcCV8P9yBIkwRp8KG7282RN/w/UlMQbAqlKRPRGwYUgkpjZQcFyIKdRhS4LPvkedxL3x/b9LDhu8f3j0WitCgZl8oQiLikMKq5SJTcmlDO0ghFcuSZS7iyCxDEdjzeAWK0DuPZqEIY3NPxamYaffhVFiWQBCuinpZ2rDwzLDPKSnNWUFRxGFBsmTfhz2ovfwsW06F+I1fH4l11hO+f1XdQ57HzNAKZYwst+H7OQop9Hlt+H5T1UDWQzZ8/zBrYeuBIgQUeCQAaDYCggVrqJJlLvLQHAGKwCtQBOshC0UYZi1sWjgVDoXvdwiKMC2cCofC9zsERZgWTsURwvez1pDaXvDygijbELXrD9+/RkOG7+8PReA1UAQtoSVsONQNQBHWJnU4KMK0cCocCt/vEBRhWjgVDoXvdwiKMC2cCofC9zsERZgWToVD4fsdgiJMC6fCofD9DkERpoVT4VD4foegCNPCqXAofL9DUIRp4VQ4FL7fISjCtHAqHArf7xAUYVo4FQ6F73cIijAtnAq4E74f7kARpohT4Ur4frgDRZgiTgUcCd9fGdEFKMIQR5BO2C4u3w3Pq6aS7Rm/oqyGUflhr2p+uaw+WTVehw6yejbaHE6FE+H7rZyAIkwXpwIuhO/vafKhCFPHqQDwO+9rvO/djdW9lqMwEYBjL5y8792N33lfYzOSes0JV19x/B4cunOt76tv56bPw3P8nmtOuHpUyZtGTsXkhO8/dlInBopQcyoOMdAkhO9fp4EmAYpQcyoOm9Udd/j+9WvsUIStIA2YT33G3PAp89WvbazKufhC8a7LN6mbvB6NK3z/ABoXFGGroj85yKmw2vrw/YMndcuhCDWnotaI3bOJMVPpgl1ebY6XtOp4zbVq99Sq3VOrdk+t2j21atXuqbV5qiknTmpCgCyb6J4J4bisX06ANY4EZIkiFCU/+bR+/El9+z+WWwNk2ZS55nFxXAaUI2CN8QJZtmKlYrwclwHkClhj7ECWTXfP2DkuG2unVoM1quh3a8Ea6AvWkBLGwPe9Pe/ZArDGhABZ+rpiNPt7DuqD//uFj/75C39ecNkUzYbXbIi04TVSkaYiTUQSUxytBDkne/CXiZfDwILBP9b7b1v8ambyc5KzB97EtF7rPPiQ/l/X8c23IEnQaqDZRLOBZhNpA2laBSy38VSDAMIj4ZHnLUdBE9VZ5bvvwTP/QifvoJe/fLOss2Cu+3j2uS/mjQY1G9RuinZbtBvUbIp2UzQbIklEGlOciDAgz7Oh/ag6SGfjGi+3ccbgm/eUWYZdrwsG2M7W1xUj6DVPOMelv3UcAWtMOJBlBO6ZcI7LWuu4A9aYfCDLsO6ZfI7L2m6yI2ANJ4AsQ7nHCY7LIdZxB6zhBJBlKPc4wXFZkTtgDVeALIO7xxWOy0rF4w5YwxUgy+CrpJbjElDYl+OSiqQhGimlKaUN0UhFklCaUJyKJBVpTHEk4oiWOS7keVjhuPS+wnJcRtZsOQLWWA+QJY6pmlKwFxHi0EIcKjJKFFLoYy2QBZXbrSyQZQzuWQ/HJaIoFlEsooiimOJYRLGIY4pDEYZ0BI4LVjgu9sJyXEYw1HIHrOEQkGVA9zjEcalqBXfAGg4BWQZ0j0Mcl+pbBwJrrPnYur5oaLCGQ0CWAXvN/TkutIbjYmOcw2yQ47Km+hmS41LdVHfAGg4BWQZ0j0Mcl0rugDUcArIM6B6HOC7VzXUHrOEQkGVA9zjEcankDljDISDLgO5xiONS9ZDdAWs4BGQZ0D0OcVwquQPWcAjIMqB7HOK4VFWCO2ANh4AsA/6yQxyX6qa6A9ZwCMgyoHsc4rhUs6LugDUcArIM6B6HOC5VleAOWMMhIMuA7nGI47Jya90Ba7gCZBm80+QKx2Xl1roD1nAFyDK4e1zhuKzohO3i8t3mzm9UB7KIIATsKmGvzTryPVlxTN97MmqwhhNAlqFiaFw+u/uV4Rl2j6lmraoJfGPP+K15KSgDY5sB+3lm7ttaVTkcEcflkNy6A9ZwAsgylHuc4LiszbA7YI3JB7IMe5b0/OS8rsm+3b1rxUOHGqIvj+OYMI4PbL/6gydcg02QW2CNc88KshzfuV+O6g++792ND13VHNVZ0hGcRD43OSfj7N7svpE9c8fvuXbudzfvMLJDYI3JAbJslnsmh+OyMQM5AtaYECDLJlJOJoTjstEmTFx6CZ16CpaW+ImNbUATF1/ofeRD3jXvp23bsCUaO5BlKygnd3Xv/pv5T39m/rMd091ADkW6e/YdvzL7zq2P3wM4BtYYF5Bl6zgV4+K4DCmHwBpbD2TZasrJ1nNcam2etppysjPYsXNmxy/N/Pu66F+qquM116rdU6t2T63aPbVq99SqVbunVu2eWpOompGzogkBz9TuAZxi5EwUeGY9mhCcz7QzcsYLntmwxofzqRk5azV28MyGNF6cT83IWdGEgGfW205NAM6nZuQsp3ZiwDPrss5k4HxqRk6lCQfPrLXOBON8po6RM/ngmRXrTDzOZ7oYOU6AZ1a6yROP85kuRo4T4JnKOi7gfKaIkeMKeAZwBuczRYwcV8AzcAfnMy2MHIfAM3AH5zMtjByHwDMO4XymhZHjEHjGIZzPtDByHALPOITzmRZGjkPgGYdwPtPCyHEIPOMQzmdaGDkOgWccwvlMCyPHIfCMQzifaWHkOASecQjnMy2MHIfAMw7hfKaFkeMQeMYhnM+0MHIcAs84hPOZFkaOQ+AZh3A+08LIcQg84xDOZ4oYOa6AZ+AOzmeKGDmugGfgDs5nmhg5joBnAGdwPtPFyHECPFPdGBdwPlPHyJl88MzKvZl4nM/UMXIwSeCZYwy+JgnnUzNylhfpJgY8c+y/PzE4n5qRc4iBJgE8s14DTQDOp2bkHDbnOW7wzPqbsLHjfGpGzhE1LvDMhjU+nE/NyDmGth48M7C2HudTM3Jqjdg9NSOn1hDjuLoIatXuqVW7p1btnlq1e2rVqt1Tq3ZPrdo9tWr31KpVu6fWkNpMPlcNS9u8sp0M9tmmrJIeCZZ2+PGoCYGlVSmcDGTa0TUu9tlWrLE7BkuzGh8ybUMaL/ts093jFizNarzItPVr7OyzTXSPW7C0qmaZAGTauspWH/zLFz92w4EbIhEHFPgU+BCiAjZUbZaCUSxteD8bWLHgYjnshOpFmLh6+5XvP+HKwfaMb9b+HgtL+7ub8naL4oiSmKKIAg/Co0MQUhpFwVnOUQEb1coTECVRaZhBRFqz0vjD65Y6Gf/eNc3Npe09+JC+/q/563ciTREG6AWmWPH7cmCKUiIvqCyhFZdFFXlUSiil//Q6fmqvd81Vm9cZmnD22Qjc4xAsbcU6E4xMW60JZ58N6x6HYGmVdSYemdbT5LPPhnKPW7C0qps88cg0KyfYZ0O5xyFYWmUdF5BpVk6wzwZ3j0uwNCtHkGlwh302+LjGwtLCkPrC0tJEpNXP6qL3fiOx9CthnVehdTz0YGk9WVjayCoei0yLoj7ItJkZtFuwFzMzaLfRbmFmhtpttFpoNdFsUaOJ0MYrDclyaCqoSBW2ziLTRpJUV9hng/K5nIKlVe5xBJnmEPtsQPc4BEurhlruINMcYp8N6B6HYGlVreAOMs0h9tmgfK7+sDRoTVLbC5CoaFB2WL5+WNqa6mdIWFpVrgMh0/jQj63ri4ZGpjnEPhvQPQ7B0qo/6A4yzSH22YDucQmWZuUOMs0h9tmA7nEIllbdXHeQaQ6xzwZ0j0uwNCt3kGkOsc8GdI9DsLSqh+wOMs0h9tmA7nEJlmblDjLNIfbZoHwud2BpVZXgDjLNIfbZgDfGIVhadVPdQaY5xD4b0D0OwdKqOXV3kGkOsc8G5XO5A0urqgR3kGkOsc+G4HO5A0urbq0jyDS4wz4b3D0OwdKqW+sIMg3usM+GGs44A0uzcgSZVj05s7u/3bnr4eIH1j2GjF3mtP3fI5StbZV59YYH6re+Oyr22VBnphyCpVW5dQGZZuUE+2zYE3cOwdKqDE88Mq2nPce99+rtV/aKanlS7AivaliyFoV2uN6//aqRHMfBaPhcjsDSqidvkpBpxy7biWGfbRqfyx1YWvUtE4NMO3bZTgz7bDP5XO7A0lYMNAHItHUaaBLYZ5vonmqS1BFYWq8JGzsybf06Pznv7OQsn/xHi0clb6BwGyL91W3vunbugz/fftswCdgKupuVM7A0q/Eh0wbQuNhnW87ncgeWVg2MtxyZNnjZbjn7bKvdU+ulpL6uqCPu1hpiyFkXQa3aPbVq99Sq3VOrdk+tWrV7atXuqVW7p9ZLSjVhaVWCJwNb5JBqwhIwPmzRwNp6GFRNWOqj8WKLNqzxwaBqwtJajR1btCGNFwZVE5ZWJXgysEXrbacmAAZVE5YqTTi2aK11JhgGNY2EpQnHFq21zgTDoKaOsDT52KIV60w8DGq6CEtOYItWuskTD4OaLsKSE9iiyjouwKCmiLDkCrYIcAYGNUWEJVewRXAHBjUthCWHsEVwBwY1LYQlh7BFDsGgpoWw5BC2yCEY1LQQlhzCFjkEg5oWwpJD2CKHYFDTQlhyCFvkEAxqWghLDmGLHIJBTQthySFskUMwqGkhLDmELXIIBjUthCWHsEUOwaCmhbDkELbIIRjUtBCWHMIWOQSDmhbCkkPYIodgUNNCWHIIW+QQDGqKCEuuYIvgDgxqighLrmCL4A4MapoIS45giwBnYFDTRVhyAltU3RgXYFBTR1iafGzRyr2ZeBjU1BGWMEnYomMMviYJBlUTlpYTPDHYomP//YmBQdWEpUMMNAnYovUaaAJgUDVhaa3Gji1afxM2dhhUTVg6osaFLdqwxgeDWm/8nh/+8IlXvOJUomGbD+cIS1uPLRpYWwyDYubHHnvyp37qJ4/tnscff+qUU3Z43qTc1Fpjl9b6qaeeOe20U4493xOGQVnKushq9VSWMgz77JPp454oioqiqIusVk9FUURRtC73NBppp9Oti6xWT51O1mgk63JPmiZ5Xmit61KrZTs9eZ6nabou9xDR7Gx7fn6hLrhaAObnF2Zn233H4P0XBLZtm52fP1hXP7W01vPzB7dtm+37v/3dI4SYm9u+b9/+uvimXPv27Z+b2y6E2IB7ALRaTc/z5ucP1iU4xW3WQc/zWq3mkT5wtKXsubnt3W5Wd4CmtrvT7WZzc0db5egz13xY3fVjrc3c3PZ69nl6+jr79u33PDE3d8LRP3ls9wBYXFzat2//7OzM7Gy79tBLvY+8MD9/cG5u+1EarI25B4Ax5sCB+fn5hTiOGo00jqMgCIQQwy+m1hqjmNkYI6XM86LT6eZ5MTvb3rZt9kjd5AHd0/uybjezXyOlNPboeS1nRURCiCAIbKWQpsmGqgOqb3+tgVVTbWvV7qlVu6dW7Z5atXtq1TqW/v8AIXo2AuQjNNcAAAAASUVORK5CYII=\n",
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from IPython.display import Image\n",
"Image(\"images/image02.png\")"
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"> before a[l]: A a[i]: A\n",
">>during a[l]: A a[i]: A\n",
"> before a[l]: B a[i]: B\n",
">>during a[l]: B a[i]: B\n",
"ABC\n",
"< after a[l]: B a[i]: B\n",
"> before a[l]: B a[i]: C\n",
">>during a[l]: C a[i]: B\n",
"ACB\n",
"< after a[l]: B a[i]: C\n",
"< after a[l]: A a[i]: A\n",
"> before a[l]: A a[i]: B\n",
">>during a[l]: B a[i]: A\n",
"> before a[l]: A a[i]: A\n",
">>during a[l]: A a[i]: A\n",
"BAC\n",
"< after a[l]: A a[i]: A\n",
"> before a[l]: A a[i]: C\n",
">>during a[l]: C a[i]: A\n",
"BCA\n",
"< after a[l]: A a[i]: C\n",
"< after a[l]: A a[i]: B\n",
"> before a[l]: A a[i]: C\n",
">>during a[l]: C a[i]: A\n",
"> before a[l]: B a[i]: B\n",
">>during a[l]: B a[i]: B\n",
"CBA\n",
"< after a[l]: B a[i]: B\n",
"> before a[l]: B a[i]: A\n",
">>during a[l]: A a[i]: B\n",
"CAB\n",
"< after a[l]: B a[i]: A\n",
"< after a[l]: A a[i]: C\n"
]
}
],
"source": [
"\n",
"# Python program to print all permutations with \n",
"# duplicates allowed \n",
" \n",
"def toString(List): \n",
" return ''.join(List) \n",
" \n",
"# Function to print permutations of string \n",
"# This function takes three parameters: \n",
"# 1. String \n",
"# 2. Starting index of the string \n",
"# 3. Ending index of the string. \n",
"def permute(a, l, r): \n",
" if l == r: \n",
" print(toString(a)) \n",
" else: \n",
" for i in range(l, r + 1): \n",
" print(\"> before a[l]: \" + str(a[l]) + \" a[i]: \" + str(a[i]))\n",
" a[l], a[i] = a[i], a[l] \n",
" print(\">>during a[l]: \" + a[l] + \" a[i]: \" + str(a[i]))\n",
" permute(a, l + 1, r) \n",
" a[l], a[i] = a[i], a[l] # backtrack \n",
" print(\"< after a[l]: \" + a[l] + \" a[i]: \" + str(a[i]))\n",
" \n",
"# Driver program to test the above function \n",
"string = \"ABC\"\n",
"n = len(string) \n",
"a = list(string) \n",
"permute(a, 0, n-1) \n",
"\n",
"# This code is contributed by Bhavya Jain \n"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['A', 'B', 'C']\n",
"A\n",
"B\n",
"3\n",
"range(0, 3)\n"
]
}
],
"source": [
"string = \"ABC\"\n",
"a = list(string)\n",
"print(a)\n",
"print(a[0])\n",
"print(a[1])\n",
"print(len(string))\n",
"lenght = len(string)\n",
"print(range(lenght))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 6 - Escreva um programa em Python para calcular o valor discriminante.\n",
"\n",
"Nota: O discriminante é o nome dado à expressão que aparece sob o sinal de raiz quadrada (radical) na fórmula quadrática (amplamente usada em Machine Learning).\n",
"\n",
"Dica: Crie uma função em Python com base na regra abaixo"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAgUAAALJCAMAAAATaKDwAAADAFBMVEX///8AAAD//Pe/vbl/fns/Pz1/f3//ogClKio/Pz+/v78AZAC/2L8/ij9/sX/NAADZPz/yv7/mf3/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////0UeTdAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAG2lUWHRTb2Z0d2FyZQAAAAAAVmlzdXN0aW4gdjcuMTCzAvNzAAAgAElEQVR4nO2di3arLLtGg8Da/Vbblfa//4vdcpCDgqKCgD5zjDbxEDUyA4iv8HoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwDP6v9gGABoAFABYAASwAsAAIYAGABUAACwAsAAJYAGABGB1Q1D4MUBVYAGABEMACMFlQ+yhAXWABgAVAAgkALAACWACkBbUPAVQHFgBYACSQALxepPYBgCshYYbI/NqHC7JiknsfsOEeHEv9iA21vwzYTZbkD8lQ+4uBRLKn/9yF2l8QbFDUAJjQA1cY4JhQ++uCJVcqABGa5HoFIEJzVHJAeVD7ywNJRQfgQStUlgAatMBcAm+a2QqDfBMWZj43QSvGoEFDLHMCZwan+9J2G70RPnoADdphmbYk+DaPBUxtRNhFubvt2qfh2cyyAkqISihOCBX/iD+fq/dUvRBKCeVEzuXjG6oXcbF0THG5GifOpGqaVAK4GQ0yg7p4FlCVYONvlsr3ZDafq7oBVSlJOeOEqbniDZV/7rRKa3dSblFVCtyqASSoi5cZyJ+nTCz1oyWL+eY3rH/JZHCWhP6MOs4svVm7Z2QFtXE1MGnE/HTy0nrgwgASWBK0gNNNCyBBfRwNzG+e++nk5QW6cEjMCxhdijGzABK0gNVgLNmZrAWKMlvUC+hsvqzhyXSl4i3XqUpnqe9Nsw0LIEEjGA/omPxyYqzZ08EGG+j5qoZvrhE4nYJPo3+i+Bi3ZSfFFQOTcqnaIRxoh2vvKdorRdxTbIwrRVCtRlCgSa4TgSEXaJnL4g7/1P6mYB3EIAMFnkcAE3g2CRjwnCKwhB5MJnhmGQiQ3AAAAfICAAuAABYAWAAEsADAAiCABQAWAAEsALAAmFtMtQ8DVAUWAFgABLAATBbUPgpQF1gAYAGQQAIAC4AAFgBYAASQAMACIIAFJYk89wVOUDtN91O7w/obAgsALAACWABgARDAAgALckDmPRhn2uh13NKC1J6GxBhYK6uypKRgsmNrTfKuJWsrE9ULP4uvkZFbWkDTkkL2NxtYVc/iyyXhtcYEU+OnULLvN7x2nGS4UINbWpCYFG5v9A7OSFYrOGtxt3/7XTn5yspcd45NN2TMQqcWkKlHef0tTO/0sod5mRpkynE5mYYzMPn2oOfrVBMZuh3RihAzkpUzvpUcD4vZ7TprOeNiiBeudmd26xxrwnGavvgHLeKGjVno1AJxbpxfCZ3GoODLEUgYjf2epryAyo35n1bjYRA7vpVIWzYf9sId6WqygHnjbPnHuvM45dbZBWVCrxYMnLmnzI5YtBiTikSrgJMF8pUS79PhIW9EioRGN3HeGlGc3dpj3XmckTIrO91aYEatkYzJo34zyzGp3HHpvBLBt0ANi0TPW7DcrXOsacfpbxMWhJiqZbNhblUOvcxp47WrRV7gfPq0BX5OZY5133HCgigq62ZqnKoJxtVoQ86YVKIcJ2bAq9B31yOgybExVV7NZha49QBdeZi2O0uh6WhcYaZ6gXOs+44TFkRRhSgfvGJUn2Y7JtU4R/8E5YBXoa9ua+z6GkF92o5kNa2gLibM6Fhqu854V4Mt1e0Fgdmtd6ybx+mmOWqHcS74bQyB6/TgbstezeNKMY5bFs/qezmZn/3wPkqmEVqNVrgmL1hU2iO7LZhfc/OvNLAgjn+xR0g4QYppgLtJa1xmwXOABQAWAAEsALAgB+ZWRM5mvku/5S0tQMTZTm5pASLOdnJLCxKTInKvBhFnPaBv2oy5sPmdtB5xNh0rIs6yIc4TJV5+2nTEmXOsiDjLhvrh+Oes6Ygz7oUg7jnOSJmVnV4tMKFbiqYjzpxjRcRZLqZE885O0xFnzrEi4iwT6qwwLwa56Ygz91gRcZaJqaLlZaENR5x5x4qIs0w4WW9BskacHTxWXCnG0XmBvN7uI+LsYMsPWo1W0FdaxX8i+SLODh4rIs5WUFWmC85Oroizg8eKu0lrXFBnfhqwAMACIIAF5zGN0DmvXi/9lre0ALFGO7mlBYg12kmvFqyf7LSkiGwoe6xR/GhWjhOxRuvIezV+i2HTsUbOsSLWKBsy3QbvNkvTsUbOsSLWKBv6dHunrOlYI+dYEWuUC+dukqHpWCPnWBFrlAv1051lni3HGrnHilijTIizQvlMhIZjjbxjRaxRJkwh6laeG4418o4VsUaZuOC3MaB3q9Zxy+I+Yo0OglajFa7JC9C7VdtcZQF6t2qZyyx4DrAAwAIggAUAFgBBxxYQ09q7/FYb02ls1M/DrRTEfWHywiK8HTWXux86urN9nwscTscW5Glgj29k60o9EC/GVRCifpGNvyyigY49IOZDR3e2+3OBw3m6BfGzuN0qGDrBUgHzotcKtP+prVNO7IeO7mz9NASWLg+nVwuo6DJqUD8pc5tnfJWBYXKuuF9D9SInckwHe02Ttvl51hhNVezZzj60RBHAzItJhoVRdCoJpAVybXsfat/ODgTfLQ6nUwuoSsgpYoeqHxzlTMYG2kgxZtaaIsd0sJeZjP2SRG6+uw8tosPSnbya0iFwX3AKNZGJpNfeO0Sk/tyB4LvF4XRqAafOl1NqT/dxh9lXn/8Fgr1CEL3NvX1oebVD50cf2Do12bne6O4hIom3k92fs4dTO033Y9LOvOHOjfltC5bBXuqDgXC0Q31ouUzpQ8wu3KOc3w89MESku5P0z93EAi8v0IVDYl4QCPYKMf1IiT9TyZEa12bSJ5gXzBccHCLyQPDdTSwYS3zGphKQyO8ro3i4tmAWMe5Ps/nZCaHmn+tDy8aapVhwcIjII8F3N7FgLFNFrdoEjOlrBE5NGFnszwn2UpOxG8bqUu5UH1oyww9GjdlINWflY0NEHgi+u0vtsDyRat0xYleKlbjLleJVpypPH1rRVqMAR3e243P3aTW6AJFt5gkrDP3wrwkiCrI8HFgQh2XqQ2vtblIFbnY3CeQCFoA+LQDZqZ2mNwbnFsACIIAFABYAASwAsAAIYAGABUAACwBa5QAsAAJYAGABEEACAAuAABaAl9Kg9jGA2sACAAuAABYAaUHtQwDVgQUAFoCXbi+ofRCgIkIA9dAPTHgmxgDz+BdMeBYLA2DCw4gaABMewqYBMOHmJBsAE27KbgNgws04bIBrAlTomNMGIFPonHwGwIQ+yW8ATOgKUs4AmNAF5QWACW1zoQEwoUkqGAATmqKiAa4JUKEaDRhggAk1aMmACZhwJS0aMAETrmDDgMKDOlM76I0//M3sIGBCOVLygCyZRGwjYvQSOyDH6tAcMKEEqaVADgvsoM6zcZXFYFrOODZbY3PAhJykGpB/UOfBH2DbDALpTMKEK0ivCZYZ1Jkyf0Ruu5CmHhhEyEFiXlBsUGdTQngWrFQPfQOgQDYSTPDSOs+gzsNKXrAtJgwowYYJBQZ1pn69QNYOPSVgQBVWTCgwqPPsGsG/UoQBVYmZUHxQZ7fVKNY2BQMupMVWZBhQg5ZMgAE1acAExBc0AWKNgAJxh0CBGGSgwPMIQINnk4AivwkwoE/ymQAD+ua0CWgOuAmHTYAAN2O3CTDgpiSbAANuzqYJ5A0DHgEhn2vRAe/axweu4XO1H2Ro8Ag+1YsxYV4PgAZP4NO+DTcHQIP787m9CjS4PbAApEgADW5PkgXQ4N6kSQAN7g0sAMkSQIM7k24BNLgtOySABrdllwXQ4J7skwAa3BNYAHZLAA3uCCwABySABvfjiAXQ4GYckgAa3IyDFkCDOzGT4HNEv259cqHB+/2jX99QpC/mif31LV++v7c/ukjqX60B8onOWP7i//17GRc2WOYGvz/hBaBpAvn+95fJED4/v0Yj5P8QSwteSoNxwf/GYuE344GCgoRK/8+XkuCf0uFz9CDy6bkG4/TPz0vZ8Cv/QAcEk/dL//Y/VVXxO5ITCN7LSZH0b7XgFyVDF4R/5HruPz35veLBezk1aqAtQP2gD1YtMDXEaInwmiW0mvj5RV7QE+HUnRJdXC2IesHXasvSe/n+R9USUS/og2Dqfk4tR+M1wvfqNYLEWvA2zUVvkQ/gGqETjrYeeyDb75ssEsCCzsljATTom0wWQIOeySUBNOiZfBZAg37JaAE06JacFggNYEKHZJUAEUadAgtAbgveb2jQISUkgAW9UaBAgAbdkdkCaNAjuSV4uXeWQScUsAAadEcJC0JXixhnq2GKSPCSHtiJaCf7oA1KWfCaLFgbcAM0QjELRg/iwzqjeGiLUhYkjMgGE1qhhAR7RnZHptACuS04NFArTKhMTgtODdoME+qRS4I9hcC6CVDhenJYkEUAX4UMRwXSOWtBZgNgQg3OSJCnEFg3ASpcwVELCgvgq5D1G4MlBywonQWETYAKBdlpweUC+CqUOQdghwUVDYAJZUmz4PpCIA6Kh+wkSNCQABaYkJMNC5o0YAIm5CJuQUuFQBwUDzkIW7AlgFwaCR7ZmN4JJYSandLISjDhJAsL0rKALJlEwkYoHwZuEp/HNBiQKZzCsyC9DMhhAUvYCKPKBA1fWVUAE45hLEg3YMykZQLywWTY4wuhlFBO5Fw+vqF6ERdLxxSXq3HiTNo9Eo3/Vi4x/wb/HUzIiJZgTz2QqoQcuKobiLfjLMoZJ0zNFW+o/HOnpR2DO5mwT98CuiOIre557QtbICTnBbJwnhJRldS6vDZJFvsz6riz1pPT/BvWqofeR6DAXvzKYXrF0CQiFwaQwJKgBZwGLUgsERKODQYcYXmhuHmN4OUFunBIzAsYDWQPq8jaIUuxANcIx4k0Gq2ZMJb4TNYOZQ1PpisVb7m2gM5S35tmOy3wrxTXDLj2vN2LlQbkaKZAGRPNRnKpvUbgVK6/9ieKj/EqwU6SrSs/r9UoaA2ygPNs3ktquhUZAuQh6bZykybAgHwkh5i0dGsJhUBm9oWbNWACBCjA/tDTiibAgEIcC0O/vnhAIVCQs0+kXGZAtm8MluR4OA3PJvVOlseVC5kAAa4iW88FmU2AAVeStReTPMUDCoHLyd+j0SkTIEAVynRudsgEGFCNch0d7ikeUAjUpWB3l4IEEyBAZT4/7YDq5SDkM9r36RsGVOcaC2R+s8gUdBaAnvOrc40FZgfGBLcQgAa1ucgCd2JZD4QGlbmuQFgBFlTm+qwgACyoTBMWQIPaNFAgwILqtJAVQIPatGEBNKhLIxZAg6o0IgEsqEorFkCDmjRjATTYA8nMZ+4Nzo43WTJYsIPaj4dtcdgCaLADWADubAE0SOfGFkCDZDqzYNcVCCxI5c4WQINUDlhA/M4IywILrmC9v7/APCb7ltPEPypWsb2NLddMfrDAP9ydbVLQII3kn7NekcseBuX/tS6ERX+CTv/k3pq7cpBzFkCDNFKTRCcpN11RrncxOV/iTKd0Xg8LrmWWJLIneqZfh0WX83JYAbdrWrf/SVEITL1JTn2LTvOIKhXUn+yd0i60ndwHuqb2Ldh/kwIapDCzgI/pIJJk1iP9lOqM2eQx/3XZQMeUp6ZnWdmjtZ0376SWOx9wdrEsY2DBFYSybpHWwV6o3YxdvRWrjglpPmGTkXLuzAttabEw1DnxWQugQQonLRAv4+q2K3tnDc7tvKgF7kKdgcQtOHTXGhpsc9YCykR1z6xAibOU7MwLQlcd5y2ABtssLHAK8kWP9I4FdKrIccqZqESoUW+mH7NoK+DcziNqa4wQu2l/oZoHC6qwtICYSwLvCkB2Oc/sOIRTmxGVQ1ypd7aOP15hEG7nqQsMwmWiiy3pGWbhNE2HmQgZLIAGm6xc2Aeg24MPZCaHBdBgi30WJIwxkhlYcAU7LRjYxvLcZLEAGmwwS3XvHlCQizVwLTge3gwL1tnVqF+BPBZAg3UeYgE0WAUWgK4sOPfUEzRYoUELvEPKZgE0WGE65TqETLUHhNXYe1EZ2ELkIyQ+FbNgekQ+/cHIuAXv949+fT9UFXsnWAUQ8Cytg5HUThvlPi0v+PqWL9/fyV81nsK/WoPH5hdkfvJztA5Gg8qSLPA8jJcI//69jAtJrCTx+/dna5Vbs7BAJIK+D6SjwOTtIhV/Ju4gikm5iLvBYvJmkx+eNrg3itT4x2QwgWfirpK5Lzm4t5I8Da0Fi5z/+8tkCJ+fX6MR8v8KK2XCS2kwrvG/sVj4PXYu+2VpAZPhYDr8i4q7w2wWf6YCxLx4NC5vCvvhaYMuAuTg6XQRYsDodHPK2d+CFQvGOUqCf0qHz9GD9S8b1WBc8PPzUjb8yr9nEbLACf/ibqjpyp9JSneW/nxkufNAg93fLgu+9G9fd7L4vZ4TvNYteImkf6tVfp9WMkQtUOFffujQigWcBi1gTEesLpc7NyTs/nZZMM36pye/Nz2Ipa6cP2qgLXhc/WBhATNpL7P9xLyALXP8aatkCC93KoF2f4csMDXErRIhmrxq9s/v4/MCqsPGZCWOTuFfMoyIh+PP/GkWtoBxNsyW68AzGb6sk9rsb5cFU6KLqwVRL/g63C2qnv2jaonPrRdMrUZsGNzwL/HC6SL+bBmPJi4euB+epuVS9Quz3ASeiZXotO9ZuJm9vb1ige1z+fvzO+UaQRDS4G2ai94iH3j0NUJTmMNaLREO8LS8Po02LaApecExoEGAJi1wH4QzR5qrI0VosKRJCxyMBfl604QGCx5oATRYAAvAMy2ABnNgAdhnAfGbBb1FG9Mz0h9qmCzI29U6NPDZlRdkyTjUfYXktfVxwoKSXG6BikNKfuy1jAXQwCc5YSkhbLoVmCEOKTWwrZAF0MAj1QLKBxNhlCMOiSWWCaUsgAYuqRZw3V9dtjikxB3DgitItcBL6xxxSLUtgAYOh/KCHHFI1S2ABpbkegFhjJkIowxxSLCgIdKvEcb6nN8N1ak4pOq1wxc0sNRqQa59pSiABROVLNjbalRmrE5ooKlkQfIzsUUtgAaaOhbsvpsEC4rSyZ3lUqM3QwPJwy2ABpL9w19fjDrMohbAhIzMh0HNSTELxAOqsCAjnVrw3N6MitClBW9YkJWSEpS7RnhDg6x0acELFuSlTwugQV66rBa8UDPIS68WQIOcdGvBk7u+zU7HFkCDXHRaOdT4FjhN12AXfVtgNRACqPtYMGE/nVsg7ykZA8wdTZiwj94tWBgAEw7QswVRA2DCTnq1YNMAmLCDHi1INgAmJNKbBbsNgAkJdGQBOWyAawJUCNCJBacFQKawRgcWZDQAJoRp3IICBsCEJQ1bUNAAmODTqAUXGAATDGW//zELLjQAJkhaywoqGAATWrLgfHNAHhMeqEIjFjQggOV5JjRgQVMGTDzLhMoWNGnAxHNMqGjBlgH5OvQPQs3Q8YN9FziIJ5hQyYKkPCBfh/4BRD9dtsO21a7b7m9CBQvS40N2JHYMNtsIm/rnEuNSOz22bXXbdW8TLrYg2YDMHfpPChDTP5fpANiZfKwJV1qwoyaYu0N/ZQdz8n3fguC48RETSp6xSjSaF2Tv0H9843fT51mwUj30DbijAq9m6wXZO/RXxUEsL0ioqd7WAEGj1wjZO/RfiCBrh1P28PR49kbbC7J36G9FmPbAk7r2vr8BglbbDjN36B8UzVYGnv50E+4jhHmOAYIGLBA0ZcKzDBA0YoEA8QXVaMgCCWKNatCaBQLEHV5NixYIEIN8Ja1aIMDzCJfReBdneDbpEhq3QFDABBjg04EFgowmwIAlnVggON+g8NDmgG06skBy2AQIsEJvFgh2mwADNujRAkF6DCsM2KZXCwSbJsCARIqdpU9Fqc1PRE2QBlzRBe8d6N0CgTLhHcoDoEESd7BAQMibBEoBWJBEuXLzWgumvtHn3wcaJFE4Myi19QWxQVOgQQp3twAapFC4SCi29Tmw4Ay3twAaJFCwWeVKC1bGUoMF29zfAmiQQNkiodjGZ6yOqwgNNimbGZTbuM/66JrQYIsnWAANtphZQHLymXVriuCX2BxoFxqsM7cgLXCjGrCgCM+wABps4J9XWPBMnmEBNFjnIRZAg1VuYEGKBLBgladYAA3WyGHBde6csAAarLDPgtBypuZS0bVYvPs4Jpba7Sw2lPh8QeAbJEoADdbwTuyeX7Vel6t3lIteJBln4ZWFHk4X5V7Xwzt2esoCaBDnqAU6TTmdeiW3yR1Kvvj0vP/6chZAgygbFsje6Jl+HRbdzstRBsTvfMoDGLP91A/cdC45ySEKBt3BLTF/soNKu9B+HhZcxYYFfEwPkSazXumnn/OU+vaDxK7BqB2LQnZqPU5S+bforZgTu9B8PrsF0CDGVolAdFoHe6IOdCxOnDXUz1xBua5ByBQObWixML8F0CBCHgtsicCdHsr9LXHdnfWwZsEAC6rgntnDFlC3AmCyeX8r478CecEuCaBBjC0LnJJ80Su9TSwqhyOh3tgGQh5tgmgr4FwNhmNEETUOYrfsLyxkATQIs2kBMZcExOuFXqSsHYHEthqZNcQq1C7Vg2HprYn3XCa62JCeYRYSo0duC6BBGOfURkqEOHRrFLq8LC3YLQEsCHPGgpQhRzKSwwJoEOSUBfMLgbJksQAaBLHnNlASk9ioMxNXapDHAmgQYs2CtshkATQIAAvAy9GgOwuOSQANQrRsgXdI2SyABksWFujnwdRlYKQZb2M6IX0jHyHxqXwWrGswPXB9ZU8c1VnmBerOLuNZGoUiqZ021nkVC15f3/Ll+/vw9vsjUCLodzkahaLBREkWeB7OLTguwZYG//69jAsPIW6BSATd/q8HuiXUhB0NYjxbqhc5YUjirsEiKmlwbhCo5W7AkReXZPYnFngaXmfB6/vLZAifn1+jEfL/nVmxgMkwoHGSytQTUaazsCMVGOSFIXE5RLYflTToIkCOm70cGt3GJTn7W5DTgi0NPl9Kgn9Kh8/RgzN764Dp7IYsGHS6mv/hUAPvhvOUlLO7xOYO9XK5E5dk97dlwSkJNqsG+reve2v7vnlO8EqwQMUNOsm0bgGnQQsY00FJy+VOO7TdX2ELNjTQS//pye/bexC1gJm0l9l+Yl7Aljn+tFUyhJfP45KSSoRLLDA1xNuXCJMGzpWiCh2SlTgq/4iOK+PhsCN/moUt0E+tuMt1wJEbl2T2V9qCVQ2mRBdXC6Je8HX/lqaZBVOrERtMXNB0jcDpIuxoGYYkLh64H5Wk5VL1C7PcBBzZuCRnf1MJxEtZsJKwtvPW78/vR1wjLPOCtjCHld2C+/++d6HOb5sW0HJ5ATTwaNgCZq8ffAtySAALPOQJbtIChwIWQAOXx1oADVzEGX6kBdDAoTsLckkADVwILAAPtgAaWHZaQPzGYW/RxvSM9CcaXAsySgANHMi+vCBLxqHuLiWv7RwtLChDBQtUNFryM6/FLIAGhh0WUELYdEM4QzRaangjLLiAWGz4UgLduV2uaDSWWCaUswAaGJIt8LosyRGNlrjjghZAg4lkC7y0zhGN1oAF0EBzLC/IEY3WggXQQJNcLyCMMRNnliEabb8F+SWABpr0a4SxPmeeMTkfjXagdggLilGrBfnAlWIJC6CBpJIFB1qNikgACySVLEh+Mrq0BdBAUMeCI3eTClkgNXi6Cv3cWS5lwajAk3quCNKNBcUkcJ5GeSyHx0K/iulAy2UFsEASHr+0sS0XqxZ8QgPJoy14wQJNMQ16sAAaaHrIDMpZgJqBpoPMoKAF0EDRfmZQUoKX7fTy2TSfGRS2ABoIms8MSlvwrK5vI5SzINOmi1sADV7NZwbpEpxopvzM1uC5QY4zUoT7WFD7zsc27VrQuAaw4BpgwWU0bEHTGuyoG8KCczTcZgALLqPhzAAWXEe7mQEsuI52M4MaFpTTqW0L2s0MyloQ+ggTffrrTrlFQ4+3vmQZTJ/60CcsOMZ1eYH+OB/Uk5jcmzuhem9YaJA2RFzzFrSqwZ6bCOcs0KO/caoenCH6Gapg513LPd3EgmIaNGaB7IaH6ddh0d+OTHv1qL7SgAg/zJBvuisPuUQNBGeHiIMFxTac3QIuB2yhw6w7nikhzQPVRCe2sIEO1DxiK2SR6+iB4Jwh4u5gQZsa5C8RiE7rYBcczhgdwzQMnJxlCn4yrUOmmiOHBYU3vCu2ILsF6odOBncBmfKLKdPg9FYWtKhBZQtkEi/yAm2ImmY3KxGeYoEu5YPd8cwtENm97OnP1gtEyospPRCc02nPPSxo8DKhiAXEXBIQr/sdUdlnZmw3YkoCaq8R9OxpfeoNEXcTC5rTYF/IYXqJECe5p5VjwIIDXG9Bcq9Lx+jCgtY0qGDBjs5WDtCHBaU0aMeC4M0gj5IaPNuCg9stkRdUpRML2soMYEEtWtIAFtSiIQt2PpsGCzJS5kjPW/B+/+jXd1gPawHz6oDLFp1NX/TzZOqyMbx2MPAAFuTf7Cyxf7UGsTzCpINs4LWp4gUCJWYY6jNsGVV0BLvPfixoJzOYp/b79yc4f9pDLKWdaZZabEz3ETI0IrEuLWhFg0Viv19Kg3HB/8Zi4Xe+g+lcT0k3BQkRVSqoP3kLwC60I305AUXWArFqplHDYMGhrQYseP38vJQNv/LP34FJQjmsjw0Smt8/5sQudEKNgiUHyzZqWG8WNKJByIKXSPq3WvQ7W8FJRBkmbAIDQlEEi4WzvN9a4Cw9N2pYbxaU0WDnRpelv5wzaqAtmK/hFfmc2yChqAXuQp2BRCzIMWpYdxa0oEHEglGDrbxAp9K+vCB8LcGou/TcqGH9WVBEgzwWvH5ULTFeLxBVM85tkJBMCRF6PKU+obOFap5bpMhAY/X8Sa5Rw2DBgY0urhNNc9Fb5AMr1whjFZ3oir2uo8uHjWSii9q7nmEWEjsu2JTn61YjNgzu0lOjhvVoQf3MYHffZl69oE26s6C6BrCgCQocMizoj6oa7O/sEhYUARbkpkcLCmgACzqkogawoB2yH3bqBg/0gQ0LilFLg8stuMQhWLBvgxktiD1DSNamyGJWeMVNfbzHG3q1oJYGGS1I61NK3PYAAAP4SURBVHqKrE4eQ27E1aBbC7JrcLkFaSk6izDMYYEKNXMfgO3XgjoanLHA3iEyXU9NEWdTp1RTutt7SE5wwThTJmCmUDMnbqFjC16Zh/gobgGd7vTy5X1+3SnVMLiRZD6UDyaILEeoGbNlQs8WZM4OUjZ2ZLAkm5w2LmgR+WX7pwjFmZlPzwLRzoWa9RtfMONqDc5ZMP761A9wGfnl1NVUAbH0wEvrHKFmsODgxs5ZMIWbBSK/3Kqa/L8sEby8IEeo2W0syKrB9rYOjZ7nJCeTUUJe5JeOONOdUg2DG0nmM5b4jBFvhXOhZvex4FoNzlpA1XWA0/XUFHGmO6UahlCcmdaDjqr4gWinQs1uUzsUZPwGxS04SJamogU3uVLUXKhBHQvKdHB2k1YjQ77v0KQFrEyPRq5ad7AgY/PRxoYqlQgluMfdJJ9cX+M5FnjcxIJrNDg2zDosuI5MX6SEBR1w6Iu1SKavsraVYxYE93Kf894aWc7sFRbAgZLkOLnlLYADhSmsQQYL7lQGN0uGcxzfwnkJoMBFnD7PBS2AA5dRToOTFiAjuJKzJ7uMBXDgYs6e8NjHT1gABypwWoNFqomuiw5bAAfqcO68B9pU3+9on+dljwWc4fipD7asv99HPYADNTl69sM3WI5agIygMgcTYNWCaw4B5ORYImSzAA40wqGEiFtQfNegDJk02GsBHGiLI+kRsaDoPkFZ9qdJ2IJy+wNXsDtdTlgAB9plb9oELEj84L79gGs5p0GiBcgIWmdnCs0tyL8HUIXtVPpwIO7E+2OB3Wzq1kEbbKXUx8pkbJksOxBV2hXrqfWxMhVZKC8noEBvrHmw9uMPL73ZE14PIp5qH5H3scW3e87vUcTS7SP4Nrr8ho97Potwwn0E3sVXuONDv08jlHIfizcra0CBOzAln5OKH7PXAGYVGHATVCo6afnhvYSxFwfFjgtcjJ+pfzj/oyStBPrC1eDD/FsjbS3QEV4d7+OVlLyJq4Fu8K72PhJTN3U90A9Wg4/UxE1eEfSE8uAjOW3T1wR9seviDxbcFvd2caBRiAQamMDtmAcQ/TdbDguegG/B3AFY8Ax8C2Sa/yWvP+SvfEP+wIIn4Fgw1Qr+I3+ECa+//0kjAquCm+HlBTrNda7w398XSoRnECgRpnfk9YIFz2DxkMF/yAuex+JK8a+x4C/58we1w0cQaDWSjxuIN3///HGbjWDBbcF9BIB7ikCA+AKAWCMgQNwhQAwyEOx4HgEW3JY9zyaVPhZQi13PKYKbsu+ZZXBPdvZfAG7J3r5MwB3Z368RuB8H+jgDt+NIf4fgbix7OI1T+1gBAAAAAAAAAAAAAAAAAAAAAOAy/h+2mablCFG+LAAAADJ0RVh0RGVzY3JpcHRpb24AUHl0aG9uIGZsb3cgY2hhcnQgLSBkZWYgZGlzY3JpbWluYW50KCmkcVdpAAAAGHRFWHRUaXRsZQBkZWYgZGlzY3JpbWluYW50KCnqF9v+AAAAJ3RFWHRDcmVhdGlvbiBUaW1lADQgTWFyIDIwMTYgMTM6NTI6MjIgKzA1MzCQXvNTAAAAGXRFWHRTb3VyY2VDb2RlTGFuZ3VhZ2UAUFlUSE9OMvxrQwAAABJ0RVh0U291cmNlQ29kZUxpbmVzADExO3UWDgAAABZ0RVh0Q3ljbG9tYXRpY0NvbXBsZXhpdHkANH/RTQUAAAAJdEVYdFNoYXBlcwAxMEbIxY8AAAAIdEVYdExpbmtzADEyNwoyjgAAAAd0SU1FB+ADBAgWFvQNDZsAAAAASUVORK5CYII=\n",
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from IPython.display import Image\n",
"Image(\"images/image01.png\")"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"value for a 1\n",
"value for b 4\n",
"value for c 4\n",
"There is only one possible solution if discriminant is zero\n",
"Discriminant: 0.0\n"
]
}
],
"source": [
"def discriminant():\n",
" import math\n",
" a = float(input(\"value for a \"))\n",
" b = float(input(\"value for b \"))\n",
" c = float(input(\"value for c \"))\n",
" discriminant = (pow(b,2) - (4 * a * c))\n",
" if discriminant > 0:\n",
" print(\"There are two possible solutions if discriminant is positive\")\n",
" print(\"Discriminant: \" + str(discriminant))\n",
" elif discriminant == 0:\n",
" print(\"There is only one possible solution if discriminant is zero\")\n",
" print(\"Discriminant: \" + str(discriminant))\n",
" elif discriminant < 0:\n",
" print(\"There are no Real solutions if discriminant is negative\")\n",
" print(\"Discriminant: \" + str(discriminant))\n",
" else:\n",
" print(\"U WOT M8\")\n",
" \n",
" \n",
"discriminant()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 7 - Escreva um programa em Python para calcular raízes quadradas usando o método babilônico.\n",
"\n",
"Talvez o primeiro algoritmo usado para se aproximar de √S seja conhecido como método babilônico, batizado em homenagem aos babilônios, ou \"Hero's method\", em homenagem ao matemático grego do primeiro século, Hero de Alexandria, que deu a primeira descrição explícita do método. \n",
"\n",
"Pode ser derivado (mas antecede por 16 séculos) do método de Newton. A ideia básica é que, se x é uma superestimativa para a raiz quadrada de um número real não negativo S, então S/x será subestimado e, portanto, pode-se esperar que a média desses dois números forneça uma melhor aproximação.\n",
"\n",
"Representação gráfica do método babilônico\n",
" https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#/media/File:Babylonian_method.svg"
]
},
{
"cell_type": "code",
"execution_count": 121,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"guess = 20\n",
"test = 400\n",
"guess = 318.7\n",
"test = 101569.68999999999\n",
"guess = 178.7224505804832\n",
"test = 31941.714341493265\n",
"guess = 123.90640962465008\n",
"test = 15352.798346071579\n",
"guess = 111.78113557638244\n",
"test = 12495.022270745592\n",
"guess = 111.12350103909002\n",
"test = 12348.43248318464\n",
"guess = 111.12155508175158\n",
"test = 12348.00000378675\n",
"guess = 111.12155506471281\n",
"test = 12348.0\n",
"guess = 111.12155506471281\n",
"test = 12348.0\n",
"over\n",
"Squareroot of 12348 is ≈ 111.12155506471281\n"
]
}
],
"source": [
"def HeronSquare(x, guess):\n",
" nearest = float(0)\n",
" test = pow(guess, 2) # test the guess\n",
" compare = x\n",
" counter = 0\n",
" foundit = False\n",
" while not foundit:\n",
" test = pow(guess, 2) # test the guess\n",
" print(\"guess = \" + str(guess))\n",
" print(\"test = \" + str(test))\n",
" counter += 1\n",
" nearest = x / guess # test failed (?) so pick quocient to see how far we are from the best guess\n",
" guess = (guess + nearest) / 2 # find new guess\n",
" if compare == test:\n",
" foundit = True\n",
" compare = test\n",
"\n",
" print(\"over\")\n",
" print(\"Squareroot of \" + str(x) + \" is ≈ \" + str(guess))\n",
" \n",
"HeronSquare(12348, 20)"
]
},
{
"cell_type": "code",
"execution_count": 112,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"X = 500.0\n",
"initial guess = 20\n",
"\n",
"\n",
"test = 400\n",
"nearest = 25.0\n",
"guess = 22.5\n",
"compare = 400\n",
"\n",
"\n",
"test = 506.25\n",
"nearest = 22.22222222222222\n",
"guess = 22.36111111111111\n",
"compare = 506.25\n",
"\n",
"\n",
"test = 500.01929012345676\n",
"nearest = 22.36024844720497\n",
"guess = 22.36067977915804\n",
"compare = 500.01929012345676\n",
"\n",
"\n",
"test = 500.00000018604726\n",
"nearest = 22.360679770837752\n",
"guess = 22.360679774997898\n",
"compare = 500.00000018604726\n",
"\n",
"\n",
"test = 500.00000000000006\n",
"nearest = 22.360679774997894\n",
"guess = 22.360679774997898\n",
"compare = 500.00000000000006\n",
"\n",
"\n",
"test = 500.00000000000006\n",
"nearest = 22.360679774997894\n",
"guess = 22.360679774997898\n",
"compare = 500.00000000000006\n",
"\n",
"\n"
]
}
],
"source": [
"# Dumb, manual way of doing it:\n",
"\n",
"x = 500.00\n",
"guess = 20\n",
"print(\"X = \" + str(x))\n",
"print(\"initial guess = \" + str(guess))\n",
"print(\"\\n\")\n",
"\n",
"test = guess ** 2 # test the guess\n",
"print(\"test = \" + str(test))\n",
"nearest = x / guess # test failed (?) so pick quocient to see how far we are from the nearest guess\n",
"print(\"nearest = \" + str(nearest))\n",
"guess = (nearest + guess) / 2 # find new guess\n",
"print(\"guess = \" + str(guess))\n",
"compare = test # guard last result, when it repeats itself it's because we found the best guess\n",
"print(\"compare = \" + str(compare))\n",
"print(\"\\n\")\n",
"\n",
"test = guess ** 2 # test the guess\n",
"print(\"test = \" + str(test))\n",
"nearest = x / guess # test failed (?) so pick quocient to see how far we are from the truth\n",
"print(\"nearest = \" + str(nearest))\n",
"guess = (nearest + guess) / 2 # find new guess\n",
"print(\"guess = \" + str(guess))\n",
"compare = test # guard last result, when it repeats itself it's because we found the best guess\n",
"print(\"compare = \" + str(compare))\n",
"print(\"\\n\")\n",
"\n",
"test = guess ** 2 # test the guess\n",
"print(\"test = \" + str(test))\n",
"nearest = x / guess # test failed (?) so pick quocient to see how far we are from the truth\n",
"print(\"nearest = \" + str(nearest))\n",
"guess = (nearest + guess) / 2 # find new guess\n",
"print(\"guess = \" + str(guess))\n",
"compare = test # guard last result, when it repeats itself it's because we found the best guess\n",
"print(\"compare = \" + str(compare))\n",
"print(\"\\n\")\n",
"\n",
"test = guess ** 2 # test the guess\n",
"print(\"test = \" + str(test))\n",
"nearest = x / guess # test failed (?) so pick quocient to see how far we are from the truth\n",
"print(\"nearest = \" + str(nearest))\n",
"guess = (nearest + guess) / 2 # find new guess\n",
"print(\"guess = \" + str(guess))\n",
"compare = test # guard last result, when it repeats itself it's because we found the best guess\n",
"print(\"compare = \" + str(compare))\n",
"print(\"\\n\")\n",
"\n",
"test = guess ** 2 # test the guess\n",
"print(\"test = \" + str(test))\n",
"nearest = x / guess # test failed (?) so pick quocient to see how far we are from the truth\n",
"print(\"nearest = \" + str(nearest))\n",
"guess = (nearest + guess) / 2 # find new guess\n",
"print(\"guess = \" + str(guess))\n",
"compare = test\n",
"print(\"compare = \" + str(compare))\n",
"print(\"\\n\")\n",
"\n",
"test = guess ** 2 # test the guess\n",
"print(\"test = \" + str(test))\n",
"nearest = x / guess # test failed (?) so pick quocient to see how far we are from the truth\n",
"print(\"nearest = \" + str(nearest))\n",
"guess = (nearest + guess) / 2 # find new guess\n",
"print(\"guess = \" + str(guess))\n",
"compare = test\n",
"print(\"compare = \" + str(compare))\n",
"print(\"\\n\")\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 8 - Escreva um programa em Python que receba um arquivo com notas de um teste e divida as notas em classes de frequência.\n",
"\n",
"Dica: seu programa deve permitir ao usuário escolher o número de classes e fazer a leitura do arquivo\n"
]
},
{
"cell_type": "code",
"execution_count": 212,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\"17.5\" deu ruim\n",
"\"18.5\" deu ruim\n",
"\"19.5\" deu ruim\n",
"\"16.5\" deu ruim\n",
"\"14.5\" deu ruim\n",
"\"13.5\" deu ruim\n",
"\"12.5\" deu ruim\n",
"\"10.5\" deu ruim\n",
"\"15.5\" deu ruim\n",
"\"13.5\" deu ruim\n",
"\"16.5\" deu ruim\n",
"\"19.5\" deu ruim\n",
"\"\" deu ruim\n"
]
},
{
"data": {
"text/plain": [
"[12.0, 20.0, 17.0, 19.0, 15.0, 11.0, 16.0, 18.0, 17.0, 20.0, 18.0, 15.0, 18.0]"
]
},
"execution_count": 212,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"notes = []\n",
"path = r\"./arquivos/notas.txt\"\n",
"file = open(path)\n",
"for item in file.read().split('\\n'):\n",
" if item.isdigit():\n",
" notes.append(float(item))\n",
" else:\n",
" print(\"\\\"\" + str(item) + \"\\\"\" + \" deu ruim\")\n",
"\n",
"notes"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 9 - Escreva um programa em Python que receba um arquivo com valores e calcule as principais medidas estatísticas: média, mediana, moda, variância e desvio padrão.\n",
"\n",
"Dica: Crie uma função Python para cada medida estatística e uma função para leitura do arquivo. Depois faça chamada a cada função para calcular as estatísticas no arquivo.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 10 - Escreva um programa em Python que dados 3 números, resolva a equação quadrática\n",
"\n",
"Nota: Em matemática, uma equação quadrática ou equação do segundo grau é uma equação polinomial de grau dois.\n",
"\n",
"Dica: Você pode usar o módulo cmath para resolver a equação quadrática usando Python. Isso ocorre porque as raízes das equações quadráticas podem ser complexas por natureza.\n",
"\n",
"Equação quadrática: ax**2 + bx + c = 0"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Parte 2 - Escalares, Vetores, Matrizes e Tensores"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# NumPy http://www.numpy.org/\n",
"import numpy as np"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Tipos de Dados e Shapes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A maneira mais comum de trabalhar com números em NumPy é através de objetos ndarray. Eles são semelhantes às listas em Python, mas podem ter qualquer número de dimensões. Além disso, o ndarray suporta operações matemáticas rápidas, o que é exatamente o que queremos.\n",
"\n",
"Como você pode armazenar qualquer número de dimensões, você pode usar ndarrays para representar qualquer um dos tipos de dados que abordamos antes: escalares, vetores, matrizes ou tensores."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Scalar"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Escalares em NumPy são mais eficientes do que em Python. Em vez dos tipos básicos do Python como int, float, etc., o NumPy permite especificar tipos mais específicos, bem como diferentes tamanhos. Então, em vez de usar int em Python, você tem acesso a tipos como uint8, int8, uint16, int16 e assim por diante, ao usar o NumPy.\n",
"\n",
"Esses tipos são importantes porque todos os objetos que você cria (vetores, matrizes, tensores) acabam por armazenar escalares. E quando você cria uma matriz NumPy, você pode especificar o tipo (mas cada item na matriz deve ter o mesmo tipo). Nesse sentido, os arrays NumPy são mais como arrays C do que as listas em Python."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 11 - Crie uma matriz NumPy que contenha um escalar, usando a função array do NumPy"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Você ainda pode realizar matemática entre ndarrays, escalares NumPy e escalares Python normais, como veremos mais adiante.\n",
"\n",
"#### Exercício 12 - Qual o shape de um Escalar?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Mesmo que os escalares estejam dentro de arrays, você ainda os usa como um escalar normal, para operações matemáticas:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = s - 2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"E x seria igual a 6. Se você verificar o tipo de x, vai perceber que é numpy.int64, pois você está trabalhando com tipos NumPy, e não com os tipos Python.\n",
"\n",
"Mesmo os tipos escalares suportam a maioria das funções de matriz. Então você pode chamar x.shape e retornaria () porque tem zero dimensões, mesmo que não seja uma matriz. Se você tentar usar o objeto como um escalar Python normal, você obterá um erro."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"type(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Vetores"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 13 - Crie um vetor com NumPy a partir de uma lista em Python e visualize o shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Se você verificar o atributo de shape do vetor, ele retornará um único número representando o comprimento unidimensional do vetor. No exemplo acima, vec.shape retorna (3,).\n",
"\n",
"Agora que há um número, você pode ver que a forma é uma tupla com os tamanhos de cada uma das dimensões do ndarray. Para os escalares, era apenas uma tupla vazia, mas os vetores têm uma dimensão, então a tupla inclui um número e uma vírgula. (Python não entende (3) como uma tupla com um item, por isso requer a vírgula. Documentação oficial do Python 3.6 sobre Tuplas: https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences\n",
"\n",
"Você pode acessar um elemento dentro do vetor usando índices, como este abaixo (como você pode ver, em Python a indexaçã começa por 0 e o índice 1 representa o segundo elemento da matriz)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"vec[1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"NumPy também suporta técnicas avançadas de indexação. Por exemplo, para acessar os itens do segundo elemento em diante, você usaria:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"vec[1:]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"NumPy slicing é bastante poderoso, permitindo que você acesse qualquer combinação de itens em um ndarray. Documentação oficial sobre indexação e slicing de arrays: https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Matrizes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Você cria matrizes usando a função de array() NumPy, exatamente como você fez com os vetores. No entanto, em vez de apenas passar uma lista, você precisa fornecer uma lista de listas, onde cada lista representa uma linha. \n",
"\n",
"#### Exercício 14 - Crie uma matriz 3x3 contendo os números de um a nove e visualize o shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Verificando o atributo shape, retornaria a tupla (3, 3) para indicar que a matriz tem duas dimensões, cada dimensão com comprimento 3.\n",
"\n",
"Você pode acessar elementos de matrizes como vetores, mas usando valores de índice adicionais. Então, para encontrar o número 6 na matriz acima, você usaria:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"m"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"m[1][2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Tensores"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Os tensores são como vetores e matrizes, mas podem ter mais dimensões. \n",
"\n",
"#### Exercício 15 - Crie um tensor 3x3x2x1 e visualize o shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 16 - Imprima na tela um único elemento do tensor\n",
"\n",
"Nota: Para acessar um elemento do tensor, usamos a indexação da mesma forma que fazemos com vetores e matrizes"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Alterando o Formato (shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Às vezes, você precisará alterar a forma de seus dados sem realmente alterar seu conteúdo. Por exemplo, você pode ter um vetor, que é unidimensional, mas precisa de uma matriz, que é bidimensional. Há duas maneiras pelas quais você pode fazer isso.\n",
"\n",
"Digamos que você tenha o seguinte vetor:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"vec = np.array([1,2,3,4])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"vec.shape"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 17 - Altere o shape do vetor acima"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 18 - Suponha que você tenha uma lista de números e que você deseja adicionar 5 a cada item da lista. Sem NumPy, você pode fazer algo como isto:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Lista de valores\n",
"valores = [1, 2, 3, 4, 5]\n",
"\n",
"# Looop for para adicionar 5 a cada elemento da lista\n",
"for i in range(len(valores)):\n",
" valores[i] += 5\n",
" \n",
"print(valores)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Mas usando NumPy, como você resolveria este mesmo problema?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 19 - Digamos que você tenha um objeto chamado \"valores\" e você queira reutilizá-lo, mas primeiro você precisa definir todos os seus valores em zero. Fácil, basta multiplicar por zero e atribuir o resultado de volta ao objeto, certo? Como você faria isso?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 20 - Considerando as duas matrizes abaixo, como você faria a soma entre elas?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = np.array([[1,3],[5,7]])\n",
"x"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"y = np.array([[2,4],[6,8]])\n",
"y"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Parte 3 - Operações com Matrizes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 21 - Dada a matriz abaixo, multiplique 0.5 por cada elemento da matriz"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"m = np.array([[1,2,3],[4,5,6]])\n",
"m"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 22 - Qual a razão da mensagem de erro ao tentar executar a multiplicação das duas matrizes abaixo?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a = np.array([[1,2,3,4],[5,6,7,8]])\n",
"a"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"b = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])\n",
"b"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.matmul(b, a)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 23 - Obter a transposição de uma matriz é realmente fácil em NumPy. Basta acessar seu atributo T. Há também a função transpose() que retorna a mesma coisa, mas raramente você verá isso usado em qualquer lugar porque digitar T é muito mais fácil. O que representa a transposta de uma matriz?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"m = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
"m"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exemplo em Redes Neurais\n",
"\n",
"Digamos que você tenha as seguintes duas matrizes, chamadas inputs e pesos:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"inputs = np.array([[-0.27, 0.45, 0.64, 0.31]])\n",
"inputs"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"inputs.shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"pesos = np.array([[0.02, 0.001, -0.03, 0.036], \\\n",
" [0.04, -0.003, 0.025, 0.009], [0.012, -0.045, 0.28, -0.067]])\n",
"\n",
"pesos"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"pesos.shape"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Os pesos são multiplicados aos inputs nas camadas das redes neurais, logo precisamos multiplicar pesos por inputs. Uma multiplicação de matrizes. Isso é muito fácil com o NumPy."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.matmul(inputs, pesos)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 24 - Ops, o que deu errado? Se você fez o exercício de multiplicação de matrizes, então você já viu esse erro antes. As matrizes estão com shapes incompatíveis porque o número de colunas na matriz esquerda, 4, não é igual ao número de linhas na matriz direita, 3.\n",
"\n",
"Como resolvemos isso? Podemos usar a transposta da matriz:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Também funciona se você gerar a transposta da matriz de inputs e trocar a ordem dos parâmetros na função:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As duas respostas são transpostas uma da outra, de modo que a multiplicação que você usa realmente depende apenas da forma (shape) que deseja para a saída."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Desafio\n",
"### Use as duas matrizes abaixo para resolver os exercícios de 25 a 28"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"$$\n",
"\\mathbf{A} = \\left[\\begin{array}{lcr}\n",
"3 & 2 & -1\\\\\n",
"6 & 4 & -2\\\\\n",
"5 & 0 & 3\\\\\n",
"\\end{array}\\right]\n",
"\\quad\n",
"\\mathbf{B} = \\left[\\begin{array}{lcr}\n",
"2 & 3 & 2\\\\\n",
"3 & -4 & -2\\\\\n",
"4 & -1 & 1\\\\\n",
"\\end{array}\\right]\n",
"$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 25 - Qual o Rank da Matriz $\\mathbf{A}$?\n",
"\n",
"Na álgebra linear, o Rank de uma matriz A é a dimensão do espaço vetorial gerado (ou estendido) por suas colunas. Isso corresponde ao número máximo de colunas linearmente independentes de A. Isso, por sua vez, é idêntico à dimensão do espaço ocupado por suas linhas. Rank é, portanto, uma medida da \"não-degeneração\" do sistema de equações lineares e transformação linear codificada por A. Existem várias definições equivalentes de Rank e o Rank de uma matriz é uma de suas características mais fundamentais."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 26 - Calcule $\\mathbf{A \\cdot B}$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 27 - Qual o segundo autovetor em $\\mathbf{B}$? "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 28 - Resolva $\\mathbf{B}\\vec{x} = \\vec{b}$ onde $\\vec{b} = \\left[14, -1, 11\\right]$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 29 - Calcule a inversa da matriz abaixo\n",
"\n",
"Uma matriz quadrada A é dita invertível quando existe outra matriz denotada A^-1 tal que\n",
"\n",
"A^-1 . A = I\n",
"\n",
"e\n",
"\n",
"A . A^-1 = I\n",
"\n",
"A inversa de uma matriz pode ser encontrada usando o comando `linalg.inverse`. Considere o seguinte sistema de equações:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$$\\begin{array}{lr}\n",
"3 x + 2 y + z & = 5\\\\\n",
"2 x - y & = 4 \\\\\n",
"x + y - 2z & = 12 \\\\\n",
"\\end{array}$$\n",
"\n",
"Podemos codificá-lo como uma equação matricial:\n",
"\n",
"$$\\left[\\begin{array}{lcr}\n",
"3 & 2 & 1\\\\\n",
"2 & -1 & 0\\\\\n",
"1 & 1 & -2\\\\\n",
"\\end{array}\\right]\n",
"\\left[\\begin{array}{l}\n",
"x\\\\\n",
"y\\\\\n",
"z\\\\\n",
"\\end{array}\\right]\n",
"=\n",
"\\left[\\begin{array}{l}\n",
"5\\\\\n",
"4\\\\\n",
"12\\\\\n",
"\\end{array}\\right]$$\n",
"\n",
"$$\\mathbf{A}\\mathbf{x} = \\mathbf{b}$$\n",
"\n",
"$$\\mathbf{A}^{-1}\\mathbf{b} = \\mathbf{x}$$\n",
"\n",
"Crie o código Python para resolver a equação matricial acima."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exercício 30 - Faça um Plot, usando Matplotlib, que mostre a relação entre x e y"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Solução\n",
"\n",
"x = [-0.42,1.34,1.6,2.65,3.53,4.48,5.48,6.21,7.49,8.14,8.91,10.1]\n",
"y = [1.58,1.61,2.04,5.47,9.8,16.46,25.34,33.32,49.7,58.79,71.26,93.34]\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fim"
]
}
],
"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.5.2"
}
},
"nbformat": 4,
"nbformat_minor": 2
}