Macmulti/exercicios_com_vetores.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercícios com Vetores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 1\n",
    "Dada uma sequência de $n$ números, imprimi-la na ordem inversa à da leitura."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    l = []\n",
    "    \n",
    "    for i in range(n):\n",
    "        num = float(input(f'Digite o {i+1}º número: '))\n",
    "        l.append(num)\n",
    "    \n",
    "    for i in range(1, len(l) + 1):\n",
    "        print(f'{l[-i]} ', end='')\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 2\n",
    "Deseja-se publicar o número de acertos de cada aluno em uma prova em forma de testes. A prova consta de $30$ questões, cada uma com cinco alternativas identificadas por $A, B, C, D$ e $E$. Para isso são dados:\n",
    "* O cartão gabarito;\n",
    "* O número de alunos da turma;\n",
    "* O cartão de respostas para cada aluno, contendo o seu número e suas respostas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n_alunos = int(input('Digite o número de alunos: '))\n",
    "    gabarito = []\n",
    "    notas = []\n",
    "    \n",
    "    for i in range(1, 31):\n",
    "        x = input(f'Digite o gabarito da {i}ª questão: ')\n",
    "        gabarito.append(x)\n",
    "        \n",
    "    for n in range(n_alunos):\n",
    "        acertos = 0\n",
    "        prova_aluno = []\n",
    "        for i in range(0, 30):\n",
    "            x = input(f'Digite a {i+1}ª resposta do aluno {n +1}: ')\n",
    "            prova_aluno.append(x)\n",
    "            \n",
    "            if prova_aluno[i].lower() == gabarito[i].lower():\n",
    "                acertos += 1\n",
    "        \n",
    "        notas.append(acertos)\n",
    "        \n",
    "    for i in range(len(notas)):\n",
    "        print(f'Aluno: {i+1} / Nota: {notas[i]}/30')\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 3\n",
    "Tentando descobrir se um dado era viciado, um dono de cassino honesto (ha! ha! ha! ha!) o lançou %n% vezes. Dados os $n$ resultados dos lançamentos, determinar o número de ocorrências de cada face.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    import random\n",
    "    \n",
    "    n = int(input('Quantas vezes deseja lançar o dado? '))\n",
    "    lista_dado = [0, 0, 0, 0, 0, 0]\n",
    "    \n",
    "    for i in range(n):\n",
    "        x = random.randint(1, 6)\n",
    "        \n",
    "        if x == 1:\n",
    "            lista_dado[0] += 1\n",
    "        elif x == 2:\n",
    "            lista_dado[1] += 1\n",
    "        elif x == 3:\n",
    "            lista_dado[2] += 1\n",
    "        elif x == 4:\n",
    "            lista_dado[3] += 1\n",
    "        elif x == 5:\n",
    "            lista_dado[4] += 1\n",
    "        elif x == 6:\n",
    "            lista_dado[5] += 1\n",
    "    \n",
    "    for i in range(len(lista_dado)):\n",
    "        print(f'Face {i+1}: {lista_dado[i]} vezes')\n",
    "        \n",
    "        \n",
    "main()        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 4\n",
    "Dados dois vetores $x$ e $y$, ambos com $n$ elementos, determinar o produto escalar desses vetores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    d = int(input('Digite a dimensão dos vetores: '))\n",
    "    x = []\n",
    "    y = []\n",
    "    prod = 0\n",
    "    \n",
    "    for i in range(d):\n",
    "        v = float(input(f'Digite o {i+1}º elemento do vetor x: '))\n",
    "        x.append(v)\n",
    "    \n",
    "    for i in range(d):\n",
    "        v = float(input(f'Digite o {i+1}º elemento do vetor y: '))\n",
    "        y.append(v)\n",
    "    \n",
    "    for i in range(d):\n",
    "        prod += (x[i]*y[i])\n",
    "    \n",
    "    print(f'O produto vetorial de x e y é {prod}')\n",
    "    \n",
    "main()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 5\n",
    "Faça um programa para resolver o seguinte problema:\n",
    "São dadas as coordenadas reais $x$ e $y$ de um ponto, um número natural $n$, e as coordenadas reais de $n$ pontos $(1 < n < 100)$. Deseja-se calcular e imprimir sem repetição os raios das circunferências centradas no ponto $(x,y)$ que passam por pelo menos um dos $n$ pontos dados.\n",
    "\n",
    "* Exemplo : $(x,y) = (1.0, 1.0)$ ; $n = 5$\n",
    "* Pontos : $(-1.0, 1.2)$ , $(1.5, 2.0)$ , $(0.0, -2.0)$ , $(0.0, 0.5)$ , $(4.0, 2.0)$\n",
    "  * Nesse caso há três circunferências de raios: $1.12$, $2.01$ e $3.162$.\n",
    "* Observações:\n",
    "  * Distância entre os pontos $(a,b)$ e $(c,d)$ é $\\sqrt{(a-c)^2 + (b-d)^2}$ \n",
    "  * Dois pontos estão na mesma circunferência se estão à mesma distância do centro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    from math import sqrt\n",
    "    \n",
    "    x_c = float(input('x do centro: '))\n",
    "    y_c = float(input('y do centro: '))\n",
    "    n = int(input('Digite a quantidade de pontos (1 < n < 100): '))\n",
    "    \n",
    "    num_circle = 0\n",
    "    x_n = []\n",
    "    y_n = []\n",
    "    \n",
    "    for i in range(n):\n",
    "        x_n.append(float(input(f'Cordenada x do ponto {i+1}: ')))\n",
    "        y_n.append(float(input(f'Cordenada y do ponto {i+1}: ')))\n",
    "    \n",
    "    for i in range(n):\n",
    "        flag = False\n",
    "        dist_i = sqrt((x_c - x_n[i])**2 + (y_c - y_n[i])**2)\n",
    "        for j in range(i):\n",
    "            dist_j = sqrt((x_c - x_n[j])**2 + (y_c - y_n[j])**2)\n",
    "            \n",
    "            if dist_i == dist_j:\n",
    "                flag = True\n",
    "                break\n",
    "        if Flag == False:\n",
    "            print(dist_i)\n",
    "            \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 6\n",
    "*(COMP 89)* Dados dois strings (um contendo uma frase e outro contendo uma palavra), determine o número de vezes que a palavra ocorre na frase.\n",
    "\n",
    "* Exemplo:\n",
    "\n",
    "Para a palavra **ANA** e a frase :\n",
    "\n",
    "**ANA** E MARI**ANA** GOSTAM DE B**ANANA**\n",
    "\n",
    "Temos que a palavra ocorre $4$ vezes na frase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    frase = input('Insira uma frase: ')\n",
    "    palavra = input('Insira uma palara para achar na frase: ')\n",
    "    \n",
    "    cont = 0\n",
    "    \n",
    "    for i in range(len(frase)):\n",
    "        if palavra.lower() == frase[i:len(palavra) + i]:\n",
    "            cont += 1\n",
    "            \n",
    "    print(f'Quantidade de vezes que a palavra {palavra} apareceu na frase: {cont}')\n",
    "            \n",
    "        \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 7\n",
    "*(MAT 88)* Dada uma seqüência de $n$ números reais, determinar os números que compõem a seqüência e o número de vezes que cada um deles ocorre na mesma.\n",
    "\n",
    "* Exemplo: $n = 8$\n",
    "\n",
    "Seqüência: $-1.7$,  $3.0$,  $0.0$,  $1.5$,  $0.0$, $-1.7$,  $2.3$, $-1,7$\n",
    "\n",
    "* Saída:           \n",
    "  * $-1.7$ ocorre $3$ vezes\n",
    "  * $3.0$ ocorre $1$ vez\n",
    "  * $0.0$ ocorre $2$ vezes\n",
    "  * $1.5$ ocorre $1$ vez\n",
    "  * $2.3$ ocorre $1$ vez\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    seq = []\n",
    "    appear = []\n",
    "    \n",
    "    for i in range(n):\n",
    "        x = float(input(f'{i+1}º: '))\n",
    "        seq.append(x)\n",
    "        \n",
    "    for i in range(len(seq)):\n",
    "        cont = 0\n",
    "        if seq[i] not in appear:\n",
    "            for j in range(len(seq)):\n",
    "            \n",
    "                if seq[i] == seq[j]:\n",
    "                    cont +=1\n",
    "            appear.append(seq[i])\n",
    "            \n",
    "            if cont == 1:\n",
    "                print(f'{seq[i]} ocorre {cont} vez')\n",
    "            else:\n",
    "                print(f'{seq[i]} ocorre {cont} vezes')\n",
    "        \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 8\n",
    " Dados dois números naturais $m$ e $n$ e duas sequências ordenadas com $m$ e $n$ números inteiros, obter uma única seqüência ordenada contendo todos os elementos das seqüências originais sem repetição.\n",
    "\n",
    "Sugestão: Imagine uma situação real, por exemplo, dois fichários de uma biblioteca."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    m = int(input('m: '))\n",
    "    n = int(input('n: '))\n",
    "    list_m = []\n",
    "    list_n = []\n",
    "    listao = [] \n",
    "    listao_sorted = []\n",
    "    \n",
    "    for i in range(m):\n",
    "        x = int(input(f'Digite o {i+1}º elemento da lista m: '))\n",
    "        list_m.append(x)\n",
    "        listao.append(x)\n",
    "    \n",
    "    for i in range(n):\n",
    "        y = int(input(f'Digite o {i+1}º elemento da lista n: '))\n",
    "        list_n.append(y)\n",
    "        listao.append(y)\n",
    "    \n",
    "    for i in range(len(listao)):\n",
    "        for index, valor in enumerate(listao_sorted):\n",
    "            if listao[i] < valor:\n",
    "                listao_sorted.insert(index, listao[i])\n",
    "                break\n",
    "        else:\n",
    "            listao_sorted.append(listao[i])\n",
    "    \n",
    "    print(f'Lista M: {list_m}')\n",
    "    print(f'Lista N: {list_n}')\n",
    "    print(f'Lista com todos os elementos ordenados: {listao_sorted}')\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 9\n",
    "Dadas duas seqüências com $n$ números inteiros entre $0$ e $9$, interpretadas como dois números inteiros de $n$ algarismos, calcular a seqüência de números que representa a soma dos dois inteiros.\n",
    "\n",
    "* Exemplo: $n = 8$,\n",
    "  * 1ª  seqüência:\t $     8    2    4    3    4    2    5    1$\n",
    "  * 2ª  seqüência:\t $     3    3    7    5    2    3    3    7$\n",
    "  * Soma: \t$1    1    6    1    8    6    5    8    8$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    seq_1 = []\n",
    "    seq_2 = []\n",
    "    soma = []\n",
    "\n",
    "    \n",
    "    for i in range(n):\n",
    "        x = int(input(f'Digite o {i+1}º termo da sequência 1: '))\n",
    "        seq_1.append(x)\n",
    "        \n",
    "    for i in range(n):\n",
    "        y = int(input(f'Digite o {i+1}º termo da sequência 2: '))\n",
    "        seq_2.append(y)\n",
    "\n",
    "    for i in range(1, n+1):\n",
    "        soma_t = str(seq_1[-i] + seq_2[-i])\n",
    "        \n",
    "        if int(soma_t) >= 10:\n",
    "            result = soma_t[-1]\n",
    "            if i != n:\n",
    "                seq_1[-i-1] += int(soma_t[0])\n",
    "                soma.append(result)\n",
    "            else:\n",
    "                soma.append(soma_t)\n",
    "        else:\n",
    "            soma.append(soma_t)\n",
    "    \n",
    "    for i in range(1, len(soma)+1):\n",
    "        print(soma[-i], end='')\n",
    "        \n",
    "        \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 10\n",
    "Calcule o valor do polinômio   $p(x) = a_{0} + a_{1}x + ... + a_{n}x^n$ em $k$ pontos distintos. São dados os valores de $n$ (grau do polinômio), de $ a_{0} + a_{1} + ... + a_{n}$ (coeficientes reais do polinômio), de $k$ e dos pontos $ x_{1} + x_{2} + ... + x_{k}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('Digite o grau do polinômio: '))\n",
    "    coef = []\n",
    "    ponto = []\n",
    "    \n",
    "    print('p(x) = a0', end='')\n",
    "    \n",
    "    for i in range(1, n+1):\n",
    "        print(f' + a{i}*x^{i}', end='')\n",
    "        \n",
    "    for i in range(n+1):\n",
    "        x = float(input(f'\\nDigite o valor do coeficiente a{i}: '))\n",
    "        coef.append(x)\n",
    "    \n",
    "    print(f'\\np(x) = {coef[0]}', end = '')\n",
    "    for i in range(1, len(coef)):\n",
    "        print(f' + {coef[i]}*x^{i}', end='')\n",
    "        \n",
    "    \n",
    "    k = int(input('\\nQuantos pontos deseja verificar o valor? '))\n",
    "    \n",
    "    if k >= 0:\n",
    "        for i in range(k):\n",
    "            x = float(input(f'x{i+1}: '))\n",
    "            ponto.append(x)\n",
    "        \n",
    "        for i in range(len(ponto)):\n",
    "            soma = coef[0]\n",
    "            for j in range(1,len(coef)):\n",
    "                soma += ponto[i]*coef[j]\n",
    "            \n",
    "            print(f'p({ponto[i]}) = {soma}')\n",
    "        \n",
    "    else:\n",
    "        print('Bye Bye')\n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 11\n",
    "Dado o polinômio $p(x) = a_{0} + a_{1}x + ... + a_{n}x^n$, isto é, os valores de $n$ e de $ a_{0} + a_{1} + ... + a_{n}$, determine os coeficientes reais da primeira derivada de $p(x)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('Digite o grau do polinômio: '))\n",
    "    coef = []\n",
    "    \n",
    "    print('p(x) = a0', end='')\n",
    "    \n",
    "    for i in range(1, n+1):\n",
    "        print(f' + a{i}*x^{i}', end='')\n",
    "        \n",
    "    for i in range(n+1):\n",
    "        x = float(input(f'\\nDigite o valor do coeficiente a{i}: '))\n",
    "        coef.append(x)\n",
    "    \n",
    "    print(f'\\np(x) = {coef[0]}', end = '')\n",
    "    for i in range(1, len(coef)):\n",
    "        print(f' + {coef[i]}*x^{i}', end='')\n",
    "    \n",
    "    print(f\"\\np'(x) = \", end='')\n",
    "    for i in range(1, n+1):\n",
    "        coef_d = coef[i]*i\n",
    "        exp = i-1\n",
    "        \n",
    "        result = f'+ {coef_d}*x^{exp}'\n",
    "        \n",
    "        if i == 1 or coef[i-1]*(i-1) == 0:\n",
    "            result = result[2:]\n",
    "        \n",
    "        if coef_d != 0:\n",
    "            if exp !=0:\n",
    "                if exp == 1:\n",
    "                    print(result[:-2], end= '')\n",
    "                else:\n",
    "                    print(result, end = '')\n",
    "            else:\n",
    "                print(f'{coef_d}', end = '')\n",
    "      \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 12\n",
    "Dado um polinômio $p(x) = a_{0} + a_{1}x + ... + a_{n}x^n$, calcular o polinômio $q(x)$ tal que $p(x) = (x-\\alpha )q(x) + p(\\alpha)$, para $m$ valores distintos de $\\alpha$ (Usar o método de Briot-Ruffini)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 13\n",
    "Dados dois polinômios reais $p(x) = a_{0} + a_{1}x + ... + a_{n}x^n$ e $q(x) = b_{0} + b_{1}x + ... + b_{m}x^m$ determinar o produto desses polinômios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('Digite o grau dos polinômios P: '))\n",
    "    coef_p = []\n",
    "    \n",
    "    print('p(x) = a0', end='')\n",
    "    \n",
    "    for i in range(1, n+1):\n",
    "        print(f' + a{i}*x^{i}', end='')\n",
    "        \n",
    "    for i in range(n+1):\n",
    "        x = float(input(f'\\nDigite o valor do coeficiente a{i}: '))\n",
    "        coef_p.append(x)\n",
    "    \n",
    "    m = int(input('\\nDigite o grau do polinômio Q: '))\n",
    "    coef_q = []\n",
    "        \n",
    "    print('q(x) = b0', end='')\n",
    "    \n",
    "    for i in range(1, m+1):\n",
    "        print(f' + b{i}*x^{i}', end='')\n",
    "        \n",
    "    for i in range(m+1):\n",
    "        x = float(input(f'\\nDigite o valor do coeficiente b{i}: '))\n",
    "        coef_q.append(x)\n",
    "    \n",
    "    coef_pq = [0]*(len(coef_p) + len(coef_q) - 1)\n",
    "    \n",
    "    for i in range(len(coef_p)):\n",
    "        for j in range(len(coef_q)):\n",
    "            coef_pq[i+j] += coef_p[i]*coef_q[j]\n",
    "    \n",
    "    print('p(x)*q(x) =', end='')\n",
    "    for i in range(len(coef_pq)):\n",
    "        \n",
    "        if i == 0:\n",
    "            print(f' {coef_pq[i]}', end='')\n",
    "        else:\n",
    "            print(f' + {coef_pq[i]}*x^{i}', end='') \n",
    "            \n",
    "                \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 14 \n",
    " *(POLI 82)* Chama-se sequência de Farey relativa a $n$, a sequência das frações racionais irredutíveis, dispostas em ordem crescente, com denominadores positivos e não maiores que $n$.\n",
    "\n",
    "Exemplo:  Se $n=5$, os termos $\\alpha$ da sequência de Farey, tais que $0 \\leq \\alpha \\leq 1$ são:\n",
    "\n",
    "![foto_1](https://www.ime.usp.br/~macmulti/figuras/Image515a.gif)\n",
    "\n",
    "Para gerarmos os termos $\\alpha$ de uma seqüência de Farey tais que $0 \\leq \\alpha \\leq 1$ , podemos usar o seguinte processo. Começamos com as frações\n",
    "\n",
    "![foto_1](https://www.ime.usp.br/~macmulti/figuras/Image515b.gif)\n",
    "\n",
    "e entre cada duas frações consecutivas\n",
    "\n",
    "![foto_3](https://www.ime.usp.br/~macmulti/figuras/Image515c.gif)\n",
    "\n",
    "introduzimos a fração:\n",
    "\n",
    "![foto_4](https://www.ime.usp.br/~macmulti/figuras/Image515d.gif)\n",
    "\n",
    "e assim sucessivamente enquanto $j + m \\leq  n$. Quando não for mais possível introduzir novas frações teremos gerado todos os termos $\\alpha$ da sequência de Farey relativa a $n$, tais que $0 \\leq \\alpha \\leq 1$.\n",
    "\n",
    "Usando o processo descrito, determine os termos $\\alpha$, $0 \\leq \\alpha \\leq 1$ , da sequência de Farey relativa a $n$, $n$ inteiro positivo.\n",
    "\n",
    "Sugestão: Gere os numeradores e os denominadores em dois vetores.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('Digite um valor para n: '))\n",
    "    num = [0]\n",
    "    den = [1]\n",
    "    \n",
    "    i, j, c, d = 0, 1, 1, n\n",
    "    \n",
    "    while (c < n):\n",
    "        k = int((n + j)/d)\n",
    "        i, j, c, d = c, d, k*c - i, k*d - j\n",
    "        \n",
    "        num.append(i)\n",
    "        den.append(j)    \n",
    "    \n",
    "    # print bonitinho\n",
    "    for i in range(len(num)):\n",
    "        print(f\"{num[i]}/{den[i]}\", end=\"\")\n",
    "        \n",
    "        if i != len(num) - 1:\n",
    "            print(end=\", \")\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 15\n",
    "Em uma classe há $n$ alunos, cada um dos quais realizou $k$ provas com pesos distintos. Dados $n$ , $k$, os pesos das $k$ provas e as notas de cada aluno, calcular a média ponderada das provas para cada aluno e a média aritmética da classe em cada uma das provas.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('Digite o número de alunos: '))\n",
    "    k = int(input('Digite o número de provas: '))\n",
    "    pesos = [ float(input(f'Digite o peso da prova {i+1}: ')) for i in range(k)]  # list comprehensions\n",
    "    medias = []\n",
    "    soma_pesos = 0\n",
    "    soma_medias = 0\n",
    "    \n",
    "    for i in range(len(pesos)):\n",
    "        soma_pesos += pesos[i]\n",
    "        \n",
    "    for i in range(n):\n",
    "        notas = []\n",
    "        soma_notas = 0\n",
    "        for j in range (k):\n",
    "            x = float(input(f'Insira a nota da {j+1}ª prova do {i+1}º aluno: '))\n",
    "            notas.append(x)\n",
    "    \n",
    "            soma_notas += notas[j]*pesos[j]\n",
    "            \n",
    "        medias.append(soma_notas/soma_pesos)\n",
    "    \n",
    "    for i in range(n):\n",
    "        print(f'Média do aluno {i+1}: {medias[i]}')\n",
    "        soma_medias += medias[i]    \n",
    "            \n",
    "    print(f'Média da turma: {soma_medias/n}')\n",
    "    \n",
    "    \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 16\n",
    "*(QUIM 84)* Dada uma seqüência $x_{1},x_{2},...,x_{k}$ de números inteiros, verifique se existem dois segmentos consecutivos iguais nesta seqüência, isto é, se existem $i$ e $m$ tais que:\n",
    "\n",
    "<center>$x_{i},x_{i+1},...,x_{i+m-1} = x_{i+m},x_{i+m+1},...,x_{i+2m-1}$</center>\n",
    "\n",
    "Imprima, caso existam, os valores de $i$ e $m$.\n",
    "\n",
    "Exemplo: Na seqüência  $7, 9, $ **5, 4, 5, 4** $, 8, 6$ existem $i=3$ e $m=2$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('Digite o comprimento da sequencia: '))\n",
    "    \n",
    "    seq = []\n",
    "    for i in range(1, 1+n):\n",
    "        e = input(f'Digite o {i}º elemento da sequencia: ')\n",
    "        seq.append(e)\n",
    "\n",
    "    achou = False\n",
    "    \n",
    "    m = 1\n",
    "    while not achou and m <= n//2:\n",
    "        \n",
    "        i = 0\n",
    "        while not achou and i <= n-2*m:\n",
    "            achou = True\n",
    "            \n",
    "            j = 0\n",
    "            while achou and j < m:\n",
    "                if seq[i+j] != seq[i+m+j]:\n",
    "                    achou = False\n",
    "                j += 1\n",
    "            \n",
    "            i += 1\n",
    "    \n",
    "        m += 1\n",
    "    \n",
    "    if achou:\n",
    "        print(f'i = {i}, m = {m-1}')\n",
    "    else:\n",
    "        print('Nao encontrei nada :(')\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercício 17\n",
    "Dada uma seqüência de $n$ números inteiros, determinar um segmento de soma máxima.\n",
    "\n",
    "Exemplo: Na seqüência $5, 2, -2, -7, 3, 14, 10, -3, 9, -6, 4, 1$ , a soma do segmento é $33$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    n = int(input('n: '))\n",
    "    seq = [int(input(f'Digite o {i+1}º elemento da sequência: ')) for i in range(n)]  # list comprehensions\n",
    "    soma_max = 0\n",
    "    \n",
    "    for i in range(n):\n",
    "        for j in range(i+1, n):\n",
    "            soma = 0\n",
    "            for num in seq[i:j+1]:\n",
    "                soma += num\n",
    "            \n",
    "            if soma > soma_max:\n",
    "                soma_max = soma\n",
    "        \n",
    "    print(soma_max)\n",
    "    \n",
    "    \n",
    "main()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "e7917003da1206007e0daef75b3cd908a43805c260e725ad79714b0c4db582a2"
  },
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}