A Lógica de Programação e os Algoritmos representam o alicerce fundamental para qualquer pessoa que deseje ingressar ou se aprofundar no vasto mundo da tecnologia e desenvolvimento de software. Dominar esses conceitos não é apenas um passo inicial, mas sim um investimento inteligente e estratégico, que impulsiona a capacidade de resolver problemas, escrever códigos eficientes e garantir um crescimento sustentável como programador.
O algoritmo é frequentemente comparado a uma receita ou a uma trajetória para atingir um objetivo ou resolver um problema.
Formalmente, um algoritmo é um procedimento descrito passo a passo para a resolução de um problema em tempo finito. Ele serve como uma sequência ordenada de instruções, que devem ser finitas e não-ambíguas, a ser seguida para a solução de um determinado problema, garantindo a sua repetibilidade.
O computador exige passos claros, objetivos, sequenciais e coesos que determinem o que deve ser feito, sem subjetividade ou ambiguidade. Um programa de computador, portanto, é um algoritmo escrito em um formato compreensível pela máquina.
O conceito de algoritmo é aplicado diariamente quando estabelecemos um planejamento mental para realizar uma tarefa. Exemplos comuns incluem receitas culinárias, manuais de instrução e roteiros para a realização de tarefas específicas.
No contexto computacional, os três tópicos fundamentais de um algoritmo são entrada, processamento e saída.
Entrada: Obter os dados necessários (interação com o usuário, leitura de arquivo, etc.).
Processamento: Aplicação de instruções e operações lógicas para transformar os dados de entrada em uma solução.
Saída: Apresentação do resultado da solução em um formato compreensível (exibição na tela, gravação em arquivo).
Para que um algoritmo seja considerado válido e eficaz, ele deve possuir as seguintes propriedades:
Completo: Todas as ações precisam ser descritas e devem ser únicas.
Sem redundância (Não-ambíguo): Um conjunto de instruções só pode ter uma única forma de ser interpretada.
Determinístico: Se as instruções forem executadas, o resultado esperado será sempre atingido.
Finito: As instruções precisam terminar após um número limitado de passos.
Enquanto o algoritmo representa a sequência de instruções (a receita), a Lógica de Programação é a estruturação de conceitos e regras que orientam a execução do algoritmo.
A lógica de programação é a forma pela qual essa "receita" será emitida, trazendo regras e conceitos que embasam os códigos que o computador irá ler, interpretar e executar.
É essencial resistir ao impulso de pular diretamente para linguagens populares (como Python ou Java) e, em vez disso, priorizar o estabelecimento de uma base sólida em lógica de programação.
Dominar a lógica oferece vantagens significativas:
Desenvolvimento de Fundamentos Claros: Serve como alicerce para códigos complexos, ensinando a abordar problemas de forma sistemática e eficaz.
Flexibilidade e Adaptabilidade: A lógica é a base comum que permeia todas as linguagens de programação, tornando o programador mais adaptável a diversas plataformas e sintaxes.
Aprimoramento na Resolução de Problemas: Ajuda a quebrar problemas complexos em partes menores e gerenciáveis, ensinando uma abordagem estruturada.
Eficiência e Qualidade do Código: Permite escrever códigos mais eficientes e limpos, facilitando a manutenção futura.
Facilitação do Aprendizado de Linguagens: Uma vez que a lógica é dominada, aprender uma nova linguagem se torna mais uma questão de sintaxe e estrutura.
Os dados são as informações a serem processadas pelo computador. Eles são classificados em três tipos principais:
Representáveis no computador, são divididos em duas classes:
Inteiros (Inteiro): Números que não possuem componentes decimais ou fracionários, podendo ser positivos, negativos ou zero (Ex: 10, 0, -10).
Reais (Real): Números que podem possuir componentes decimais ou fracionários, positivos ou negativos (Ex: 20.05, -15.2).
São sequências de caracteres que podem incluir letras, dígitos e símbolos especiais. Nos algoritmos, são geralmente representados por aspas (") no início e término (Ex: "AbC", "1.2"). É crucial notar que "1.2" é literal, mas 1.2 é real.
Usados para representar os dois únicos valores lógicos possíveis: Verdadeiro (V) e Falso (F). Podem ser representados também por sim/não, 1/0, ou true/false.
Para manipular os dados, utilizamos Constantes e Variáveis, que são entidades destinadas a guardar informações.
Uma constante armazena um valor fixo, que NÃO mudará durante o tempo de execução do programa. O valor é definido uma única vez (Ex: o valor de PI: 3,1415926).
Uma variável armazena um valor que varia com o tempo. Seu conteúdo pode ser alterado, consultado ou apagado quantas vezes forem necessárias. Ao alterar o conteúdo, a informação anterior é perdida, pois a variável armazena sempre a última informação recebida.
Uma variável possui geralmente três atributos:
Nome: Deve ser iniciado com uma letra, sem caracteres especiais (exceto underline _), sem espaços em branco e sem hífen.
Tipo de dado: Numérico, literal ou lógico.
Informação (Valor): De acordo com o tipo de dado definido.
A atribuição é a operação para armazenar um determinado conteúdo em uma variável, geralmente representada pela seta apontando para a esquerda ($\leftarrow$).
Exemplo: variável ← constante (Ex: idade ← 12)
Existem diversas formas de representar algoritmos, variando no nível de detalhamento. As formas mais conhecidas são: Descrição Narrativa, Fluxograma e Pseudocódigo (Portugol).
Os algoritmos são expressos diretamente em linguagem natural (Português). Embora não exija aprender novos conceitos, sua principal desvantagem é que a linguagem natural pode dar margem a várias interpretações e ambiguidades, dificultando a transcrição para um programa.
É uma representação gráfica que utiliza formas geométricas diferentes para ações (instruções, comandos) distintos. É mais precisa que a Descrição Narrativa.
Símbolo | Significado | Fonte(s) |
Oval | Início e final do algoritmo | |
Paralelogramo deitado | Operação de entrada de dados | |
Retângulo | Operação de processamento ou atribuição | |
Losango | Estrutura de decisão (o famoso "se") | |
Quadrado com curva inferior | Operação de saída de dados | |
Seta | Indica o fluxo de dados |
A desvantagem do Fluxograma é que, se for muito grande, fica difícil de entender, e é necessário conhecer o significado de cada símbolo. Contudo, o entendimento de elementos gráficos é muitas vezes mais simples que o de textos.
O Pseudocódigo é uma representação informal de algoritmos, escrita em uma linguagem que mistura elementos de linguagem de programação com linguagem natural (Português). Ele é rico em detalhes, como a definição dos tipos das variáveis. Não é executável, mas serve como um guia.
Portugol é uma linguagem algorítmica desenvolvida para o ensino de lógica de programação, atuando como uma ponte entre o esboço (pseudocódigo) e a codificação real, adotando uma sintaxe próxima ao português.
Estrutura Básica do Pseudocódigo (Portugol):
Algoritmo <nome_do_algoritmo>
<declaração_de_variáveis> (Parte opcional)
Início
<corpo do algoritmo>
Fim
Comandos de Entrada e Saída de Dados:
Leia: Comando de Entrada de Dados, utilizado para obter informações do usuário via teclado, lendo e armazenando na variável indicada. Sintaxe: leia (variável);.
Escreva: Comando de Saída de Dados, utilizado para mostrar informações (variável, constante ou expressão) na tela do computador. Sintaxe: escreva (variável);.
Comentários: A inserção de //comentário facilita a leitura do algoritmo por outros programadores e auxilia o programador a relembrar o código.
Operadores são símbolos que representam atribuições, cálculos e ordem dos dados, utilizados em expressões matemáticas, lógicas e relacionais.
Quanto ao número de operandos:
Unários: Atuam sobre um único operando (Ex: -x, x++ (incrementa +1), x-- (decrementa -1)).
Binários: Atuam sobre dois operandos (Ex: z = x + y).
Quanto à função:
Tipo de Operador | Símbolos Comuns | Função | Fonte(s) |
Aritméticos |
| Realizam operações matemáticas básicas. Só podem ser usados entre tipos de dados numéricos (inteiros e/ou reais). | |
De Atribuição |
| Atribuem o resultado de uma operação ao primeiro operando. | |
Relacionais |
| Comparar valores entre variáveis e expressões. O retorno é sempre um valor do tipo Booleano (Verdadeiro/Falso). | |
Lógicos |
| \ |
|
As operações obedecem a regras matemáticas de prioridade:
Parênteses: Expressões dentro de parênteses são resolvidas primeiro (de dentro para fora).
Exponenciação (^, **).
Divisão (/) e Multiplicação (*) (Mesma prioridade, resolvidas da esquerda para a direita).
Adição (+) e Subtração (-) (Mesma prioridade, resolvidas da esquerda para a direita).
As Estruturas de Seleção (ou Estruturas Condicionais) são comandos que auxiliam no direcionamento da sequência de execução de um programa, por meio da avaliação de condições lógicas. Permitem a escolha de um grupo de ações a ser executado quando determinadas condições são ou não satisfeitas.
O IF/ELSE é a estrutura mais fundamental para tomar decisões no algoritmo. A condição é verificada, e a "decisão" de execução é tomada a partir do resultado, que deve ser Verdadeiro ou Falso.
Simples (Somente IF/SE): A condição é verificada. Se for satisfeita (Verdadeira), as instruções são executadas. Se for Falsa, as instruções são ignoradas, e o código segue.
Composta (IF/ELSE - SE/SENÃO): Se a condição for Verdadeira, as instruções do IF/SE são executadas. Se a condição for Falsa, são executadas as instruções dentro do ELSE/SENÃO.
Aninhada (Encadeada): Ocorre quando uma seleção está dentro de outra seleção. É usada, em geral, para realizar várias comparações com a mesma variável, permitindo a escolha de apenas um entre vários comandos possíveis.
A estrutura SWITCH/CASE é ideal para ser utilizada quando é necessário testar a mesma variável com uma série de valores várias vezes. Funciona de maneira semelhante ao IF/SE encadeado, mas evita uma longa série de testes IF/SE.
A variável a ser testada deve ser sempre do tipo inteiro ou literal.
BREAK/PARE: É essencial para forçar a saída do SWITCH/ESCOLHA após um CASE/CASO ter atendido a condição. Sem ele, todos os CASE/CASO subsequentes seriam testados.
DEFAULT/SENÃO: É um comando opcional que define um fluxo alternativo (instruções) para as situações que não foram atendidas por nenhum CASE/CASO.
As Estruturas de Repetição (também chamadas de Laços ou Loops) são comandos que permitem que uma sequência de instruções seja executada várias vezes até que uma condição seja satisfeita. Servem para repetir um conjunto de instruções sem a necessidade de escrevê-las repetidamente.
A repetição envolve a avaliação de uma condição.
A estrutura FOR deve ser usada quando o número exato de repetições é conhecido.
Contém por padrão:
Variável de inicialização: Inicia a variável de controle do laço, executada apenas uma vez no início.
Condição: Determina o final do laço. É testada antes de executar qualquer instrução dentro do laço.
Incremento/Decremento: Executado no final do laço, alterando o valor da variável de controle a cada repetição.
É considerada a estrutura de repetição mais simples e é ideal para situações em que não se sabe o número exato de vezes em que o bloco de instruções deve ser repetido.
A condição é validada antes de cada repetição do laço.
Enquanto a condição for Verdadeira, o bloco de instruções é executado. Se for Falsa, o laço é finalizado.
A principal característica do DO/WHILE é que ele testa a condição de validação do laço apenas no final do comando.
Isso assegura que todas as instruções dentro do laço serão executadas pelo menos uma vez, independentemente da condição estabelecida.
Somente após a primeira execução, as instruções serão repetidas se a condição de validação for Verdadeira.
A partir deste nível, aprofundamos em conceitos cruciais para a eficiência de execução e análise de desempenho, temas de alta relevância em concursos públicos e desenvolvimento de sistemas críticos.
Um procedimento recursivo é aquele que chama a si mesmo durante a execução. É uma técnica importante e poderosa, mas que deve ter sua complexidade assintótica analisada com cuidado.
Um algoritmo recursivo deve ter um caso base (parada) onde a recursão se encerra, como no cálculo do fatorial (fatorial(x) para x<=1 retorna 1). A complexidade de algoritmos recursivos, como o cálculo do fatorial, pode ser O(N).
A busca binária também pode ser implementada recursivamente, dividindo o problema em dois a cada passo.
A ordenação de sequências é um dos problemas mais importantes em computação, dada a sua vasta aplicação.
Neste método, o algoritmo varre o arranjo, encontrando o elemento máximo (ou mínimo) e o trocando de posição. A complexidade desse algoritmo é quadrática no tamanho $N$ da entrada, sendo proporcional a $(N^2 - N) / 2$, ou seja, O(N²).
A complexidade da ordenação por inserção varia com a entrada.
Melhor caso: O arranjo já está ordenado em ordem crescente. O custo é proporcional a $N$, ou seja, O(N).
Pior caso: O arranjo está ordenado em ordem decrescente. O custo é proporcional a $(N^2 + N) / 2$, ou seja, O(N²).
Este é um algoritmo de "divisão e conquista". Ele divide o arranjo em duas partes, ordena cada uma e, em seguida, une as duas partes. O custo de combinar as soluções é $O(N)$ em cada nível da recursão.
O custo total do Mergesort é O(N log N), um desempenho superior aos algoritmos quadráticos para grandes volumes de dados.
O algoritmo mais usado para ordenação.
Pior caso: O(N²).
Caso médio: O(N log N).
Busca Sequencial (Não-informada): Simplesmente varre o arranjo do início ao fim até encontrar o elemento. O custo no pior caso é O(N). O custo médio também é de ordem O(N).
Busca Binária: Supondo que o arranjo está ordenado, este algoritmo divide o problema em dois a cada passo. O número de iterações é $O(\log_2 N)$ (logaritmo de N na base 2). O custo total é O(log N).
Para resolver problemas mais desafiadores, o programador deve se familiarizar com estruturas de dados fundamentais, como:
Listas (Arrays): Sequências de elementos.
Pilhas (Stacks): Permitem a inserção e remoção de elementos apenas no topo (LIFO - Last In, First Out). (Nota: Procedimentos recursivos utilizam o Stack para gerenciar chamadas e variáveis locais).
Filas (Queues): Permitem a inserção e remoção de elementos apenas no início (FIFO - First In, First Out).
Para julgar um algoritmo, diversos fatores são considerados: tempo de escrita, complexidade de manutenção, consumo de memória e, principalmente, a eficiência de execução. A eficiência está relacionada à qualidade do código, tipo de processador, compilador e linguagem.
A análise de complexidade envolve avaliar o desempenho dos algoritmos em termos de tempo e espaço. Para quantificar a complexidade, utiliza-se a ordem de crescimento do tempo de processamento em função do tamanho da entrada ($N$).
A notação Big Oh indica a ordem de um algoritmo. O custo $T(N)$ de um algoritmo é $O(f(N))$ se, para $N$ grande, o desempenho do algoritmo for limitado a um múltiplo de $f(N)$.
A análise assintótica se preocupa com o comportamento para grandes valores de N. Em geral, a complexidade é considerada no pior caso. As partes de um programa que consomem mais recursos são geralmente os laços (loops), e a análise se concentra neles.
Notação | Big Oh | Ordem de Crescimento | Esforço Computacional (Didático) | Exemplo de AlgoritmoFonte(s) |
O(1) | Ordem Constante | Custo fixo (independente de N) | Trecho de programa com custo constante | |
O(log N) | Ordem Logarítmica | Crescimento lento (muito eficiente) | Busca Binária | |
O(N) | Ordem Linear | Crescimento proporcional a N | Busca Sequencial, Fatorial Iterativo | |
O(N log N) | Ordem Quase-Linear | Muito eficiente para ordenação | Mergesort, Quicksort (caso médio) | |
O(N²) | Ordem Quadrática | Crescimento rápido | Ordenação por Seleção, Ordenação por Inserção (pior caso) | |
O(N³) | Ordem Cúbica | Crescimento muito rápido | Soluções ingênuas para problemas complexos | |
O(2^N) | Ordem Exponencial | Crescimento explosivo (muito ineficiente) | Problemas de força bruta |
Um tipo de algoritmo muito eficiente é aquele com complexidade logarítmica. A base do logaritmo não importa na notação Big Oh.
Exemplos clássicos de O(log N):
Busca Binária: A cada passo, o problema é reduzido pela metade, resultando em um custo total de $O(\log N)$.
Laços com Divisão/Multiplicação Exponencial: Laços onde a variável de controle é repetidamente multiplicada ou dividida por uma constante (Ex: $x = x * 2$ ou $x = x / 2$).
Muitos problemas são resolvidos por este método genérico, no qual o problema é dividido em partes, resolvidas independentemente e depois combinadas.
Um exemplo notável é o Mergesort, onde o custo total $T(N)$ segue uma relação de recorrência como $T(N) = 2 \cdot T(\frac{N}{2}) + C \cdot N$. A solução para essa relação de recorrência é $O(N \log N)$.
Para relações de recorrência gerais, $T(N) = A \cdot T(\frac{N}{B}) + cN^L$, a complexidade pode ser determinada pelo Teorema Mestre, que é um conhecimento avançado e crucial em provas de algoritmos:
Condição | Solução da Complexidade $T(N)$ |
$A > B^L$ | $O(N^{\log_B A})$ |
$A = B^L$ | $O(N^L \log N)$ |
$A < B^L$ | $O(N^L)$ |
Embora os textos não detalhem "tratamento de exceções" (erros de software), a preocupação em concursos públicos se concentra na eficiência e nos casos críticos (as "exceções" de desempenho).
Pior Caso vs. Caso Médio: Um algoritmo pode ter desempenho diferente dependendo da entrada (como a Ordenação por Inserção). Em geral, a complexidade é analisada considerando o pior caso, que é quando o algoritmo tem o desempenho mais lento.
Otimização: Concentre as otimizações somente em pontos críticos (geralmente laços), e apenas depois de se certificar que o algoritmo funciona.
Para solidificar o conhecimento em lógica, é essencial a prática constante e a resolução de exercícios.
Resolver problemas de lógica pode ser desafiador, mas as seguintes estratégias facilitam a trajetória:
Entenda o Problema: Compreenda completamente as especificações, entradas, saídas e requisitos antes de escrever qualquer código.
Quebre em Etapas Menores: Divida o problema complexo em partes menores e resolva cada parte separadamente.
Pense em Termos de Algoritmos: Identifique os passos necessários e determine a ordem correta de execução.
Faça Esboços e Diagramas: Visualize o fluxo da solução (usando fluxogramas ou pseudocódigo) para encontrar falhas de lógica antes de implementar.
Pratique Regularmente: A lógica de programação é uma habilidade que se aprimora com a prática constante.
Depure seu Código: Use ferramentas de depuração para identificar erros ou falhas de lógica, analisando o comportamento passo a passo.
A prática deve começar com exercícios básicos que envolvem as estruturas de controle e operadores, tais como:
Cálculo e verificação de divisibilidade (Par ou Ímpar).
Comparação de números (Maior/Menor/Igual).
Verificação de condições múltiplas (Ex: Verificar idade: menor, adulto ou idoso; Aprovação por nota).
Cálculo de salário líquido, IMC e médias de notas.
Cálculo de fatorial (envolvendo repetição ou recursão).
Impressão de tabuadas (usando laços FOR ou WHILE).
Problemas que exigem a estrutura de repetição para encontrar uma solução (Ex: o problema de crescimento entre Francisco e Sara, que exige um laço para contar os anos).
Ao dominar esses conceitos fundamentais e avançados, você não apenas estará preparado para enfrentar os desafios de qualquer linguagem de programação, mas também terá a base teórica e prática exigida para obter sucesso nos concursos públicos mais rigorosos da área de TI.