PASSO_08_VETORES.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "ddFQ6Zv0Jknr",
        "gQOxpOHnJrS7",
        "IC57wZgIKfia",
        "La2rABLKLCQ6",
        "YMexNlfKLLg1",
        "I6HxhumuLWlq",
        "2h4zYAeFLjBb",
        "zJ7AIY7vLteg",
        "DNlf72rFLvh4",
        "hJP7jgbZL7ny",
        "zKzrZqBjMDEQ",
        "HuT2AFMvMM9U",
        "s_cnmuS6Melo",
        "bBIPTHgGQ_zx",
        "drh-3Lx3RUhM",
        "FsHkxXYBRY-M"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# PASSO 08 – VETORES/LISTAS\n",
        "\n",
        "Estrutura de dados.\n",
        "- Listas (`list`): Estruturas para armazenar e manipular coleções de dados.\n",
        "- Vetores [`vet`] : Sequência de dados ocupando posições consecutivas de memória em uma ordem.\n",
        "- Métodos como `append()`, `sort()`, `index()`, etc.\n",
        "- Funções como `len()` para tamanho e `sum()` para soma.\n",
        "  - `list()`: Cria uma lista (vetor).\n",
        "  - `sum()`: Calcula a soma dos elementos de uma lista.\n",
        "  - `len()`: Retorna o tamanho de uma lista.\n",
        "  - `append()`: Adiciona um elemento a lista.\n",
        "  - `enumerate()`: Contador automático ao iterar sobre uma lista.\n",
        "\n",
        "**Exemplo:**\n",
        "```python\n",
        "notas = [7.5, 8.0, 6.5, 9.0]\n",
        "soma = sum(notas)\n",
        "media = soma / len(notas)\n",
        "print(f\"A média das notas é {media}\")\n",
        "```"
      ],
      "metadata": {
        "id": "ddFQ6Zv0Jknr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###71)\n",
        "Faça um programa que preencha automaticamente um vetor numérico com 8\n",
        "posições, conforme abaixo:\n",
        "\n",
        "999| 999| 999| 999| 999| 999| 999| 999\n",
        "\n"
      ],
      "metadata": {
        "id": "gQOxpOHnJrS7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vetor = [999] * 8\n",
        "\n",
        "print(vetor)\n"
      ],
      "metadata": {
        "id": "b_yylEUBKNEo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###72)\n",
        "Crie um programa que preencha automaticamente (usando lógica, não apenas\n",
        "atribuindo diretamente) um vetor numérico com 10 posições, conforme abaixo:\n",
        "\n",
        "5 | 10 | 15 | 20 | 25 | 30 | 35 | 40 | 45 | 50\n"
      ],
      "metadata": {
        "id": "IC57wZgIKfia"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vetor = []\n",
        "\n",
        "for i in range(1, 11):\n",
        "    vetor.append(i * 5)\n",
        "\n",
        "print(' | '.join(map(str, vetor)))  # Converte cada elemento da lista vetor em uma string e junta todos os elementos com o separador |."
      ],
      "metadata": {
        "id": "7LjGMrgtK8Yc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###73)\n",
        "Crie um programa que preencha automaticamente (usando lógica, não apenas\n",
        "atribuindo diretamente) um vetor numérico com 10 posições, conforme abaixo:\n",
        "\n",
        "9| 8| 7| 6| 5| 4| 3| 2| 1| 0|\n"
      ],
      "metadata": {
        "id": "La2rABLKLCQ6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vetor = []\n",
        "\n",
        "for i in range(9, -1, -1):\n",
        "    vetor.append(i)\n",
        "\n",
        "print(' | '.join(map(str, vetor)))\n"
      ],
      "metadata": {
        "id": "LdAR1w2kLH5F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###74)\n",
        "Crie um programa que preencha automaticamente (usando lógica, não apenas\n",
        "atribuindo diretamente) um vetor numérico com 10 posições, conforme abaixo:\n",
        "\n",
        "5 | 3 | 5 | 3 | 5 | 3 | 5 | 3 | 5 | 3 |\n",
        "\n"
      ],
      "metadata": {
        "id": "YMexNlfKLLg1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vetor = []\n",
        "\n",
        "for i in range(10):\n",
        "    if i % 2 == 0:\n",
        "        vetor.append(5)\n",
        "    else:\n",
        "        vetor.append(3)\n",
        "\n",
        "print(' | '.join(map(str, vetor)))\n"
      ],
      "metadata": {
        "id": "AH6neBYsLR2e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###75)\n",
        "Crie um programa que preencha automaticamente (usando lógica, não apenas\n",
        "atribuindo diretamente) um vetor numérico com 16 posições com os primeiros\n",
        "elementos da sequência de Fibonacci:\n",
        "\n",
        "1 | 1 | 2 | 3 | 5 | 8 | 13 | 21 | 34 | 55 | 89 | 144 | 233 | 377 | 610 | 987\n"
      ],
      "metadata": {
        "id": "I6HxhumuLWlq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vetor_fibonacci = []\n",
        "\n",
        "vetor_fibonacci.append(1)\n",
        "vetor_fibonacci.append(1)\n",
        "\n",
        "for i in range(2, 16):\n",
        "    proximo_elemento = vetor_fibonacci[i-1] + vetor_fibonacci[i-2]\n",
        "    vetor_fibonacci.append(proximo_elemento)\n",
        "\n",
        "print(' | '.join(map(str, vetor_fibonacci)))\n"
      ],
      "metadata": {
        "id": "KFwIx4DrLerV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###76)\n",
        "Crie um programa que preencha automaticamente um vetor numérico com 7\n",
        "números gerados aleatoriamente pelo computador e depois mostre os valores\n",
        "gerados na tela."
      ],
      "metadata": {
        "id": "2h4zYAeFLjBb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "vetor = []\n",
        "\n",
        "for _ in range(7):\n",
        "    numero_aleatorio = random.randint(0, 100)  # Gera um número aleatório entre 0 e 100\n",
        "    vetor.append(numero_aleatorio)\n",
        "\n",
        "print(vetor)\n"
      ],
      "metadata": {
        "id": "VXYIy6twLlFT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###77)\n",
        "Faça um programa que leia 7 nomes de pessoas e guarde-os em um vetor. No\n",
        "final, mostre uma listagem com todos os nomes informados, na ordem inversa\n",
        "daquela em que eles foram informados."
      ],
      "metadata": {
        "id": "zJ7AIY7vLteg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vet = [input(\"Nome: \") for _ in range(7)] # Lê 7 nomes e os armazena em um vetor\n",
        "\n",
        "print()\n",
        "print(vet[::-1]) # Exibe os nomes na ordem inversa\n"
      ],
      "metadata": {
        "id": "pKY0VMSHLsiE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###78)\n",
        "Escreva um programa que leia 15 números e guarde-os em um vetor. No final,\n",
        "mostre o vetor inteiro na tela e em seguida mostre em que posições foram\n",
        "digitados valores que são múltiplos de 10."
      ],
      "metadata": {
        "id": "DNlf72rFLvh4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vet = [int(input(\"Número: \")) for _ in range(15)]  # Cria uma lista 'vet' com 15 números inteiros digitados\n",
        "\n",
        "print()\n",
        "print(vet)\n",
        "\n",
        "posicoes_multiplos_de_10 = [i for i, num in enumerate(vet) if num % 10 == 0]  # Cria a lista com posições dos números que são múltiplos de 10 na lista 'vet'\n",
        "print(\"Posições dos múltiplos de 10:\", posicoes_multiplos_de_10)              # Imprime as posições dos múltiplos de 10\n"
      ],
      "metadata": {
        "id": "BHATRwumLz9r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###79)\n",
        "Desenvolva um programa que leia 10 números inteiros e guarde-os em um vetor.\n",
        "No final, mostre quais são os números pares que foram digitados e em que\n",
        "posições eles estão armazenados."
      ],
      "metadata": {
        "id": "hJP7jgbZL7ny"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Tuplas - lista imutavel - permitem armazenar múltiplos elementos em uma única variável\n",
        "\n",
        "vet = [int(input(\"Número: \")) for _ in range(10)]\n",
        "\n",
        "print(vet)\n",
        "\n",
        "pares = [(num, i) for i, num in enumerate(vet) if num % 2 == 0]  # Cria uma lista de tuplas (num, i) onde num é um número par da lista 'vet' e i é o índice desse número\n",
        "for num, i in pares:                                             # Itera sobre cada tupla (num, i) na lista 'pares'\n",
        "    print(f'Número: {num} Posição: {i}', end=' | ')              # Imprime o número e sua posição, separados por ' | '\n"
      ],
      "metadata": {
        "id": "tbzOeuWaL8-P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###80)\n",
        "Faça um algoritmo que preencha um vetor de 30 posições com números entre 1 e\n",
        "15 sorteados pelo computador. Depois disso, peça para o usuário digitar um\n",
        "número (chave) e seu programa deve mostrar em que posições essa chave foi\n",
        "encontrada. Mostre também quantas vezes a chave foi sorteada."
      ],
      "metadata": {
        "id": "zKzrZqBjMDEQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "vet = [random.randint(1, 15) for _ in range(30)]\n",
        "\n",
        "print(vet)\n",
        "print()\n",
        "chave = int(input('Número de 1 a 15: '))\n",
        "\n",
        "# Encontra as posições da chave e conta quantas vezes ela aparece\n",
        "posicoes = [i for i, num in enumerate(vet) if num == chave] # Cria uma lista com as posições (índices) onde o número na lista 'vet' é igual à 'chave'\n",
        "quantidade = len(posicoes)                                  # Conta quantas vezes a 'chave' aparece na lista 'vet' contando o número de elementos na lista 'posicoes'\n",
        "\n",
        "print(f'Posições: {posicoes}')\n",
        "print(f'Quantidade: {quantidade}')\n"
      ],
      "metadata": {
        "id": "H3UHulf8MEaW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###81)\n",
        "Crie um programa que leia a idade de 8 pessoas e guarde-as em um vetor. No\n",
        "final, mostre:\n",
        "\n",
        "a) Qual é a média de idade das pessoas cadastradas\n",
        "\n",
        "b) Em quais posições temos pessoas com mais de 25 anos\n",
        "\n",
        "c) Qual foi a maior idade digitada (podem haver repetições)\n",
        "\n",
        "d) Em que posições digitamos a maior idade"
      ],
      "metadata": {
        "id": "HuT2AFMvMM9U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vetor = [int(input('Idade: ')) for _ in range(8)]\n",
        "\n",
        "print('Vetor:', vetor, '\\n')\n",
        "\n",
        "# Calcula e exibe a média de idade\n",
        "media = sum(vetor) / len(vetor)            # Divide a soma(sum) do vetor pelo quantidade de itens(len)\n",
        "print('Média:', round(media, 2))\n",
        "\n",
        "# Encontra e exibe as posições das pessoas com mais de 25 anos\n",
        "posicoes_mais_25 = [i for i, idade in enumerate(vetor) if idade > 25]    # Cria uma lista com as posições (í) das idades maiores que 25 na lista 'vetor'\n",
        "print('Posições com idade maior de 25 anos:', posicoes_mais_25)\n",
        "\n",
        "# Encontra e exibe a maior idade\n",
        "maior_idade = max(vetor)\n",
        "print('Maior idade:', maior_idade)\n",
        "\n",
        "# Encontra e exibe as posições da maior idade\n",
        "posicoes_maior_idade = [i +1 for i, idade in enumerate(vetor) if idade == maior_idade] # Cria uma lista com as posições (í) da maior idade na lista 'vetor', ajustando para começar em 1\n",
        "print('Posições da maior idade:', posicoes_maior_idade)\n"
      ],
      "metadata": {
        "id": "PT6WCTUbMYKY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###82)\n",
        "Faça um algoritmo que leia a nota de 10 alunos de uma turma e guarde-as em\n",
        "um vetor. No final, mostre:\n",
        "\n",
        "a) Qual é a média da turma\n",
        "\n",
        "b) Quantos alunos estão acima da média da turma\n",
        "\n",
        "c) Qual foi a maior nota digitada\n",
        "\n",
        "d) Em que posições a maior nota aparece"
      ],
      "metadata": {
        "id": "s_cnmuS6Melo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vetorM = [int(input('Nota: ')) for _ in range(10)]\n",
        "\n",
        "# Calcula e exibe a média da turma\n",
        "mediaN = sum(vetorM) / len(vetorM)\n",
        "print('Média:', round(mediaN, 2))\n",
        "\n",
        "# Conta e exibe quantos alunos estão acima da média\n",
        "alunos_acima_media = sum(1 for nota in vetorM if nota > mediaN)\n",
        "print(f'{alunos_acima_media} alunos acima da média.')\n",
        "\n",
        "# Encontra e exibe a maior nota\n",
        "maiorN = max(vetorM)\n",
        "print('Maior nota:', maiorN)\n",
        "\n",
        "# Encontra e exibe as posições da maior nota\n",
        "posicoes_maior_nota = [i+1 for i, nota in enumerate(vetorM) if nota == maiorN]\n",
        "print('Posições da maior nota:', posicoes_maior_nota)\n"
      ],
      "metadata": {
        "id": "v_UVf16EMuly"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###83)\n",
        "Crie uma lógica que preencha um vetor de 20 posições com números\n",
        "aleatórios (entre 0 e 99) gerados pelo computador. Logo em seguida, mostre os\n",
        "números gerados e depois coloque o vetor em ordem crescente, mostrando no final\n",
        "os valores ordenados."
      ],
      "metadata": {
        "id": "bBIPTHgGQ_zx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "vetDesordenado = [random.randint(0, 99) for _ in range(20)]\n",
        "\n",
        "print(\"Vetor desordenado:\", vetDesordenado)\n",
        "\n",
        "vetOrdenado = sorted(vetDesordenado)\n",
        "print(\"Vetor ordenado:\", vetOrdenado)\n"
      ],
      "metadata": {
        "id": "jxNIwXbYRHs_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###84)\n",
        "Crie um programa que leia o nome e a idade de 9 pessoas e guarde esses\n",
        "valores em dois vetores, em posições relacionadas. No final, mostre uma listagem\n",
        "contendo apenas os dados das pessoas menores de idade."
      ],
      "metadata": {
        "id": "drh-3Lx3RUhM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# A função 'zip' permite combinar duas ou mais sequências (listas, tuplas, etc.) em um objeto zip.\n",
        "# A partir desse objeto zip, é possível criar iteráveis de tuplas contendo elementos correspondentes de cada sequência original\n",
        "vetorNome = []\n",
        "vetorIdade = []\n",
        "\n",
        "for _ in range(9):\n",
        "    nome = input('Nome: ')\n",
        "    idade = int(input('Idade: '))\n",
        "    vetorNome.append(nome)\n",
        "    vetorIdade.append(idade)\n",
        "\n",
        "print('Dados das pessoas menores de idade:')\n",
        "menores_de_idade = [(nome, idade) for nome, idade in zip(vetorNome, vetorIdade) if idade < 18] # zip combinando os dois vetores com idade menor de 18\n",
        "for nome, idade in menores_de_idade:\n",
        "    print(f'{nome} = {idade}', end=' ')\n"
      ],
      "metadata": {
        "id": "Im3DGsjSRZmR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###85)\n",
        "Faça um algoritmo que leia o nome, o sexo e o salário de 5 funcionários e\n",
        "guarde esses dados em três vetores. No final, mostre uma listagem contendo\n",
        "apenas os dados das funcionárias mulheres que ganham mais de R$5 mil"
      ],
      "metadata": {
        "id": "FsHkxXYBRY-M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "vetorNome = []\n",
        "vetorSexo = []\n",
        "vetorSalario = []\n",
        "\n",
        "for _ in range(5):\n",
        "    nome = input('Nome: ')\n",
        "    sexo = input('Sexo (F/M): ').upper()\n",
        "    salario = int(input('Salário: '))\n",
        "\n",
        "    vetorNome.append(nome)\n",
        "    vetorSexo.append(sexo)\n",
        "    vetorSalario.append(salario)\n",
        "\n",
        "print('Funcionárias mulheres com salário acima de R$5 mil:')\n",
        "for nome, sexo, salario in zip(vetorNome, vetorSexo, vetorSalario):\n",
        "    if sexo == 'F' and salario > 5000:\n",
        "        print(f'Nome: {nome}, Salário: R${salario}')\n"
      ],
      "metadata": {
        "id": "uM2LhJd2RfLp"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}