ADS0009_Thiago_Magalhães_Nogueira_ (3)

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
 "colab": {
 "provenance": []
 },
 "kernelspec": {
 "name": "python3",
 "display_name": "Python 3"
 },
 "language_info": {
 "name": "python"
 }
 },
 "cells": [
 {
 "cell_type": "markdown",
 "source": [
 "CURSO:ANALISE E DESENVOLVIMENTO DE SISTEMA \n",
 "Disciplina:Estrutura de Dados\n",
 "\n",
 "Discente: Thiago Magalhães Nogueira\n",
 "\n",
 "Professor: Luís Fabrício de Freitas Souza\n",
 "\n",
 "\n"
 ],
 "metadata": {
 "id": "MTxMAtrdsHDz"
 }
 },
 {
 "cell_type": "markdown",
 "source": [
 "# LISTA DE ATIVIDADE COMPLEMENTAR 1°"
 ],
 "metadata": {
 "id": "IfB2OMXCqgsG"
 }
 },
 {
 "cell_type": "markdown",
 "source": [
 "1. Defina vetor, e em que pode ser aplicado em sistemas de informação?"
 ],
 "metadata": {
 "id": "YBG3iDoTuo1Q"
 }
 },
 {
 "cell_type": "markdown",
 "source": [
 "R: Um vetor é uma estrutura de dados que armazena elementos em uma sequência ordenada, permitindo o acesso a cada elemento por meio de um índice numérico. Em sistemas de informação, vetores são usados para armazenar, manipular e representar dados relacionados, como listas, matrizes, áudio, vídeo, processamento de imagens, geometria computacional, algoritmos de ordenação, entre outras aplicações."
 ],
 "metadata": {
 "id": "y74aAufQusCW"
 }
 },
 {
 "cell_type": "markdown",
 "source": [
 "2. Faça um programa que leia 5 valores inteiros, armazeno-os em um vetor, calcule e apresente\n",
 "a soma destes valores."
 ],
 "metadata": {
 "id": "hcLtl1XCuu32"
 }
 },
 {
 "cell_type": "code",
 "source": [
 "def main():\n",
 " valores = []\n",
 "\n",
 " for i in range(3):\n",
 " valor = int(input(f\"Digite o {i+1}º valor: \"))\n",
 " valores.append(valor)\n",
 " soma = sum(valores)\n",
 " print(f\"A soma dos valores é: {soma}\")\n",
 "\n",
 "if __name__ == \"__main__\":\n",
 " main()"
 ],
 "metadata": {
 "id": "GPlaNQRLuxaH"
 },
 "execution_count": null,
 "outputs": []
 },
 {
 "cell_type": "markdown",
 "source": [
 "3. Altere o programa anterior para calcular e apresentar a média dos valores entrados e\n",
 "aqueles que são maiores e menores que a média."
 ],
 "metadata": {
 "id": "4-wLq10lux2M"
 }
 },
 {
 "cell_type": "code",
 "source": [
 "def main():\n",
 "\n",
 " valores = []\n",
 "\n",
 " for i in range(2):\n",
 " valor = int(input(f\"Digite o {i+1}º valor: \"))\n",
 " valores.append(valor)\n",
 "\n",
 " soma = sum(valores)\n",
 "\n",
 " media = soma / len(valores)\n",
 "\n",
 " maiores = [valor for valor in valores if valor > media]\n",
 " menores = [valor for valor in valores if valor < media]\n",
 "\n",
 " print(f\"A média dos valores é: {media:.2f}\")\n",
 " print(\"Valores maiores que a média:\", maiores)\n",
 " print(\"Valores menores que a média:\", menores)\n",
 "\n",
 "if __name__ == \"__main__\":\n",
 " main()"
 ],
 "metadata": {
 "id": "RQwdmbVtu0z-"
 },
 "execution_count": null,
 "outputs": []
 },
 {
 "cell_type": "markdown",
 "source": [
 "4. Faça um programa que leia 10 valores reais e os apresente na ordem inversa entrada."
 ],
 "metadata": {
 "id": "hQ8aBntyu1Qi"
 }
 },
 {
 "cell_type": "code",
 "source": [
 "def main():\n",
 " valores = []\n",
 "\n",
 " for i in range(10):\n",
 " valor = float(input(f\"Digite o {i+1}º valor real: \"))\n",
 " valores.append(valor)\n",
 "\n",
 " print(\"Valores na ordem inversa:\")\n",
 " for valor in reversed(valores):\n",
 " print(valor)\n",
 "\n",
 "if __name__ == \"__main__\":\n",
 " main()"
 ],
 "metadata": {
 "id": "zRfC9ZHcu5Iu"
 },
 "execution_count": null,
 "outputs": []
 },
 {
 "cell_type": "markdown",
 "source": [
 "5. Faça um programa que leia 10 números inteiros, armazene-os em um vetor, solicite um valor\n",
 "de referência inteiro e:\n",
 "\n",
 "a) imprima os números do vetor que são maiores que o valor referência\n",
 "b) retorne quantos números armazenados no vetor são menores que o valor de referência\n",
 "c) retorne quantas vezes o valor de referência aparece no vetor"
 ],
 "metadata": {
 "id": "zgQY5Wyuu5fI"
 }
 },
 {
 "cell_type": "code",
 "source": [
 "def main():\n",
 "\n",
 " numeros = []\n",
 "\n",
 " for i in range(10):\n",
 " numero = int(input(f\"Digite o {i+1}º número inteiro: \"))\n",
 " numeros.append(numero)\n",
 "\n",
 " valor_referencia = int(input(\"Digite o valor de referência inteiro: \"))\n",
 "\n",
 " print(\"Números maiores que o valor de referência:\")\n",
 " for numero in numeros:\n",
 " if numero > valor_referencia:\n",
 " print(numero)\n",
 "\n",
 " menores_que_referencia = sum(1 for numero in numeros if numero < valor_referencia)\n",
 " print(f\"Quantidade de números menores que o valor de referência: {menores_que_referencia}\")\n",
 "\n",
 " ocorrencias_referencia = numeros.count(valor_referencia)\n",
 " print(f\"Quantidade de vezes que o valor de referência aparece no vetor: {ocorrencias_referencia}\")\n",
 "\n",
 "if __name__ == \"__main__\":\n",
 " main()"
 ],
 "metadata": {
 "id": "ysjxxHIdvOXZ"
 },
 "execution_count": null,
 "outputs": []
 },
 {
 "cell_type": "markdown",
 "source": [
 "6. Dados dois vetores x e y em um espaço de 10 dimensões, determine o produto escalar\n",
 "desses vetores usando um laço."
 ],
 "metadata": {
 "id": "Ykwd-NPvvOpf"
 }
 },
 {
 "cell_type": "code",
 "source": [
 "def calcular_produto_escalar(vetor1, vetor2):\n",
 " produto_escalar = 0\n",
 " for i in range(len(vetor1)):\n",
 " produto_escalar += vetor1[i] * vetor2[i]\n",
 " return produto_escalar\n",
 "\n",
 "def main():\n",
 "\n",
 " vetor_x = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n",
 " vetor_y = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n",
 "\n",
 "\n",
 " produto_escalar = calcular_produto_escalar(vetor_x, vetor_y)\n",
 " print(\"O produto escalar entre os vetores é:\", produto_escalar)\n",
 "\n",
 "if __name__ == \"__main__\":\n",
 " main()"
 ],
 "metadata": {
 "colab": {
 "base_uri": "https://localhost:8080/"
 },
 "id": "mwuVb2kc_vUX",
 "outputId": "1397dba7-33d0-4235-8fd0-5139af9bbfe0"
 },
 "execution_count": 12,
 "outputs": [
 {
 "output_type": "stream",
 "name": "stdout",
 "text": [
 "O produto escalar entre os vetores é: 1430\n"
 ]
 }
 ]
 },
 {
 "cell_type": "markdown",
 "source": [
 "7. O que é, e para que serve uma pilha?"
 ],
 "metadata": {
 "id": "2Q6z2c1P3k1F"
 }
 },
 {
 "cell_type": "markdown",
 "source": [
 "R:Uma pilha é uma estrutura de dados
baseada no princípio \"último a entrar, primeiro a sair\", em que o último elemento adicionado é o primeiro a ser removido.\n",
 " Ela é usada para controlar a ordem de operações ou armazenar temporariamente elementos. As pilhas têm várias aplicações, incluindo a rastreamento de chamadas de funções, desfazer ações, avaliação de expressões matemáticas, busca em profundidade, gerenciamento de histórico de navegação e garantia de sintaxe correta em linguagens de programação."
 ],
 "metadata": {
 "id": "5cjCCO7eHVq9"
 }
 },
 {
 "cell_type": "markdown",
 "source": [
 "8. Em que situações uma pilha pode ser utilizada?"
 ],
 "metadata": {
 "id": "TyNpx15qvUxB"
 }
 },
 {
 "cell_type": "markdown",
 "source": [
 "R: Uma pilha é útil em situações que envolvem a ordem das operações ou armazenamento temporário. Ela é usada para rastrear chamadas de funções, desfazer ações, avaliar expressões matemáticas, realizar busca em profundidade, gerenciar históricos de navegação, validar sintaxe, manipular cartas em jogos, resolver expressões postfixas, alocar memória dinamicamente e processar históricos de comandos."
 ],
 "metadata": {
 "id": "pBxIolfMIjVs"
 }
 },
 {
 "cell_type": "markdown",
 "source": [
 "9. Dado uma pilha que armazene números, escreva uma função para ordenar os valores da\n",
 "pilha em ordem crescente."
 ],
 "metadata": {
 "id": "aNEhWLIyvXyx"
 }
 },
 {
 "cell_type": "code",
 "source": [
 "def sort_stack(stack):\n",
 " aux_stack = []\n",
 "\n",
 " while stack:\n",
 " temp = stack.pop()\n",
 "\n",
 " while aux_stack and aux_stack[-1] > temp:\n",
 " stack.append(aux_stack.pop())\n",
 "\n",
 " aux_stack.append(temp)\n",
 "\n",
 " while aux_stack:\n",
 " stack.append(aux_stack.pop())\n",
 "\n",
 "def main():\n",
 " stack = [34, 3, 31, 98, 92, 23]\n",
 " print(\"Pilha original:\", stack)\n",
 " sort_stack(stack)\n",
 " print(\"Pilha ordenada:\", stack)\n",
 "\n",
 "if __name__ == \"__main__\":\n",
 " main()"
 ],
 "metadata": {
 "id": "RBX3Os5PKGXH"
 },
 "execution_count": null,
 "outputs": []
 },
 {
 "cell_type": "markdown",
 "source": [
 "10. Escreva um programa que acumula n valores da sequência de Fibonacci em uma pilha."
 ],
 "metadata": {
 "id": "JJe4iqm5vfLX"
 }
 },
 {
 "cell_type": "code",
 "source": [
 "class Pilha:\n",
 " def __init__(self):\n",
 " self.pilha = []\n",
 "\n",
 " def empilhar(self, elemento):\n",
 " self.pilha.append(elemento)\n",
 "\n",
 " def desempilhar(self):\n",
 " if self.pilha:\n",
 " return self.pilha.pop()\n",
 " else:\n",
 " print(\"A pilha está vazia!\")\n",
 "\n",
 "def fibonacci(n):\n",
 " pilha = Pilha()\n",
 "\n",
 " a, b = 0, 1\n",
 " for _ in range(n):\n",
 " pilha.empilhar(a)\n",
 " a, b = b, a + b\n",
 "\n",
 " return pilha\n",
 "\n",
 "def main():\n",
 " n = int(input(\"Digite o número de valores da sequência de Fibonacci a acumular: \"))\n",
 " resultado = fibonacci(n)\n",
 "\n",
 " print(\"Valores da sequência de Fibonacci acumulados na pilha:\")\n",
 " while True:\n",
 " valor = resultado.desempilhar()\n",
 " if valor is not None:\n",
 " print(valor)\n",
 " else:\n",
 " break\n",
 "\n",
 "if __name__ == \"__main__\":\n",
 " main()"
 ],
 "metadata": {
 "id": "7Mbl_9_KvgJh"
 },
 "execution_count": null,
 "outputs": []
 },
 {
 "cell_type": "markdown",
 "source": [
 "11. Faça um programa que possa ser inseridos números dentro de uma fila, e que possa\n",
 "retornar os números inteiros na sequência, sendo o primeiro a entrar, será o primeiro a sair. O\n",
 "tamanho da fila deve ser definido pelo usuário."
 ],
 "metadata": {
 "id": "PRwh_sy9KT3q"
 }
 },
 {
 "cell_type": "code",
 "source": [
 "class Fila:\n",
 " def __init__(self):\n",
 " self.fila = []\n",
 "\n",
 " def enfileirar(self, elemento):\n",
 " self.fila.append(elemento)\n",
 "\n",
 " def desenfileirar(self):\n",
 " if self.fila:\n",
 " return self.fila.pop(0)\n",
 " else:\n",
 " print(\"A fila está vazia!\")\n",
 "\n",
 "def main():\n",
 " tamanho_fila = int(input(\"Digite o tamanho da fila: \"))\n",
 " fila = Fila()\n",
 "\n",
 " while True:\n",
 " print(\"\\nOpções:\")\n",
 " print(\"1 - Enfileirar número\")\n",
 " print(\"2 - Desenfileirar número\")\n",
 " print(\"3 - Sair\")\n",
 " opcao = int(input(\"Escolha uma opção: \"))\n",
 "\n",
 " if opcao == 1:\n",
 " numero = int(input(\"Digite um número inteiro para enfileirar: \"))\n",
 " fila.enfileirar(numero)\n",
 " elif opcao == 2:\n",
 " numero_desenfileirado = fila.desenfileirar()\n",
 " if numero_desenfileirado is not None:\n",
 " print(f\"Número desenfileirado: {numero_desenfileirado}\")\n",
 " elif opcao == 3:\n",
 " break\n",
 " else:\n",
 " print(\"Opção inválida!\")\n",
 "\n",
 "if __name__ == \"__main__\":\n",
 " main()"
 ],
 "metadata": {
 "id": "Y_xfgCV2KUzL"
 },
 "execution_count": null,
 "outputs": []
 },
 {
 "cell_type": "markdown",
 "source": [
 "12. Faça uma função para retornar os elementos da fila que possuam números pares."
 ],
 "metadata": {
 "id": "HH9_ISvKLv2C"
 }
 },
 {
 "cell_type": "code",
 "source": [
 "class Fila:\n",
 " def __init__(self):\n",
 " self.fila = []\n",
 "\n",
 " def enfileirar(self, elemento):\n",
 " self.fila.append(elemento)\n",
 "\n",
 " def desenfileirar(self):\n",
 " if self.fila:\n",
 " return self.fila.pop(0)\n",
 " else:\n",
 " print(\"A fila está vazia!\")\n",
 "\n",
 " def elementos_pares(self):\n",
 " return [elemento for elemento in self.fila if elemento % 2 == 0]\n",
 "\n",
 "def main():\n",
 " fila = Fila()\n",
 "\n",
 " fila.enfileirar(1)\n",
 " fila.enfileirar(2)\n",
 " fila.enfileirar(3)\n",
 " fila.enfileirar(4)\n",
 " fila.enfileirar(5)\n",
 " fila.enfileirar(6)\n",
 "\n",
 " elementos_pares = fila.elementos_pares()\n",
 " print(\"Elementos pares na fila:\", elementos_pares)\n",
 "\n",
 "if __name__ == \"__main__\":\n",
 " main()"
 ],
 "metadata": {
 "colab": {
 "base_uri": "https://localhost:8080/"
 },
 "id": "xrdLHq0VLwmE",
 "outputId": "d5332f0e-c122-4de1-fcdd-173069dccf85"
 },
 "execution_count": 15,
 "outputs": [
 {
 "output_type": "stream",
 "name": "stdout",
 "text": [
 "Elementos pares na fila: [2, 4, 6]\n"
]
 }
 ]
 }
 ]
}