# Visão Geral da Linguagem de Programação Portugol
A linguagem de programação Portugol é uma ferramenta fundamental no aprendizado de lógica de programação. Este resumo destaca suas estruturas básicas, estruturas avançadas, tipos de dados, operações aritméticas, operações de comparação e comandos, fornecendo uma compreensão abrangente.

## Introdução
Portugol é uma linguagem educacional projetada para facilitar a transição para linguagens de programação mais complexas. Seu uso é prevalente em cursos introdutórios de programação, oferecendo uma abordagem didática para construção de algoritmos.
## Estruturas Básicas
### 1. Estrutura Sequencial
- Execução passo a passo, de cima para baixo.
- Utilização dos comandos `Escreva` e `Leia`.
- Exemplo:

    inteiro idade
    
    Escreva("Digite sua idade: ")
    Leia(idade)

### 2. Estrutura de Decisão (Seleção)
- Comandos `se` e `senao` para tomada de decisões.
- Exemplo:

    inteiro idade
    
    Leia(idade)
    
    se idade >= 18 entao
        Escreva("Você é maior de idade.")
    senao
        Escreva("Você é menor de idade.")
    fimse

### 3. Estrutura de Repetição (Iteração)
- Comandos `enquanto`, `para` e `escolha caso` para controle de fluxo.
- Exemplo:

    inteiro opcao
    
    Escreva("Escolha uma opção (1 a 3): ")
    Leia(opcao)
    
    escolha caso opcao
        caso 1
            Escreva("Você escolheu a opção 1.")
        caso 2
            Escreva("Você escolheu a opção 2.")
        caso 3
            Escreva("Você escolheu a opção 3.")
        senao
            Escreva("Opção inválida.")
    fimescolha

### 3. Estrutura de Repetição (Iteração)
- Comandos `enquanto`, `faça enquanto`, `para` e `escolha caso` para controle de fluxo.
- Exemplo ` enquanto`:

    inteiro contador = 1
    
    enquanto contador <= 5 faca
        Escreva("Contagem: ", contador)
        contador = contador + 1
    fimenquanto

- Exemplo com `faça enquanto`:

    inteiro senha
    
    faca
        Escreva("Digite a senha: ")
        Leia(senha)
    enquanto senha != 1234

    algoritmo exemplo_faca_enquanto
    var
        contador: inteiro

    inicio
        contador <- 1
    
    faca
  		escreva("Contagem:", contador)
        contador <- contador + 1
    ate contador > 5
    
    escreva("Fim do programa.")

    fimalgoritmo   

- Exemplo com `para`:

    para (x=1; x<=5 ; x++)  faca {
        Escreva("Iteração: ", i)
    fimpara
    }

## Estruturas Avançadas
### 4. Vetores e Matrizes
- Declaração e manipulação de vetores e matrizes.
- Exemplo de Vetor:

    inteiro numeros[5]
    
    para inteiro i de 0 ate 4 faca
        Escreva("Digite o número ", i + 1, ": ")
        Leia(numeros[i])
    fimpara
    
    Escreva("Valores do vetor: ")
    
    para inteiro i de 0 ate 4 faca
        Escreva(numeros[i], " ")
    fimpara

- Exemplo de Matriz:

    inteiro matriz[3][3]
    
    para (i=0; i<=2; i++)faca {
        para (j=0; j=2; j++) faca{
            Escreva("Digite o valor para a posição [", i, "][", j, "]: ")
            }
            Leia(matriz[i][j])
            }
        fimpara
    fimpara
    
    Escreva("Valores da matriz: ")
    
    para (i=0; i=2; i++)faca{
        para (j=0; j=2; j++)  faca{
            Escreva(matriz[i][j], " ")
            }
        fimpara
        Escreva()
    fimpara

### 5. Funções
- As funções em Portugol permitem modularizar o código, dividindo-o em partes menores e mais gerenciáveis.
- Exemplo de Declaração e Uso de Função:

    // Função para calcular a soma de dois números inteiros
    funcao soma(a, b)
        retorne a + b
    fimfuncao
    
    // Utilizando a função
    inteiro resultado
    resultado = soma(3, 5)
    Escreva("A soma é: ", resultado)

- Exemplo de Função com Parâmetros e Retorno:

    // Função que verifica se um número é positivo, negativo ou zero
    funcao classificarNumero(numero)
        se numero > 0 entao
            retorne "Positivo"
        senao se numero < 0 entao
            retorne "Negativo"
        senao
            retorne "Zero"
        fimse
    fimfuncao
    
    // Utilizando a função
    inteiro num = -10
    caractere classificacao
    classificacao = classificarNumero(num)
    Escreva("O número ", num, " é ", classificacao)

- Observação: Funções facilitam a reutilização de código e tornam o programa mais modular e legível.

### 6. Sub-rotinas (Funções e Procedimentos)
- Modularização do código para facilitar a manutenção.
- Exemplo:

    funcao soma(a, b)
        retorne a + b
    fimfuncao
    
    inteiro resultado
    resultado = soma(3, 5)

## Tipos de Dados
- `Inteiro`
- `Real`
- `Lógico`
- `Caractere`
- `Texto`
- `Data`
- `Vetor`
- `Matriz`

### Exemplos
- `real preco = 29.99`
- `inteiro idade = 25`
- `logico aprovado = verdadeiro`
- `caracter letra = 'A'`
- `texto nome = "João"`
- `vetor nomes [5] = ["João", "Ana", "Paulo", "Denis", "Matheus"]`
- `matriz numeros [3][3] = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]`

## Constantes
- `LETRA_MAIUSCULA`

## Operações Aritméticas
- `+` (Soma)
- `-` (Subtração)
- `*` (Multiplicação)
- `/` (Divisão)
- `%` (Resto da Divisão - Mod)

## Operações de Comparação
- `>` (Maior)
- `<` (Menor)
- `>=` (Maior ou Igual)
- `<=` (Menor ou Igual)
- `==` (Igual)
- `<>` (Diferente)

# Operandos para atribuição de valores:
## Operadores de Atribuição Composta em C++
## Operadores de Atribuição Composta em C++

| Operador | Descrição |
| -------- | --------------------------------------------------------------- |
| `+=` | Soma o valor de `variavel2` à `variavel1` |
| `-=` | Subtrai o valor de `variavel2` da `variavel1` |
| `*=` | Multiplica `variavel1` por `variavel2` |
| `/=` | Divide `variavel1` por `variavel2` |
| `%=` | Obtém o resto da divisão de `variavel1` por `variavel2` |
| `&=` | Efetua a operação AND bit a bit entre `variavel1` e `variavel2` |
| `^=` | Efetua a operação XOR bit a bit entre `variavel1` e `variavel2` |
| `++` | Incrementa `variavel1` em 1 |
| `--` | Decrementa `variavel1` em 1 |

**Observações:**

* Os operadores `^=`, `|=` e `&=` são usados para operações bit a bit, e só funcionam com tipos de dados inteiros.
* Os operadores `++` e `--` podem ser usados como prefixo ou sufixo. No caso de prefixo, o valor é incrementado/decrementado antes de ser usado na expressão. No caso de sufixo, o valor é incrementado/decrementado depois de ser usado na expressão.

# Comandos, Tipos de Dados e Estruturas em Portugol e JavaScript

| Portugol | JavaScript |
|----------------------|---------------------|
| `algoritmo` | `console.log` |
| `declare` | `let` ou `const` |
| `escreva` | `console.log` |
| `leia` | `prompt` |
| `se...senão` `Senão Se` | `if...else` `else if` |
| `para...faça` | `for` |
| `enquanto` | `while` |
| `faca...enquanto` | `do...while` |
| `escolha...caso` | `switch...case` |
| `funcao` | `function` |
| `retorne` | `return` |
| `vetor` | `Array` |
| `matriz` | `Array` de `Array` |
| `inteiro` | `number` |
| `real` | `number` |
| `lógico` | `boolean` |
| `caractere` | `string` |
| `texto` | `string` |
| `data` | `Date` |

# Conclusão
- Resumo das principais características e vantagens do Portugol.
- Destaque para aplicações específicas e limitações.
- Incentivo ao aprendizado contínuo de programação.