ROTA · 36 CLASSES · 1 GRUPOS

Entrevistas em Go

Pratique padrões de algoritmos e raciocínio para entrevistas usando Go.

Começar esta rota →Ver as classes

Pré-requisitos orientam, mas nunca bloqueiam. Cinco classes da árvore são grátis com conta.

O ARCO DA ROTA

01Entrevistas

ORDEM RECOMENDADA

36 classes, do primeiro passo ao fechamento.

Cada classe leva cerca de 15–25 minutos no novo formato de slides. Você pode sair da ordem quando outro nó fizer mais sentido.

01
BaseComo passar em entrevistas de algoritmos: o mapa de padrões
Entrevistas de algoritmos testam um punhado de padrões repetidos. Veja o mapa completo, entenda por que decorar soluções falha e resolva os três primeiros problemas em Go.
15–25 minAbrir →
02
BaseBig-O na prática em Go
O(1), O(log n), O(n), O(n log n) e O(n²) medidos em código Go real: contadores de operações, o custo escondido das operações da linguagem e como estimar antes de codar.
15–25 minAbrir →
03
BaseSlices, maps e strings: a caixa de ferramentas Go
As três estruturas que resolvem 90% das entrevistas em Go: slices como pilha e fila, maps como conjunto e contador, strings com runas e Builder — com os custos e as pegadinhas de cada uma.
15–25 minAbrir →
04
Binary SearchBinary search: a intuição
O padrão do corte de metades a partir da intuição do dicionário: invariante L/R, por que mid+1 e mid-1 evitam o loop infinito, overflow no cálculo do meio e a busca em respostas numéricas.
15–25 minAbrir →
05
Binary SearchFirst true: a chave 🔑 de todo binary search
O template first true: todo binary search é achar a fronteira onde uma condição vira verdadeira. Registrar-e-continuar, o guard do -1 e a busca em espaços de resposta.
15–25 minAbrir →
06
Binary SearchArrays ordenados: first occurrence e not-smaller-than
Binary search com duplicatas: primeira ocorrência, menor elemento não menor que o alvo e contagem de ocorrências em O(log n) — três aplicações diretas do template first true.
15–25 minAbrir →
07
Binary SearchArrays implicitamente ordenados: rotated minimum e peak
Binary search em arrays que não parecem ordenados: o mínimo do array rotacionado, o pico da montanha e a busca completa no rotacionado — encontrando a condição monotônica escondida.
15–25 minAbrir →
08
Binary SearchBinary search avançado: minimizar o máximo
Binary search na resposta em escala: o problema dos jornais (minimizar o máximo), a velocidade mínima de Koko e o espelho maximizar-o-mínimo — com verificadores gulosos e a receita completa do padrão.
15–25 minAbrir →
09
Binary SearchBinary search: speedrun
Revisão cronometrada do módulo: os quatro templates de binary search resolvidos de memória, com metas de tempo, checklist de invariantes e o fluxograma de decisão.
15–25 minAbrir →
10
Two PointersTwo pointers: a intuição
O segundo grande padrão da trilha: dois índices que juntos fazem em O(n) o que um loop duplo faz em O(n²) — com two sum sorted, palíndromo com runas e merge de arrays ordenados.
15–25 minAbrir →
11
Two PointersMesma direção: remove duplicates e fast/slow
A formação fast/slow: um ponteiro explora, o outro constrói — remove duplicates in-place, move zeros com swap e verificação de subsequência com dois cursores.
15–25 minAbrir →
12
Two PointersDireções opostas: two sum sorted e container
A formação das pontas em profundidade: container com mais água e sua prova de eliminação, 3-sum closest com two sum como sub-rotina, e squares of sorted array preenchendo de trás para frente.
15–25 minAbrir →
13
Two PointersSliding window de tamanho fixo
A janela deslizante de tamanho fixo: some uma vez, atualize com entra-e-sai — soma máxima de janela, contagem de vogais e detecção de anagrama com contagens incrementais.
15–25 minAbrir →
14
Two PointersSliding window variável: longest substring
A janela que cresce e encolhe: longest substring without repeating, o menor subarray com soma alvo e substituições limitadas — o template expande-valida-encolhe e a prova do O(n) amortizado.
15–25 minAbrir →
15
Two PointersPrefix sums
Somas de intervalos arbitrários em O(1): o array acumulado com zero inicial, o truque do map para contar subarrays com soma alvo (funciona com negativos) e o pivot index — o fecho do módulo Two Pointers.
15–25 minAbrir →
16
DFSDFS: a intuição da busca em profundidade
Entenda DFS como uma pilha de decisões: caso base, chamada recursiva, ordem de visita e custo em árvores, com exercícios determinísticos em Go.
15–25 minAbrir →
17
DFSDFS em árvores: profundidade e nós visíveis
Aplique DFS a árvores: carregue estado pelo caminho, calcule profundidade máxima e conte nós visíveis sem misturar ramos.
15–25 minAbrir →
18
DFSDFS com retorno: resumos que sobem pela árvore
Use retornos de DFS como resumos de subárvore: soma, altura e diâmetro em uma passagem post-order, sem recomputação quadrática.
15–25 minAbrir →
19
DFSDFS em grafos e matrizes: visitados sem ciclos
Leve DFS de árvores para grafos: marque antes de expandir, conte componentes e trate matrizes como grafos implícitos sem loops infinitos.
15–25 minAbrir →
20
DFSMemoização: cada estado resolvido uma vez
Transforme recursão exponencial em busca sobre estados: defina a chave, consulte o cache e armazene resultados completos com memoização em Go.
15–25 minAbrir →
21
DFSDFS: speedrun
Revise DFS sob cronômetro com quatro problemas já estudados: profundidade, ilhas, diâmetro e memoização, com checklist de invariantes.
15–25 minAbrir →
22
BacktrackingBacktracking: escolha, explore e desfaça
Entenda backtracking como DFS sobre escolhas: mantenha uma solução parcial, explore cada opção e desfaça a mutação sem vazar estado entre ramos.
15–25 minAbrir →
23
BacktrackingPermutações: used, path e restauração dupla
Gere permutações com path e used por posição, restaure ambos após cada ramo e copie soluções para evitar aliasing de slices em Go.
15–25 minAbrir →
24
BacktrackingCombinações e subsets: avance o índice, não repita ordens
Gere subsets e combinações sem duplicar ordens: use start crescente, emita no nível correto e copie o path para romper aliases de slices.
15–25 minAbrir →
25
BacktrackingPoda: corte apenas o que não pode dar solução
Acelere backtracking com poda provada: use limites monotônicos, ordenação e restrições incrementais, comparando estados visitados em vez de tempo.
15–25 minAbrir →
26
BacktrackingDedup em backtracking: pule irmãos, não valores
Remova soluções duplicadas na origem: ordene, pule valores iguais no mesmo nível e preserve repetições legítimas em níveis diferentes.
15–25 minAbrir →
27
BacktrackingBacktracking: speedrun
Revise backtracking em quatro desafios cronometrados: permutações, combinações, poda por saldo e subsets únicos, sem teoria nova.
15–25 minAbrir →
28
BFSBFS: fila, níveis e menor distância
Entenda BFS pela invariante da fila: processe por níveis, marque ao enfileirar e obtenha menor distância por arestas em grafos sem pesos.
15–25 minAbrir →
29
BFSBFS em árvores: zigzag e visão direita
BFS em árvores: zigzag e visão direita: aplicações de BFS com fila linear, descoberta única e análise determinística.
15–25 minAbrir →
30
BFSBFS em matriz: ondas e caminho mínimo
BFS em matriz: ondas e caminho mínimo: aplicações de BFS com fila linear, descoberta única e análise determinística.
15–25 minAbrir →
31
BFSBFS em grafos: distâncias e word ladder
BFS em grafos: distâncias e word ladder: aplicações de BFS com fila linear, descoberta única e análise determinística.
15–25 minAbrir →
32
BFSBFS: speedrun
Revise fila, níveis, ondas em matriz e distâncias em grafo em quatro exercícios curtos, sem teoria nova.
15–25 minAbrir →
33
Concorrência na entrevistaPerguntas de goroutines: ordem, races e closures
Responda o que um programa concorrente pode imprimir distinguindo ordem válida, happens-before, data race e captura de loops no Go moderno.
15–25 minAbrir →
34
Concorrência na entrevistaPuzzles de channels: deadlocks, fan-out e fan-in
Diagnostique deadlocks e leaks, domine rendezvous, buffer e close, e monte fan-out/fan-in com ownership e encerramento comprováveis.
15–25 minAbrir →
35
Concorrência na entrevistaWorker pool ao vivo: implemente sem vazar goroutines
Implemente um worker pool sob pressão com concorrência limitada, identidade estável, backpressure e shutdown completo.
15–25 minAbrir →
36
Concorrência na entrevistaMutex vs channel: o tradeoff que a entrevista cobra
Escolha mutex, channel ou atomic pelo invariante, ownership e lifecycle — não por slogans — e explique custo, contenção e correção.
15–25 minAbrir →

PRÉVIA DA PRIMEIRA CLASSE

Como passar em entrevistas de algoritmos: o mapa de padrões

seen := make(map[int]bool)
for _, value := range values {
	complement := target - value
	if seen[complement] {
		fmt.Println(value, complement) // par encontrado em uma passada
		break
	}
	seen[value] = true // memória troca dois loops por um
}

Uma entrevista de algoritmos parece exigir uma solução inédita em 40 minutos, mas as perguntas são variações de poucos padrões: binary search, two pointers, sliding window, DFS, BFS e backtracking. O enunciado muda; o mecanismo se repete. Em vez de decorar centenas de respostas, aprenda a perguntar: qual é a forma da entrada, que informação posso guardar e o que posso descartar a cada passo?

Essa leitura transforma preparação em reconhecimento. Entrada ordenada sugere eliminar metades; pares e intervalos sugerem ponteiros ou janelas; árvores e grafos sugerem travessias; escolhas combinatórias sugerem backtracking. O código visual mostra a mesma troca em miniatura: guardar valores já vistos permite buscar o complemento de uma soma em uma passada, sem testar todos os pares.

Entender o mecanismo também sustenta as perguntas de acompanhamento: por que left = mid + 1? O que ocorre com entrada vazia? Qual é o custo de tempo e memória? A força bruta costuma funcionar no exemplo pequeno, mas o padrão certo reduz O(n²) para O(n), O(n log n) ou O(log n). Nesta trilha, você vai visualizar o estado de cada padrão, dominar a caixa de ferramentas de Go e justificar cada decisão — não apenas produzir código que compila.

Antes de rodar, preveja os dois números que o programa imprime para size = 1000. Depois teste size igual a 10.000 e 100.000: a coluna da binária deve crescer pouquíssimo enquanto a linear explode. Por fim, mude target para values[0] — por que a linear vence nesse caso específico, e por que isso não muda a análise de pior caso?

package main

import "fmt"

func steps(values []int, target int) (linear, binary int) {
	for _, value := range values {
		linear++
		if value == target {
			break
		}
	}
	left, right := 0, len(values)-1
	for left <= right {
		mid := left + (right-left)/2
		binary++
		if values[mid] == target {
			return linear, binary
		}
		if values[mid] < target {
			left = mid + 1
		} else {
			right = mid - 1
		}
	}
	return linear, binary
}

func main() {
	size := 1000
	values := make([]int, size)
	for index := range values {
		values[index] = index
	}
	target := values[size-1]
	linear, binary := steps(values, target)
	fmt.Println("linear:", linear, "| binária:", binary)
}

Antes do mapa, uma prova concreta de que padrão não é estética: é custo. O programa abaixo procura um valor em um array ordenado de duas maneiras — percorrendo tudo e cortando pela metade — e conta quantas comparações cada uma gasta. É o mesmo resultado, com esforços muito diferentes.

{/*  */}

package main

import "fmt"

A busca linear é a força bruta honesta: olha cada posição até achar. O contador registra cada comparação com um elemento do array.

{/*  */}

// linearSteps conta comparações da busca linear até achar target.
func linearSteps(values []int, target int) int {
	steps := 0
	for _, value := range values {
		steps++
		if value == target {
			return steps
		}
	}
	return steps
}

A busca binária usa a informação que a linear desperdiça: o array está ordenado. Se o elemento do meio é menor que o alvo, todo mundo à esquerda dele também é — dá para descartar metade do array com uma única comparação. Essa é a essência do padrão que você vai dominar nas aulas 4 a 9.

{/*  */}

// binarySteps conta comparações da busca binária no mesmo array.
func binarySteps(values []int, target int) int {
	steps := 0
	left, right := 0, len(values)-1
	for left <= right {
		mid := left + (right-left)/2
		steps++
		if values[mid] == target {
			return steps
		}

A introdução termina aqui

Entre para continuar nos slides, rodar o código e enfrentar os desafios.

Começar pela rota →

ESTA ROTA E TODAS AS OUTRAS

Qualquer plano abre os 188 nós.

Mensal R$19,90 · anual R$149 · lifetime R$499. Todos têm garantia de 7 dias.

Comparar os 3 planos →Começar pelas classes grátis