## Lógica de Programação: <span style="color: rgb(30,144,255);">Conceitos</span>
### Ementa
- [O que é Lógica de Programação?](#o-que-e-logica-de-programacao)
- [Formas de Representação](#formas-de-representacao)
- Pseudocódigo
- Fluxograma
- [Elementos Básicos da Lógica de Programação](#elementos-basicos-da-logica-de-programacao)
- Variáveis e Constantes
- Tipos de Dados
- Operadores (Aritméticos, Comparação, Lógicos)
- [Estruturas de Controle](#estruturas-de-controle)
- Condicionais (`if`, `else`, `elif`)
- Estruturas de Repetição (`for`, `while`)
- [Funções](#funcoes)
- Definição e Uso
- Parâmetros e Retorno
- [Exercícios Práticos](#exercicios-praticos)
- [Referências](#referencias)
### O que é Lógica de Programação?
<div style="text-align: justify">
Lógica de Programação é a habilidade de pensar de forma estruturada e sequencial para resolver problemas. Ela envolve a criação de <i>algoritmos</i>, que são conjuntos de passos bem definidos para realizar uma tarefa ou solucionar um problema.
</div>
#### Por que é importante ?
- É a base para aprender qualquer linguagem de programação
- Desenvolve o raciocínio lógico e a capacidade de resolver problemas
- Permite transformar ideias em instruções que um computador (ou nós mesmos) podemos executar.
### Formas de Representação
#### Exemplo Prático: Pseudocódigo
O **pseudocódigo** é uma forma de escrever algoritmos de maneira simples, sem se preocupar com a sintaxe de uma linguagem de programação.
#### Tarefa Diária:
```
Início
Acordar
Tomar café
Estudar
Se (Está na hora do trabalho?) então
Trabalhar
Senão
Descansar
Fim Se
Almoçar
Jantar
Dormir
Fim
```
#### Explicação:
- O pseudocódigo descreve a mesma lógica do fluxograma, mas em formato textual.
- É uma ótima maneira de planejar um programa antes de escrever o código real.
#### Exemplo Prático: Fluxograma
<div style="text-align: justify">
Agora que entendemos os conceitos básicos, podemos aplicar a lógica de programação em um exemplo prático. Um fluxograma é uma ferramenta visual que representa um algoritmo.
</div>
#### Tarefa Diária:
```mermaid
flowchart TD
st[Acordar] --> op1[Tomar café]
op1 --> op2[Estudar]
op2 --> cond1{Está na hora do trabalho?}
cond1 -- Sim --> op3[Trabalhar]
cond1 -- Não --> op4[Descansar]
op3 --> op5[Almoçar]
op4 --> op5
op5 --> op6[Jantar]
op6 --> e[Dormir]
```
#### Explicação:
- **Acordar**: Início do dia.
- **Tomar café**: Primeira ação após acordar.
- **Estudar**: Atividade seguinte.
- **Decisão**: Verifica se está na hora de trabalhar.
- Se Sim, ir Trabalhar.
- Se Não, ir Descansar.
- **Almoçar**: Refeição após trabalhar ou descansar.
- **Jantar**: Última refeição do dia.
- **Dormir**: Fim do dia.
#### Algoritmos
Um **algoritmo** é uma sequência finita de passos bem definidos para resolver um problema ou realizar uma tarefa.
#### Fases de um Algoritmo
```mermaid
flowchart LR
subgraph Entrada
e1[Receber dados de entrada]
style e1 fill:#FFD700,stroke:#FFA500,stroke-width:2px,color:#000000
end
subgraph Processamento
p1[Processar os dados]
p2[Realizar cálculos ou operações]
style p1 fill:#87CEEB,stroke:#1E90FF,stroke-width:2px,color:#000000
style p2 fill:#87CEEB,stroke:#1E90FF,stroke-width:2px,color:#000000
end
subgraph Saída
s1[Exibir resultados]
style s1 fill:#98FB98,stroke:#32CD32,stroke-width:2px,color:#000000
end
e1 --> p1 --> p2 --> s1
```
### Elementos Básicos da Lógica de Programação
#### Variáveis e Constantes
**Variáveis**
* Variáveis são "caixas" que armazenam dados na memória do computador.
* Elas têm um nome (identificador) e um valor que pode ser alterado durante a execução do programa.
* Exemplo: `idade = 25` (a variável `idade` armazena o valor 25).
**Constantes**
* Constantes são valores fixos que não mudam durante a execução do programa.
* Em muitas linguagens, constantes são escritas em letras maiúsculas por convenção.
* Exemplo: `PI = 3.14159.`
Exemplo: javacript
```javascript=
let nome = "Maria"; // Pode ser alterada
nome = "João"; // Agora nome é "João"
// Constante (usamos 'const' para declarar constantes)
const PI = 3.14159; // Valor fixo, não pode ser alterado
```
### Tipos de Dados
Os tipos de dados definem o tipo de valor que uma variável pode armazenar. Eles são essenciais para organizar e manipular informações em um programa.
#### Principais Tipos de Dados:
| Tipo de Dado | Descrição | Exempo |
|:--------------:|:------------------------------------:|:---------------------------------------:|
| **`int`** | Números inteiros | `idade = 25` |
| **`float`** | Números decimais | `altura = 1.75` |
| **`str`** | Texto (sequência de caracteres) | `nome = "Maria"` |
| **`bool`** | Valores lógicos (`True` ou `False`)| `aprovado = True` |
| **`list`** | Lista de valores | `numeros = [1, 2, 3]` |
| **`tuple`** | Tupla (lista imutável) | `coordenadas = (10, 20)` |
| **`dict`** | Dicionário (pares chave-valor) | `pessoa = {"nome": "João", "idade": 30}` |
| **`set`** | Conjunto (valores únicos) | `letras = {"a", "b", "c"}` |
#### Operadores
Os operadores são símbolos que realizam operações sobre variáveis e valores. Eles se dividem em:
1. Operadores Aritméticos
1. Operadores de Comparação
1. Operadores Lógicos
#### **1. Operadores Aritméticos**
Realizam cálculos matemáticos.
| Operador | Descrição | Exemplo | Resultado |
|:----------:|:---------------------:|:-------------------:|:-----------:|
| `+` | Soma | `10 + 5` | `15` |
| `-` | Subtração | `10 - 5` | `5` |
| `*` | Multiplicação | `10 * 5` | `50` |
| `/` | Divisão | `10 / 5` | `2.0` |
| `%` | Resto da divisão | `10 % 3` | `1` |
| `**` | Exponenciação | `2 ** 3` | `8` |
#### **2. Operadores de Comparação**
Comparam dois valores e retornam `True` ou `False`.
| Operador | Descrição | Exemplo | Resultado |
|:----------:|:---------------------:|:-------------------:|:-----------:|
| `==` | Igual | `10 == 5` | `False` |
| `!=` | Diferente | `10 != 5` | `True` |
| `>` | Maior | `10 > 5` | `True` |
| `<` | Menor | `10 < 5` | `False` |
| `>=` | Maior ou igual | `10 >= 5` | `True` |
| `<=` | Menor ou igual | `10 <= 5` | `False` |
#### **3. Operadores Lógicos**
Combinam expressões lógicas.
| Operador | Descrição | Exemplo | Resultado |
|:----------:|:---------------------:|:------------------------------------:|:-----------:|
| `and` | E (AND) | `(10 > 5) and (5 < 3)` | `False` |
| `or` | Ou (OR) | `(10 > 5) or (5 < 3)` | `True` |
| `not` | Não (NOT) | `not (10 > 5)` | `False` |
#### Estruturas Condicionais
As estruturas condicionais permitem que o programa tome decisões com base em condições. Elas são fundamentais para controlar o fluxo de execução do código
1. `if` (se)
Executa um bloco de código se a condição for verdadeira.
```javascript=
let idade = 18;
if (idade >= 18) {
console.log("Maior de idade");
}
```
2. `else` (senão)
Executa um bloco de código se a condição do `if` for falsa.
```javascript=
let idade = 15;
if (idade >= 18) {
console.log("Maior de idade");
} else {
console.log("Menor de idade");
}
```
3. `elif` (senão se)
Verifica uma nova condição se a anterior for falsa
```javascript=
let nota = 7.5;
if (nota >= 9) {
console.log("A");
} else if (nota >= 7) {
console.log("B");
} else {
console.log("C");
}
```
#### Estruturas de Repetição (Laços de Controle)
As estruturas de repetição permitem executar um bloco de código várias vezes. Elas são úteis para automatizar tarefas repetitivas.
1. `for` (para)
Repete um bloco de código um número específico de vezes
```javascript=
for (let i = 0; i < 5; i++) { // Repete 5 vezes
console.log(i); // 0, 1, 2, 3, 4
}
```
2. `while` (enquanto)
repete um bloco de código enquanto uma condição for verdadeira
```javascript=
let contador = 0;
while (contador < 5) {
console.log(contador); // 0, 1, 2, 3, 4
contador++;
}
```
#### Funções
As funções são blocos de código que realizam tarefas específicas e podem ser reutilizados. Elas ajudam a organizar o código e evitar repetições
1. Definição
* Use a palavra-chave `function` para criar uma função.
```javascript=
function saudacao(nome) {
console.log(`Olá, ${nome}!`);
}
```
2. Parâmetros
* Valores que a função recebe como entrada.
```javascript=
function soma(a, b) {
return a + b;
}
```
3. Retorno
* Valor que a função devolve como resultado
```javascript=
let resultado = soma(10, 5); // resultado = 15
```
Exemplo completo
```javascript=
// Função sem retorno
function saudacao(nome) {
console.log(`Olá, ${nome}!`);
}
saudacao("Maria"); // Saída: Olá, Maria!
// Função com retorno
function soma(a, b) {
return a + b;
}
let resultado = soma(10, 5); // resultado = 15
console.log(resultado); // Saída: 15
```
### Exercícios Práticos
Compilador Online: [programiz.com](https://www.programiz.com/javascript/online-compiler/)
1. **Algoritmos**
- Escreva um algoritmo (em pseudocódigo) para calcular a área de um retângulo. O algoritmo deve receber a base e a altura como entrada e exibir a área.
:heavy_check_mark: **Resposta**
```
Início
Ler base
Ler altura
área = base * altura
Exibir área
Fim
```
2. **Variáveis e Constantes**
- Crie um programa em Python que declare uma variável para armazenar o nome de uma pessoa e uma constante para armazenar o valor de π (pi). Em seguida, exiba os valores.
:heavy_check_mark: **Resposta**
```javascript=
const nome = "João";
const PI = 3.14159;
console.log("Nome:", nome);
console.log("Valor de PI:", PI);
```
3. **Tipos de Dados**
- Declare variáveis em javascript para armazenar os seguintes valores:
- Um número inteiro.
- Um número decimal.
- Uma string.
- Um valor booleano.
- Em seguida, exiba o tipo de cada variável.
:heavy_check_mark: **Resposta**
```javascript=
let idade = 25;
let altura = 1.75;
let nome = "Maria";
let aprovado = true;
console.log(typeof idade); // "number"
console.log(typeof altura); // "number"
console.log(typeof nome); // "string"
console.log(typeof aprovado); // "boolean"
```
4. **Operadores Aritméticos**
- Crie um programa que calcule a média de três notas e exiba o resultado.
:heavy_check_mark: **Resposta**
```javascript=
let nota1 = 8.5;
let nota2 = 7.0;
let nota3 = 9.0;
let media = (nota1 + nota2 + nota3) / 3;
console.log("Média:", media);
```
5. **Operadores de Comparação**
- Escreva um programa que verifique se um número é maior que 10 e exiba "Maior que 10" ou "Menor ou igual a 10".
:heavy_check_mark: **Resposta**
```javascript=
let numero = 15;
if (numero > 10) {
console.log("Maior que 10");
} else {
console.log("Menor ou igual a 10");
}
```
6. **Operadores Lógicos**
- Crie um programa que verifique se um número está entre 10 e 20 (inclusive).
:heavy_check_mark: **Resposta**
```javascript=
let numero = 15;
if (numero >= 10 && numero <= 20) {
console.log("Está entre 10 e 20");
} else {
console.log("Não está entre 10 e 20");
}
```
7. **Condicionais (if, else, else if)**
- Escreva um programa que classifique uma nota em:
- "A" (9 a 10),
- "B" (7 a 8.9),
- "C" (5 a 6.9),
- "D" (abaixo de 5).
:heavy_check_mark: **Resposta**
```javascript=
let nota = 7.5;
if (nota >= 9) {
console.log("A");
} else if (nota >= 7) {
console.log("B");
} else if (nota >= 5) {
console.log("C");
} else {
console.log("D");
}
```
8. **Loop for**
- Crie um programa que exiba os números de 1 a 10.
:heavy_check_mark: **Resposta**
```javascript=
for (let i = 1; i <= 10; i++) {
console.log(i);
}
```
9. ***Loop* while**
- Escreva um programa que exiba os números de 1 a 10 usando um loop while
:heavy_check_mark: **Resposta**
```javascript=
let contador = 1;
while (contador <= 10) {
console.log(contador);
contador++;
}
```
10. **Funções Simples**
- Crie uma função chamada saudacao que receba um nome como parâmetro e exiba "Olá, [nome]!".
:heavy_check_mark: **Resposta**
```javascript=
function saudacao(nome) {
console.log(`Olá, ${nome}!`);
}
saudacao("Maria");
```
### Referências
- Documentação oficial do Python: [python.com]()
- Tutoriais de Markdown: [hackmd.io](https://hackmd.io/?nav=overview)
- Guias de pseudocódigo: [geeksforgeeks.org](https://www.geeksforgeeks.org/)
- W3Schools: [w3schools.com](https://www.w3schools.com/)
{"title":"Lógica de Programação","lang":"pt-BR","description":"Forma de organizar pensamentos para resolver problemas.","contributors":"[{\"id\":\"37fbba84-7263-4d6e-84fe-f71d1fdeb5fe\",\"add\":34283,\"del\":14468}]"}