Para solucionarmos um problema através de um programa de computador precisamos executar várias etapas. Explique, em ordem de execução, cada uma destas etapas. (1,0 pt)
Passo 1
O enunciado pede que eu explique, em ordem de execução, as várias etapas necessárias para solucionar um problema por meio de um programa de computador. Não há dados numéricos nem restrição de linguagem; o objetivo é descrever cada etapa e a ordem em que elas ocorrem.
Passo 2
Etapa 1 — Entendimento do problema (leitura e especificação).
- O que é: descobrir exatamente o que se quer resolver. Significa ler o enunciado, identificar entrada(s), saída(s), restrições (tamanho dos dados, tempo/memória) e casos especiais.
- Por que é importante: programar antes de entender é furada — leva a refatorações caras e erros.
- Como fazer na prática: escreva com suas palavras o que o programa deve fazer; liste exemplos simples de entrada e saída; identifique limites (por exemplo, entradas vazias, números negativos, tamanhos máximos).
- Exemplo rápido: se o problema pede “ordenar uma lista”, pergunte: lista de que tamanho? números ou texto? ordenação estável necessária? aceita ordenação in-place?
Passo 3
Etapa 2 — Modelagem e análise (pensar em alto nível).
- O que é: transformar o enunciado em um modelo lógico/matemático. Pensar qual estrutura representa melhor os dados (lista, fila, grafo, árvore, conjunto).
- Conceitos importantes: invariantes (propriedades que não mudam), complexidade esperada (tempo e memória), casos extremos.
- Como fazer: esboce uma solução verbal ou com diagrama; estime se uma solução ingênua cabe nas restrições; se não, pensar em opções mais eficientes.
- Dica prática: para prova, sempre escreva o modelo e justifique por que ele atende as restrições.
Passo 4
Etapa 3 — Projeto do algoritmo (passo a passo lógico).
- O que é: definir o procedimento detalhado que transforma a entrada na saída — o “receita” que o programa seguirá.
- Ferramentas: pseudocódigo, fluxograma ou sequência de passos numerados.
- O que incluir: inicializações, laços, condições, como tratar casos especiais.
- Exemplo simples de pseudocódigo (só ideia): “para cada elemento da lista, inserir em uma estrutura ordenada” — aqui você decide depois se usa insertion sort, heapsort, etc.
- Na prova: escreva o algoritmo em pseudocódigo claro; isso já vale pontos e facilita a codificação.
Passo 5
Etapa 4 — Escolha de estruturas de dados e sub-algoritmos prontos.
- O que é: decidir que estruturas (vetor, lista ligada, pilha, fila, dicionário/hash, grafo) e que algoritmos auxiliares serão usados.
- Por que: a estrutura certa reduz a complexidade e a implementação.
- Exemplo: se precisa de buscas rápidas por chave, escolher tabela hash; se precisa de percurso por níveis, escolher fila.
- Dica: na prova não invente estruturas complexas se uma simples prova suficiente; prefira soluções claras e justificadas.
Passo 6
Etapa 5 — Escrita do pseudocódigo detalhado e verificação por dry-run.
- O que é: detalhar cada linha do algoritmo em pseudocódigo e “executar com a mão” (dry-run) em casos de teste que você listou no Passo 1.
- Objetivo do dry-run: encontrar erros lógicos antes de codificar (casos fora do escopo, índices fora do intervalo, inicializações esquecidas).
- Como fazer: escolha um exemplo pequeno e execute passo a passo anotando valores das variáveis.
Passo 7
Etapa 6 — Implementação (codificação) no idioma escolhido.
- O que é: traduzir o pseudocódigo para código-fonte em uma linguagem de programação.
- Boas práticas: nomes claros para variáveis e funções, funções curtas, evitar duplicação, comentar trechos não óbvios.
- Dicas para provas de programação: começar por uma versão simples que funciona para casos fáceis; depois estender para casos gerais.
Passo 8
Etapa 7 — Compilação/Build e preparação do ambiente de execução.
- O que é: transformar o código em um executável (linguagens compiladas) ou preparar o interpretador/ambiente (linguagens interpretadas).
- O que checar: mensagens do compilador, warnings, dependências, versão da linguagem.
- Dica prática: atenção a diferenças entre ambiente de desenvolvimento e ambiente da prova/avaliador (por exemplo, encoding de arquivo, limites de memória).
Passo 9
Etapa 8 — Testes e depuração (debugging).
- Tipos de teste: testes unitários (pequenas funções), testes de integração (sistema completo), testes com casos limites e aleatórios.
- Como testar: use os exemplos do Passo 1, casos limites e entradas grandes (para checar tempo).
- Como depurar: inserir prints/exibições, usar um depurador passo a passo, reduzir o problema (isolar função com bug).
- O que procurar: erros de lógica, off-by-one, condições de contorno, vazamento de memória.
- Na prova: sempre que possível, mostre um ou dois testes e como o código lida com eles; isso demonstra confiança.
Passo 10
Etapa 9 — Otimização (se necessário).
- Quando: só depois do código correto; otimizar cedo pode introduzir bugs.
- O que otimizar: algoritmos (reduzir complexidade), estruturas de dados, constantes (reduzir cópias, evitar operações custosas).
- Como avaliar: medir — se o tempo/ memória está dentro dos limites, talvez não é preciso otimizar.
- Dica: prefira otimizações que mantenham o código legível e documente as mudanças.
Passo 11
Etapa 10 — Documentação, entrega e manutenção.
- Documentação: explicação do que o programa faz, como usar, limitações, comentários importantes no código.
- Entrega/deploy: empacotar, enviar ao avaliador, colocar em repositório (git) ou subir para ambiente de produção.
- Manutenção: preparar-se para corrigir bugs relatados e evoluir funcionalidades.
- Na prova: inclua comentários e um README curto se for pedido; facilita correção.
Passo 12
Resumo prático e ordem curta (para decorar na prova).
- A sequência típica a decorar: Entendimento → Modelagem/Análise → Projeto do algoritmo → Pseudocódigo/Dry-run → Implementação → Compilação → Testes/Depuração → Otimização → Documentação/Entrega → Manutenção.
- Pequeno incentivo: siga a sequência e faça dry-runs simples — isso evita 80% dos erros comuns. Dá para fazer tudo com calma se dividir o tempo nos passos.
Resposta
Entendimento do problema; Modelagem e análise; Projeto do algoritmo; Escolha de estruturas de dados; Escrita do pseudocódigo e dry-run; Implementação (codificação); Compilação/build; Testes e depuração; Otimização (se necessário); Documentação, entrega e manutenção.