O que muda agora: de valores soltos a dados organizados

O mundo real vem em montes

Imagine um programa que calcula a média de uma prova. Com duas notas, duas variáveis resolvem: nota1 e nota2. Com a turma inteira de trinta e cinco alunos, criar trinta e cinco variáveis seria absurdo, e trocar de turma quebraria tudo. É o mesmo desconforto que você sentiu quando descobriu que copiar e colar instruções não escalava e precisou do laço. Agora o desconforto é do outro lado: não é a repetição que falta, é um lugar para guardar o monte de dados que a repetição vai percorrer. Esse lugar é a estrutura de dados.

No curso passado você conheceu a primeira delas, a lista, e ela já resolve muita coisa: uma fila de nomes, uma sequência de preços. Mas a lista é só a porta de entrada. Tem dado que forma uma tabela com linhas e colunas (as notas de várias provas de vários alunos). Tem dado que é texto e precisa ser esmiuçado letra por letra (validar um e-mail, contar palavras). Tem dado em que o importante é a etiqueta, não a posição (o preço do produto tal, o telefone da pessoa tal). E tem dado em que só interessa se algo pertence ou não ao grupo, sem repetição. Cada um desses casos tem uma estrutura feita sob medida, e conhecê-las é metade do trabalho de um programador.

A estrutura certa muda tudo

Escolher a estrutura de dados errada não trava o programa, mas o deixa desajeitado, lento e cheio de gambiarra. Guardar a agenda de telefones numa lista, por exemplo, obriga o programa a varrer a lista inteira toda vez que alguém procura um contato. Guardar a mesma agenda num dicionário, com o nome servindo de etiqueta, faz a busca ser instantânea. O programa faz a mesma coisa nos dois casos, mas um trabalha suando e o outro trabalha sorrindo. Boa parte do que você vai aprender aqui é esse faro: olhar para um problema e sentir qual estrutura pede menos esforço.

precos <- [12, 8, 20, 5]
total <- 0
maior <- 0
para cada p em precos faça
  total <- total + p
  se p > maior então
    maior <- p
  fim
fim
escreva("Total ", total, " | Maior ", maior)

O caminho que vem pela frente

Depois de dominar as estruturas de dados, o curso avança para o que se faz com elas. Você vai aprofundar as funções, aquelas máquininhas que recebem uma entrada e devolvem uma saída, entendendo escopo, retorno e efeitos colaterais. Vai aprender a dividir um problema grande em partes menores e a ideia elegante da recursão. E vai encarar os algoritmos clássicos que todo programador carrega: buscar um item rápido, colocar uma bagunça em ordem, e medir se um programa é eficiente ou desperdiçador. No fim, robustez e código limpo transformam um algoritmo que funciona num programa em que dá para confiar.

1. Organizar dados: decisões avançadas, laços sob controle, matrizes, strings, dicionários e conjuntos.
2. Estruturar código: funções profundas, decomposição e recursão.
3. Algoritmos clássicos: busca, ordenação e a noção de eficiência (Big-O).
4. Programas confiáveis: erros e robustez, código limpo e o projeto final.