Compilado de exercicios em Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6c213a5f",
   "metadata": {},
   "source": [
    "# Listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d455b6c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "###Exercício 1\n",
    "\n",
    "# input:\n",
    "vec = input().split()\n",
    "vec = [int(x) for x in vec]\n",
    "\n",
    "# soma dos vetores:\n",
    "s = 0\n",
    "\n",
    "for x in range(len(vec)):\n",
    "    s+=vec[x]\n",
    "print(s)\n",
    "\n",
    "# número de ocorrências:\n",
    "l = []\n",
    "\n",
    "for x in vec:\n",
    "    if x == vec[-1]:\n",
    "        l.append(x)\n",
    "print(len(l))\n",
    "\n",
    "# máximo da lista:\n",
    "print(max(vec))\n",
    "\n",
    "#indices dos máximos:\n",
    "i = list()\n",
    "for indice, item in enumerate(vec):\n",
    "    if item == max(vec):\n",
    "        i.append(indice)\n",
    "print(*i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99d1b3a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Exercício 2\n",
    "\n",
    "# input:\n",
    "vec = []\n",
    "\n",
    "while True:\n",
    "    i = input()\n",
    "    i = int(i)\n",
    "    if i < 0:\n",
    "        break\n",
    "    else:\n",
    "        vec.append(i)\n",
    "\n",
    "# qnt de valores > 5:\n",
    "qnt_cinco = []\n",
    "for x in vec:\n",
    "    if x > 5:\n",
    "        qnt_cinco.append(x)\n",
    "c = len(qnt_cinco)\n",
    "print(c)\n",
    "# soma dos valores pares e valores ímpares:\n",
    "s_p = 0\n",
    "s_i = 0\n",
    "for x in vec:\n",
    "    if x%2 == 0:\n",
    "        s_p += x\n",
    "    else:\n",
    "        s_i += x\n",
    "print(s_p)\n",
    "print(s_i)\n",
    "\n",
    "# qnt total de valores:\n",
    "comp = len(vec)\n",
    "print(comp)\n",
    "\n",
    "# o vetor:\n",
    "print(*vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9395d9db",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Exercício 3\n",
    "\n",
    "#Input dos dados\n",
    "dt, M, n = input().split()\n",
    "dt,M,n =float(dt), int(M), int(n)\n",
    "\n",
    "d = []\n",
    "for i in range(n):\n",
    "    d.append([float(x) for x in input().split()])\n",
    "\n",
    "for j in range(1,M+1):\n",
    "    for i in range(len(d)):\n",
    "        d[i][0] += d[i][3] * dt\n",
    "        d[i][1] += d[i][4] * dt\n",
    "        d[i][2] += d[i][5] * dt\n",
    "        \n",
    "for i in range(len(d)):        \n",
    "    print('%.2f %.2f %.2f' % (d[i][0],d[i][1],d[i][2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6753b30f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.00 1.00 20.00 5.00 17.00 19.00 14.00 4.00 18.00 5.00\n",
      "2.00 2.00\n",
      "3.00 2.00\n",
      "23.00 40.00\n",
      "28.00 200.00\n",
      "45.00 3400.00\n",
      "64.00 64600.00\n",
      "78.00 904400.00\n",
      "82.00 3617600.00\n",
      "100.00 65116800.00\n",
      "105.00 325584000.00\n"
     ]
    }
   ],
   "source": [
    "### Exercício 4\n",
    "\n",
    "n = [float(x) for x in input().split()]\n",
    "\n",
    "s = n[0]\n",
    "p = n[0]\n",
    "\n",
    "for i in range(1,len(n)):\n",
    "    print('%.2f' % s, '%.2f' % p)\n",
    "    s += n[i]\n",
    "    p *= n[i]\n",
    "print('%.2f' % s, '%.2f' % p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "0663151a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 3 -1 2 -10 5 5 2 3 1\n",
      "2 1 3 5\n",
      "1 1 1 -3 -5 6 7 8 8 10 89 3 2 2 1 1 -9 -7 12 31\n",
      "1 6 7 8 10 89 3 2 12 31\n"
     ]
    }
   ],
   "source": [
    "### Exercício 5\n",
    "\n",
    "# input:\n",
    "vet = [int(i) for i in input().split()]\n",
    "\n",
    "# vetores positivos:\n",
    "vet_pos = []\n",
    "\n",
    "for i in vet:\n",
    "    if vet[i] >= 0:\n",
    "        vet_pos.append(vet[i])\n",
    "#print(*vet_pos)\n",
    "\n",
    "# excluir valores repetidos\n",
    "vet_f = []\n",
    "\n",
    "for i in vet_pos:\n",
    "    if i not in vet_f:\n",
    "        vet_f.append(i)\n",
    "print(*vet_f)\n",
    "\n",
    "# 2 forma de resolução:\n",
    "\n",
    "v = [int(x) for x in input().split()]\n",
    "p = [x for x in v if x > -1]\n",
    "\n",
    "p_r = []\n",
    "for i in p:\n",
    "    if i not in p_r:\n",
    "        p_r.append(i)\n",
    "print(*p_r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "54679a67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14 6 15 14 13 18 1 0 1 13 15 12 12 0 14 7 19 5 12\n",
      "0 2\n",
      "1 2\n",
      "12 3\n",
      "13 2\n",
      "14 3\n",
      "15 2\n"
     ]
    }
   ],
   "source": [
    "### Exercício 6\n",
    "\n",
    "vet = list(map(int,input().strip().split()))\n",
    "vet = sorted(vet)\n",
    "set_vet = list(set(vet))\n",
    "\n",
    "s = 0\n",
    "for i in set_vet:\n",
    "    s = 0\n",
    "    for j in vet:\n",
    "        if j == i:\n",
    "            s += 1\n",
    "    if s > 1:\n",
    "        print(i, s) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f51bda6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Exercício 7 (Problema do polígono)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cbab05b",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Exercício 8\n",
    "# Meu código (não entendi o que falhou):\n",
    "t_a, a = int(input()), set(list(map(int,input().strip().split())))\n",
    "\n",
    "t_b, b = int(input()), set(list(map(int,input().strip().split())))\n",
    "\n",
    "c = a & b\n",
    "d = len(c)\n",
    "\n",
    "if d == 0:\n",
    "    print('*')\n",
    "else:\n",
    "    c = sorted(c)\n",
    "    print(*c)\n",
    "    \n",
    "# Resolução correta:\n",
    "t_a = int(input())\n",
    "a = list(map(int,input().strip().split()))\n",
    "\n",
    "t_b = int(input())\n",
    "b = list(map(int,input().strip().split()))\n",
    "\n",
    "if (len(a) == t_a and len(b) == t_b):\n",
    "    intersec = [str(i) for i in a if i in b]\n",
    "    print(*intersec if intersec else '*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8794677d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "3 4\n",
      "5 4\n",
      "3 2\n",
      "1 4\n",
      "3 6\n",
      "2 5\n",
      "1 4\n",
      "7 8\n",
      "9 1\n",
      "2 0\n",
      "1 0\n",
      "3 5\n",
      "6 1\n",
      "3 2\n",
      "E\n"
     ]
    }
   ],
   "source": [
    "### Exercício 9\n",
    "\n",
    "#Equipes\n",
    "eq_oit = [['A','B'],['C','D'],['E','F'],['G','H'],['I','J'],['K','L'],['M','N'],['O','P']]\n",
    "#print(eq_oit)\n",
    "\n",
    "###Entrada dos confrontos oitavas de final:\n",
    "c_oit = []\n",
    "\n",
    "for i in range(8):\n",
    "    j = [int(x) for x in input().split()]\n",
    "    c_oit.append(j)\n",
    "#print(c_oit)\n",
    "\n",
    "##Lista com equipes que passaram das oitavas:\n",
    "eq_qua = []\n",
    "\n",
    "for (aa,bb) in zip (c_oit,eq_oit):\n",
    "    if aa[0] > aa[1]:\n",
    "        eq_qua.append(bb[0])\n",
    "    else:\n",
    "        eq_qua.append(bb[1])\n",
    "#print(eq_qua)\n",
    "\n",
    "###Entrada dos confrontos quartas de final:\n",
    "c_qua = []\n",
    "for i in range(4):\n",
    "    j = [int(x) for x in input().split()]\n",
    "    c_qua.append(j)\n",
    "#print(c_qua)\n",
    "\n",
    "##Lista com equipes que passaram das quartas:\n",
    "eq_sem = []\n",
    "n = 0\n",
    "for i in c_qua:\n",
    "    if i[0] > i[1]:\n",
    "        d = eq_qua[n]\n",
    "        eq_sem.append(d)\n",
    "    else:\n",
    "        d = eq_qua[n+1]\n",
    "        eq_sem.append(d)\n",
    "    n+=2\n",
    "#print(eq_sem)\n",
    "\n",
    "###Entrada dos confrontos semifinal:\n",
    "c_sem = []\n",
    "for i in range(2):\n",
    "    j = [int(x) for x in input().split()]\n",
    "    c_sem.append(j)\n",
    "#print(c_sem)\n",
    "\n",
    "##Lista com equipes que passaram da semifinal:\n",
    "eq_fin = []\n",
    "n = 0\n",
    "for i in c_sem:\n",
    "    if i[0] > i[1]:\n",
    "        d = eq_sem[n]\n",
    "        eq_fin.append(d)\n",
    "    else:\n",
    "        d = eq_sem[n+1]\n",
    "        eq_fin.append(d)\n",
    "    n+=2\n",
    "#print(eq_fin)\n",
    "\n",
    "###Entrada do confronto da final:\n",
    "c_f = [int(x) for x in input().split()]\n",
    "#print(c_f)\n",
    "\n",
    "##Definicão do campeão:\n",
    "a = c_f[0]\n",
    "b = c_f[1]\n",
    "\n",
    "if a > b:\n",
    "    print(eq_fin[0])\n",
    "else:\n",
    "    print(eq_fin[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "166e76a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filomen 2 5 8 9 7 10 4\n",
      "Afonso 1 2 8 5 7 9 15 14\n",
      "Samuel 5 6 8 7 1 2 10\n",
      "FIM\n",
      "1-2-10-15-20\n",
      "Filomen\t2\n",
      "Afonso\t3\n",
      "Samuel\t3\n"
     ]
    }
   ],
   "source": [
    "### Exercicio 10\n",
    "\n",
    "#Entrada das apostas:\n",
    "m = []\n",
    "while True:\n",
    "    l = input().split()\n",
    "    if l[-1] != 'FIM':\n",
    "        m.append(l)\n",
    "        continue\n",
    "    else:\n",
    "        break\n",
    "\n",
    "l_l = len(l)\n",
    "l_m = len(m)\n",
    "#print(m)\n",
    "\n",
    "#Entrada dos resultados:\n",
    "r = input().split('-')\n",
    "l_r = len(r)\n",
    "#print(r)\n",
    "\n",
    "#Condições para o resultado:\n",
    "c = []\n",
    "for k in range(l_m):\n",
    "    a = m.pop()\n",
    "    s = 0\n",
    "    for i in a:\n",
    "        for j in r:\n",
    "            if j == i:\n",
    "                s+=1\n",
    "    b = [a[0],s]\n",
    "    c.append(b)\n",
    "c.sort()\n",
    "#print('Esta é a lista c ordenada: \\n', c, '\\n')\n",
    "\n",
    "#Set com os números em ordem:\n",
    "s = set()\n",
    "\n",
    "for i,j in c:\n",
    "    s.add(j)\n",
    "#print('Este é o set s: \\n',s, '\\n')\n",
    "\n",
    "#Comparação entre os números:\n",
    "for i in s:\n",
    "    #print('Este é o índice i:',i)\n",
    "    for l,k in c:\n",
    "        #print('Este é o índice l:',l)\n",
    "        #print('Este é o índice k:',k)\n",
    "        if i == k:\n",
    "            print(f'{l}\\t{i}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1307a11a",
   "metadata": {},
   "source": [
    "# Matrizes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4d64b4f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 1\n",
    "\n",
    "#Input dimensões das matrizes\n",
    "l1,c1,l2,c2 = input().split()\n",
    "l1,c1,l2,c2 = int(l1), int(c1), int(l2), int(c2)\n",
    "\n",
    "#Verificar compatibilidade e construir matrizes\n",
    "m1 = []\n",
    "m2 = []\n",
    "\n",
    "for i in range(l1):\n",
    "    m1.append([float(x) for x in input().split()])\n",
    "for j in range(l2):\n",
    "    m2.append([float(x) for x in input().split()])\n",
    "\n",
    "if c1 != l2:\n",
    "    print('Incompatíveis')\n",
    "else:\n",
    "    l3 = l1\n",
    "    c3 = c2\n",
    "    c = [[0 for colunas in range(c3)] for linhas in range(l3)]\n",
    "\n",
    "    #Multiplicação das matrizes\n",
    "    for i in range(l1):\n",
    "        for j in range(c2):\n",
    "            for k in range(l2):\n",
    "                c[i][j] += m1[i][k] * m2[k][j]\n",
    "\n",
    "    for q in range(l3):\n",
    "        for w in range(c3):\n",
    "            c[q][w] = '%.2f' % c[q][w]\n",
    "            c[q][w] = float(c[q][w])\n",
    "\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a67259f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 2\n",
    "\n",
    "#Input da matriz e seu tamanho:\n",
    "m, n = input().split()\n",
    "m, n = int(m),int(n)\n",
    "\n",
    "a = []\n",
    "\n",
    "for i in range(m):\n",
    "    a.append([int(x) for x in input().split()])\n",
    "#print(a)\n",
    "\n",
    "#Ampulheta:\n",
    "s = []\n",
    "for i in range(m-2):\n",
    "    for j in range(n-2):\n",
    "        aux = a[i][j] + a[i][j+1] + a[i][j+2] + a[i+1][j+1] + a[i+2][j] + a[i+2][j+1] + a[i+2][j+2]\n",
    "        s.append(aux)\n",
    "s = sorted(s)\n",
    "print(s[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7d08a836",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 3\n",
    "#Input da ordem da matriz e seus elementos:\n",
    "m = int(input())\n",
    "a = [int(x) for x in input().split()]\n",
    "t_a = len(a)\n",
    "\n",
    "m_ = [[0 for colunas in range(m)]for linhas in range(m)]\n",
    "\n",
    "#Inversão da lista a:\n",
    "inv_a = []\n",
    "for i in range(t_a):\n",
    "    b = a.pop()\n",
    "    inv_a.append(b)\n",
    "    \n",
    "#Transformar a em m_:\n",
    "\n",
    "for i in range(m):\n",
    "    for j in range(m):\n",
    "        m_[i][j] = inv_a[-1]\n",
    "        inv_a.pop()\n",
    "\n",
    "#Output da matriz:\n",
    "for k in m_:\n",
    "    print(*k)\n",
    "\n",
    "#Verificação da matriz permutação:\n",
    "for k in m_:\n",
    "    k = tuple(k)\n",
    "    z = k.count(0)\n",
    "    u = k.count(1)\n",
    "    s = sum(k)\n",
    "    if z == (m-1) and u == 1 and s == 1:\n",
    "        for v in range(m):\n",
    "            q = 0\n",
    "            for b in range(m):\n",
    "                q += m_[b][v]\n",
    "            if q == 1:\n",
    "                continue\n",
    "            else:\n",
    "                break\n",
    "    else:\n",
    "        break\n",
    "\n",
    "if z == (m-1) and u == 1 and s == 1 and q == 1:\n",
    "    print('True')\n",
    "else:\n",
    "    print('False')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d64f07ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 4\n",
    "\n",
    "#Input da ordem e matriz\n",
    "m,n = input().split()\n",
    "m,n = int(m), int(n)\n",
    "\n",
    "l = [int(x) for x in input().split()]\n",
    "t_l = len(l)\n",
    "mt = []\n",
    "\n",
    "for i in range(0, t_l,n):\n",
    "    mt.append(l[i:i+n])\n",
    "\n",
    "for r in mt:\n",
    "    print(*r)\n",
    "    \n",
    "#Condições:\n",
    "\n",
    "###If da quina (0,0):\n",
    "if mt[0][0] < mt[0][1] and mt[0][0] < mt[1][0] and mt[0][0] < mt[1][1]:\n",
    "    print('(0, 0)')\n",
    "    \n",
    "###If da linha 0 até n-1:\n",
    "for x in range(1,n-1):\n",
    "    if mt[0][x] < mt[0][x-1] and mt[0][x] < mt[0][x+1] and mt[0][x] < mt[1][x-1] and mt[0][x] < mt[1][x] and mt[0][x] < mt[1][x+1]:\n",
    "        print(f'(0, {x})') \n",
    "\n",
    "###if da quina (0,n):\n",
    "for t in range(n):\n",
    "    so = 0\n",
    "    if mt[0][t] < mt[0][t-1] and mt[0][t] < mt[1][t-1] and mt[0][t] < mt[1][t]:\n",
    "        so += 1\n",
    "    else:\n",
    "        continue\n",
    "if so == 1:\n",
    "    print(f'(0, {t})')\n",
    "\n",
    "###If da coluna 0 até m-1:\n",
    "for z in range(1,m-1):\n",
    "    if mt[z][0] < mt[z-1][0] and mt[z][0] < mt[z+1][0] and mt[z][0] < mt[z-1][1] and mt[z][0] < mt[z][1] and mt[z][0] < mt[z+1][1]:\n",
    "        print(f'({z}, 0)')\n",
    "\n",
    "###If do meio do meio\n",
    "for k in range(1,m-1):\n",
    "    for l in range(1,n-1):\n",
    "        if (mt[k][l]) < (mt[k-1][l-1]) and (mt[k][l]) < mt[k][l-1] and (mt[k][l]) < mt[k+1][l-1] and (mt[k][l]) < mt[k-1][l] and (mt[k][l]) < mt[k+1][l] and (mt[k][l]) < mt[k-1][l+1] and (mt[k][l]) < mt[k][l+1] and (mt[k][l]) < mt[k+1][l+1]:\n",
    "            print(f'({k}, {l})')\n",
    "        \n",
    "###if da coluna n até m-1:\n",
    "for v in range(1,m-1):\n",
    "    if mt[v][n-1] < mt[v-1][n-1] and mt[v][n-1] < mt[v+1][n-1] and mt[v][n-1] < mt[v-1][n-2] and mt[v][n-1] < mt[v][n-2] and mt[v][n-1] < mt[v+1][n-2]:\n",
    "        print(f'({v}, {n-1})')\n",
    "\n",
    "###if da quina (m,0):\n",
    "for y in range(m):\n",
    "    sm = 0\n",
    "    if mt[y][0] < mt[y-1][0] and mt[y][0] < mt[y][1] and mt[y][0] < mt[y-1][1]:\n",
    "        sm += 1\n",
    "    else:\n",
    "        continue\n",
    "if sm == 1: \n",
    "    print(f'({y}, 0)')\n",
    "\n",
    "###if da linha m até n-1:\n",
    "for g in range(1,n-1):\n",
    "    if mt[m-1][g] < mt[m-1][g-1] and mt[m-1][g] < mt[m-1][g+1] and mt[m-1][g] < mt[m-2][g-1] and mt[m-1][g] < mt[m-2][g] and mt[m-1][g] < mt[m-2][g+1]:\n",
    "        print(f'({m-1}, {g})')\n",
    "    \n",
    "###if da quina (m,n):\n",
    "if mt[m-1][n-1] < mt[m-1][n-2] and mt[m-1][n-1] < mt[m-2][n-2] and mt[m-1][n-1] < mt[m-2][n-1]:\n",
    "    print(f'({m-1}, {n-1})')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6c9b25d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 5\n",
    "#Input da ordem da matriz\n",
    "\n",
    "n = int(input())\n",
    "\n",
    "m = []\n",
    "for x in range(n):\n",
    "    l_aux = [int(x) for x in input().split()]\n",
    "    m.append(l_aux)\n",
    "\n",
    "res_som1 = []\n",
    "for y in m:\n",
    "    res = sum(y)\n",
    "    if res not in res_som1:\n",
    "        res_som1.append(res)\n",
    "\n",
    "res_som2 = []\n",
    "for s in range(n):\n",
    "    resul = 0\n",
    "    for d in range(n):\n",
    "        resul += m[d][s]\n",
    "    if resul not in res_som2: \n",
    "        res_som2.append(resul)\n",
    "\n",
    "resul2 = m[0][0]        \n",
    "for f in range(n-1):\n",
    "    resul2 += m[f+1][f+1]\n",
    "\n",
    "resul3 = 0\n",
    "for g,h in zip(range(n), reversed(range(n))):\n",
    "    resul3 += m[h][g]\n",
    "    \n",
    "tsl = len(res_som1)\n",
    "tsc = len(res_som2)\n",
    "\n",
    "if tsl != 1 or tsc != 1 or resul2 != resul3:\n",
    "    print('-1')\n",
    "\n",
    "if tsl == 1 and tsc == 1 and resul2 == resul3:\n",
    "    print(*res_som1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5cc79cc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 6\n",
    "\n",
    "import copy\n",
    "\n",
    "#input da ordem da matriz e seus elementos;\n",
    "m,n = input().split()\n",
    "m,n = int(m), int(n)\n",
    "a = m-1\n",
    "b = n-1\n",
    "\n",
    "m_ = []\n",
    "for q in range(m):\n",
    "    q_ = [int(x) for x in input().split()]\n",
    "    m_.append(q_)\n",
    "\n",
    "mt = copy.deepcopy(m_)\n",
    "\n",
    "for t in range(m):\n",
    "    for y in range(n):\n",
    "        if m_[t][y] == 1:\n",
    "            m_[t][y] *= -1 \n",
    "\n",
    "for w in range(m):\n",
    "    for e in range(n):\n",
    "        if (w>0 and w<m-1 and e>0 and e<n-1): #(meio)\n",
    "            if mt[w][e] == 0:\n",
    "                a = mt[w-1][e-1] + mt[w][e-1] + mt[w+1][e-1] + mt[w-1][e] + mt[w+1][e] + mt[w-1][e+1] + mt[w][e+1] + mt[w+1][e+1]\n",
    "                m_[w][e] = a\n",
    "                \n",
    "        if (w==0 and e==0): #(quina I)\n",
    "            if mt[w][e] == 0:\n",
    "                a = mt[w][e+1] + mt[w+1][e] + mt[w+1][e+1]\n",
    "                m_[w][e] = a\n",
    "                \n",
    "        if (0<w<m-1 and e==0): #(meio da col I)\n",
    "            if mt[w][e] == 0:\n",
    "                a = mt[w-1][e] + mt[w+1][e] + mt[w-1][e+1] + mt[w][e+1] + mt[w+1][e+1]\n",
    "                m_[w][e] = a\n",
    "        if (w==m-1 and e==0): #(quina II)\n",
    "            if mt[w][e] == 0:\n",
    "                a = mt[w-1][e] + mt[w-1][e+1] + mt[w][e+1]\n",
    "                m_[w][e] = a\n",
    "                \n",
    "        if (w==0 and e==n-1): #(quina IV)\n",
    "            if mt[w][e] == 0:\n",
    "                a = mt[w][e-1] + mt[w+1][e-1] + mt[w+1][e]\n",
    "                m_[w][e] = a\n",
    "        if (w == 0 and 0<e<n-1):\n",
    "            if mt[w][e] == 0:\n",
    "                a = mt[w][e-1] + mt[w][e+1] + mt[w+1][e-1] + mt[w+1][e] + mt[w+1][e+1]\n",
    "                m_[w][e] = a\n",
    "        if (w == m-1 and e == n-1):\n",
    "            if mt[w][e] == 0:\n",
    "                a = mt[w-1][e] + mt[w-1][e-1] + mt[w][e-1]\n",
    "                m_[w][e] = a\n",
    "                \n",
    "        if (0<w<m-1 and e== n-1 ):\n",
    "            if mt[w][e] == 0:\n",
    "                a = mt[w-1][e] + mt[w-1][e-1] + mt[w][e-1] + mt[w+1][e-1] + mt[w+1][e]\n",
    "                m_[w][e] = a\n",
    "                \n",
    "        if (w == m-1 and 0<e<n-1):\n",
    "            if mt[w][e] == 0:\n",
    "                a = mt[w][e-1] + mt[w][e+1] + mt[w-1][e-1] + mt[w-1][e] + mt[w-1][e+1]\n",
    "                m_[w][e] = a\n",
    "\n",
    "for r in m_:\n",
    "    print(*r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1ee7d993",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 7\n",
    "\n",
    "\tmatriz.append([int(i) for i in input().split()])\n",
    "    \n",
    "rainhas = []\n",
    "for l in range(8):\n",
    "    for c in range(8):\n",
    "        if(matriz[l][c]==1):\n",
    "            rainhas.append([l,c])\n",
    "            \n",
    "controle = False\n",
    "for x in rainhas:\n",
    "    aux = rainhas.copy()\n",
    "    aux.remove(x)\n",
    "    for y in aux:\n",
    "        #linhas iguais\n",
    "        if(x[0]==y[0]):\n",
    "            controle = True\n",
    "            \n",
    "        #colunas iguais    \n",
    "        if(x[1]==y[1]):\n",
    "            controle = True\n",
    "            \n",
    "        #diagonais principais iguais    \n",
    "        if(x[0]-x[1]==y[0]-y[1]):\n",
    "            controle = True\n",
    "            \n",
    "        #diagonais secundarias iguais\n",
    "        if(x[0]+x[1]==y[0]+y[1]):\n",
    "            controle = True\n",
    "            \n",
    "if(controle):\n",
    "    print('S')\n",
    "else:\n",
    "    print('N')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "097c8d70",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3c0b675b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 9\n",
    "\n",
    "mt = []\n",
    "\n",
    "for n in range(9):\n",
    "    mt.append([int(x) for x in input().split()])\n",
    "    \n",
    "l = len(mt)\n",
    "c = len(mt[0])\n",
    "\n",
    "sudoku = False\n",
    "for i in range(l):\n",
    "    aux_l = []\n",
    "    for j in range(c):\n",
    "        if mt[i][j] not in aux_l:\n",
    "            aux_l.append(mt[i][j])\n",
    "    if len(aux_l) == 9:\n",
    "        sudoku = True\n",
    "    else:\n",
    "        sudoku = False\n",
    "        \n",
    "for j in range(c):\n",
    "    aux_c = []\n",
    "    for i in range(l):\n",
    "        if mt[j][i] not in aux_c:\n",
    "            aux_c.append(mt[j][i])\n",
    "        if len(aux_c) == 9:\n",
    "            sudoku = True\n",
    "        else:\n",
    "            sudoku = False\n",
    "\n",
    "break_out = False\n",
    "\n",
    "for f in range(9):\n",
    "    aux_q = []\n",
    "    if break_out == False:\n",
    "        for g in range(3):\n",
    "            for h in range(3):\n",
    "                if mt[g][h] not in aux_q:\n",
    "                    aux_q.append(mt[g][h])\n",
    "                    if (len(aux_q)) == 9:\n",
    "                        sudoku = True\n",
    "                        continue\n",
    "                    else:\n",
    "                        sudoku = False\n",
    "                        break_out = True\n",
    "            print(aux_q)\n",
    "if (sudoku):\n",
    "    print('SIM')\n",
    "else:\n",
    "    print('NAO')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "043f6923",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6a0ebf4",
   "metadata": {},
   "source": [
    "\n",
    "# Tuplas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9d50937",
   "metadata": {},
   "source": [
    "### 1) Exercício para escrever por extenso números de 0 a 20, utilizando tuplas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4be6de8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número entre 0 e 20:5\n",
      "Você digitou o número cinco.\n"
     ]
    }
   ],
   "source": [
    "#Meu código:\n",
    "\n",
    "num = int(input('Digite um número entre 0 e 20:'))\n",
    "\n",
    "resp = ''\n",
    "tupla = ('zero', 'um', 'dois', 'três', 'quatro', 'cinco', 'seis', 'sete', 'oito', 'nove', 'dez', 'onze', 'doze', 'treze', 'catorze', 'quinze', 'dezesseis', 'dezessete', 'dezoito', 'dezenove', 'vinte')\n",
    "\n",
    "if 20 >= num >= 0:\n",
    " resp = tupla[num]\n",
    " print('Você digitou o número {}.'.format(resp)) \n",
    "else:\n",
    " print('Tente novamente! Digite um número de 0 a 20')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c4965448",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite um número entre 0 e 20:9\n",
      "Você digitou o número nove\n"
     ]
    }
   ],
   "source": [
    "# Resolução:\n",
    "\n",
    "cont = ('zero', 'um', 'dois', 'três', 'quatro', 'cinco', 'seis', 'sete', 'oito', 'nove', 'dez', 'onze', 'doze', 'treze', 'catorze', 'quinze', 'dezesseis', 'dezessete', 'dezoito', 'dezenove', 'vinte')\n",
    "while True:\n",
    "    num = int(input('Digite um número entre 0 e 20:'))\n",
    "    if 20 >= num >= 0:\n",
    "        break\n",
    "    print('Tente novamente! ', end='')\n",
    "print(f'Você digitou o número {cont[num]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f136d1a6",
   "metadata": {},
   "source": [
    "## Dicionários e tuplas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03a40a20",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 1\n",
    "\n",
    "ag = {}\n",
    "\n",
    "while True:\n",
    "    ent = list(eval(input()))\n",
    "    command = ent.pop(0)\n",
    "    if command == 'Encerrar':\n",
    "        break\n",
    "    if command == 'InserirTelefone':\n",
    "        if ent[0] not in ag:\n",
    "            ag[ent[0]] = [ent[1]]\n",
    "        else:\n",
    "            if ent[1] not in ag[ent[0]]:\n",
    "                ag[ent[0]].append(ent[1])\n",
    "    if command == 'InserirPessoa':\n",
    "        if ent[0] not in ag:\n",
    "            ag[ent[0]] = []\n",
    "    if command == 'ExcluirPessoa':\n",
    "        if ent[0] in ag:\n",
    "            del ag[ent[0]]\n",
    "    if command == 'ExcluirTelefone':\n",
    "        if (ent[0] in ag and ent[1] in ag[ent[0]]):\n",
    "            tel = ent[1]\n",
    "            opl = ag[ent[0]]\n",
    "            npl = opl\n",
    "            i = 0\n",
    "            for l in opl:\n",
    "                if(l == tel):\n",
    "                    npl.pop(i)\n",
    "                i+=1\n",
    "            ag[ent[0]] = npl\n",
    "print(ag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2e1cd36",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 2 (Ok)\n",
    "\n",
    "#Dicionário com as traduções:\n",
    "dic_trad = {'UUU':'Phe','CUU':'Leu','UUA':'Leu','AAG':'Lis','UCU':'Ser','UAU':'Tyr', 'CAA':'Gln'}\n",
    "\n",
    "#Input:\n",
    "seq = input()\n",
    "tm_seq_e = len(seq)\n",
    "\n",
    "##Separar uma linha de caracteres de 3 por vez:\n",
    "\n",
    "aux = list(seq)\n",
    "r = []\n",
    "\n",
    "for x in range(0,tm_seq_e,3):\n",
    "    l = aux[x] + aux[x+1] + aux[x+2]\n",
    "    r.append(dic_trad[l])\n",
    "\n",
    "b = ''\n",
    "for g in range(len(r)):\n",
    "    if g == len(r)-1:\n",
    "        b+= r[g]\n",
    "    else:\n",
    "        b+=r[g]+'-'\n",
    "    \n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59d48497",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 3 (Não)\n",
    "\n",
    "dic_aux = {}\n",
    "dic_res = {}\n",
    "\n",
    "#Input:\n",
    "while True:\n",
    "    a = eval(input())\n",
    "    if a == ('VCP',):\n",
    "        break\n",
    "    else:\n",
    "        if (a[0] not in dic_aux):\n",
    "            dic_aux[a[0]] = [a[1]]\n",
    "        else:\n",
    "            dic_aux[a[0]] += [a[1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fb069d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Conversão: (1 caso errado)\n",
    "\n",
    "num_map = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '10': 10, 'J': 11, 'Q': 12, 'K': 13, 'A': 14}\n",
    "naipe_map = {'ouros': 1, 'espadas': 2, 'copas': 3, 'paus': 4}\n",
    "\n",
    "#Input:\n",
    "r1 = input().split()\n",
    "r2 = input().split()\n",
    "\n",
    "tr_1 = len(r1)\n",
    "tr_2 = len(r2)\n",
    "\n",
    "num_1 = []\n",
    "naipe_1 = []\n",
    "\n",
    "for s in range(tr_1):\n",
    "    if s % 2 == 0:\n",
    "        num_1.append(r1[s])\n",
    "    else:\n",
    "        naipe_1.append(r1[s])\n",
    "\n",
    "for d in range(tr_2):\n",
    "    if d % 2 == 0:\n",
    "        num_1.append(r2[d])\n",
    "    else:\n",
    "        naipe_1.append(r2[d])\n",
    "\n",
    "def conv_string (z,c):\n",
    "    for x in range(len(z)):\n",
    "        for y in c:\n",
    "            if z[x] == y:\n",
    "                z[x] = c[y]\n",
    "    return z\n",
    "    \n",
    "num_1 = conv_string(num_1,num_map)\n",
    "naipe_1 = conv_string(naipe_1,naipe_map)\n",
    "\n",
    "jog_1 = 0\n",
    "jog_2 = 0\n",
    "\n",
    "for x in range(0,len(num_1),2):\n",
    "    if naipe_1[x] > naipe_1[x+1]:\n",
    "        jog_1 += 1         \n",
    "    elif naipe_1[x] < naipe_1[x+1]:\n",
    "        jog_2 += 1\n",
    "    elif naipe_1[x] == naipe_1[x+1]:\n",
    "        if num_1[x] > num_1[x+1]:\n",
    "            jog_1 += 1     \n",
    "        elif num_1[x] < num_1[x+1]:\n",
    "            jog_2 += 1   \n",
    "            \n",
    "if jog_1 > jog_2:\n",
    "    print('1')\n",
    "elif jog_1 < jog_2:\n",
    "    print('2')\n",
    "else:\n",
    "    print('0')\n",
    "#Não sei dizer onde está errado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93e39b18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 5 (Ok)\n",
    "\n",
    "#Input:\n",
    "\n",
    "let = {'A':'', 'B':'', 'C':'', 'D':'', 'E':'', 'F':'', 'G':'', 'H':'', 'I':'', 'J':'', 'K':'', 'L':'', 'M':'', 'N':'', 'O':'', 'P':'', 'Q':'', 'R':'', 'S':'', 'T':'', 'U':'', 'V':'', 'W':'', 'X':'', 'Y':'', 'Z':'',' ': ' ', '.':'.', ',': ','}\n",
    "\n",
    "con = list(input())\n",
    "pal = list(input())\n",
    "\n",
    "for x,y in zip(let,con):\n",
    "    let[x] = y\n",
    "\n",
    "aux = []\n",
    "for a in pal:\n",
    "    for b in let:\n",
    "        if a == let[b]:\n",
    "            aux.append(b)\n",
    "\n",
    "r = ''.join(aux)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4639d62c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 6\n",
    "\n",
    "import copy\n",
    "\n",
    "#Input\n",
    "frase_ = input().split(' ')\n",
    "frase_1 = copy.deepcopy(frase_)\n",
    "\n",
    "frase = []\n",
    "\n",
    "for a in frase_:\n",
    "    n = a.lower()\n",
    "    frase.append(n)\n",
    "\n",
    "\n",
    "def ret_pont (pont):\n",
    "    for a in range(len(frase)):\n",
    "        if pont in frase[a]:\n",
    "            b = list(frase[a])\n",
    "            for x in b:\n",
    "                if x == pont:\n",
    "                    b.remove(x)\n",
    "                    frase[a] = ''.join(b)\n",
    "    return frase\n",
    "\n",
    "frase = ret_pont('!')\n",
    "frase = ret_pont('?')\n",
    "frase = ret_pont(',')\n",
    "frase = ret_pont('.')\n",
    "    \n",
    "dic_con = {}\n",
    "\n",
    "for x in frase:\n",
    "    if x not in dic_con:\n",
    "        dic_con[x] = 0\n",
    "    else:\n",
    "        dic_con[x] += 1\n",
    "\n",
    "#Palavras diferentes:\n",
    "pal_dif = len(dic_con)\n",
    "\n",
    "#Palavras repetidas:\n",
    "s = 0\n",
    "for x in dic_con:\n",
    "    if dic_con[x] != 0:\n",
    "        s += dic_con[x]  \n",
    "pal_rep = s\n",
    "\n",
    "#Frases:\n",
    "d = 0\n",
    "for x in range(len(frase_1)):\n",
    "    if '.' in frase_1[x] or '!' in frase_1[x] or '?' in frase_1[x]:\n",
    "        d += 1      \n",
    "print(pal_dif, pal_rep,d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a80412c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 7\n",
    "bur ={'A':1,'B':2,'C':0,'D':1,'E':0,'F':0,'G':0,'H':0,'I':0,'J':0,'K':0,'L':0,'M':0,'N':0,'O':1,'P':1,'Q':1,'R':1,'S':0,'T':0,'U':0,'V':0,'W':0,'X':0,'Y':0,'Z':0}\n",
    "\n",
    "def ver_bur (pal):\n",
    "    c = 0\n",
    "    for letra, valor in bur.items():\n",
    "        if letra in pal:\n",
    "            v = pal.count(letra)\n",
    "            c += v * valor\n",
    "    return c\n",
    "\n",
    "n = int(input())\n",
    "pal = []\n",
    "for i in range(n):\n",
    "    pal.append(input())\n",
    "\n",
    "for y in pal:\n",
    "    r = ver_bur(y)\n",
    "    print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ab4b195",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 8\n",
    "\n",
    "n = int(input())\n",
    "dic_trad = {}\n",
    "    \n",
    "for i in range(n):\n",
    "    x = input().split(' => ')\n",
    "    dic_trad[x[0]] = x[1]\n",
    "\n",
    "while True:\n",
    "    f = input()\n",
    "    if f == '*':\n",
    "        break\n",
    "    if f != '*':\n",
    "        f = f.split()\n",
    "        aux = []\n",
    "        for j in f:\n",
    "            for palavra, traducao in dic_trad.items():\n",
    "                if j in palavra and j == palavra:\n",
    "                    j = traducao\n",
    "                    aux.append(j)\n",
    "                if j not in dic_trad and j not in aux:\n",
    "                    aux.append(j)\n",
    "        print(*aux)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8af7841",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26bd7855",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ef342df",
   "metadata": {},
   "source": [
    "# Funções:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "52519fe7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12:00\n",
      "12:00 P.M\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "# Exercício 1\n",
    "\"\"\" Esboço do código \"\"\"\n",
    "\n",
    "def converte(horario):\n",
    "    h = horario.split(':')\n",
    "    h[0] = int(h[0])\n",
    "    \n",
    "    if h[0] >= 22 and h[0] < 24:\n",
    "        h[0] = h[0] - 12\n",
    "        h[0] = str(h[0])\n",
    "        h = ':'.join(h)\n",
    "        r =h, 'P.M'\n",
    "    \n",
    "    elif h[0] > 12 and h[0] <= 21:\n",
    "        h[0] = h[0] - 12\n",
    "        h[0] = str(h[0])\n",
    "        h = ':'.join(h)\n",
    "        r ='0'+h, 'P.M'\n",
    "    \n",
    "    elif h[0] == 12:\n",
    "        h[0] = str(h[0])\n",
    "        h = ':'.join(h)\n",
    "        r =h, 'P.M'\n",
    "        \n",
    "    elif 10 > h[0] >= 1:\n",
    "        h[0] = str(h[0])\n",
    "        h = ':'.join(h)\n",
    "        r ='0'+h, 'A.M'\n",
    "        \n",
    "    elif 10 <= h[0] < 12:\n",
    "        h[0] = str(h[0])\n",
    "        h = ':'.join(h)\n",
    "        r =h, 'A.M'\n",
    "        \n",
    "    elif h[0] == 0:\n",
    "        h[0] = 12\n",
    "        h[0] = str(h[0])\n",
    "        h = ':'.join(h)\n",
    "        r =h, 'A.M'  \n",
    "    return r  \n",
    "        \n",
    "\n",
    "while True:\n",
    "    horario = input()\n",
    "    if horario=='-1':\n",
    "        break\n",
    "    else:\n",
    "        print(*converte(horario))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4ee3dc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 2\n",
    "\"\"\" Esboço do código \"\"\"\n",
    "def estacao_do_ano(data):\n",
    "    meses = {\"janeiro\": \"01\", \"fevereiro\": \"02\",\n",
    "           \"março\": \"03\", \"abril\": \"04\",\n",
    "           \"maio\": \"05\", \"junho\": \"06\",\n",
    "           \"julho\": \"07\", \"agosto\": \"08\",\n",
    "           \"setembro\": \"09\", \"outubro\": \"10\",\n",
    "           \"novembro\": \"11\", \"dezembro\": \"12\"\n",
    "           }\n",
    "    estacao = {\"Primavera\": [\"09\", \"10\", \"11\", \"12\"],\n",
    "               \"Verão\": [\"12\", \"01\", \"02\", \"03\"],\n",
    "               \"Outono\": [\"03\", \"04\", \"05\", \"06\"],\n",
    "               \"Inverno\": [\"06\", \"07\", \"08\", \"09\"]\n",
    "               }\n",
    "    data = data.split('/' if len(data) == 5 else ' ')\n",
    "    if len(data) > 2:\n",
    "        data[2] = meses[data[2]]\n",
    "        data.pop(1)\n",
    "        for est,mes in estacao.items():\n",
    "            for i in range(4):\n",
    "                aux = []\n",
    "                if data[1] == mes[i] and data[1] not in mes[-1]:\n",
    "                    r = est\n",
    "                elif data[1] == mes[i] and data[1] == mes[-1]:\n",
    "                    j = int(data[0])\n",
    "                    if 31 >= j >= 21:\n",
    "                        r = est\n",
    "                    elif 20 >= j >= 0:\n",
    "                        r = [est+1]\n",
    "    if len(data) == 2:\n",
    "        for est,mes in estacao.items():\n",
    "            for i in range(4):\n",
    "                if data[1] == mes[i] and data[1] not in mes[-1]:\n",
    "                    r = est\n",
    "                elif data[1] == mes[i] and data[1] == mes[-1]:\n",
    "                    j = int(data[0])\n",
    "                    if 31 >= j >= 21:\n",
    "                        r = est\n",
    "                    elif 20 >= j >= 0:\n",
    "                        r = [est+1]\n",
    "        \n",
    "    return r\n",
    "while True:\n",
    "    data = input()\n",
    "    if data=='-1':\n",
    "        break\n",
    "    else:                \n",
    "        print(estacao_do_ano(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5590c86",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "912d9f9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09289cbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1d500db",
   "metadata": {},
   "source": [
    "# Arquivos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b08fbc58",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67f1f158",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11e094ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercício 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "065ea6c8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6beac200",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57fd84c3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}