Entrevistas Técnicas para Vagas Rust: Guia Completo de Preparação

fn exemplo_ownership() {
    let s1 = String::from("olá");
    let s2 = s1;           // s1 é movido para s2
    // println!("{}", s1);  // ERRO: s1 não é mais válido
    println!("{}", s2);     // OK

    let s3 = s2.clone();   // cópia explícita (deep copy)
    println!("{} {}", s2, s3); // ambos válidos
}

fn exemplo_borrowing() {
    let mut dados = vec![1, 2, 3];

    // Múltiplas referências imutáveis: OK
    let r1 = &dados;
    let r2 = &dados;
    println!("{:?} {:?}", r1, r2);

    // Referência mutável após imutáveis não serem mais usadas: OK
    dados.push(4);

    // Referência mutável exclusiva
    let r3 = &mut dados;
    r3.push(5);
    // let r4 = &dados; // ERRO: não pode ter &T enquanto &mut T existe
}

// O compilador não sabe se o retorno vem de x ou y
fn mais_longo<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// Struct com lifetime
struct Extrator<'a> {
    texto: &'a str,
}

impl<'a> Extrator<'a> {
    fn primeira_palavra(&self) -> &'a str {
        self.texto.split_whitespace().next().unwrap_or("")
    }
}

// Static dispatch: monomorphized, inline possível
fn imprimir_static(item: &impl std::fmt::Display) {
    println!("{}", item);
}

// Dynamic dispatch: vtable, mais flexível
fn imprimir_dynamic(item: &dyn std::fmt::Display) {
    println!("{}", item);
}

// Coleção heterogênea: precisa de trait object
fn colecao_heterogenea() {
    let items: Vec<Box<dyn std::fmt::Display>> = vec![
        Box::new(42),
        Box::new("texto"),
        Box::new(3.14),
    ];
    for item in &items {
        println!("{}", item);
    }
}

use thiserror::Error;

#[derive(Error, Debug)]
enum ServiceError {
    #[error("Usuário não encontrado: {0}")]
    UsuarioNaoEncontrado(i64),

    #[error("Erro de banco de dados")]
    Database(#[from] sqlx::Error),

    #[error("Validação falhou: {0}")]
    Validacao(String),
}

fn buscar_usuario(id: i64) -> Result<Usuario, ServiceError> {
    if id <= 0 {
        return Err(ServiceError::Validacao("ID deve ser positivo".into()));
    }
    // ... implementação
    Ok(Usuario { id, nome: "teste".into() })
}

use std::collections::HashMap;
use std::collections::VecDeque;

struct LruCache<K, V> {
    capacidade: usize,
    mapa: HashMap<K, V>,
    ordem: VecDeque<K>,
}

impl<K: Eq + std::hash::Hash + Clone, V> LruCache<K, V> {
    fn new(capacidade: usize) -> Self {
        LruCache {
            capacidade,
            mapa: HashMap::with_capacity(capacidade),
            ordem: VecDeque::with_capacity(capacidade),
        }
    }

    fn get(&mut self, chave: &K) -> Option<&V> {
        if self.mapa.contains_key(chave) {
            // Move para o final (mais recente)
            self.ordem.retain(|k| k != chave);
            self.ordem.push_back(chave.clone());
            self.mapa.get(chave)
        } else {
            None
        }
    }

    fn put(&mut self, chave: K, valor: V) {
        if self.mapa.contains_key(&chave) {
            self.ordem.retain(|k| k != &chave);
        } else if self.mapa.len() >= self.capacidade {
            // Remove o menos recente
            if let Some(antiga) = self.ordem.pop_front() {
                self.mapa.remove(&antiga);
            }
        }
        self.ordem.push_back(chave.clone());
        self.mapa.insert(chave, valor);
    }

    fn len(&self) -> usize {
        self.mapa.len()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn teste_lru_basico() {
        let mut cache = LruCache::new(2);
        cache.put("a", 1);
        cache.put("b", 2);
        assert_eq!(cache.get(&"a"), Some(&1));

        cache.put("c", 3); // remove "b" (menos recente)
        assert_eq!(cache.get(&"b"), None);
        assert_eq!(cache.get(&"c"), Some(&3));
    }
}

struct FlattenIter<I>
where
    I: Iterator,
    I::Item: IntoIterator,
{
    outer: I,
    inner: Option<<I::Item as IntoIterator>::IntoIter>,
}

impl<I> FlattenIter<I>
where
    I: Iterator,
    I::Item: IntoIterator,
{
    fn new(iter: I) -> Self {
        FlattenIter {
            outer: iter,
            inner: None,
        }
    }
}

impl<I> Iterator for FlattenIter<I>
where
    I: Iterator,
    I::Item: IntoIterator,
{
    type Item = <I::Item as IntoIterator>::Item;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            if let Some(ref mut inner) = self.inner {
                if let Some(item) = inner.next() {
                    return Some(item);
                }
            }
            match self.outer.next() {
                Some(next_inner) => {
                    self.inner = Some(next_inner.into_iter());
                }
                None => return None,
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn teste_flatten() {
        let dados = vec![vec![1, 2], vec![3], vec![4, 5, 6]];
        let resultado: Vec<i32> = FlattenIter::new(dados.into_iter()).collect();
        assert_eq!(resultado, vec![1, 2, 3, 4, 5, 6]);
    }

    #[test]
    fn teste_flatten_vazio() {
        let dados: Vec<Vec<i32>> = vec![vec![], vec![], vec![]];
        let resultado: Vec<i32> = FlattenIter::new(dados.into_iter()).collect();
        assert!(resultado.is_empty());
    }
}

use std::sync::{Arc, Mutex, atomic::{AtomicU64, Ordering}};

trait Counter: Send + Sync {
    fn incrementar(&self);
    fn valor(&self) -> u64;
    fn resetar(&self);
}

// Implementação com Mutex
struct MutexCounter {
    valor: Mutex<u64>,
}

impl MutexCounter {
    fn new() -> Self {
        MutexCounter {
            valor: Mutex::new(0),
        }
    }
}

impl Counter for MutexCounter {
    fn incrementar(&self) {
        let mut guard = self.valor.lock().unwrap();
        *guard += 1;
    }

    fn valor(&self) -> u64 {
        *self.valor.lock().unwrap()
    }

    fn resetar(&self) {
        *self.valor.lock().unwrap() = 0;
    }
}

// Implementação com Atomic (mais performática)
struct AtomicCounter {
    valor: AtomicU64,
}

impl AtomicCounter {
    fn new() -> Self {
        AtomicCounter {
            valor: AtomicU64::new(0),
        }
    }
}

impl Counter for AtomicCounter {
    fn incrementar(&self) {
        self.valor.fetch_add(1, Ordering::Relaxed);
    }

    fn valor(&self) -> u64 {
        self.valor.load(Ordering::Relaxed)
    }

    fn resetar(&self) {
        self.valor.store(0, Ordering::Relaxed);
    }
}

// Teste comparativo
fn benchmark_counter(counter: Arc<dyn Counter>, num_threads: usize, ops_per_thread: u64) {
    let mut handles = vec![];

    for _ in 0..num_threads {
        let c = Arc::clone(&counter);
        handles.push(std::thread::spawn(move || {
            for _ in 0..ops_per_thread {
                c.incrementar();
            }
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    let esperado = (num_threads as u64) * ops_per_thread;
    assert_eq!(counter.valor(), esperado);
}

#[derive(Debug, PartialEq)]
enum Token {
    Numero(f64),
    Mais,
    Menos,
    Vezes,
    Dividir,
    AbreParentese,
    FechaParentese,
}

fn tokenizar(expressao: &str) -> Result<Vec<Token>, String> {
    let mut tokens = Vec::new();
    let mut chars = expressao.chars().peekable();

    while let Some(&c) = chars.peek() {
        match c {
            ' ' => { chars.next(); }
            '+' => { tokens.push(Token::Mais); chars.next(); }
            '-' => { tokens.push(Token::Menos); chars.next(); }
            '*' => { tokens.push(Token::Vezes); chars.next(); }
            '/' => { tokens.push(Token::Dividir); chars.next(); }
            '(' => { tokens.push(Token::AbreParentese); chars.next(); }
            ')' => { tokens.push(Token::FechaParentese); chars.next(); }
            '0'..='9' | '.' => {
                let mut num_str = String::new();
                while let Some(&c) = chars.peek() {
                    if c.is_ascii_digit() || c == '.' {
                        num_str.push(c);
                        chars.next();
                    } else {
                        break;
                    }
                }
                let num: f64 = num_str.parse()
                    .map_err(|_| format!("Número inválido: {}", num_str))?;
                tokens.push(Token::Numero(num));
            }
            _ => return Err(format!("Caractere inesperado: {}", c)),
        }
    }

    Ok(tokens)
}

fn avaliar(expressao: &str) -> Result<f64, String> {
    let tokens = tokenizar(expressao)?;
    let mut pos = 0;
    let resultado = parse_expressao(&tokens, &mut pos)?;
    if pos != tokens.len() {
        return Err("Tokens inesperados no final".to_string());
    }
    Ok(resultado)
}

fn parse_expressao(tokens: &[Token], pos: &mut usize) -> Result<f64, String> {
    let mut resultado = parse_termo(tokens, pos)?;

    while *pos < tokens.len() {
        match tokens[*pos] {
            Token::Mais => {
                *pos += 1;
                resultado += parse_termo(tokens, pos)?;
            }
            Token::Menos => {
                *pos += 1;
                resultado -= parse_termo(tokens, pos)?;
            }
            _ => break,
        }
    }

    Ok(resultado)
}

fn parse_termo(tokens: &[Token], pos: &mut usize) -> Result<f64, String> {
    let mut resultado = parse_fator(tokens, pos)?;

    while *pos < tokens.len() {
        match tokens[*pos] {
            Token::Vezes => {
                *pos += 1;
                resultado *= parse_fator(tokens, pos)?;
            }
            Token::Dividir => {
                *pos += 1;
                let divisor = parse_fator(tokens, pos)?;
                if divisor == 0.0 {
                    return Err("Divisão por zero".to_string());
                }
                resultado /= divisor;
            }
            _ => break,
        }
    }

    Ok(resultado)
}

fn parse_fator(tokens: &[Token], pos: &mut usize) -> Result<f64, String> {
    if *pos >= tokens.len() {
        return Err("Expressão incompleta".to_string());
    }

    match tokens[*pos] {
        Token::Numero(n) => {
            *pos += 1;
            Ok(n)
        }
        Token::AbreParentese => {
            *pos += 1;
            let resultado = parse_expressao(tokens, pos)?;
            if *pos >= tokens.len() || tokens[*pos] != Token::FechaParentese {
                return Err("Parêntese não fechado".to_string());
            }
            *pos += 1;
            Ok(resultado)
        }
        _ => Err(format!("Token inesperado: {:?}", tokens[*pos])),
    }
}

use std::collections::HashMap;
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::RwLock;

struct RateLimiter {
    limite: u32,
    janela: Duration,
    registros: Arc<RwLock<HashMap<String, Vec<Instant>>>>,
}

impl RateLimiter {
    fn new(limite: u32, janela: Duration) -> Self {
        RateLimiter {
            limite,
            janela,
            registros: Arc::new(RwLock::new(HashMap::new())),
        }
    }

    async fn permitir(&self, chave: &str) -> bool {
        let agora = Instant::now();
        let mut registros = self.registros.write().await;

        let timestamps = registros
            .entry(chave.to_string())
            .or_insert_with(Vec::new);

        // Remove timestamps fora da janela
        timestamps.retain(|&t| agora.duration_since(t) < self.janela);

        if timestamps.len() < self.limite as usize {
            timestamps.push(agora);
            true
        } else {
            false
        }
    }

    async fn limpar_expirados(&self) {
        let agora = Instant::now();
        let mut registros = self.registros.write().await;
        registros.retain(|_, timestamps| {
            timestamps.retain(|&t| agora.duration_since(t) < self.janela);
            !timestamps.is_empty()
        });
    }
}

## Antes de Enviar

### Código
- [ ] Código compila sem warnings (`cargo clippy`)
- [ ] Formatação padronizada (`cargo fmt`)
- [ ] Sem dependências desnecessárias
- [ ] Tratamento de erros adequado (sem unwrap em produção)
- [ ] Nomes descritivos em variáveis e funções

### Testes
- [ ] Testes unitários para lógica core
- [ ] Testes de integração para APIs
- [ ] Todos passando (`cargo test`)
- [ ] Edge cases cobertos

### Documentação
- [ ] README com instruções de setup e uso
- [ ] Decisões de design documentadas
- [ ] API documentada (se aplicável)
- [ ] Exemplos de uso

### Git
- [ ] Commits atômicos e descritivos
- [ ] Histórico limpo (sem "fix typo" em sequência)
- [ ] .gitignore configurado

// Modelo mental para resolver problemas em entrevista:

// 1. Entender o problema (repita em suas palavras)
// 2. Definir tipos de entrada/saída
fn resolver(input: &[i32]) -> Vec<i32> {
    todo!()
}

// 3. Escrever testes primeiro
#[test]
fn teste_basico() {
    assert_eq!(resolver(&[1, 2, 3]), vec![3, 2, 1]);
}

#[test]
fn teste_vazio() {
    assert_eq!(resolver(&[]), vec![]);
}

// 4. Implementar solução simples (brute force)
// 5. Otimizar se necessário
// 6. Discutir complexidade (tempo e espaço)