---
# System prepended metadata

title: Lógica de Programação

---

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