Pilha Genérica

Parte da seção Object Oriented Programming do Journey de Rust da Coddy — lição 59 de 61.

Desafio

Fácil

Uma pilha (stack) é uma estrutura de dados fundamental que segue o princípio "Last In, First Out" (LIFO) — o último item adicionado é o primeiro a ser removido. Pense em uma pilha de pratos: você adiciona pratos no topo e os remove do topo.

Vamos construir uma estrutura de dados Stack genérica que pode conter qualquer tipo de elemento! Uma pilha segue o princípio "Last In, First Out" — como uma pilha de livros onde você só pode adicionar ou remover do topo.

Você organizará seu código em dois arquivos:

stack.rs: Defina sua struct Stack<T> genérica que usa um Vec<T> internamente para armazenar elementos. Implemente três métodos: new para criar uma pilha vazia, push para adicionar um elemento ao topo e pop para remover e retornar o elemento do topo (retornando Option<T>, já que a pilha pode estar vazia).
main.rs: Importe seu módulo stack e demonstre sua Stack funcionando com inteiros. Crie uma pilha, faça o push dos números fornecidos nela, depois faça o pop dos elementos e imprima cada um. Use unwrap_or para lidar com o Option retornado pelo pop — se a pilha estiver vazia, use -1 como o valor padrão.

Uma pilha precisa de duas operações essenciais:

push — adiciona um elemento ao topo da pilha
pop — remove e retorna o elemento do topo

O método pop deve retornar um Option<T>, pois a pilha pode estar vazia. O tipo Vec já possui um método pop que retorna Option<T>, o qual você pode aproveitar em sua implementação.

Sua pilha deve funcionar assim: quando você faz o push dos valores 10, 20 e 30 (nessa ordem), fazer o pop três vezes deve resultar em 30, 20 e 10 (ordem inversa). Um quarto pop em uma pilha vazia deve retornar o valor padrão.

Imprima cada valor retornado pelo pop em sua própria linha:

Por exemplo, com as entradas 5, 15 e 25:

Você receberá três entradas: três inteiros para fazer o push na pilha (analise cada um como i32). Após fazer o push dos três, faça o pop quatro vezes para demonstrar tanto os pops bem-sucedidos quanto o caso da pilha vazia.

Experimente você mesmo

mod stack;

use stack::Stack;

fn main() {
    // Lê três números inteiros da entrada
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let num1: i32 = input1.trim().parse().expect("Invalid number");

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let num2: i32 = input2.trim().parse().expect("Invalid number");

    let mut input3 = String::new();
    std::io::stdin().read_line(&mut input3).expect("Failed to read line");
    let num3: i32 = input3.trim().parse().expect("Invalid number");

    // TODO: Criar uma nova Stack

    // TODO: Fazer o push dos três números na pilha (num1, num2, num3 nessa ordem)

    // TODO: Fazer o pop quatro vezes e imprimir cada resultado
    // Use unwrap_or(-1) para lidar com o caso de pilha vazia
}