Entrevistas em Rust

Derive Big-O pelos estados visitados, pelo armazenamento criado e pelos custos reais de Vec, HashMap, ordenação e aritmética.

Use Vec, fatias, HashMap e String com contratos de ownership claros, custos derivados e tratamento correto de UTF-8.

Implemente busca binária com um intervalo semiaberto, prove cada descarte e evite loops infinitos, índices inválidos e overflow.

Transforme condições monotônicas em first true, lower bound e posições de inserção com um intervalo semiaberto.

Delimite blocos de valores repetidos com lower e upper bound, derive a contagem e preserve O(log n) mesmo com muitas duplicatas.

Descubra condições monotônicas em arrays rotacionados e sequências unimodais para encontrar mínimos e picos em O(log n).

Converta minimizar o máximo em first true, escreva verificadores gulosos e derive O(n log R) com aritmética segura.

Reconheça problemas de two pointers e prove qual ponta pode avançar sem eliminar uma resposta melhor.

Use fast como leitor e slow como fronteira de escrita para compactar uma fatia ordenada no lugar.

Resolva two sum em dados ordenados com O(n) tempo, O(1) espaço e uma regra explícita para duplicatas.

Calcule a primeira janela uma vez e atualize cada deslocamento com um valor que sai e outro que entra.

Encontre a maior substring sem valores escalares repetidos e diferencie contagens escalares de offsets em bytes.

Use prefix[0] = 0 para responder somas de faixas meio-abertas em O(1) após um único pré-processamento.

Use Vec<char> como pilha para validar delimitadores, modelar desfazer e explicar por que o topo preserva a ordem necessária.

Resolva next greater element em O(n) com índices pendentes, comparação estrita, Option e uma prova amortizada por push e pop.

Use VecDeque<usize> para expirar índices antigos e manter o máximo de todas as janelas fixas em tempo linear.

Represente grafos com Vec<Vec<usize>>, escolha pilha ou fila, marque vértices na descoberta e derive O(V+E).

Percorra árvores de filhos possuídos com empréstimos, combine resumos das subárvores e analise tempo O(n) e pilha O(h).

Faça DFS em listas de adjacência, marque antes da recursão, conte componentes e detecte ciclos dirigidos com três cores.

Use VecDeque, marque no enqueue e calcule níveis, distâncias e caminhos mínimos em grafos sem peso.

Modele células como um grafo implícito, valide matrizes irregulares e calcule ondas BFS por quatro vizinhos em O(C).

Reconheça árvores de escolhas, mantenha o caminho da ramificação atual e restaure cada mutação antes de explorar o próximo irmão.

Gere permutações de valores distintos com path e used, restaure os dois estados e clone cada folha para resultados independentes.

Use uma fronteira start crescente para gerar combinações e subsets sem ordens duplicadas, com casos de borda e custo de saída explícitos.

Prove skips de irmãos duplicados e podas de soma monotônica sem eliminar soluções alcançáveis, com somas em i128 e restauração explícita.

Use BinaryHeap como max-heap, inverta a prioridade com Reverse e defina desempates lexicográficos sem supor estabilidade.

Mantenha um min-heap de tamanho k para selecionar os k maiores, defina bordas e empates, e ordene somente quando a API exigir.

Intercale k fatias ordenadas com uma fronteira por fluxo, desempate determinístico e custo O(k + N log(h + 1)), onde h é o máximo de fluxos ativos.

Modele estados sobrepostos, guarde resultados possíveis e impossíveis e derive tempo, espaço e profundidade da pilha em uma solução memoizada.

Converta uma recorrência em ordem bottom-up, prove dependências prontas e reduza uma tabela 1D para memória constante sem perder correção.

Modele predecessores em uma grade retangular, represente bloqueios e estados inalcançáveis e reduza a tabela para uma linha com overflow explícito.

Use spawn, move, Send e JoinHandle para transferir trabalho entre threads, tratar panic e coletar resultados determinísticos sem prometer ordem.

Coordene mpsc, clones de Sender, fechamento por drop e sync_channel sem criar ciclos entre send, recv e join.

Separe ownership compartilhado de acesso exclusivo com Arc e Mutex, limite guards e encerre um worker pool com mensagens e joins.

Resolva um speedrun misto com um loop de quatro passos, invariantes explícitas, casos de borda e custos derivados antes do tempo terminar.