Variáveis: var, := e o fim do undefined

func Swap(a int, b int) (int, int) {
	a, b = b, a
	return a, b
}

A garantia que faz isso funcionar: na atribuição múltipla, todo o lado direito é avaliado antes da primeira gravação. b e a são lidos, e só então gravados em a e b. Custo O(1). Parâmetros de função são variáveis locais comuns em Go — reatribuí-los não afeta o chamador, então usar a e b como espaço de trabalho é legítimo. (Há uma versão ainda mais curta, return b, a, igualmente correta — o objetivo pedagógico aqui era a atribuição múltipla, que você vai reencontrar em contextos onde o return direto não existe, como trocar elementos de um slice: values[i], values[j] = values[j], values[i].)

A armadilha é a versão ingênua em duas linhas: a = b seguida de b = a. Depois da primeira linha, o valor original de a não existe mais — a segunda linha copia b para b, e o resultado é (2, 2) em vez de (2, 1). O caso de teste Swap(7, 7) é o único que essa versão passa por coincidência; os outros três a reprovam. Em linguagens sem atribuição múltipla, a correção exige temp := a antes — em Go, esse temp é ruído.

Duas decisões independentes, dois ifs independentes:

func FillDefaults(name string, quantity int) (string, int) {
	if name == "" {
		name = "sem nome"
	}
	if quantity == 0 {
		quantity = 1
	}
	return name, quantity
}

Comparar com o zero value do tipo — "" para string, 0 para int — é o idioma padrão de “este campo não foi preenchido” em Go, e você o verá em código de verdade constantemente (é também a base do comportamento de structs e JSON mais adiante no curso). Reatribuir os parâmetros evita declarar variáveis novas só para carregar os mesmos dados. Custo O(1).

A armadilha estrutural é acoplar as decisões: if name == "" && quantity == 0 { ... } else { ... } trata “ambos vazios” e “ambos preenchidos”, mas escolhe errado nos casos mistos 3 e 4 — exatamente os que o harness cobra. Quando duas decisões são independentes no enunciado, mantê-las independentes no código não é só correção: é o que impede a explosão de ramos (2 campos acoplados = 4 combinações; 5 campos = 32). Vale registrar a limitação honesta do idioma: ele não distingue “usuário digitou 0” de “usuário não preencheu”. Aqui o contrato diz que 0 significa não preenchido, então está correto; quando o seu domínio precisar da distinção, a ferramenta muda (ponteiros, aula 15).

func OrderSummary(product string, quantity int, unitCents int) string {
	totalCents := quantity * unitCents
	return fmt.Sprintf("%dx %s = R$ %d.%02d", quantity, product, totalCents/100, totalCents%100)
}

A variável intermediária totalCents é a decisão de estilo que importa aqui. Sem ela, a expressão quantity*unitCents apareceria duas vezes dentro do Sprintf — uma para /100, outra para %100 — e toda duplicação de expressão é um lugar onde uma futura edição corrige um lado e esquece o outro. Com ela, a conta tem nome, acontece uma vez e o Sprintf lê como a etiqueta que produz. O tipo de totalCents é int, inferido da multiplicação entre inteiros — nenhuma anotação necessária. Custo O(n) no tamanho da string.

As armadilhas são reprises das aulas anteriores em combinação: multiplicar em float (float64(quantity) * float64(unitCents) / 100) reintroduz o arredondamento binário que centavos inteiros existem para evitar; e usar %d em vez de %02d nos centavos passa nos casos 1 e 3 mas falha no caso 4 (R$ 149.0 em vez de R$ 149.00). Note o padrão dos exercícios até aqui: os casos de teste são escolhidos para reprovar as soluções quase certas — leia sempre todos os casos antes de codificar, como você faria com uma especificação.