{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fd43faf5",
   "metadata": {},
   "source": [
    "## Exercício 01: Implementar em linguagem Python o pseudocódigo do algoritmo ``Pilha`` visto na Aula 04."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a12f01b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pilha:\n",
    "    def __init__(self, capacidade):\n",
    "        self.capacidade = capacidade\n",
    "        self.topo = -1\n",
    "        self.valores = [0] * capacidade\n",
    "\n",
    "    def esta_vazia(self):\n",
    "        return self.topo == -1\n",
    "\n",
    "    def esta_cheia(self):\n",
    "        return self.topo == self.capacidade - 1\n",
    "\n",
    "    def empilhar(self, valor):\n",
    "        if self.esta_cheia():\n",
    "            return print(\"Pilha cheia. Não é possível empilhar.\")\n",
    "        self.topo += 1\n",
    "        self.valores[self.topo] = valor\n",
    "\n",
    "    def desempilhar(self):\n",
    "        if self.esta_vazia():\n",
    "            return print(\"Pilha vazia. Não é possível desempilhar.\")\n",
    "        valor = self.valores[self.topo]\n",
    "        self.topo -= 1\n",
    "        return valor\n",
    "\n",
    "    def ver_topo(self):\n",
    "        if self.esta_vazia():\n",
    "            return print(\"Pilha vazia.\")\n",
    "        return self.valores[self.topo]\n",
    "\n",
    "    def imprimir(self):\n",
    "        for i in range(self.topo + 1):\n",
    "            print(self.valores[i], end=' | ')\n",
    "        print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bade18b",
   "metadata": {},
   "source": [
    "### 1.1. Teste o método ``esta_vazia()`` através do método ``desempilhar()``;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0bc981d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "Pilha vazia. Não é possível desempilhar.\n"
     ]
    }
   ],
   "source": [
    "pilha = Pilha(5)\n",
    "\n",
    "print(pilha.esta_vazia())\n",
    "pilha.desempilhar()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5599446",
   "metadata": {},
   "source": [
    "### 1.2. Demonstre o empilhamento de cada um dos caracteres que compõem o seu primeiro nome;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "070fd41c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P | R | O | F | E | \n"
     ]
    }
   ],
   "source": [
    "pilha.empilhar('P')\n",
    "pilha.empilhar('R')\n",
    "pilha.empilhar('O')\n",
    "pilha.empilhar('F')\n",
    "pilha.empilhar('E')\n",
    "\n",
    "pilha.imprimir()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4251bd9a",
   "metadata": {},
   "source": [
    "### 1.3. Teste o método ``esta_cheia()`` através do método ``empilhar(valor)``;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "989ee94e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "Pilha cheia. Não é possível empilhar.\n"
     ]
    }
   ],
   "source": [
    "print(pilha.esta_cheia())\n",
    "pilha.empilhar('X')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6e0b02c",
   "metadata": {},
   "source": [
    "### 1.4. Após executar as operações anteriores, demonstre qual elemento está no topo da Pilha;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "9ee7d28b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elemento no topo: E\n"
     ]
    }
   ],
   "source": [
    "print(f\"Elemento no topo: {pilha.ver_topo()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c4948b0",
   "metadata": {},
   "source": [
    "### 1.5. Execute o método ``desempilhar()`` por três vezes e verifique qual elemento está no topo da Pilha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "ac8da96c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E\n",
      "F\n",
      "O\n",
      "Elemento no topo: R\n"
     ]
    }
   ],
   "source": [
    "print(pilha.desempilhar())\n",
    "print(pilha.desempilhar())\n",
    "print(pilha.desempilhar())\n",
    "print(f\"Elemento no topo: {pilha.ver_topo()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38878521",
   "metadata": {},
   "source": [
    "## Exercício 02: Suponha que você insira a sequência ``S, A, T, C`` em uma Pilha. Então você desempilha três elementos. Qual o valor do atributo ``topo`` da Pilha?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "d2e427a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Topo antes dos desempilhamentos: C\n",
      "Topo após três desempilhamentos: S\n"
     ]
    }
   ],
   "source": [
    "exercicio2 = Pilha(4)\n",
    "\n",
    "exercicio2.empilhar('S')\n",
    "exercicio2.empilhar('A')\n",
    "exercicio2.empilhar('T')\n",
    "exercicio2.empilhar('C')\n",
    "\n",
    "print(f\"Topo antes dos desempilhamentos: {exercicio2.ver_topo()}\")\n",
    "\n",
    "exercicio2.desempilhar()\n",
    "exercicio2.desempilhar()\n",
    "exercicio2.desempilhar()\n",
    "\n",
    "print(f\"Topo após três desempilhamentos: {exercicio2.ver_topo()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3a2ea65",
   "metadata": {},
   "source": [
    "O valor do atributo ``topo`` é ``0``, pois após remover ``C``, ``T`` e ``A`` restou apenas o elemento ``S`` na posição ``0``."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1a8fdc1",
   "metadata": {},
   "source": [
    "## Exercício 03\n",
    "\n",
    "1. Uma Pilha está vazia quando o atributo ``topo`` é igual a ``-1``.\n",
    "2. Uma Pilha está cheia quando o atributo ``topo`` é igual a ``capacidade - 1``.\n",
    "3. Quando a Pilha está vazia, ``topo = -1``.\n",
    "4. Quando a Pilha está cheia, ``topo = capacidade - 1``.\n",
    "5. Quando a Pilha contém apenas um elemento, ``topo = 0``."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c41b0db0",
   "metadata": {},
   "source": [
    "## Exercício 04: Preencha a tabela abaixo com os nomes em inglês correspondentes aos nomes em português:\n",
    "\n",
    "| Nome em Português | Nome comum usado em Inglês |\n",
    "|---|---|\n",
    "| ``Pilha`` | ``Stack`` |\n",
    "| ``empilhar`` | ``push`` |\n",
    "| ``desempilhar`` | ``pop`` |\n",
    "| ``esta_vazia`` | ``is_empty`` / ``isEmpty`` |\n",
    "| ``esta_cheia`` | ``is_full`` / ``isFull`` |\n",
    "| ``topo`` | ``top`` / ``peek`` |\n",
    "| ``capacidade`` | ``capacity`` |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7639aa5e",
   "metadata": {},
   "source": [
    "## Exercício 05: Utilizando a classe ``Pilha`` implementada no Exercício 01, resolva os desafios abaixo:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9df3b270",
   "metadata": {},
   "source": [
    "### 5.1. **Inversão de Palavra**: receba uma palavra e utilize a Pilha para exibi-la invertida;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "7c8ad0cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RODALIPMOC\n",
      "ETYB\n"
     ]
    }
   ],
   "source": [
    "def inverter(palavra):\n",
    "    pilha = Pilha(len(palavra))\n",
    "    for letra in palavra:\n",
    "        pilha.empilhar(letra)\n",
    "\n",
    "    invertida = \"\"\n",
    "    while not pilha.esta_vazia():\n",
    "        invertida += pilha.desempilhar()\n",
    "    return invertida\n",
    "\n",
    "print(inverter(\"COMPILADOR\"))\n",
    "print(inverter(\"BYTE\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bac81425",
   "metadata": {},
   "source": [
    "### 5.2. **Palíndromo**: receba uma palavra e utilize a Pilha para verificar se ela é um palíndromo;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "f2759484",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ARARA: É um palíndromo\n",
      "PROGRAMA: Não é um palíndromo\n"
     ]
    }
   ],
   "source": [
    "def eh_palindromo(palavra):\n",
    "    pilha = Pilha(len(palavra))\n",
    "    for letra in palavra:\n",
    "        pilha.empilhar(letra)\n",
    "\n",
    "    invertida = \"\"\n",
    "    while not pilha.esta_vazia():\n",
    "        invertida += pilha.desempilhar()\n",
    "    return palavra == invertida\n",
    "\n",
    "for palavra in [\"ARARA\", \"PROGRAMA\"]:\n",
    "    if eh_palindromo(palavra):\n",
    "        print(f\"{palavra}: É um palíndromo\")\n",
    "    else:\n",
    "        print(f\"{palavra}: Não é um palíndromo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82ab2b10",
   "metadata": {},
   "source": [
    "### 5.3. **Balanceamento de Parênteses**: receba uma expressão matemática e utilize a Pilha para verificar se os parênteses estão balanceados;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "576e8e43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def balanceado(expressao):\n",
    "    pilha = Pilha(len(expressao))\n",
    "    for caractere in expressao:\n",
    "        if caractere == '(':\n",
    "            pilha.empilhar(caractere)\n",
    "        elif caractere == ')':\n",
    "            if pilha.esta_vazia():\n",
    "                return False\n",
    "            pilha.desempilhar()\n",
    "    return pilha.esta_vazia()\n",
    "\n",
    "print(balanceado(\"(a + b) * (c - d)\"))\n",
    "print(balanceado(\"((a + b) * (c - d)\"))"
   ]
  }
 ],
 "metadata": {
  "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.13.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}