Programação Descomplicada Aprendendo a Lógica de Programação

Você está em: Início > Artigos > Desenvolvimento > Lógica de Programação

Olá! Caro leitor, neste artigo irei falar sobre programação descomplicada, trazendo uma visão simples e clara na área de desenvolvimento.

O que é Lógica de Programação?

Lógica de Programação é a habilidade de organizar e estruturar o pensamento de forma sequencial e lógica, para resolver problemas computacionais de maneira eficiente. É uma das habilidades mais importantes para programadores, já que é a base para a criação de algoritmos e programas de computador.

Um programador com boa habilidade em Lógica de Programação é capaz de resolver problemas complexos de forma eficiente, escrever códigos mais organizados, com menos erros e mais fáceis de manter e entender. Portanto, é fundamental para quem quer se tornar um programador ou desenvolvedor de software bem-sucedido.

Os Fundamentos da Lógica da Programação

A Lógica de Programação envolve o uso de estruturas de controle, como condições (if/else) e loops (for/while), para controlar o fluxo de execução de um programa. Além disso, inclui o uso de operações matemáticas, lógicas e outras para manipular dados e realizar cálculos.

• Algoritmos: são sequências de instruções lógicas que resolvem um problema específico.
• Estruturas de controle: permitem ao programador controlar o fluxo de execução do programa. As estruturas mais comuns são as condições (if/else) e os loops (for/while).
• Variáveis: são espaços de memória reservados para armazenar dados que podem ser usados em cálculos e decisões no programa.
• Operadores: permitem realizar cálculos e manipular valores. Os operadores mais comuns incluem os aritméticos (+, -, *, /) e os relacionais (>, <, =). Estruturas de dados: permitem organizar e manipular grandes conjuntos de dados de forma eficiente. As estruturas mais comuns incluem arrays, listas e mapas.

Como Praticar Lógica de Programação Sem Um Computador

Existem várias maneiras de praticar Lógica de Programação sem a necessidade de um computador. Algumas sugestões incluem:

Resolver problemas de matemática: problemas de matemática envolvem muitos dos mesmos conceitos que a Lógica de Programação, como a resolução de problemas em etapas e a manipulação de dados.

Além disso, a matemática oferece muitos problemas interessantes e desafiadores para solucionar.

Jogos de tabuleiro: jogos de tabuleiro como xadrez, damas, jogo da velha, entre outros, exigem a capacidade de pensar estrategicamente e prever os movimentos do oponente, o que envolve a Lógica de Programação.

Montar quebra-cabeças: montar um quebra-cabeça envolve a capacidade de pensar em soluções e seguir um conjunto de regras para alcançar um objetivo, o que pode ajudar a desenvolver a Lógica de Programação.

Criar fluxogramas: a criação de fluxogramas é uma forma visual de representar um algoritmo. Tente criar fluxogramas para resolver problemas simples do cotidiano, como preparar um café da manhã, fazer uma lista de compras ou realizar uma tarefa específica no trabalho.

Criar diagramas de blocos: diagramas de blocos são outra forma visual de representar um algoritmo.

Tente criar diagramas de blocos para resolver problemas simples, como fazer uma receita ou organizar seu tempo em um determinado dia.

Essas atividades podem ajudar a desenvolver a Lógica de Programação de forma não computacional e podem ser uma maneira divertida de praticar suas habilidades de resolução de problemas e pensamento lógico.

Conceitos Básicos de Algoritmos

Um algoritmo é uma sequência finita de instruções bem definidas e ordenadas, que descrevem a maneira de resolver um problema ou realizar uma tarefa específica. É uma espécie de receita, que orienta o processo de solução de um problema.

Os algoritmos podem ser utilizados em diversas áreas, como ciência da computação, matemática, física, engenharia, entre outras, para descrever a maneira como um problema deve ser solucionado.

Eles são especialmente importantes na programação de computadores, pois são usados para definir a lógica e a sequência de passos que um programa deve seguir para executar uma tarefa.

Um algoritmo deve ser preciso, passível de ser entendido por outras pessoas, independente da linguagem de programação utilizada, e deve ser capaz de resolver o problema proposto.

Ele pode ser representado por meio de fluxogramas, pseudocódigo, ou outras formas de representação, e é uma parte fundamental da Lógica de Programação.

Formalizando a Escrita de Algoritmos

Existem diversas formas de formalizar a escrita de algoritmos, mas em geral, é importante seguir algumas boas práticas para garantir que o algoritmo seja claro, fácil de entender e possa ser executado de forma correta. Algumas dicas incluem:

• Definir o problema: antes de começar a escrever o algoritmo, é importante entender claramente qual é o problema que você está tentando resolver. Defina o problema com clareza e certifique-se de que você sabe exatamente qual é a saída esperada.
• Utilizar uma linguagem clara e precisa: utilize uma linguagem clara e precisa para escrever o algoritmo. Evite termos ambíguos ou confusos e utilize nomes de variáveis e funções que sejam significativos para o problema que você está resolvendo.

• Dividir o algoritmo em etapas: quebre o problema em etapas menores e organize as instruções em uma sequência lógica. Certifique-se de que cada etapa do algoritmo tenha um objetivo claro e seja independente das demais.
• Utilizar fluxogramas ou pseudocódigo: represente o algoritmo utilizando fluxogramas ou pseudocódigo. Os fluxogramas são diagramas que representam graficamente as etapas do algoritmo, enquanto o pseudocódigo é uma forma de escrever o algoritmo de forma mais próxima à linguagem natural.
• Testar o algoritmo: antes de utilizar o algoritmo em um programa, teste-o para garantir que ele esteja correto e produza a saída esperada. Tente identificar possíveis erros ou falhas no algoritmo e revise-o sempre que necessário.

Seguindo essas boas práticas, você poderá formalizar a escrita de algoritmos de forma clara e precisa, o que facilitará a compreensão e a execução do algoritmo.

Variáveis

Dentro de um algoritmo, as variáveis são entidades que armazenam valores temporários ou permanentes. Elas são usadas para armazenar e manipular dados durante a execução do algoritmo.

As variáveis podem ter diferentes tipos, como inteiros, números reais, booleanos, caracteres, dentre outros. O tipo de variável usado depende dos dados que precisam ser armazenados e manipulados no algoritmo.

As variáveis têm um nome que é usado para se referir a elas no código do algoritmo. É importante escolher nomes de variáveis que sejam descritivos e representem claramente o valor que está sendo armazenado.

As variáveis são declaradas no início do algoritmo e podem ser inicializadas com um valor específico ou podem ser deixadas sem valor inicial, dependendo das necessidades do algoritmo.

Durante a execução do algoritmo, os valores armazenados nas variáveis podem ser alterados conforme necessário.

Constantes

Em algoritmos, as constantes são valores que não mudam durante a execução do programa. Elas são valores fixos que são definidos no início do algoritmo e permanecem constantes ao longo de toda a execução do programa.

As constantes são úteis em algoritmos para representar valores que não devem ser alterados durante a execução do programa.

Isso pode incluir valores como números fixos, valores de configuração, parâmetros de entrada ou outros dados que não mudam.

As constantes são geralmente definidas usando uma declaração de constante no início do programa, e são escritas em maiúsculas para indicar que são valores constantes.

Em muitas linguagens de programação, as constantes não podem ser modificadas durante a execução do programa, tornando-as mais seguras e confiáveis do que variáveis que podem mudar durante a execução do programa.

Usar constantes em algoritmos pode ajudar a tornar o código mais legível e fácil de entender, pois torna claro quais valores são importantes para o algoritmo e quais valores são variáveis que podem mudar ao longo da execução do programa.

Comandos de Atribuição, Entrada e Saída de Dados

Dentro de um algoritmo, os comandos de atribuição são usados para armazenar e recuperar dados da entrada e saída de dados.

Existem diferentes formas de realizar a entrada e saída de dados em um algoritmo, dependendo da linguagem de programação que está sendo usada.

Para realizar a entrada de dados em um algoritmo, o programa pode usar comandos que leiam dados do usuário, como o comando “read” em algumas linguagens.

Por exemplo, em uma linguagem de programação como C++, um comando de entrada de dados poderia ser:

int idade;
cout << "Digite a sua idade: ";
cin >> idade;

Nesse exemplo, o comando “cout” é usado para exibir uma mensagem ao usuário pedindo que ele digite a sua idade. Em seguida, o comando “cin” é usado para ler o valor digitado pelo usuário e armazená-lo na variável “idade”.

Para realizar a saída de dados em um algoritmo, o programa pode usar comandos que exibam informações na tela ou em outros dispositivos de saída, como o comando “print” em algumas linguagens. Por exemplo, em uma linguagem de programação como Python, um comando de saída de dados poderia ser:

nome = "João"
idade = 30
print("O nome é", nome, "e a idade é", idade)

Nesse exemplo, o comando “print” é usado para exibir na tela uma mensagem contendo o nome e a idade de uma pessoa. Os valores das variáveis “nome” e “idade” são inseridos na mensagem usando a sintaxe de concatenação de strings da linguagem Python.

Em resumo, os comandos de atribuição em algoritmos permitem que os dados sejam lidos da entrada, armazenados em variáveis e exibidos na saída de forma organizada e estruturada.

Operadores aritméticos e expressões aritméticas

Os operadores aritméticos são usados em algoritmos para realizar operações matemáticas básicas, como adição, subtração, multiplicação e divisão. Eles são usados em expressões aritméticas para calcular um resultado a partir de um ou mais valores numéricos.

Os operadores aritméticos mais comuns em algoritmos são:

Adição (+): usado para adicionar dois valores

Subtração (-): usado para subtrair um valor de outro

Multiplicação (*): usado para multiplicar dois valores

Divisão (/): usado para dividir um valor por outro

Módulo (%): usado para calcular o resto de uma divisão inteira

As expressões aritméticas combinam valores e operadores aritméticos para calcular um resultado. Por exemplo, a expressão aritmética “2 + 3 * 4” primeiro multiplica 3 por 4 e, em seguida, adiciona 2 ao resultado, produzindo um resultado final de 14.

Em algoritmos, as expressões aritméticas podem ser usadas em uma variedade de situações, como cálculos de fórmulas matemáticas, manipulação de valores em variáveis, e em condições lógicas e de decisão.

Além dos operadores aritméticos básicos, algumas linguagens de programação também suportam operadores adicionais, como exponenciação, radiciação, e outras funções matemáticas mais avançadas.

O uso desses operadores pode variar de acordo com a linguagem de programação utilizada.

Expressões Lógicas e Estruturas de Decisão

As expressões lógicas e as estruturas de decisão são elementos fundamentais em algoritmos e programação para controlar o fluxo do programa baseado em condições lógicas.

As expressões lógicas são usadas para comparar valores e produzir resultados verdadeiros ou falsos (booleans).

Por exemplo, uma expressão lógica pode comparar se dois valores são iguais, se um valor é maior do que outro, ou se uma variável contém um valor específico. As operações lógicas mais comuns são:

Igualdade (==): testa se dois valores são iguais.

Desigualdade (!=): testa se dois valores são diferentes.

Maior que (>): testa se um valor é maior que outro.

Menor que (<): testa se um valor é menor que outro.

Maior ou igual (>=): testa se um valor é maior ou igual a outro.

Menor ou igual (<=): testa se um valor é menor ou igual a outro. As estruturas de decisão são usadas para controlar o fluxo do programa baseado em condições lógicas.

A estrutura mais comum é a instrução “if”, que permite que o programa execute diferentes blocos de código baseado em uma condição lógica.

Por exemplo, em um algoritmo que verifica se uma pessoa é maior de idade, pode-se usar a estrutura de decisão “if” para determinar se a pessoa é maior de idade ou não:

int idade = 20;
if (idade >= 18) {
    // bloco de código executado se a idade for maior ou igual a 18
    cout << "Você é maior de idade" << endl;
} else {
    // bloco de código executado se a idade for menor que 18
    cout << "Você é menor de idade" << endl;
}

Nesse exemplo, a estrutura de decisão “if” é usada para comparar a idade com o valor 18. Se a idade for maior ou igual a 18, o bloco de código dentro das chaves “{}” será executado, imprimindo na tela a mensagem “Você é maior de idade”.

Se a idade for menor que 18, o bloco de código dentro do “else” será executado, imprimindo a mensagem “Você é menor de idade”.

Existem outras estruturas de decisão mais avançadas, como a estrutura “switch”, que é usada para comparar uma variável com vários valores possíveis e executar diferentes blocos de código dependendo do valor da variável.

A escolha da estrutura de decisão depende das necessidades específicas do algoritmo e da linguagem de programação utilizada.

Operadores Relacionais, Operadores Lógicos e Expressões Lógicas

Os operadores relacionais, operadores lógicos e expressões lógicas são usados em conjunto com as estruturas de decisão para controlar o fluxo do programa baseado em condições lógicas.

Os operadores relacionais são usados para comparar valores e produzir um resultado verdadeiro ou falso. Eles são comumente usados em expressões lógicas. Os operadores relacionais mais comuns são:

Igual (==): testa se dois valores são iguais.

Diferente (!=): testa se dois valores são diferentes.

Maior que (>): testa se um valor é maior do que outro.

Menor que (<): testa se um valor é menor do que outro.

Maior ou igual a (>=): testa se um valor é maior ou igual a outro.

Menor ou igual a (<=): testa se um valor é menor ou igual a outro.

Os operadores lógicos são usados para combinar expressões lógicas e produzir um resultado verdadeiro ou falso. Os operadores lógicos mais comuns são:

E (&&): retorna verdadeiro se ambas as expressões lógicas são verdadeiras.

Ou (||): retorna verdadeiro se pelo menos uma das expressões lógicas é verdadeira.

Não (!): inverte o valor da expressão lógica, retornando verdadeiro se a expressão lógica é falsa, e falso se a expressão lógica é verdadeira.

As expressões lógicas combinam valores e operadores relacionais para produzir um resultado verdadeiro ou falso. Por exemplo, a expressão lógica “idade >= 18 && salario > 1000” verifica se a idade é maior ou igual a 18 E o salário é maior do que 1000.

Se ambos os valores forem verdadeiros, a expressão lógica será verdadeira, caso contrário, será falsa.

As estruturas de decisão, como a instrução “if”, podem usar expressões lógicas para controlar o fluxo do programa.

Por exemplo, em um algoritmo que verifica se um usuário pode acessar um recurso, pode-se usar a expressão lógica “usuario_autorizado && recurso_disponivel” dentro de uma instrução “if” para verificar se o usuário está autorizado e se o recurso está disponível antes de conceder acesso ao recurso.

O uso de operadores relacionais, operadores lógicos e expressões lógicas permite que os algoritmos e programas executem ações baseadas em condições lógicas, tornando-os mais flexíveis e poderosos.

Estrutura de Decisão

As estruturas de decisão são usadas em algoritmos para controlar o fluxo do programa baseado em condições lógicas.

As estruturas de decisão mais comuns são a instrução “if”, a instrução “else if” e a instrução “else”. A instrução “if” permite executar uma ação se uma expressão lógica for verdadeira. A sintaxe básica da instrução “if” é:

if (expressão lógica) {
    // ação a ser executada se a expressão lógica for verdadeira
}

Por exemplo, o seguinte código verifica se a idade é maior ou igual a 18 e imprime uma mensagem se for verdadeiro:

int idade = 20;
if (idade >= 18) {
    System.out.println("Você tem idade suficiente para votar.");
}

Se a idade for menor do que 18, a ação dentro do bloco de código não será executada.

A instrução “else if” é usada para verificar outras condições se a primeira expressão lógica não for verdadeira. A sintaxe básica da instrução “else if” é:

if (expressão lógica 1) {
    // ação a ser executada se a expressão lógica 1 for verdadeira
} else if (expressão lógica 2) {
    // ação a ser executada se a expressão lógica 2 for verdadeira
} else {
    // ação a ser executada se nenhuma das expressões lógicas anteriores for verdadeira
}

Por exemplo, o seguinte código verifica se a idade é maior ou igual a 18 ou se a pessoa é um estudante e imprime uma mensagem correspondente:

int idade = 16;
boolean estudante = true;

if (idade >= 18) {
    System.out.println("Você tem idade suficiente para votar.");
} else if (estudante) {
    System.out.println("Você é um estudante e pode votar quando tiver 16 anos.");
} else {
    System.out.println("Você não tem idade suficiente para votar e não é um estudante.");
}

A instrução “else” é usada para executar uma ação se nenhuma das expressões lógicas anteriores for verdadeira. A sintaxe básica da instrução “else” é:

if (expressão lógica) {
    // ação a ser executada se a expressão lógica for verdadeira
} else {
    // ação a ser executada se a expressão lógica for falsa
}

Por exemplo, o seguinte código verifica se a idade é maior ou igual a 18 e imprime uma mensagem se for verdadeiro, caso contrário, imprime uma mensagem diferente:

int idade = 16;
if (idade >= 18) {
    System.out.println("Você tem idade suficiente para votar.");
} else {
    System.out.println("Você não tem idade suficiente para votar.");
}

O uso de estruturas de decisão em conjunto com expressões lógicas permite que os algoritmos e programas tomem decisões e executem ações baseadas em condições lógicas, tornando-os mais flexíveis e poderosos.

Estruturas de Repetição

As estruturas de repetição, também conhecidas como laços ou loops, são usadas em algoritmos e programas para executar uma determinada sequência de instruções várias vezes, de acordo com uma condição lógica.

As estruturas de repetição mais comuns são o “for”, o “while” e o “do-while”.

A estrutura “for” é usada quando se sabe antecipadamente o número de vezes que as instruções devem ser executadas. A sintaxe básica da estrutura “for” é:

for (inicialização; condição; atualização) {
    // sequência de instruções a serem executadas
}

Onde:

“inicialização” é uma instrução que é executada uma única vez, antes do início do laço, para inicializar uma variável de controle;

“condição” é uma expressão lógica que é verificada a cada iteração do laço. Se a condição for verdadeira, as instruções dentro do bloco de código são executadas; caso contrário, o laço é encerrado;

“atualização” é uma instrução que é executada no final de cada iteração, para atualizar a variável de controle. Por exemplo, o seguinte código imprime os números de 1 a 10:

for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

A estrutura “while” é usada quando não se sabe antecipadamente quantas vezes as instruções devem ser executadas. A sintaxe básica da estrutura “while” é:

while (condição) {
    // sequência de instruções a serem executadas
}

Onde:

“condição” é uma expressão lógica que é verificada a cada iteração do laço. Se a condição for verdadeira, as instruções dentro do bloco de código são executadas; caso contrário, o laço é encerrado.

Por exemplo, o seguinte código imprime os números de 1 a 10:

int i = 1;
while (i <= 10) {
    System.out.println(i);
    i++;
}

A estrutura “do-while” é semelhante à estrutura “while”, mas as instruções são executadas pelo menos uma vez, independentemente da condição lógica.

A sintaxe básica da estrutura “do-while” é:

do {
    // sequência de instruções a serem executadas
} while (condição);

Onde:

“condição” é uma expressão lógica que é verificada no final de cada iteração do laço.

Se a condição for verdadeira, as instruções dentro do bloco de código são executadas novamente; caso contrário, o laço é encerrado.

Por exemplo, o seguinte código imprime os números de 1 a 10:

int i = 1;
do {
    System.out.println(i);
    i++;
} while (i <= 10);

O uso de estruturas de repetição permite que os algoritmos e programas executem tarefas repetitivas de maneira eficiente e flexível, aumentando a produtividade e reduzindo o tempo de desenvolvimento.

Estrutura de Repetição Para…Faça

A estrutura de repetição “para…faça” (ou “for…do” em algumas linguagens de programação) é uma variação da estrutura “for” e é utilizada quando é necessário executar um conjunto de instruções um número fixo de vezes.

A sintaxe básica da estrutura “para…faça” é a seguinte:

para variável = valorInicial até valorFinal faça
    // sequência de instruções a serem executadas
Fimpara

Onde:

“variável” é uma variável que será utilizada como contador;

“valorInicial” é o valor inicial da variável de controle;

“valorFinal” é o valor final da variável de controle;

“faça” é a palavra-chave que indica o início do bloco de código a ser executado a cada iteração. Por exemplo, o seguinte código em pseudocódigo imprime os números de 1 a 10:

para i = 1 até 10 faça
    escreva(i)
fimpara

Essa estrutura de repetição é semelhante à estrutura “for” convencional, mas com uma sintaxe mais simples e intuitiva.

A estrutura “para…faça” é especialmente útil quando se sabe antecipadamente o número de iterações necessárias e quando se trabalha com contadores simples.

Estrutura de Repetição Enquanto…Faça

A estrutura de repetição “enquanto…faça” (ou “while…do” em algumas linguagens de programação) é utilizada quando é necessário executar um conjunto de instruções enquanto uma condição for verdadeira.

A sintaxe básica da estrutura “enquanto…faça” é a seguinte:

enquanto condição faça
    // sequência de instruções a serem executadas
Fimenquanto

Onde:

“condição” é uma expressão lógica que é avaliada a cada iteração da estrutura;

“faça” é a palavra-chave que indica o início do bloco de código a ser executado enquanto a condição for verdadeira.

Por exemplo, o seguinte código em pseudocódigo imprime os números de 1 a 10:

i = 1
enquanto i <= 10 faça
    escreva(i)
    i = i + 1
fimenquanto

Esse código utiliza a variável “i” como um contador e executa o laço enquanto o valor de “i” for menor ou igual a 10.

A cada iteração, o valor de “i” é incrementado em 1 e o número correspondente é impresso na tela. A estrutura “enquanto…faça” é muito útil quando não se sabe antecipadamente quantas iterações serão necessárias, mas sabe-se a condição que deve ser satisfeita para encerrar o laço.

É importante ter cuidado para garantir que a condição de saída seja alcançada em algum momento, caso contrário o laço pode se tornar infinito e causar um travamento no programa.

Algumas das literaturas ligadas ao estudo de Lógica de Programação incluem:

“Algoritmos: Teoria e Prática” de Thomas Cormen, Charles Leiserson, Ronald Rivest e Clifford Stein.

“Introdução à Programação com Python: Algoritmos e Lógica de Programação para Iniciantes” de Nilo Ney Coutinho Menezes.

“Lógica de Programação: Crie seus primeiros programas usando Javascript e HTML” de Silvio Guedes Crespo.

“Aprenda a Programar: Algoritmos, Lógica de Programação e Desenvolvimento de Aplicativos” de Rodrigo Gonçalves Santana. “Programação em C: Algoritmos, Estruturas de Dados e Objetos” de Ana Fernanda Gomes Ascencio e Edilene Aparecida Veneruchi de Campos.