## 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:

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

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

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.

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.

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

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

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

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.

function saudacao(nome) {
    console.log(`Olá, ${nome}!`);
}

2. Parâmetros
* Valores que a função recebe como entrada.

function soma(a, b) {
    return a + b;
}

3. Retorno
* Valor que a função devolve como resultado

let resultado = soma(10, 5);  // resultado = 15

Exemplo completo

// 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**

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**

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**

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**

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**

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**

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**

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**

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**

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/)