tds-lp

Apostila de Portugol

Disciplina: Lógica de Programação – Prof. Mauro Borges França

Curso: Técnico em Desenvolvimento de Sistemas Integrado ao Ensino Médio - TDS

Material: apostila de Portugol (VisuAlg), organizada na mesma sequência das aulas de lógica e no mesmo modelo das apostilas de Linguagem C e Python.

Sumário

Como encontrar um assunto: use este sumário para navegar pelos capítulos ou consulte o Índice por assunto no final da apostila. Nos arquivos digitais, os itens são clicáveis. No material impresso, procure pelo número da seção (ex.: 5.14), que aparece no título de cada seção.

• Capítulo 0 – Preparando o ambiente
• Capítulo 1 – Introdução: do pensamento ao algoritmo
  • 1.1 – Conceitos iniciais
  • 1.2 – Método para a construção de algoritmos
  • 1.3 – Tipos de algoritmos
  • 1.4 – Estrutura do algoritmo no VisuAlg
  • 1.5 – Tipos básicos de dados (primitivos)
  • 1.6 – Constantes
  • 1.7 – Variáveis
  • 1.8 – Formação de identificadores
  • 1.9 – Declaração e atribuição
  • 1.10 – Operadores aritméticos
  • 1.11 – Operadores relacionais
  • 1.12 – Operadores lógicos e tabela verdade
  • 1.13 – Comandos de entrada e saída
  • 1.14 – Blocos de comandos e indentação
  • 1.15 – Prática
• Capítulo 2 – Estrutura Condicional (Parte 1)
  • 2.1 – Operadores relacionais
  • 2.2 – Operadores lógicos
  • 2.3 – Estruturas condicionais (estruturas de controle)
  • 2.4 – Vamos para a prática
• Capítulo 3 – Estrutura Condicional (Parte 2): escolha/caso
  • 3.1 – Estrutura de seleção escolha/caso
  • 3.2 – Comparação com o se/senao
• Capítulo 4 – Estruturas de Repetição
  • 4.1 – Repetição baseada em contagem: para
  • 4.2 – Repetição com teste no início: enquanto
  • 4.3 – Repetição com teste no final: repita
  • 4.4 – Qual estrutura escolher?
• Capítulo 5 – Estrutura de Dados: Vetores
  • 5.1 – O que é um vetor?
  • 5.2 – Diferença entre variável simples e vetor
  • 5.3 – Declaração de um vetor
  • 5.4 – Índices e posições
  • 5.5 – Limites do vetor
  • 5.6 – Atribuição direta de valores
  • 5.7 – Leitura de valores em um vetor
  • 5.8 – Exibição dos valores
  • 5.9 – Percurso em ordem normal e inversa
  • 5.10 – Soma dos valores de um vetor
  • 5.11 – Cálculo da média
  • 5.12 – Contagem de valores
  • 5.13 – Exibição de valores que atendem a uma condição
  • 5.14 – Maior valor do vetor
  • 5.15 – Menor valor do vetor
  • 5.16 – Maior e menor valor no mesmo algoritmo
  • 5.17 – Localização da posição do maior valor
  • 5.18 – Busca de um valor no vetor
  • 5.19 – Alteração de uma posição
  • 5.20 – Capacidade e quantidade preenchida
  • 5.21 – Vetores paralelos
  • 5.22 – Exemplo completo: análise de notas
  • 5.23 – Erros comuns no uso de vetores
  • 5.24 – Resumo do capítulo
  • 5.25 – Atividades de fixação
• Capítulo 6 – Estrutura de Dados: Matriz
  • 6.1 – O que é uma matriz
  • 6.2 – Declaração de uma matriz
  • 6.3 – Acesso aos elementos
  • 6.4 – Leitura e escrita em matrizes
  • 6.5 – Exibindo a matriz em formato de tabela
  • 6.6 – Média de cada aluno (cálculo por linha)
• Capítulo 7 – Procedimentos
  • 7.1 – O que são funções e procedimentos?
  • 7.2 – Procedimentos no VisuAlg
  • 7.3 – Organizando as listas de exercícios com menu
  • 7.4 – Como escrever um procedimento no VisuAlg
  • 7.5 – Onde colocar e como chamar o procedimento
  • 7.6 – Exemplo completo: uma lista com menu
  • 7.7 – Como adaptar um exercício que você já resolveu
  • 7.8 – Cuidados importantes
• Capítulo 8 – Funções
  • 8.1 – O que são funções?
  • 8.2 – Estrutura básica de uma função
  • 8.3 – Tipos de funções quanto aos parâmetros
  • 8.4 – Como chamar uma função
  • 8.5 – Parâmetros e argumentos
  • 8.6 – Tipos de retorno das funções
  • 8.7 – Compare os exemplos
  • 8.8 – Retornar não é o mesmo que exibir
  • 8.9 – Como planejar uma função simples
  • 8.10 – Dicas importantes
• Apêndice – Tabela de referência rápida do VisuAlg

Apresentação

Esta apostila reúne, em um único material, tudo o que estudamos na parte de Portugol da disciplina. Os algoritmos são escritos no VisuAlg, um ambiente que permite editar, interpretar e executar algoritmos em uma linguagem semelhante ao português estruturado.

A ideia central desta apostila é simples: a lógica vem antes da linguagem. Antes de escrever qualquer comando, precisamos entender o problema, definir os dados de entrada, o processamento e os dados de saída. Depois disso, a escrita no VisuAlg é uma consequência natural desse raciocínio.

ENTRADA → receber os dados
   ↓
PROCESSAMENTO → realizar cálculos e decisões
   ↓
SAÍDA → apresentar os resultados

Esta apostila também serve de ponte para as linguagens C e Python. Quando você aprender uma delas, perceberá que os conceitos são os mesmos e que o que muda é apenas a forma de escrever.

Sequência da apostila

Observação: os exercícios de cada capítulo estão nos Cadernos e Listas de Exercícios da disciplina. Use esta apostila para estudar os conceitos e as listas para praticá-los.

Capítulo 0 – Preparando o ambiente

Versão utilizada na disciplina: VisuAlg 3.0.7 Tipagem: Estática (os tipos são declarados antes do uso) Forma de execução: Interpretada (o VisuAlg executa o algoritmo diretamente) Ambiente indicado: VisuAlg 3.0.7 (Windows)

No VisuAlg, escrevemos e executamos o algoritmo no mesmo programa. Não há etapa de compilação separada: basta clicar em Executar para ver o resultado.

algoritmo.alg → VisuAlg → execução na tela

Links

• Download do VisuAlg 3.0.7

Passo a passo

1. Baixe o arquivo .zip do VisuAlg pelo link acima.
2. Extraia o conteúdo em uma pasta de fácil acesso, por exemplo, C:\VisuAlg.
3. Abra o programa VisuAlg a partir da pasta extraída.
4. Crie um novo algoritmo pelo menu Arquivo → Novo.
5. Escreva o algoritmo seguindo a estrutura apresentada no Capítulo 1.
6. Salve o arquivo com a extensão .alg na pasta da aula (ou no seu pendrive).
7. Clique em Executar para rodar o algoritmo e acompanhar a saída na janela de execução.

Ponto de atenção – organização: crie uma pasta para cada lista de exercícios. Isso facilita encontrar os arquivos e evita confusão quando você tiver muitos algoritmos.

Capítulo 1 – Introdução: do pensamento ao algoritmo

1.1 – Conceitos iniciais

• Programação: ato de escrever instruções para que máquinas executem uma determinada função ou várias funções encadeadas.
• Lógica de programação: metodologia para resolver problemas, criando uma sequência organizada de passos que resultam em uma ação.
• Algoritmo: sequência finita e ordenada de passos para atingir um objetivo. Pense em uma receita de bolo: cada etapa precisa acontecer na ordem certa.
• Linguagem de programação: conjunto de regras usado para escrever o algoritmo de forma que o computador consiga executá-lo. Em nosso caso, o Portugol escrito no VisuAlg.

1.2 – Método para a construção de algoritmos

Antes de escrever qualquer linha no VisuAlg, siga estes passos:

1. Compreender o problema: leia o enunciado com atenção e destaque os pontos mais importantes.
2. Definir os dados de entrada: quais dados serão fornecidos pelo usuário?
3. Definir o processamento: quais cálculos ou decisões serão feitos? Há alguma restrição?
4. Definir os dados de saída: o que deve ser mostrado ao final?
5. Construir o algoritmo: escrever a solução em um dos tipos apresentados na seção 1.3.
6. Testar o algoritmo: fazer simulações (teste de mesa) com valores conhecidos.

Esse método é o mesmo para qualquer linguagem. Ele vale para o Portugol, para o C e para o Python.

1.3 – Tipos de algoritmos

Existem três formas muito usadas para descrever um algoritmo:

1. Descrição narrativa: os passos são escritos em linguagem natural, como o português do dia a dia.
2. Fluxograma: os passos são representados por símbolos gráficos pré-definidos.
3. Pseudocódigo ou Portugol: os passos são escritos com regras predefinidas, mais próximas de uma linguagem de programação.

Exemplo em descrição narrativa

Faça um algoritmo que mostre o resultado da multiplicação de dois números.

Passo 1 – receber os dois números que serão multiplicados.
Passo 2 – multiplicar os números.
Passo 3 – mostrar o resultado obtido.

Exemplo em Portugol

O mesmo algoritmo, agora escrito no formato do VisuAlg:

Algoritmo "multiplicacao"
// Disciplina   : Lógica de Programação
// Professor    : Mauro Borges França
// Descrição    : Mostrar o resultado da multiplicação de dois números
// Autor(a)     : Nome do(a) aluno(a)
// Data atual   : 26/10/2026
Var
   // Seção de declaração das variáveis
   n1, n2, m: inteiro

Inicio
   // Seção de comandos
   escreva("Digite dois números: ")
   leia(n1)
   leia(n2)
   m <- n1 * n2
   escreva("O resultado é = ", m)
Fimalgoritmo

Observação: note que a lógica é a mesma nos três tipos. O que muda é a forma de representar os passos. No Portugol, a sequência de passos ganha uma estrutura formal, e é por isso que ele é o tipo mais usado no VisuAlg.

1.4 – Estrutura do algoritmo no VisuAlg

Todo algoritmo em VisuAlg segue a mesma organização:

INÍCIO → DECLARAÇÃO DE VARIÁVEIS → SEÇÃO DE COMANDOS → FIM

Algoritmo "nome_do_algoritmo"
// Seção 1 – Identificação: título, descrição, autor e data
// Disciplina   : Lógica de Programação
// Professor    : Mauro Borges França
// Descrição    : O que o programa faz
// Autor(a)     : Nome do(a) aluno(a)
// Data atual   : 26/10/2026

Var
   // Seção 2 – Declaração de todas as variáveis

Inicio
   // Seção 3 – Comandos de entrada, processamento e saída

Fimalgoritmo

Ponto de atenção – identificação: preencha sempre o cabeçalho com os dados do algoritmo. Ele não altera o resultado, mas organiza o trabalho e identifica o autor.

1.5 – Tipos básicos de dados (primitivos)

Exemplos do dia a dia:

• Inteiro: a escada possui 8 degraus; o meu vizinho adotou 2 cães.
• Real: a altura é 1,73 metro; o saldo bancário é de R$ 215,20.
• Caractere: o nome do vencedor é “Felisberto Laranjeira”.
• Lógico: a porta está aberta ou fechada; a lâmpada está ligada ou desligada.

Ponto de atenção – separador decimal: no código, escreva números reais com ponto (ex.: 7.5). Na tela, o resultado aparece formatado conforme a configuração do VisuAlg.

1.6 – Constantes

Uma constante é um dado que não muda durante a execução do algoritmo. O valor é o mesmo do início ao fim.

Exemplos: 5, "Não fume", 2527, -0.58, verdadeiro, falso.

Quando o valor é usado diretamente no comando, dizemos que ele é uma constante literal:

escreva("Bem-vindo ao sistema")
m <- n1 * 2

1.7 – Variáveis

Uma variável é um dado que pode mudar durante a execução do algoritmo. Ela recebe um nome e guarda um valor de um tipo específico.

Exemplos de variáveis: a cotação do dólar, o peso de uma pessoa, o índice mensal da inflação, a idade de um cliente.

Para dar nome às variáveis, use nomes que expliquem o conteúdo: idade, nota1, salarioBruto.

1.8 – Formação de identificadores

Os identificadores são os nomes das variáveis, dos algoritmos, dos procedimentos e das funções. Para criá-los, siga estas regras:

• devem começar por uma letra;
• podem ser seguidos de letras ou números;
• não devem conter espaços nem caracteres especiais (como -, /, &, *).

Dica: o VisuAlg não diferencia letras maiúsculas de minúsculas nos nomes, mas use sempre o mesmo padrão em todo o algoritmo para facilitar a leitura.

1.9 – Declaração e atribuição

Declarar uma variável é informar ao VisuAlg o nome e o tipo dela. A declaração é feita na seção Var:

Var
   nome: caractere
   idade: inteiro
   nota: real
   aprovado: logico

Atribuir um valor é guardar um conteúdo em uma variável já declarada. Usamos o símbolo <-:

nome <- "Vagner"
idade <- 18
nota <- 93.5
aprovado <- verdadeiro

Ponto de atenção – = × <-: o símbolo <- guarda um valor na variável. O sinal = compara dois valores e resulta em verdadeiro ou falso. Veremos isso melhor na seção 2.1.

1.10 – Operadores aritméticos

O resultado de uma operação aritmética é um número, inteiro ou real.

Ponto de atenção – divisão: / produz um resultado com casas decimais, enquanto div descarta a parte decimal. Use % para descobrir se um número é par (resto zero na divisão por 2).

1.11 – Operadores relacionais

Os operadores relacionais comparam dois valores do mesmo tipo. O resultado é sempre verdadeiro ou falso.

Os exemplos completos estão na seção 2.1.

1.12 – Operadores lógicos e tabela verdade

Os operadores lógicos combinam proposições simples para formar novas proposições.

A tabela verdade mostra todas as combinações possíveis de valores lógicos.

Negação (nao)

Conjunção (e)

Disjunção (ou)

Exemplo: “Se chover e relampejar, eu fico em casa” só se confirma quando as duas situações acontecem ao mesmo tempo. Já com “Se chover ou relampejar”, basta uma das duas.

1.13 – Comandos de entrada e saída

Os algoritmos precisam receber dados do usuário para realizar os cálculos. Para isso usamos o comando de entrada:

leia(a)
leia(nome)

Para mostrar resultados usamos os comandos de saída. A diferença entre eles é a quebra de linha:

• escreva(...): mostra o conteúdo e permanece na mesma linha;
• escreval(...): mostra o conteúdo e pula para a linha seguinte.

escreva("Mauro ")
escreva("Borges França")
escreval("")
escreval("Próxima linha")

Dentro de escreva e escreval, podemos juntar textos e variáveis separados por vírgula:

escreval("A idade do cliente é: ", idade)

Formatando a saída com casas decimais

Para mostrar um número real com duas casas decimais, use : seguido do tamanho total e das casas decimais:

media <- 7.333
escreval("Média: ", media:4:2)

Esse comando mostra Média: 7,33.

1.14 – Blocos de comandos e indentação

Os comandos são organizados em blocos. Cada bloco tem um início e um fim, como as seções Var e Inicio, ou os comandos se e fimse.

Para deixar esses blocos visíveis, usamos a indentação, ou seja, um recuo no início das linhas que pertencem a um bloco. A indentação não altera o resultado, mas torna o algoritmo muito mais fácil de ler e de corrigir.

Código não indentado (difícil de ler):

Algoritmo "calcula_idade"
Var
nome:caractere
ano_nascimento:inteiro
idade:inteiro
Inicio
escreval("Favor forneça o nome do cliente:")
leia(nome)
escreval("Entre com seu ano de nascimento:")
leia(ano_nascimento)
idade<-2026-ano_nascimento
escreval("A idade do cliente é:",idade)
Fimalgoritmo

Código indentado (fácil de ler):

Algoritmo "calcula_idade"
Var
   nome: caractere
   ano_nascimento: inteiro
   idade: inteiro
Inicio
   escreval("Favor forneça o nome do cliente:")
   leia(nome)
   escreval("Entre com seu ano de nascimento:")
   leia(ano_nascimento)
   idade <- 2026 - ano_nascimento
   escreval("A idade do cliente é:", idade)
Fimalgoritmo

1.15 – Prática

Antes de avançar, pratique os conceitos deste capítulo. Use sempre a sequência: nome do algoritmo, cabeçalho, declaração de variáveis, cálculo e saída.

Exercício 1 – Acesso ao cinema

O dono de uma rede de cinemas deseja indicar filmes de acordo com a faixa etária de seus clientes. Crie um algoritmo que receba o nome e o ano de nascimento do cliente e mostre quantos anos ele fez (ou fará) neste ano.

Exercício 2 – As quatro operações

Uma professora de matemática deseja um programa que receba dois números inteiros e mostre o resultado das quatro operações (adição, subtração, multiplicação e divisão) entre eles.

Dica: resolva estes exercícios no VisuAlg e faça o teste de mesa com valores conhecidos antes de considerar o algoritmo pronto.

Capítulo 2 – Estrutura Condicional (Parte 1)

2.1 – Operadores relacionais

Um operador relacional compara dois valores do mesmo tipo básico e resulta em verdadeiro ou falso. Veja alguns exemplos, supondo que x vale 10:

Acessibilidade visual: uma expressão com operadores relacionais sempre resulta em um valor lógico. Por exemplo, a expressão 5 > 10 é falsa, porque 5 não é maior que 10.

2.2 – Operadores lógicos

Os operadores lógicos formam novas expressões a partir de outras expressões lógicas, usando e, ou e nao.

2.2.1 – Assimilando o operador e

Suponha que x vale 10:

Observação: todas as condições devem ser verdadeiras para que a expressão inteira seja verdadeira.

Exemplo prático: João quer sair para jogar futebol, mas sua mãe estabeleceu duas condições: terminar a lição de casa e ter um tempo ensolarado. Só se ambas forem verdadeiras, ele pode sair.

escreva("João terminou a lição de casa? (S/N): ")
leia(licao_de_casa)
escreva("O tempo está ensolarado? (S/N): ")
leia(tempo_ensolarado)

se (licao_de_casa = "S") e (tempo_ensolarado = "S") entao
   escreval("João pode sair de casa")
senao
   escreval("João não pode sair de casa")
fimse

2.2.2 – Assimilando o operador ou

Suponha que x vale 10:

Observação: basta que pelo menos uma condição seja verdadeira para que o resultado seja verdadeiro.

Exemplo prático: Mariana quer assistir TV, mas seus pais só permitem se ela terminar a lição de casa ou se for final de semana. Basta uma das duas condições.

escreva("Mariana terminou a lição de casa? (S/N): ")
leia(licao_de_casa)
escreva("É final de semana? (S/N): ")
leia(final_de_semana)

se (licao_de_casa = "S") ou (final_de_semana = "S") entao
   escreval("Mariana pode assistir TV")
senao
   escreval("Mariana não pode assistir TV")
fimse

2.2.3 – Assimilando o operador nao

Suponha que x vale 10:

Observação: o operador nao sempre inverte o resultado da expressão lógica.

Exemplo prático: Carlos só pode jogar videogame se não houver tarefas pendentes.

escreva("Carlos tem tarefas pendentes? (S/N): ")
leia(tarefas_pendentes)

se nao (tarefas_pendentes = "S") entao
   escreval("Carlos pode jogar videogame")
senao
   escreval("Carlos não pode jogar videogame")
fimse

2.3 – Estruturas condicionais (estruturas de controle)

Uma estrutura condicional permite que um bloco de comandos seja executado somente quando uma condição é satisfeita. Assim, o fluxo do programa muda de acordo com a expressão lógica.

2.3.1 – Estrutura condicional simples

Usamos a estrutura se quando queremos executar um bloco somente se a condição for verdadeira. Se for falsa, o bloco é ignorado.

se <condicao> entao
   <comando 1>
   <comando 2>
fimse

Observação:

• Verdadeiro: executa o bloco de comandos.
• Falso: pula o bloco de comandos.

Exemplo:

Algoritmo "exemplo_condicional_simples"
// Descrição   : Exemplo de estrutura condicional simples
// Autor(a)    : Mauro Borges França
// Data atual  : 26/10/2026
Var
   idade: inteiro
Inicio
   escreva("Digite a sua idade: ")
   leia(idade)

   se idade >= 18 entao
      escreval("Você é maior de idade!")
   fimse
Fimalgoritmo

2.3.2 – Estrutura condicional composta

Usamos a estrutura se/senao quando há dois caminhos possíveis: um para o caso verdadeiro e outro para o caso falso.

se <condicao> entao
   <comando 1>
   <comando 2>
senao
   <comando 3>
   <comando 4>
fimse

Observação:

• Verdadeiro: executa somente o bloco do se.
• Falso: executa somente o bloco do senao.

Exemplo:

Algoritmo "exemplo_condicional_composta"
// Descrição   : Exemplo de estrutura condicional composta
// Autor(a)    : Mauro Borges França
// Data atual  : 26/10/2026
Var
   idade: inteiro
Inicio
   escreva("Digite a sua idade: ")
   leia(idade)

   se idade >= 18 entao
      escreval("Você é maior de idade!")
   senao
      escreval("Você é menor de idade!")
   fimse
Fimalgoritmo

2.3.3 – E se eu tiver mais de duas possibilidades?

Muitas vezes, uma decisão tem três ou mais caminhos. Considere a divisão tradicional de uma população em faixas etárias:

• Jovens: até 19 anos;
• Adultos: de 20 a 59 anos;
• Idosos: 60 anos ou mais.

Para isso, colocamos um se dentro do senao. Assim, se a primeira condição for falsa, o programa testa a próxima:

se <condicao 1> entao
   <comando 1>
senao
   se <condicao 2> entao
      <comando 2>
   senao
      <comando 3>
   fimse
fimse

Observação:

• Se a condição 1 for verdadeira, executa o comando 1.
• Caso contrário, entra no senao e testa a condição 2.
• Se a condição 2 for falsa, executa o último senao.

Exemplo:

Algoritmo "exemplo_condicional_faixas"
// Descrição   : Exemplo de estrutura condicional com mais de duas possibilidades
// Autor(a)    : Mauro Borges França
// Data atual  : 26/10/2026
Var
   idade: inteiro
Inicio
   escreva("Digite a sua idade: ")
   leia(idade)

   se idade <= 19 entao
      escreval("Você é uma pessoa jovem!")
   senao
      se (idade >= 20) e (idade <= 59) entao
         escreval("Você é uma pessoa adulta!")
      senao
         escreval("Você é uma pessoa idosa!")
      fimse
   fimse
Fimalgoritmo

Dica: quando o encadeamento de se fica muito longo, a estrutura escolha/caso (Capítulo 3) costuma ser mais clara.

2.4 – Vamos para a prática

Depois de estudar os operadores e as estruturas condicionais, siga estas dicas para elaborar seus algoritmos:

1. Coloque o nome do algoritmo e preencha o cabeçalho (autor, descrição, data).
2. Declare todas as variáveis na seção Var.
3. Pense logicamente no problema antes de escrever os comandos.
4. Use as estruturas condicionais para tomar as decisões e mostre o que se pede.
5. Faça a indentação corretamente.
6. Faça o teste de mesa para garantir que o algoritmo funciona.
7. Salve o algoritmo na sua pasta ou no pendrive.

Os exercícios sobre estrutura condicional estão nas Listas 04 a 08 do caderno de exercícios.

Capítulo 3 – Estrutura Condicional (Parte 2): escolha/caso

3.1 – Estrutura de seleção escolha/caso

Quando temos várias estruturas se aninhadas, o código fica longo e difícil de acompanhar. A estrutura escolha resolve esse problema: ela testa o valor de uma única variável e vai direto ao bloco correspondente.

escolha <variavel de verificacao>
   caso <valor 1>
      <comando 1>
      <comando 2>
   caso <valor 2>
      <comando 3>
   caso <valor 3>
      <comando 4>
   outrocaso
      <comando 5>
fimescolha

Observação:

• O VisuAlg compara a variável com cada caso, na ordem em que aparecem.
• Somente o bloco do caso correspondente é executado.
• O outrocaso é opcional, mas é muito útil para tratar valores que não estão previstos. Ele será usado na maioria das aplicações.

3.2 – Comparação com o se/senao

Para ver a diferença, considere um algoritmo que recebe um número de 1 a 7 e mostra o dia da semana correspondente.

Solução com se/senao encadeados:

Algoritmo "dia_da_semana_se_senao"
// Disciplina  : Lógica de Programação
// Descrição   : Dia da semana - com se/senao
// Autor(a)    : Professor Mauro Borges França
// Data atual  : 26/10/2026
Var
   dia: inteiro
Inicio
   escreva("Digite um número de 1 a 7: ")
   leia(dia)

   se dia = 1 entao
      escreval("Domingo")
   senao
      se dia = 2 entao
         escreval("Segunda-feira")
      senao
         se dia = 3 entao
            escreval("Terça-feira")
         senao
            se dia = 4 entao
               escreval("Quarta-feira")
            senao
               se dia = 5 entao
                  escreval("Quinta-feira")
               senao
                  se dia = 6 entao
                     escreval("Sexta-feira")
                  senao
                     se dia = 7 entao
                        escreval("Sábado")
                     senao
                        escreval("Número inválido")
                     fimse
                  fimse
               fimse
            fimse
         fimse
      fimse
   fimse
Fimalgoritmo

Observação: a lógica funciona, mas o código fica difícil de ler, com muitos níveis de recuo.

Solução com escolha/caso:

Algoritmo "dia_da_semana_escolha"
// Disciplina  : Lógica de Programação
// Descrição   : Dia da semana - com escolha/caso
// Autor(a)    : Professor Mauro Borges França
// Data atual  : 26/10/2026
Var
   dia: inteiro
Inicio
   escreva("Digite um número de 1 a 7: ")
   leia(dia)

   escreva("Dia da semana: ")
   escolha dia
      caso 1
         escreval("Domingo")
      caso 2
         escreval("Segunda-feira")
      caso 3
         escreval("Terça-feira")
      caso 4
         escreval("Quarta-feira")
      caso 5
         escreval("Quinta-feira")
      caso 6
         escreval("Sexta-feira")
      caso 7
         escreval("Sábado")
      outrocaso
         escreval("Número inválido")
   fimescolha
Fimalgoritmo

Observação: as duas soluções produzem o mesmo resultado. A versão com escolha é mais clara e mais fácil de manter. Por isso, ela é indicada quando a decisão depende do valor de uma mesma variável.

Quando usar cada uma?

Capítulo 4 – Estruturas de Repetição

4.1 – Repetição baseada em contagem: para

Use a estrutura para quando você sabe quantas vezes o trecho deve ser repetido. A variável de controle (por exemplo, i) começa no valor inicial, aumenta a cada volta e para ao atingir o valor final.

para <variavel> de <valor inicial> ate <valor final> [passo <incremento>] faca
   <comando 1>
   <comando 2>
fimpara

Observação: o passo é opcional. Quando ele não é informado, a variável aumenta de 1 em 1. Com passo 2, a variável aumenta de 2 em 2.

Exemplo 1 – Contar de 1 a 10:

Algoritmo "estrutura_para"
// Disciplina   : Lógica de Programação
// Descrição    : Demonstrar a estrutura PARA
// Data atual   : 26/10/2026
Var
   i: inteiro
Inicio
   para i de 1 ate 10 faca
      escreval("Número -> ", i)
   fimpara
Fimalgoritmo

Saída esperada:

Número -> 1
Número -> 2
...
Número -> 10

Exemplo 2 – Somar os 100 primeiros números:

Algoritmo "soma_de_1_a_100"
// Descrição    : Somar os números de 1 até 100
// Data atual   : 26/10/2026
Var
   i, soma: inteiro
Inicio
   soma <- 0
   para i de 1 ate 100 faca
      soma <- soma + i
   fimpara
   escreval("A soma dos números de 1 até 100 é: ", soma)
Fimalgoritmo

Saída esperada: A soma dos números de 1 até 100 é: 5050.

Explicação:

• A variável soma começa com 0.
• A cada volta, o valor de i é somado a soma.
• Ao final, soma guarda o total acumulado.

4.2 – Repetição com teste no início: enquanto

Use a estrutura enquanto quando não sabemos quantas vezes o trecho será repetido. A condição é testada antes de cada volta. Se ela for falsa logo no início, o bloco nunca é executado.

enquanto (<condicao>) faca
   <comando 1>
   <comando 2>
fimenquanto

Exemplo 1 – Contar de 1 a 5:

Algoritmo "contar_com_enquanto"
Var
   contador: inteiro
Inicio
   contador <- 1
   enquanto (contador <= 5) faca
      escreval("Número: ", contador)
      contador <- contador + 1
   fimenquanto
   escreval("Saiu do laço")
Fimalgoritmo

Ponto de atenção: dentro do enquanto é obrigatório alterar a variável da condição (aqui, contador <- contador + 1). Se isso não acontecer, a condição nunca se torna falsa e o laço não termina.

Exemplo 2 – Ler números até o usuário digitar zero:

Algoritmo "ler_numeros_ate_zero"
Var
   numero: inteiro
Inicio
   escreva("Digite um número (0 para sair): ")
   leia(numero)

   enquanto (numero <> 0) faca
      escreval("Você digitou: ", numero)
      escreva("Digite outro número (0 para sair): ")
      leia(numero)
   fimenquanto

   escreval("Programa encerrado.")
Fimalgoritmo

Explicação:

• O laço continua enquanto o número digitado for diferente de zero (<>).
• Se o usuário digitar zero logo no início, o laço não é executado.

4.3 – Repetição com teste no final: repita

Use a estrutura repita quando o bloco deve ser executado pelo menos uma vez. A condição é testada no final de cada volta. A repetição continua até que a condição se torne verdadeira.

repita
   <comando 1>
   <comando 2>
ate (<condicao>)

Diferença para o enquanto: no enquanto, a repetição continua enquanto a condição é verdadeira. No repita, ela continua até a condição ficar verdadeira. Por isso, as condições costumam ser escritas de forma oposta.

Exemplo 1 – Contar de 1 a 5:

Algoritmo "contar_com_repita"
Var
   contador: inteiro
Inicio
   contador <- 1
   repita
      escreval("Número: ", contador)
      contador <- contador + 1
   ate (contador > 5)
   escreva("Saiu do laço")
Fimalgoritmo

Exemplo 2 – Ler números até o usuário digitar zero:

Algoritmo "ler_numeros_com_repita"
Var
   numero: inteiro
Inicio
   repita
      escreva("Digite um número (0 para sair): ")
      leia(numero)
   ate (numero = 0)

   escreva("Programa encerrado.")
Fimalgoritmo

Explicação: o número é lido pelo menos uma vez, e o processo se repete até que o usuário digite 0. Compare com o exemplo do enquanto: a condição foi invertida (<> virou =).

4.4 – Qual estrutura escolher?

Dica: pergunte-se “eu sei quantas vezes vou repetir?”. Se sim, use para. Se não, pergunte “o bloco precisa rodar pelo menos uma vez?”. Se sim, use repita; se não, use enquanto.

Os exercícios sobre repetição estão nas Listas 09 a 12 do caderno de exercícios.

Capítulo 5 – Estrutura de Dados: Vetores

Objetivos

Ao final deste capítulo, você deverá ser capaz de:

• compreender o conceito de vetor;
• diferenciar uma variável simples de uma estrutura composta;
• declarar vetores no VisuAlg;
• acessar, preencher e alterar posições de um vetor;
• percorrer um vetor em ordem normal e inversa;
• realizar cálculos com os valores armazenados;
• localizar elementos em um vetor;
• identificar erros comuns no uso de índices.

5.1 – O que é um vetor?

Um vetor, também chamado de array, é uma variável composta homogênea de uma dimensão. Isso significa que ele:

• armazena vários valores do mesmo tipo;
• usa um único nome para todos os valores;
• organiza os valores em posições;
• identifica cada posição por um índice.

Imagine um vetor como uma gaveta dividida em compartimentos numerados. Cada compartimento guarda um valor.

Considere cinco idades: 18, 20, 17, 22, 19. Em vez de declarar cinco variáveis diferentes, declaramos apenas um vetor:

idades: vetor[1..5] de inteiro

Assim, idades[1] representa o valor 18, e idades[4] representa o valor 22.

Características de um vetor

• É uma estrutura de dados simples.
• Possui uma quantidade definida de posições.
• Armazena dados do mesmo tipo.
• Permite acesso direto a qualquer posição.
• Utiliza índices para identificar os elementos.
• Serve de base para estruturas mais complexas, como matrizes.

5.2 – Diferença entre variável simples e vetor

Var
   idade: inteiro
   idades: vetor[1..5] de inteiro

A variável idade guarda um único valor. O vetor idades pode guardar cinco valores inteiros.

Sem o vetor, para armazenar dez notas precisaríamos de dez variáveis (nota1, nota2, …, nota10). Com o vetor, basta uma declaração: notas: vetor[1..10] de real.

5.3 – Declaração de um vetor

Para declarar um vetor, precisamos definir três coisas:

1. o nome do vetor;
2. o intervalo de índices (inicial e final);
3. o tipo dos valores armazenados.

nomeVetor: vetor[indiceInicial..indiceFinal] de tipo

Exemplos:

notas: vetor[1..10] de real
nomes: vetor[1..5] de caractere
idades: vetor[1..20] de inteiro
respostas: vetor[1..10] de logico

No primeiro exemplo, notas é o nome, o índice vai de 1 até 10 (são 10 posições), e os valores são do tipo real.

5.4 – Índices e posições

Cada elemento do vetor é identificado por um índice, escrito entre colchetes.

notas[1] <- 8.5
notas[2] <- 7.0
notas[3] <- 9.5

Atenção: o índice não é o valor armazenado. Na instrução notas[2] <- 7.0, o 2 é a posição e 7.0 é o valor guardado nela.

5.5 – Limites do vetor

Ao declarar numeros: vetor[1..5] de inteiro, as posições válidas são 1, 2, 3, 4 e 5. Portanto, numeros[1] e numeros[5] são acessos válidos, enquanto numeros[0] e numeros[6] são inválidos.

No VisuAlg, o programador define o índice inicial na declaração. Por exemplo, numeros: vetor[0..4] de inteiro tem as posições 0, 1, 2, 3 e 4. Nesta disciplina, utilizaremos normalmente vetores que começam na posição 1.

Ponto de atenção: esse é um ponto em que o VisuAlg se diferencia de C e de Python, nos quais o primeiro índice é sempre 0. Ao migrar para essas linguagens, lembre-se de converter os limites.

5.6 – Atribuição direta de valores

Podemos armazenar um valor diretamente em uma posição, ou alterar um valor já guardado:

numeros[1] <- 10
numeros[2] <- 25
numeros[3] <- 8

numeros[2] <- 30

O valor anterior da posição 2 é substituído.

5.7 – Leitura de valores em um vetor

Normalmente, usamos uma estrutura de repetição para preencher o vetor. A variável de controle do laço funciona como índice.

Algoritmo "leitura_vetor"
Var
   numeros: vetor[1..5] de inteiro
   i: inteiro
Inicio
   // Percorre todas as posições do vetor
   para i de 1 ate 5 faca
      escreva("Digite o ", i, "º número: ")
      leia(numeros[i])
   fimpara
Fimalgoritmo

O comando leia(numeros[i]) usa o valor de i para escolher a posição que será preenchida:

5.8 – Exibição dos valores

Depois de preencher o vetor, outro laço mostra seus valores:

escreval("")
escreval("Valores armazenados:")

para i de 1 ate 5 faca
   escreval("Posição ", i, ": ", numeros[i])
fimpara

5.9 – Percurso em ordem normal e inversa

Um vetor pode ser percorrido em duas ordens.

Ordem normal (da primeira até a última posição):

para i de 1 ate 5 faca
   escreval(numeros[i])
fimpara

Ordem inversa (da última até a primeira posição), usando passo -1:

para i de 5 ate 1 passo -1 faca
   escreval(numeros[i])
fimpara

Exemplo completo, com preenchimento e as duas ordens:

Algoritmo "ordem_normal_inversa"
Var
   numeros: vetor[1..5] de inteiro
   i: inteiro
Inicio
   // Preenchimento do vetor
   para i de 1 ate 5 faca
      escreva("Digite o ", i, "º número: ")
      leia(numeros[i])
   fimpara

   // Exibição em ordem normal
   escreval("")
   escreval("===== ORDEM NORMAL =====")
   para i de 1 ate 5 faca
      escreval("Posição ", i, ": ", numeros[i])
   fimpara

   // Exibição em ordem inversa
   escreval("")
   escreval("===== ORDEM INVERSA =====")
   para i de 5 ate 1 passo -1 faca
      escreval("Posição ", i, ": ", numeros[i])
   fimpara
Fimalgoritmo

5.10 – Soma dos valores de um vetor

Depois de armazenar os valores, podemos realizar cálculos. A soma usa um acumulador, que é uma variável iniciada com zero:

Algoritmo "soma_vetor"
Var
   numeros: vetor[1..5] de inteiro
   i, soma: inteiro
Inicio
   soma <- 0

   para i de 1 ate 5 faca
      escreva("Digite o ", i, "º número: ")
      leia(numeros[i])
   fimpara

   para i de 1 ate 5 faca
      soma <- soma + numeros[i]
   fimpara

   escreval("Soma dos valores: ", soma)
Fimalgoritmo

5.11 – Cálculo da média

Para calcular a média, somamos todos os valores e dividimos pela quantidade de elementos:

Algoritmo "media_vetor"
Var
   notas: vetor[1..5] de real
   i: inteiro
   soma, media: real
Inicio
   soma <- 0

   para i de 1 ate 5 faca
      escreva("Digite a ", i, "ª nota: ")
      leia(notas[i])
      soma <- soma + notas[i]
   fimpara

   media <- soma / 5
   escreval("Média das notas: ", media:4:2)
Fimalgoritmo

5.12 – Contagem de valores

Podemos usar uma condição para contar os elementos que têm uma característica. Por exemplo, contar os números pares:

Algoritmo "contar_pares"
Var
   numeros: vetor[1..5] de inteiro
   i, qtdPares: inteiro
Inicio
   qtdPares <- 0

   para i de 1 ate 5 faca
      escreva("Digite o ", i, "º número: ")
      leia(numeros[i])
   fimpara

   para i de 1 ate 5 faca
      se numeros[i] % 2 = 0 entao
         qtdPares <- qtdPares + 1
      fimse
   fimpara

   escreval("Quantidade de números pares: ", qtdPares)
Fimalgoritmo

5.13 – Exibição de valores que atendem a uma condição

Além de contar, podemos mostrar somente os elementos desejados. Por exemplo, os números maiores que 10:

escreval("Números maiores que 10:")

para i de 1 ate 5 faca
   se numeros[i] > 10 entao
      escreval(numeros[i])
   fimse
fimpara

5.14 – Maior valor do vetor

Para encontrar o maior valor, começamos considerando que o primeiro elemento é o maior. Depois, comparamos os demais elementos com ele:

maior <- numeros[1]

Algoritmo "maior_valor"
Var
   numeros: vetor[1..5] de inteiro
   i, maior: inteiro
Inicio
   para i de 1 ate 5 faca
      escreva("Digite o ", i, "º número: ")
      leia(numeros[i])
   fimpara

   // O primeiro elemento é inicialmente considerado o maior
   maior <- numeros[1]

   // Comparação com os demais elementos
   para i de 2 ate 5 faca
      se numeros[i] > maior entao
         maior <- numeros[i]
      fimse
   fimpara

   escreval("Maior valor: ", maior)
Fimalgoritmo

Por que não começar com zero?

Considere o vetor -5, -2, -10, -4, -8. Se começássemos com maior <- 0, o algoritmo informaria que o maior valor é zero, mesmo que zero não esteja no vetor. Por isso, é mais seguro usar maior <- numeros[1].

5.15 – Menor valor do vetor

O processo para encontrar o menor valor é semelhante. A diferença é o operador de comparação:

menor <- numeros[1]

para i de 2 ate 5 faca
   se numeros[i] < menor entao
      menor <- numeros[i]
   fimse
fimpara

5.16 – Maior e menor valor no mesmo algoritmo

Os dois valores podem ser encontrados no mesmo laço:

Algoritmo "maior_menor"
Var
   numeros: vetor[1..5] de inteiro
   i, maior, menor: inteiro
Inicio
   para i de 1 ate 5 faca
      escreva("Digite o ", i, "º número: ")
      leia(numeros[i])
   fimpara

   // Inicialização com o primeiro valor
   maior <- numeros[1]
   menor <- numeros[1]

   // Comparação com os demais valores
   para i de 2 ate 5 faca
      se numeros[i] > maior entao
         maior <- numeros[i]
      fimse

      se numeros[i] < menor entao
         menor <- numeros[i]
      fimse
   fimpara

   escreval("Maior valor: ", maior)
   escreval("Menor valor: ", menor)
Fimalgoritmo

5.17 – Localização da posição do maior valor

Além do valor, podemos guardar a posição em que ele foi encontrado:

Algoritmo "posicao_maior"
Var
   numeros: vetor[1..5] de inteiro
   i, maior, posMaior: inteiro
Inicio
   para i de 1 ate 5 faca
      escreva("Digite o ", i, "º número: ")
      leia(numeros[i])
   fimpara

   maior <- numeros[1]
   posMaior <- 1

   para i de 2 ate 5 faca
      se numeros[i] > maior entao
         maior <- numeros[i]
         posMaior <- i
      fimse
   fimpara

   escreval("Maior valor: ", maior)
   escreval("Posição do maior valor: ", posMaior)
Fimalgoritmo

5.18 – Busca de um valor no vetor

Buscar um valor é percorrer o vetor e verificar se ele está armazenado. Usamos uma variável lógica para indicar se o valor foi encontrado:

Algoritmo "buscar_valor"
Var
   numeros: vetor[1..5] de inteiro
   i, procurado: inteiro
   encontrou: logico
Inicio
   para i de 1 ate 5 faca
      escreva("Digite o ", i, "º número: ")
      leia(numeros[i])
   fimpara

   escreva("Digite o número que deseja procurar: ")
   leia(procurado)

   encontrou <- falso

   para i de 1 ate 5 faca
      se numeros[i] = procurado entao
         escreval("Número encontrado na posição ", i)
         encontrou <- verdadeiro
      fimse
   fimpara

   se encontrou = falso entao
      escreval("Número não encontrado.")
   fimse
Fimalgoritmo

Observação: se o mesmo número aparecer mais de uma vez, o algoritmo mostrará todas as posições em que ele foi encontrado.

5.19 – Alteração de uma posição

Podemos pedir ao usuário uma posição e substituir o valor que está nela. Antes de alterar, é preciso validar a posição:

Algoritmo "alterar_posicao"
Var
   numeros: vetor[1..5] de inteiro
   i, posicao, novoValor: inteiro
Inicio
   para i de 1 ate 5 faca
      escreva("Digite o valor da posição ", i, ": ")
      leia(numeros[i])
   fimpara

   escreva("Informe a posição que deseja alterar: ")
   leia(posicao)

   // Validação da posição
   se (posicao >= 1) e (posicao <= 5) entao
      escreva("Informe o novo valor: ")
      leia(novoValor)
      numeros[posicao] <- novoValor
      escreval("Valor alterado com sucesso.")
   senao
      escreval("Posição inválida.")
   fimse

   escreval("")
   escreval("Vetor atualizado:")
   para i de 1 ate 5 faca
      escreval("Posição ", i, ": ", numeros[i])
   fimpara
Fimalgoritmo

5.20 – Capacidade e quantidade preenchida

Um vetor pode ter mais posições do que os dados realmente utilizados. A capacidade é o tamanho declarado; a quantidade preenchida é o número de posições que o usuário efetivamente usou.

nomes: vetor[1..10] de caractere
qtd: inteiro

escreva("Quantos nomes deseja cadastrar? ")
leia(qtd)

para i de 1 ate qtd faca
   escreva("Digite o ", i, "º nome: ")
   leia(nomes[i])
fimpara

Nesse caso, a capacidade é 10, e a quantidade utilizada é o valor de qtd.

5.21 – Vetores paralelos

Vetores paralelos são vetores diferentes cujas posições representam informações relacionadas. A posição i de um vetor corresponde à posição i do outro.

nomes: vetor[1..5] de caractere
notas: vetor[1..5] de real

Assim, nomes[3] e notas[3] representam os dados do mesmo aluno (Maria, com nota 9.0).

Algoritmo "alunos_notas"
Var
   nomes: vetor[1..5] de caractere
   notas: vetor[1..5] de real
   i: inteiro
Inicio
   // Cadastro dos alunos
   para i de 1 ate 5 faca
      escreva("Digite o nome do ", i, "º aluno: ")
      leia(nomes[i])
      escreva("Digite a nota de ", nomes[i], ": ")
      leia(notas[i])
   fimpara

   // Apresentação dos dados
   escreval("")
   escreval("===== ALUNOS E NOTAS =====")
   para i de 1 ate 5 faca
      escreval("Aluno: ", nomes[i])
      escreval("Nota: ", notas[i])
      escreval("--------------------------")
   fimpara
Fimalgoritmo

5.22 – Exemplo completo: análise de notas

Este exemplo reúne vários conceitos do capítulo. O algoritmo deverá:

• ler cinco notas;
• calcular a média;
• informar a maior e a menor nota;
• contar quantas notas estão acima da média;
• mostrar as notas em ordem inversa.

Algoritmo "analise_notas"
Var
   notas: vetor[1..5] de real
   i, qtdAcima: inteiro
   soma, media, maior, menor: real
Inicio
   soma <- 0
   qtdAcima <- 0

   // Leitura das notas
   para i de 1 ate 5 faca
      escreva("Digite a ", i, "ª nota: ")
      leia(notas[i])
      soma <- soma + notas[i]
   fimpara

   // Cálculo da média
   media <- soma / 5

   // Maior e menor valor
   maior <- notas[1]
   menor <- notas[1]
   para i de 2 ate 5 faca
      se notas[i] > maior entao
         maior <- notas[i]
      fimse
      se notas[i] < menor entao
         menor <- notas[i]
      fimse
   fimpara

   // Contagem das notas acima da média
   para i de 1 ate 5 faca
      se notas[i] > media entao
         qtdAcima <- qtdAcima + 1
      fimse
   fimpara

   // Apresentação
   escreval("")
   escreval("===== NOTAS INFORMADAS =====")
   para i de 1 ate 5 faca
      escreval("Nota ", i, ": ", notas[i]:4:2)
   fimpara

   escreval("")
   escreval("===== RESULTADOS =====")
   escreval("Média: ", media:4:2)
   escreval("Maior nota: ", maior:4:2)
   escreval("Menor nota: ", menor:4:2)
   escreval("Notas acima da média: ", qtdAcima)

   escreval("")
   escreval("===== ORDEM INVERSA =====")
   para i de 5 ate 1 passo -1 faca
      escreval(notas[i]:4:2)
   fimpara
Fimalgoritmo

5.23 – Erros comuns no uso de vetores

1. Não usar o índice:

leia(numeros)      // Incorreto
leia(numeros[i])   // Correto

2. Acessar uma posição que não existe: com numeros: vetor[1..5] de inteiro, a posição 6 não existe.

numeros[6] <- 10   // Incorreto

3. Usar limites diferentes no laço: o laço deve percorrer exatamente as posições declaradas.

para i de 1 ate 10 faca   // Incorreto: o vetor só tem 5 posições
   leia(numeros[i])
fimpara

para i de 1 ate 5 faca    // Correto
   leia(numeros[i])
fimpara

4. Confundir posição com valor: em numeros[3] <- 20, o 3 é a posição e o 20 é o valor.

5. Não inicializar um acumulador: antes de somar, é preciso zerar a variável (soma <- 0).

6. Inicializar o maior valor com zero: prefira maior <- numeros[1], como visto na seção 5.14.

7. Usar nomes diferentes: se o vetor foi declarado como numeros, use sempre numeros[i], e não numero[i].

5.24 – Resumo do capítulo

5.25 – Atividades de fixação

Pratique os conceitos com os exercícios das Listas 13 e 14 do caderno de exercícios. Para começar, tente estes desafios:

1. Ler oito números inteiros, armazená-los em um vetor e mostrar todos na ordem em que foram informados.
2. Ler dez números inteiros e mostrá-los na ordem inversa à de entrada.
3. Ler dez números inteiros e mostrar todos, somente os pares e a quantidade de pares.
4. Ler seis números reais e mostrar a soma, a média e os valores maiores que a média.
5. Ler oito números inteiros e mostrar o maior, a posição do maior, o menor e a posição do menor.
6. Ler dez números inteiros, pedir um número ao usuário e informar se ele está no vetor, mostrando sua posição.

Capítulo 6 – Estrutura de Dados: Matriz

6.1 – O que é uma matriz

Uma matriz é uma variável composta homogênea e multidimensional. Todos os seus elementos têm o mesmo tipo e o mesmo nome, e são distinguidos pelos índices que indicam a posição de cada um.

A diferença para o vetor é a quantidade de dimensões: o vetor tem uma dimensão, enquanto a matriz pode ter duas ou mais. A forma mais comum é a de duas dimensões, como nas planilhas eletrônicas, com linhas e colunas.

Características de uma matriz:

• é uma estrutura de dados composta e multidimensional;
• cada valor ocupa uma posição específica, identificada por vários índices (um para a linha e outro para a coluna);
• representa naturalmente dados em forma de tabela, como as notas de vários alunos em várias disciplinas.

Diferença entre variável simples, vetor e matriz

Veja as três declarações lado a lado:

Var
   nota: real                    // variável simples
   notas: vetor[1..4] de real    // vetor
   notas: vetor[1..3,1..4] de real   // matriz

6.2 – Declaração de uma matriz

No VisuAlg, a matriz é declarada com a palavra vetor, informando um intervalo de índices para cada dimensão, separados por vírgula:

notas: vetor[1..3, 1..4] de real

Nesse exemplo:

• notas é o nome da matriz;
• a primeira dimensão vai de 1 a 3 (são 3 linhas, por exemplo, 3 alunos);
• a segunda dimensão vai de 1 a 4 (são 4 colunas, por exemplo, 4 notas);
• os valores armazenados são do tipo real.

6.3 – Acesso aos elementos

Cada valor da matriz é acessado com dois índices: primeiro a linha, depois a coluna.

notas[1,1] <- 7.5
notas[1,2] <- 8.0
notas[1,3] <- 9.0
notas[1,4] <- 6.0

notas[2,1] <- 6.0
notas[2,2] <- 9.5
notas[2,3] <- 7.0
notas[2,4] <- 4.0

notas[3,1] <- 5.0
notas[3,2] <- 3.0
notas[3,3] <- 3.0
notas[3,4] <- 9.0

Assim, notas[2,1] acessa a linha 2 e a coluna 1, ou seja, a primeira nota do segundo aluno, que vale 6.0.

Observação: no VisuAlg, os índices começam normalmente em 1, e não existe posição zero neste material. Essa é mais uma diferença em relação a C e Python.

6.4 – Leitura e escrita em matrizes

Para preencher ou exibir uma matriz, usamos dois laços aninhados:

• o laço externo, com a variável i, controla as linhas;
• o laço interno, com a variável j, controla as colunas.

Exemplo: ler as quatro notas de três alunos e apresentá-las na tela.

Algoritmo "matriz_notas"
// Disciplina   : Lógica de Programação
// Descrição    : Ler 4 notas de 3 alunos e apresentar na tela
// Data atual   : 26/10/2026
Var
   notas: vetor[1..3, 1..4] de real
   i, j: inteiro
Inicio
   // Entrada de dados
   para i de 1 ate 3 faca
      escreval("Forneça as notas do ", i, "º aluno")
      para j de 1 ate 4 faca
         escreva("Digite a ", j, "ª nota: ")
         leia(notas[i, j])
      fimpara
   fimpara

   // Apresentação dos dados
   para i de 1 ate 3 faca
      escreval("O ", i, "º aluno tirou as notas:")
      para j de 1 ate 4 faca
         escreval(j, "ª nota: ", notas[i, j])
      fimpara
   fimpara
Fimalgoritmo

Observação: são necessários dois laços porque a matriz tem duas dimensões. Combinando i (linha) e j (coluna), percorremos cada célula pela sua posição [i, j].

Como o algoritmo percorre a matriz:

1. i = 1: o laço interno preenche notas[1,1], notas[1,2], notas[1,3] e notas[1,4].
2. i = 2: o laço interno preenche a segunda linha.
3. i = 3: o laço interno preenche a terceira linha.

Ponto de atenção: o laço interno termina completamente antes de a variável i avançar. Por isso, j volta a 1 a cada nova linha.

6.5 – Exibindo a matriz em formato de tabela

Para mostrar a matriz como uma tabela, escrevemos os valores de uma linha na mesma linha da tela, usando escreva, e pulamos de linha ao final de cada uma com escreval:

para i de 1 ate 3 faca
   para j de 1 ate 4 faca
      escreva(notas[i, j]:6:2)
   fimpara
   escreval("")
fimpara

O escreval("") no final de cada linha faz a quebra, e a formatação :6:2 alinha os valores em colunas.

6.6 – Média de cada aluno (cálculo por linha)

Quando queremos a média de cada linha, usamos um acumulador que é zerado a cada nova linha. Assim, a soma de um aluno não se mistura com a do outro:

para i de 1 ate 3 faca
   soma <- 0
   para j de 1 ate 4 faca
      soma <- soma + notas[i, j]
   fimpara
   media <- soma / 4
   escreval("Média do ", i, "º aluno: ", media:4:2)
fimpara

Ponto de atenção: o soma <- 0 fica dentro do laço externo. Se ele ficasse antes dos laços, a soma acumularia os valores de todos os alunos.

Os exercícios sobre matrizes estão nas Listas 15 e 16 do caderno de exercícios.

Capítulo 7 – Procedimentos

7.1 – O que são funções e procedimentos?

Imagine que você está escrevendo um livro e precisa repetir a mesma frase várias vezes. Em vez de escrevê-la de novo, daria um nome a ela e a chamaria sempre que precisasse.

Na programação, funções e procedimentos são exatamente isso: blocos de código com uma tarefa específica, que recebem um nome. Escrevemos o código uma vez e o utilizamos quantas vezes forem necessárias.

Por que usar?

• Organização: o código fica mais limpo e fácil de entender.
• Reaproveitamento: não é preciso repetir o mesmo código.
• Manutenção: uma mudança é feita em um único lugar e vale para todo o programa.

Os procedimentos executam uma ação e não retornam um valor. As funções, que veremos no Capítulo 8, devolvem um resultado.

7.2 – Procedimentos no VisuAlg

Um procedimento é declarado entre procedimento e fimprocedimento, com sua própria seção var e seu próprio inicio:

procedimento nome_do_procedimento()
var
   // variáveis locais, se houver
inicio
   // comandos do procedimento
fimprocedimento

Exemplo: um procedimento que exibe uma saudação.

Algoritmo "saudacao"
Var
// Seção de declarações das variáveis globais

// Seção de procedimentos
procedimento saudacao()
inicio
   escreval("Olá! Seja bem-vindo(a) ao meu programa.")
   escreval("Este é um procedimento simples.")
fimprocedimento

// Corpo do algoritmo
Inicio
   escreval("--- Início do programa principal ---")
   saudacao()
   escreval("--- Fim do programa principal ---")
Fimalgoritmo

Saída esperada:

--- Início do programa principal ---
Olá! Seja bem-vindo(a) ao meu programa.
Este é um procedimento simples.
--- Fim do programa principal ---

Atenção: criar um procedimento não o executa. Ele só roda quando é chamado pelo nome, com os parênteses (saudacao()).

7.3 – Organizando as listas de exercícios com menu

Para organizar uma lista de exercícios, cada exercício vai para o seu próprio procedimento, e o algoritmo principal apresenta um menu para escolher qual deles executar.

Imagine uma lista com três exercícios:

O menu permite escolher o exercício. Cada procedimento contém a resolução completa: leitura dos dados, processamento e apresentação do resultado.

7.4 – Como escrever um procedimento no VisuAlg

Observe um procedimento que soma dois números:

procedimento exercicio01()
var
   numero1, numero2, soma: real
inicio
   escreva("Digite o primeiro número: ")
   leia(numero1)
   escreva("Digite o segundo número: ")
   leia(numero2)

   soma <- numero1 + numero2
   escreval("Soma: ", soma:8:2)
fimprocedimento

As variáveis declaradas dentro do procedimento são locais: só existem dentro dele. Por isso, soma pertence apenas a exercicio01().

Nesta atividade, os procedimentos são sem parâmetros: os parênteses ficam vazios, e os dados são pedidos com leia dentro de cada procedimento. Como o procedimento não retorna valor, basta chamá-lo (exercicio01()). Não escrevemos resultado <- exercicio01().

7.5 – Onde colocar e como chamar o procedimento

Os procedimentos ficam antes do inicio do algoritmo principal. Veja um programa completo com um exercício:

Algoritmo "primeiro_procedimento"

procedimento exercicio01()
var
   numero1, numero2, soma: real
inicio
   escreva("Digite o primeiro número: ")
   leia(numero1)
   escreva("Digite o segundo número: ")
   leia(numero2)

   soma <- numero1 + numero2
   escreval("Soma: ", soma:8:2)
fimprocedimento

// Início do algoritmo principal
Inicio
   escreval("Vamos executar o exercício 01!")
   exercicio01()
   escreval("O exercício terminou.")
Fimalgoritmo

A execução acontece nesta ordem:

1. O programa começa no inicio principal e mostra a primeira mensagem.
2. Encontra exercicio01() e executa os comandos desse procedimento.
3. Ao chegar a fimprocedimento, volta para o comando seguinte à chamada.
4. Mostra O exercício terminou. e encerra o algoritmo.

Atenção: o inicio dentro do procedimento pertence ao exercício. O inicio principal, depois dos procedimentos, é o ponto em que o programa começa a executar.

7.6 – Exemplo completo: uma lista com menu

Vamos reunir dois exercícios em um único arquivo, lista01.alg:

• Exercício 01: somar dois números.
• Exercício 02: calcular a área de um retângulo.

Os exercícios são ilustrativos. Na atividade, utilize os enunciados das suas listas.

Algoritmo "lista01"
Var
   opcao: inteiro

// Exercício 01 – Somar dois números
procedimento exercicio01()
var
   numero1, numero2, soma: real
inicio
   escreval("--- EXERCÍCIO 01: SOMA ---")
   escreva("Digite o primeiro número: ")
   leia(numero1)
   escreva("Digite o segundo número: ")
   leia(numero2)

   soma <- numero1 + numero2
   escreval("Soma: ", soma:8:2)
fimprocedimento

// Exercício 02 – Calcular a área de um retângulo
procedimento exercicio02()
var
   base, altura, area: real
inicio
   escreval("--- EXERCÍCIO 02: ÁREA ---")
   escreva("Digite a base em metros: ")
   leia(base)
   escreva("Digite a altura em metros: ")
   leia(altura)

   area <- base * altura
   escreval("Área: ", area:8:2, " m2")
fimprocedimento

// Algoritmo principal: menu e chamadas
Inicio
   repita
      escreval("")
      escreval("==============================")
      escreval("           LISTA 01")
      escreval("==============================")
      escreval("1 - Somar dois números")
      escreval("2 - Calcular a área do retângulo")
      escreval("0 - Sair")
      escreva("Escolha uma opção: ")
      leia(opcao)
      escreval("")

      escolha opcao
         caso 1
            exercicio01()
         caso 2
            exercicio02()
         caso 0
            escreval("Programa encerrado.")
         outrocaso
            escreval("Opção inválida! Tente novamente.")
      fimescolha
   ate (opcao = 0)
Fimalgoritmo

Entendendo o menu

A variável opcao está na seção var do algoritmo principal, pois é usada pelo menu. As variáveis de cálculo ficam dentro dos respectivos procedimentos.

Acompanhando uma execução

1. O usuário digita 1 no menu.
2. O caso 1 chama exercicio01().
3. O usuário informa os números 5 e 3.
4. O procedimento mostra a soma 8 e termina.
5. A execução volta ao menu. Como a opção é diferente de 0, a repetição continua.
6. O usuário pode executar outro exercício, repetir o mesmo ou digitar 0 para sair.

7.7 – Como adaptar um exercício que você já resolveu

Abra o algoritmo do exercício e identifique as variáveis e os comandos que resolvem o problema. Depois:

1. Crie um procedimento com o número do exercício, antes do inicio principal.
2. Coloque as variáveis do exercício na seção var desse procedimento.
3. Coloque a resolução entre inicio e fimprocedimento.
4. Acrescente a opção correspondente nas mensagens do menu.
5. Acrescente um caso que chame o procedimento.

Para incluir o exercício 03, por exemplo:

// Junto das mensagens com as opções:
escreval("3 - Descrição do exercício 03")

// Dentro de escolha opcao, antes de outrocaso:
caso 3
   exercicio03()

Atenção: esse trecho mostra apenas o que acrescentar; ele não é um programa completo. Não copie um algoritmo inteiro para dentro do procedimento. Cada arquivo tem um único Algoritmo e um único Fimalgoritmo, e cada procedimento tem o seu próprio inicio e fimprocedimento.

7.8 – Cuidados importantes

• Escreva fimprocedimento em uma única palavra, sem espaço e sem sublinhado.
• Use o mesmo nome na declaração e na chamada do procedimento.
• Coloque os procedimentos antes do inicio principal.
• Deixe a resolução de cada exercício dentro do seu procedimento; no caso, coloque apenas a chamada.
• Leia os dados sempre que o exercício for executado.
• Inicialize os acumuladores e contadores antes de usá-los.

Capítulo 8 – Funções

8.1 – O que são funções?

Funções são partes do algoritmo que recebem um nome, realizam uma tarefa e devolvem um resultado para o trecho que as chamou. Elas podem receber dados para realizar essa tarefa.

Imagine uma calculadora com uma tecla dobro. Ao receber o número 5, ela calcula 5 × 2 e devolve 10. Se receber 8, devolve 16. A regra é sempre a mesma; o que muda é o valor recebido.

8.2 – Estrutura básica de uma função

funcao <nome>(<parametros>): <tipo_do_retorno>
var
   // variáveis locais, quando necessárias
inicio
   // comandos da função
   retorne <resultado>
fimfuncao

A seção var pode ser omitida quando a função não precisa de variáveis locais. O tipo do retorno aparece depois dos parênteses, precedido por dois-pontos.

8.3 – Tipos de funções quanto aos parâmetros

No VisuAlg, toda função devolve um valor. Quanto ao recebimento de dados, estudaremos duas formas:

8.3.1 – Função sem parâmetros e com retorno

Essa função não recebe valores na chamada, mas devolve um resultado. No exemplo, ela fornece uma aproximação de π:

funcao fornecerPi(): real
inicio
   retorne 3.14159
fimfuncao

Recebe: nenhum parâmetro. Retorna: um valor do tipo real.

A chamada fica assim, no algoritmo principal, com valor declarado como real:

valor <- fornecerPi()
escreval(valor)

8.3.2 – Função com parâmetros e com retorno

Essa função recebe um ou mais valores na chamada, usa esses dados no processamento e devolve um resultado. No exemplo, ela recebe um número inteiro e devolve o seu dobro:

funcao dobro(valor: inteiro): inteiro
inicio
   retorne valor * 2
fimfuncao

Recebe: um parâmetro do tipo inteiro. Retorna: um valor do tipo inteiro.

Atenção: definir uma função não a executa. Para utilizá-la, é preciso fazer uma chamada.

8.4 – Como chamar uma função

No VisuAlg, declaramos a função depois das variáveis do algoritmo principal e antes do inicio principal:

Algoritmo "exemplo_funcao"
Var
   numero, resultado: inteiro

funcao dobro(valor: inteiro): inteiro
inicio
   retorne valor * 2
fimfuncao

Inicio
   numero <- 5
   resultado <- dobro(numero)
   escreval("Dobro: ", resultado)
Fimalgoritmo

O algoritmo exibe Dobro: 10.

Acompanhe a execução

1. O algoritmo começa nos comandos principais, e numero recebe 5.
2. A chamada dobro(numero) envia o valor 5 para a função.
3. O parâmetro valor recebe 5, e a função calcula 5 * 2.
4. A função devolve 10, e esse valor é guardado em resultado.
5. O comando escreval mostra o resultado na tela.

Na atribuição resultado <- dobro(numero), o lado direito é resolvido primeiro. Depois, o valor devolvido pela função é guardado na variável à esquerda.

Reutilize a mesma função

A função é escrita uma vez e pode ser usada quantas vezes forem necessárias:

resultado <- dobro(3)
escreval(resultado)     // mostra 6

resultado <- dobro(8)
escreval(resultado)     // mostra 16

8.5 – Parâmetros e argumentos

• Parâmetro é a variável indicada na definição da função para receber um dado.
• Argumento é o valor ou a expressão enviada na chamada.

Na definição dobro(valor: inteiro), valor é o parâmetro. Na chamada dobro(5), o 5 é o argumento. Na chamada dobro(numero), o argumento é o valor guardado em numero.

Uma função com dois parâmetros

funcao somar(a, b: inteiro): inteiro
inicio
   retorne a + b
fimfuncao

Como a e b têm o mesmo tipo, podem ser declarados juntos. Na chamada, o primeiro valor é recebido por a e o segundo por b:

primeiro <- 4
segundo <- 6
total <- somar(primeiro, segundo)
escreval("Soma: ", total)

Os nomes das variáveis enviadas não precisam ser iguais aos nomes dos parâmetros. O que importa é respeitar a quantidade, a ordem e os tipos dos dados esperados.

8.6 – Tipos de retorno das funções

Além de observar se a função recebe parâmetros, precisamos identificar qual tipo de valor ela devolve. Esse tipo é informado depois dos dois-pontos finais da declaração.

Observação: as duas classificações se combinam. Uma função pode receber parâmetros e retornar um valor lógico; outra pode não receber parâmetros e retornar um texto.

8.6.1 – Função com retorno inteiro

As funções dobro e somar, apresentadas anteriormente, retornam valores inteiro:

resultado <- dobro(5)
escreval(resultado)     // mostra 10

8.6.2 – Função com retorno real e variável local

Usamos o retorno real quando o resultado pode ter parte decimal, como em uma média. Uma função também pode ter variáveis locais, declaradas na sua própria seção var.

No exemplo, n1 e n2 são parâmetros, e m é uma variável local:

funcao calcularMedia(n1, n2: real): real
var
   m: real
inicio
   m <- (n1 + n2) / 2
   retorne m
fimfuncao

A chamada calcularMedia(7, 8) devolve 7.5. Para guardar esse resultado, use uma variável do tipo real.

Exemplo completo, com entrada de dados:

Algoritmo "media_com_funcao"
Var
   nota1, nota2, media: real

funcao calcularMedia(n1, n2: real): real
var
   m: real
inicio
   m <- (n1 + n2) / 2
   retorne m
fimfuncao

Inicio
   escreva("Digite a primeira nota: ")
   leia(nota1)
   escreva("Digite a segunda nota: ")
   leia(nota2)

   media <- calcularMedia(nota1, nota2)
   escreval("Média: ", media:4:2)
Fimalgoritmo

Observe a divisão de tarefas: o algoritmo principal lê os dados e exibe o resultado; a função calcula e devolve a média. A variável local m não é usada diretamente pelo algoritmo principal.

8.6.3 – Função com retorno lógico

Usamos o retorno logico quando a função responde a uma verificação. O resultado será verdadeiro ou falso:

funcao ehPositivo(numero: inteiro): logico
inicio
   retorne numero > 0
fimfuncao

Recebe: um número inteiro. Retorna: um valor lógico.

resultadoLogico <- ehPositivo(4)
escreval(resultadoLogico)     // mostra verdadeiro

As chamadas ehPositivo(0) e ehPositivo(-3) devolvem falso.

8.6.4 – Função com retorno de texto

Usamos o retorno caractere quando a função devolve uma palavra, frase ou mensagem:

funcao obterMensagem(): caractere
inicio
   retorne "Bem-vindo ao sistema!"
fimfuncao

Recebe: nenhum parâmetro. Retorna: um texto do tipo caractere.

mensagem <- obterMensagem()
escreval(mensagem)

Observação: o tipo do parâmetro pode ser diferente do tipo do retorno. Em ehPositivo, o parâmetro numero é inteiro, mas o resultado devolvido é logico. O primeiro tipo descreve o dado que entra; o segundo descreve o resultado que volta.

8.7 – Compare os exemplos

8.8 – Retornar não é o mesmo que exibir

O comando retorne entrega um resultado ao trecho do algoritmo que fez a chamada. O comando escreval mostra uma informação na tela.

resultado <- dobro(5)

Essa linha guarda 10 em resultado, mas não mostra nada na tela. Para exibir o valor, usamos:

escreval(resultado)

8.9 – Como planejar uma função simples

1. Escolha uma tarefa pequena, como calcular o dobro ou somar dois números.
2. Decida se a função precisa receber dados na chamada.
3. Se precisar, defina os nomes e os tipos dos parâmetros.
4. Defina o tipo do resultado que será devolvido.
5. Escolha um nome que explique a tarefa.
6. Escreva os comandos e use retorne para devolver o resultado.
7. Faça a chamada e teste com valores cujo resultado você já conhece.

Antes de escrever, responda: quais dados entram, o que será feito com eles e qual resultado deve voltar?

8.10 – Dicas importantes

• Declare as funções antes dos comandos principais.
• Defina se o retorno será inteiro, real, logico ou caractere.
• Lembre-se de chamar a função. Apenas defini-la não executa seus comandos.
• Use nomes descritivos, como calcularMedia ou areaRetangulo.
• Mantenha uma tarefa clara por função.
• Declare as variáveis auxiliares dentro da função quando forem usadas apenas nela.
• Use uma variável de tipo compatível para guardar o retorno.
• Confira o resultado com um cálculo feito à mão.

Os exercícios sobre procedimentos e funções estão nas Listas 17 a 19 do caderno de exercícios.

Apêndice – Tabela de referência rápida do VisuAlg

Conclusão

No Portugol, aprendemos a pensar antes de programar: entender o problema, separar entrada, processamento e saída, e testar a solução. Os conceitos de sequência, decisão, repetição, estruturas de dados, procedimentos e funções são a base de qualquer linguagem de programação.

Quando você estudar C ou Python, a lógica será exatamente a mesma. O que muda é a gramática: tipos antes dos nomes, ponto e vírgula, chaves ou indentação, e índices que começam em zero. Se o algoritmo está correto em Portugol, a tradução é uma questão de conhecer a nova linguagem.

Os links e as telas de instalação podem mudar com o tempo. Em caso de diferença visual, utilize sempre a página oficial indicada e procure a opção equivalente.

Índice por assunto

Os números indicam a seção da apostila (ex.: 5.14 = Capítulo 5, seção 14). Nos arquivos digitais, clique no número para ir direto ao conteúdo.

Assuntos de lógica de programação

A

• Acumulador (somar valores em uma variável) — 4.1, 5.10, 6.6
• Algoritmo – conceito — 1.1
• Algoritmo – estrutura (Algoritmo, Var, Inicio, Fimalgoritmo) — 1.4
• Alterar um valor do vetor — 5.18
• Ambiente de programação (instalação do VisuAlg) — Cap. 0
• Argumento — 8.5
• Atividades de fixação / exercícios — 1.15, 2.4, 4.4, 5.25, 6.6, 7.8, 8.10
• Atribuição — 1.9

B

• Blocos de comandos — 1.14
• Busca de um valor no vetor — 5.18

C

• Capacidade do vetor — 5.20
• Chamada de função — 8.4
• Chamada de procedimento — 7.5
• Comentários — 1.4
• Condicional composta (se/senao) — 2.3.2
• Condicional encadeada (mais de duas possibilidades) — 2.3.3
• Condicional simples (se) — 2.3.1
• Constantes — 1.6
• Contagem de valores — 5.12

D

• Declaração de variáveis — 1.9
• Divisão (/ × div) — 1.10

E

• Escolha/caso — 3.1, 3.2
• Escolha entre se/senao e escolha/caso — 3.2
• Exibição com casas decimais — 1.13

F

• Fluxograma — 1.3
• Função – conceito — 8.1

I

• Identificadores (regras para nomes) — 1.8
• Indentação — 1.14
• Índices começam em 1 — 5.4, 5.5

L

• Leitura de dados (leia) — 1.13
• Lógica de programação — 1.1

M

• Maior valor do vetor — 5.14, 5.16
• Matriz – acesso aos elementos — 6.3
• Matriz – conceito — 6.1
• Matriz – declaração — 6.2
• Matriz – exibição em tabela — 6.5
• Matriz – leitura e escrita — 6.4
• Média de cada aluno (cálculo por linha) — 6.6
• Média de um vetor — 5.11
• Menor valor do vetor — 5.15, 5.16
• Menu de exercícios com procedimentos — 7.3, 7.6, 7.7

N

• Número par ou ímpar (resto da divisão) — 1.10, 5.12

O

• Operadores aritméticos — 1.10
• Operadores lógicos — 1.12, 2.2
• Operadores relacionais — 1.11, 2.1
• Ordem inversa do vetor — 5.9

P

• Parâmetro — 8.5
• Passo (incremento do para) — 4.1, 5.9
• Para (repetição por contagem) — 4.1
• Posição do maior valor — 5.17
• Procedimento – conceito — 7.1
• Procedimento – declaração e chamada — 7.2, 7.4, 7.5
• Processamento, entrada e saída — Apresentação

R

• Repetição – escolha da estrutura — 4.4
• Repita (teste no final) — 4.3
• Resultado de função: retorne × escreval — 8.8
• Retorno de função (tipos) — 8.6, 8.7

S

• Saída (escreva, escreval) — 1.13
• Se/senao — 2.3.1, 2.3.2, 2.3.3
• Soma de valores do vetor — 5.10

T

• Tabela verdade — 1.12
• Teste de mesa — 1.2, 2.4
• Tipos de dados (inteiro, real, caractere, logico) — 1.5
• Tipos de funções quanto aos parâmetros — 8.3
• Tipos de retorno das funções — 8.6, 8.7

V

• Variável – conceito — 1.7
• Variável local — 7.4, 8.6.2
• Variável simples × vetor × matriz — 5.2, 6.1
• Vetor – análise completa de notas — 5.22
• Vetor – conceito — 5.1
• Vetor – declaração — 5.3
• Vetor – erros comuns — 5.23
• Vetor – resumo dos comandos — 5.24
• Vetores paralelos — 5.21

Comandos e recursos do VisuAlg

Símbolos e operadores

• <- (atribuição) — 1.9
• = (igual) × <- (atribuição) — 1.9, 1.11
• <> (diferente) — 1.11, 2.1
• e, ou, nao — 1.12, 2.2
• % (resto), mod — 1.10
• div (divisão inteira) — 1.10
• ^ (potência) — 1.10
• :4:2 (formatação) — 1.13
• // (comentário) — 1.4

E

• enquanto — 4.2
• escolha / caso / outrocaso — 3.1

F

• funcao / fimfuncao — 8.2
• fimprocedimento — 7.2

L

• leia — 1.13

P

• para / fimpara — 4.1
• passo — 4.1, 5.9
• procedimento — 7.2

R

• repita / ate — 4.3
• retorne — 8.2

S

• se / entao / senao / fimse — 2.3

V

• var — 1.4
• vetor[...] de — 5.3, 6.2

Copyleft 🄯 2026 - Professor Mauro Borges França.