{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Capítulos 1-3: Conceitos Básicos e Variáveis\n", "\n", "**Disciplina:** FSC1189 - Algoritmo e Programação\n", "\n", "Este notebook contém exercícios práticos dos primeiros capítulos da apostila, com resoluções em Python e visualizações." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercício 1.1: Cálculo de Trajetória de Projétil\n", "\n", "**Enunciado:**\n", "\n", "Um projétil é lançado com velocidade inicial $v_0 = 20$ m/s em um ângulo de $\\theta = 35°$. \n", "Calcule:\n", "1. Altura máxima: $H = \\frac{v_0^2 \\sin^2(\\theta)}{2g}$\n", "2. Alcance horizontal: $R = \\frac{v_0^2 \\sin(2\\theta)}{g}$\n", "3. Tempo de voo: $T = \\frac{2v_0 \\sin(\\theta)}{g}$\n", "\n", "Use $g = 9.81$ m/s²" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "# Dados do problema\n", "v0 = 20 # m/s\n", "theta_graus = 35 # graus\n", "g = 9.81 # m/s^2\n", "\n", "# Conversão para radianos\n", "theta = np.radians(theta_graus)\n", "\n", "# Cálculos\n", "H = (v0**2 * np.sin(theta)**2) / (2 * g)\n", "R = (v0**2 * np.sin(2 * theta)) / g\n", "T = (2 * v0 * np.sin(theta)) / g\n", "\n", "print(\"=== SOLUÇÃO - TRAJETÓRIA DE PROJÉTIL ===\")\n", "print(f\"Velocidade inicial: {v0} m/s\")\n", "print(f\"Ângulo de lançamento: {theta_graus}°\")\n", "print()\n", "print(f\"Altura máxima (H): {H:.3f} m\")\n", "print(f\"Alcance horizontal (R): {R:.3f} m\")\n", "print(f\"Tempo de voo (T): {T:.3f} s\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Visualização da Trajetória" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "source": [ "# Gerar trajetória\n", "t = np.linspace(0, T, 100)\n", "x = v0 * np.cos(theta) * t\n", "y = v0 * np.sin(theta) * t - 0.5 * g * t**2\n", "\n", "# Gráfico\n", "plt.figure(figsize=(10, 6))\n", "plt.plot(x, y, 'b-', linewidth=2, label='Trajetória')\n", "plt.plot(R, 0, 'ro', markersize=10, label='Ponto de impacto')\n", "plt.plot(R/2, H, 'g*', markersize=15, label='Altura máxima')\n", "\n", "plt.xlabel('Alcance Horizontal (m)', fontsize=12)\n", "plt.ylabel('Altura (m)', fontsize=12)\n", "plt.title(f'Trajetória de Projétil (v₀={v0} m/s, θ={theta_graus}°)', fontsize=14, fontweight='bold')\n", "plt.grid(True, alpha=0.3)\n", "plt.legend(fontsize=11)\n", "plt.xlim(0, R*1.1)\n", "plt.ylim(0, H*1.2)\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "## Exercício 2.1: Análise de Movimento com Operadores Lógicos\n", "\n", "**Enunciado:**\n", "\n", "Determine o tipo de movimento para diferentes valores de velocidade e aceleração.\n", "- Se $v > 0$ e $a > 0$: Movimento acelerado progressivo\n", "- Se $v > 0$ e $a < 0$: Movimento retardado progressivo\n", "- Se $v < 0$ e $a < 0$: Movimento acelerado retrógrado\n", "- Se $v < 0$ e $a > 0$: Movimento retardado retrógrado" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "source": [ "def classificar_movimento(v, a):\n", " \"\"\"\n", " Classifica o tipo de movimento baseado em velocidade e aceleração.\n", " \n", " Args:\n", " v: velocidade (m/s)\n", " a: aceleração (m/s²)\n", " \n", " Returns:\n", " str: classificação do movimento\n", " \"\"\"\n", " if v == 0:\n", " return \"Repouso\"\n", " elif v > 0 and a > 0:\n", " return \"Movimento acelerado progressivo\"\n", " elif v > 0 and a < 0:\n", " return \"Movimento retardado progressivo\"\n", " elif v < 0 and a < 0:\n", " return \"Movimento acelerado retrógrado\"\n", " elif v < 0 and a > 0:\n", " return \"Movimento retardado retrógrado\"\n", " else:\n", " return \"Movimento uniforme\"\n", "\n", "# Casos de teste\n", "casos = [\n", " (10, 2),\n", " (10, -2),\n", " (-10, -2),\n", " (-10, 2),\n", " (5, 0),\n", " (0, 0)\n", "]\n", "\n", "print(\"=== CLASSIFICAÇÃO DE MOVIMENTOS ===\")\n", "print(\"v (m/s) | a (m/s²) | Classificação\")\n", "print(\"-\" * 50)\n", "\n", "for v, a in casos:\n", " tipo = classificar_movimento(v, a)\n", " print(f\"{v:7} | {a:8} | {tipo}\")" ] }, { "cell_type": "markdown", "source": "### Visualização: Diagrama de Fases de Movimento\n\nO movimento pode ser visualizado no plano velocidade-aceleração. Os 4 quadrantes representam as 4 categorias de movimento.", "metadata": {} }, { "cell_type": "code", "source": "# Visualizar os casos de teste no plano v×a\nfig, ax = plt.subplots(figsize=(10, 8))\n\n# Extrair coordenadas\nv_vals = np.array([caso[0] for caso in casos])\na_vals = np.array([caso[1] for caso in casos])\n\n# Cores para cada quadrante\ncores_quadrantes = {\n 'Movimento acelerado progressivo': 'green',\n 'Movimento retardado progressivo': 'blue',\n 'Movimento acelerado retrógrado': 'red',\n 'Movimento retardado retrógrado': 'orange',\n 'Repouso': 'gray',\n 'Movimento uniforme': 'purple'\n}\n\n# Cores para os pontos\ncores_pontos = [cores_quadrantes[classificar_movimento(v, a)] for v, a in casos]\n\n# Plotar quadrantes coloridos\nax.axhspan(-15, 0, xmin=0.5, xmax=1.0, alpha=0.15, color='blue', label='v > 0, a < 0')\nax.axhspan(0, 15, xmin=0.5, xmax=1.0, alpha=0.15, color='green', label='v > 0, a > 0')\nax.axhspan(-15, 0, xmin=0.0, xmax=0.5, alpha=0.15, color='red', label='v < 0, a < 0')\nax.axhspan(0, 15, xmin=0.0, xmax=0.5, alpha=0.15, color='orange', label='v < 0, a > 0')\n\n# Linhas dos eixos\nax.axhline(0, color='black', linewidth=1, linestyle='-', alpha=0.5)\nax.axvline(0, color='black', linewidth=1, linestyle='-', alpha=0.5)\n\n# Plotar pontos dos casos de teste (com deslocamento para visualizar)\nfor i, (v, a) in enumerate(casos):\n tipo = classificar_movimento(v, a)\n cor = cores_quadrantes[tipo]\n ax.scatter(v, a, s=150, c=cor, edgecolors='black', linewidth=1.5, zorder=5)\n ax.annotate(f'({v}, {a})', xy=(v, a), xytext=(5, 5), textcoords='offset points',\n fontsize=9, bbox=dict(boxstyle='round,pad=0.3', facecolor='yellow', alpha=0.6))\n\n# Rótulos dos quadrantes\nax.text(8, 8, 'Acelerado\\nProgressivo', fontsize=11, ha='center', va='center',\n bbox=dict(boxstyle='round', facecolor='green', alpha=0.2))\nax.text(8, -8, 'Retardado\\nProgressivo', fontsize=11, ha='center', va='center',\n bbox=dict(boxstyle='round', facecolor='blue', alpha=0.2))\nax.text(-8, -8, 'Acelerado\\nRetrógrado', fontsize=11, ha='center', va='center',\n bbox=dict(boxstyle='round', facecolor='red', alpha=0.2))\nax.text(-8, 8, 'Retardado\\nRetrógrado', fontsize=11, ha='center', va='center',\n bbox=dict(boxstyle='round', facecolor='orange', alpha=0.2))\n\nax.set_xlabel('Velocidade v (m/s)', fontsize=13, fontweight='bold')\nax.set_ylabel('Aceleração a (m/s²)', fontsize=13, fontweight='bold')\nax.set_title('Diagrama de Fases de Movimento (plano v × a)', fontsize=14, fontweight='bold')\nax.set_xlim(-15, 15)\nax.set_ylim(-15, 15)\nax.grid(True, alpha=0.3, linestyle='--')\nax.set_aspect('equal')\nplt.tight_layout()\nplt.show()", "metadata": {}, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "## Exercício 3.1: Validação de Dados Experimentais\n", "\n", "**Enunciado:**\n", "\n", "Um experimento mede a aceleração da gravidade 5 vezes. Os valores medidos são:\n", "$$g_{medido} = [9.87, 9.79, 9.82, 9.85, 9.80] \\text{ m/s}^2$$\n", "\n", "Valide cada medida verificando se está dentro de 5% do valor teórico ($g_{teórico} = 9.81$ m/s²)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "source": [ "# Dados\n", "g_teorico = 9.81\n", "g_medidos = [9.87, 9.79, 9.82, 9.85, 9.80]\n", "tolerancia_percent = 5.0\n", "\n", "# Calcular limites\n", "limite_inf = g_teorico * (1 - tolerancia_percent/100)\n", "limite_sup = g_teorico * (1 + tolerancia_percent/100)\n", "\n", "print(\"=== VALIDAÇÃO DE MEDIDAS DE GRAVIDADE ===\")\n", "print(f\"Valor teórico: {g_teorico} m/s²\")\n", "print(f\"Tolerância: ±{tolerancia_percent}%\")\n", "print(f\"Intervalo aceitável: [{limite_inf:.3f}, {limite_sup:.3f}] m/s²\")\n", "print()\n", "print(\"Medida # | Valor (m/s²) | Erro (%) | Status\")\n", "print(\"-\" * 50)\n", "\n", "medidas_validas = 0\n", "\n", "for i, g_med in enumerate(g_medidos, 1):\n", " erro_percent = abs(g_med - g_teorico) / g_teorico * 100\n", " \n", " if limite_inf <= g_med <= limite_sup:\n", " status = \"✓ VÁLIDO\"\n", " medidas_validas += 1\n", " else:\n", " status = \"✗ INVÁLIDO\"\n", " \n", " print(f\"{i:7} | {g_med:12.2f} | {erro_percent:8.2f} | {status}\")\n", "\n", "print()\n", "print(f\"Medidas válidas: {medidas_validas}/{len(g_medidos)}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Visualização das Medidas" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "source": [ "fig, ax = plt.subplots(figsize=(10, 6))\n", "\n", "# Plotar medidas\n", "medida_num = list(range(1, len(g_medidos) + 1))\n", "cores = ['green' if limite_inf <= g <= limite_sup else 'red' for g in g_medidos]\n", "\n", "ax.scatter(medida_num, g_medidos, c=cores, s=100, alpha=0.7, label='Medidas')\n", "\n", "# Linha do valor teórico\n", "ax.axhline(g_teorico, color='blue', linestyle='-', linewidth=2, label=f'Teórico: {g_teorico} m/s²')\n", "\n", "# Área de tolerância\n", "ax.axhspan(limite_inf, limite_sup, alpha=0.2, color='green', label=f'Intervalo ±{tolerancia_percent}%')\n", "\n", "ax.set_xlabel('Número da Medida', fontsize=12)\n", "ax.set_ylabel('Aceleração da Gravidade (m/s²)', fontsize=12)\n", "ax.set_title('Validação de Medidas Experimentais de g', fontsize=14, fontweight='bold')\n", "ax.set_xticks(medida_num)\n", "ax.legend(fontsize=11)\n", "ax.grid(True, alpha=0.3)\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "source": "### Visualização: Escalas de Temperatura\n\nComparação visual das três escalas de temperatura (Celsius, Fahrenheit e Kelvin) com pontos notáveis da Física.", "metadata": {} }, { "cell_type": "code", "source": "# Criar comparação visual das escalas\ncelsius_range = np.linspace(-50, 150, 200)\nfahrenheit_range = ConversorTemperatura.celsius_para_fahrenheit(celsius_range)\nkelvin_range = ConversorTemperatura.celsius_para_kelvin(celsius_range)\n\nfig, ax = plt.subplots(figsize=(12, 8))\n\n# Plotar as três escalas como linhas\nax.plot(celsius_range, celsius_range, linewidth=3, label='Celsius', color='blue', alpha=0.8)\nax.plot(celsius_range, fahrenheit_range, linewidth=3, label='Fahrenheit', color='red', alpha=0.8)\nax.plot(celsius_range, kelvin_range, linewidth=3, label='Kelvin', color='green', alpha=0.8)\n\n# Pontos notáveis em Celsius\npontos_notaveis = [\n (-273.15, 'Zero Absoluto'),\n (0, 'Fusão da água'),\n (25, 'Ambiente'),\n (37, 'Corpo humano'),\n (100, 'Ebulição da água'),\n (273.15, 'Outro zero absoluto em K'),\n]\n\n# Plotar pontos notáveis\nfor C, descricao in pontos_notaveis:\n F = ConversorTemperatura.celsius_para_fahrenheit(C)\n K = ConversorTemperatura.celsius_para_kelvin(C)\n \n # Apenas plotar se estiver dentro do range\n if -50 <= C <= 150:\n ax.scatter([C], [C], s=100, c='blue', edgecolors='darkblue', linewidth=1.5, zorder=5)\n ax.scatter([C], [F], s=100, c='red', edgecolors='darkred', linewidth=1.5, zorder=5)\n ax.scatter([C], [K], s=100, c='green', edgecolors='darkgreen', linewidth=1.5, zorder=5)\n \n # Rótulo\n offset_y = 20 if C < 50 else -30\n ax.annotate(descricao, xy=(C, F), xytext=(0, offset_y), textcoords='offset points',\n fontsize=9, ha='center',\n bbox=dict(boxstyle='round,pad=0.3', facecolor='yellow', alpha=0.6),\n arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0', color='gray'))\n\nax.set_xlabel('Celsius (°C)', fontsize=13, fontweight='bold')\nax.set_ylabel('Temperatura (em escala)', fontsize=13, fontweight='bold')\nax.set_title('Comparação de Escalas de Temperatura', fontsize=14, fontweight='bold')\nax.legend(fontsize=12, loc='upper left')\nax.grid(True, alpha=0.3, linestyle='--')\nax.set_xlim(-50, 150)\nax.set_ylim(-300, 450)\nplt.tight_layout()\nplt.show()\n\n# Tabela de conversão\nprint(\"=== TABELA DE CONVERSÃO DE TEMPERATURA ===\")\nprint(\"Celsius (°C) | Fahrenheit (°F) | Kelvin (K)\")\nprint(\"-\" * 50)\n\ntemperaturas_celsius = [-273.15, -40, 0, 25, 37, 100]\nfor C in temperaturas_celsius:\n F = ConversorTemperatura.celsius_para_fahrenheit(C)\n K = ConversorTemperatura.celsius_para_kelvin(C)\n print(f\"{C:11.2f} | {F:15.2f} | {K:9.2f}\")", "metadata": {}, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "## Exercício 3.2: Conversão de Unidades com Variáveis\n", "\n", "**Enunciado:**\n", "\n", "Crie um conversor de unidades para temperatura (Celsius ↔ Fahrenheit ↔ Kelvin).\n", "\n", "Fórmulas:\n", "- Celsius para Fahrenheit: $F = C \\times \\frac{9}{5} + 32$\n", "- Celsius para Kelvin: $K = C + 273.15$\n", "- Fahrenheit para Celsius: $C = (F - 32) \\times \\frac{5}{9}$" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "source": [ "class ConversorTemperatura:\n", " \"\"\"Conversor de unidades de temperatura.\"\"\"\n", " \n", " @staticmethod\n", " def celsius_para_fahrenheit(celsius):\n", " return celsius * 9/5 + 32\n", " \n", " @staticmethod\n", " def celsius_para_kelvin(celsius):\n", " return celsius + 273.15\n", " \n", " @staticmethod\n", " def fahrenheit_para_celsius(fahrenheit):\n", " return (fahrenheit - 32) * 5/9\n", " \n", " @staticmethod\n", " def kelvin_para_celsius(kelvin):\n", " return kelvin - 273.15\n", "\n", "# Teste com valores típicos\n", "conversoes = [\n", " (0, \"Ponto de fusão da água\"),\n", " (25, \"Temperatura ambiente\"),\n", " (100, \"Ponto de ebulição da água\"),\n", " (-40, \"Ponto onde C = F\"),\n", "]\n", "\n", "print(\"=== CONVERSOR DE TEMPERATURA ===\")\n", "print()\n", "\n", "for celsius, descricao in conversoes:\n", " fahrenheit = ConversorTemperatura.celsius_para_fahrenheit(celsius)\n", " kelvin = ConversorTemperatura.celsius_para_kelvin(celsius)\n", " \n", " print(f\"{descricao}:\")\n", " print(f\" {celsius}°C = {fahrenheit:.2f}°F = {kelvin:.2f}K\")\n", " print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "## Exercício Proposto 1: Energia Potencial Gravitacional\n", "\n", "**Desafio:**\n", "\n", "Uma caixa de massa $m = 5$ kg é levantada a uma altura $h = 2$ metros. \n", "Calcule a energia potencial gravitacional: $E_p = mgh$\n", "\n", "Use $g = 9.81$ m/s². Teste sua solução com diferentes valores de massa e altura." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "source": [ "def energia_potencial(m, h, g=9.81):", " \"\"\"Calcula energia potencial gravitacional: Ep = mgh.", " ", " Args:", " m: massa em kg", " h: altura em metros", " g: aceleração da gravidade (padrão 9.81 m/s²)", " ", " Returns:", " float: energia potencial em joules", " \"\"\"", " return m * g * h", "", "# Dados para análise", "massas = np.linspace(1, 20, 50) # kg", "alturas = np.linspace(0, 50, 50) # m", "M, H = np.meshgrid(massas, alturas)", "Ep = energia_potencial(M, H)", "", "fig, axes = plt.subplots(1, 2, figsize=(14, 5))", "", "# Gráfico 1: Ep vs h para diferentes massas", "for m_val in [1, 5, 10, 20]:", " h_arr = np.linspace(0, 50, 100)", " axes[0].plot(h_arr, energia_potencial(m_val, h_arr),", " label=f'm = {m_val} kg', lw=2)", "axes[0].set_xlabel('Altura (m)', fontsize=12)", "axes[0].set_ylabel('Ep (J)', fontsize=12)", "axes[0].set_title('Energia Potencial vs Altura', fontsize=12, fontweight='bold')", "axes[0].legend(fontsize=10)", "axes[0].grid(True, alpha=0.3)", "", "# Gráfico 2: mapa de calor Ep(m, h)", "im = axes[1].contourf(M, H, Ep, levels=20, cmap='viridis')", "plt.colorbar(im, ax=axes[1], label='Ep (J)')", "axes[1].set_xlabel('Massa (kg)', fontsize=12)", "axes[1].set_ylabel('Altura (m)', fontsize=12)", "axes[1].set_title('Mapa de Energia Potencial', fontsize=12, fontweight='bold')", "", "plt.tight_layout()", "plt.show()", "", "# Teste com valores específicos", "print(\"=== ENERGIA POTENCIAL GRAVITACIONAL ===\")", "print(f\"Uma caixa de 5 kg levantada a 2 m:\")", "print(f\"Ep = {energia_potencial(5, 2):.2f} J\")", "print()", "print(\"Exemplos para diferentes massas e alturas:\")", "for m in [1, 5, 10, 20]:", " for h in [1, 5, 10]:", " print(f\" m={m:2}kg, h={h:2}m → Ep = {energia_potencial(m, h):7.2f} J\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "## Exercício Proposto 2: Lei de Coulomb\n", "\n", "**Desafio:**\n", "\n", "Calcule a força eletrostática entre duas cargas usando a Lei de Coulomb:\n", "\n", "$$F = k \\frac{|q_1 q_2|}{r^2}$$\n", "\n", "onde $k = 8.99 \\times 10^9$ N·m²/C² (constante de Coulomb)\n", "\n", "Teste com cargas típicas e distâncias variadas." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "source": [ "k = 8.99e9 # constante de Coulomb", "", "def forca_coulomb(q1, q2, r):", " \"\"\"Calcula força eletrostática (Lei de Coulomb).", " ", " F = k * |q1 * q2| / r²", " ", " Args:", " q1, q2: cargas em coulombs", " r: distância em metros", " ", " Returns:", " float: força em newtons (valor absoluto)", " \"\"\"", " return k * abs(q1 * q2) / r**2", "", "# Análise: F vs r para diferentes pares de cargas", "r = np.linspace(0.1, 5.0, 200) # metros", "", "pares = [", " (1e-6, 1e-6, '+1µC / +1µC (repulsão)'),", " (1e-6, 2e-6, '+1µC / +2µC'),", " (1e-6, -1e-6, '+1µC / -1µC (atração)'),", " (2e-6, 2e-6, '+2µC / +2µC'),", "]", "", "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(13, 5))", "", "# Gráfico 1: F vs r em escala log", "for q1, q2, label in pares:", " F = forca_coulomb(q1, q2, r)", " ax1.plot(r, F, label=label, lw=2)", "", "ax1.set_xlabel('Distância (m)', fontsize=12)", "ax1.set_ylabel('|F| (N)', fontsize=12)", "ax1.set_title('Lei de Coulomb: F vs r', fontsize=12, fontweight='bold')", "ax1.legend(fontsize=9)", "ax1.grid(True, alpha=0.3)", "ax1.set_yscale('log')", "", "# Gráfico 2: gráfico de barras para distâncias pontuais", "r_tab = np.array([0.1, 0.5, 1.0, 2.0, 5.0])", "q1, q2 = 1e-6, 1e-6", "F_tab = forca_coulomb(q1, q2, r_tab)", "ax2.bar(range(len(r_tab)), F_tab, tick_label=[f'{r:.1f} m' for r in r_tab],", " color='steelblue', alpha=0.8, edgecolor='black', linewidth=1.2)", "ax2.set_ylabel('Força (N)', fontsize=12)", "ax2.set_title(f'Lei de Coulomb para q₁=q₂=1µC', fontsize=12, fontweight='bold')", "ax2.grid(True, alpha=0.3, axis='y')", "", "plt.tight_layout()", "plt.show()", "", "# Resultados numéricos", "print(\"=== LEI DE COULOMB ===\")", "print(f\"k = {k:.2e} N·m²/C²\")", "print()", "print(\"Força entre duas cargas de +1µC:\")", "for dist in [0.1, 0.5, 1.0, 2.0, 5.0]:", " F = forca_coulomb(1e-6, 1e-6, dist)", " print(f\" r = {dist:3.1f} m → F = {F:10.4f} N\")" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python", "version": "3.9.0" } }, "nbformat": 4, "nbformat_minor": 4 }