O documento descreve o programa VisuALG, que permite editar, interpretar e executar algoritmos escritos em pseudocódigo. O VisuALG possui uma interface gráfica simples com editor de texto e ferramentas para executar e depurar algoritmos. O documento também fornece exemplos básicos de algoritmos em Portugol, incluindo um programa "Olá Mundo" e explicações sobre elementos fundamentais como declarações, variáveis, constantes e operadores.

1. VisuALG #1 – Introdução
VisuALG
O VisuALG (Visualizador de algoritmo), criado pelo professor Cláudio Morgado de Souza, é um
programa que edita, interpreta e executa algoritmos escritos em pseudocódigo (Portugol), como um
programa normal de computador. É um programa de livre uso e distribuição, empregado no ensino
de programação em várias escolas e universidades no Brasil e no exterior.
Instalação
O VisuALG é um programa simples, que não depende de DLLs, OCXs ou outros componentes. Sua
instalação não copia arquivos para nenhuma outra pasta a não ser aquela em que for instalado, e
toma em torno de 1 MB de espaço em disco. A instalação é muito simples, basta executar o
instalador e acionar os botões Avançar. Ao inciar o software, vemos uma tela com o esqueleto de
um algoritmo já criado, cuja intenção é, além de poupar trabalho ao usuário, mostrar o formato
básico de algoritmo que deve ser utilizado, bem como a forma dos comentários, conforme a
imagem abaixo:

2. A tela principal do VisuALG
1. Barra de menus;
2. Barra de ferramentas;
3. Barra de execução de algoritmo;
4. Editor de texto;
5. Visualizador de variáveis;
6. Simulador de saída;
7. Barra de status.
Olá mundo! Hello World!
O “Olá Mundo” ou “Alô Mundo” é um famoso programa de computador que imprime “Olá
Mundo!” ou “Hello World!”, no dispositivo de saída. É utilizado como um teste ou como um
exemplo de código minimalista de uma linguagem de programação. Dito isto, vamos escrever nosso
“Olá mundo” em Portugol, no VisuALG.
Insira o código abaixo no editor de texto do VisuALG, em seguida pressione a tecla F9 do seu
teclado. A tecla F9 inicia, ou continua, a execução automática do algoritmo.

3. 1
2
3
4
5
6
7
8
9
10
11
12
13
algoritmo "Olá mundo"
// Função: Olá mundo
// Autor: Andrey Smith
// Data: 01/05/2014
// Seção de Declarações
var
inicio
// Seção de Comandos
escreva ("Olá mundo!")
fimalgoritmo
Este deve ser o resultado.
Conclusão
Programar utilizando o VisuALG é simples e fácil. Por utilizar uma linguagem em nosso idioma,
ele torna-se um grande facilitador para iniciantes em programação.
Até o próximo!
:wq!
Andrey Smith
https://andreysmith.wordpress.com/2014/05/01/visualg-1-introducao/

4. VisuALG #2 – Algoritmo
Algoritmo
É uma forma estruturada de resolver problemas numa sequência lógica, passo a passo até obter o
resultado desejado. Todo tipo de problema que temos no dia a dia, resolvemos através de
algoritmos, que muitas vezes não são nem percebidos como tal.
Abaixo temos um exemplo de algoritmo para realizar uma chamada telefônica em um telefone
público:
1
2
3
4
5
6
7
8
9
10
11
12
13
Tirar o telefone do gancho;
Ouvir o sinal de linha;
Inserir o cartão no telefone público;
Teclar o número desejado;
Se chamar e alguém atender...
* Conversar;
* Desligar;
* Retirar o cartão;
Senão...
* Desligar;
* Voltar ao início.
De forma bem simples, para facilitar o entendimento, algoritmo é uma receita.
Abaixo temos um exemplo de receita:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Picanha assada no forno
Receita da Tia Nastácia
Ingredientes
01 picanha;
02 tabletes de caldo de carne;
250 gramas de margarina;
02 colheres (sopa) de molho inglês;
01 cebola grande ralada;
Sal, alho e pimenta.
Modo de preparo
Tempere a picanha com alho socado, sal e pimenta e deixe tomar
gosto por 02 horas;
Coloque a picanha em uma assadeira, com a parte da gordura para
baixo;
Espalhe o molho inglês misturado com o caldo de carne, margarina
e cebola ralada;

5. Cubra com papel alumínio e asse em forno quente por 20 minutos;
Retire o papel, vire a parte da gorda para cima e asse por mais
25 minutos;
Retire e sirva com arroz branco, vinagrete e aipim cozido.
Nos dois exemplos vistos, foi necessário seguir uma sequência ordenada de passos para se obter o
resultado desejado. A receita acima está dividida em duas partes: ingredientes e modo de preparo.
Vamos dividir nossa receita-algoritmo em três partes: Cabeçalho, sessão de declarações e sessão de
comandos.
No cabeçalho encontramos informações gerais, como data, autor, contato do autor, comentários e
etc.
A sessão de declarações pode ser comparada com os ingredientes da receita. A sessão de comandos
pode ser comparada com o modo de preparo da receita.
Comentário
É utilizado para adicionar informações afim de: facilitar o entendimento de quem ler o algortimo,
adicionar observações sobre o funcionamento do programa, etc. É importante frisar que os
comentários não são executados pelo programa, ou seja, no momento da execução do programa os
comentários são ignorados.
No VisuALG, um comentário inicia com //.
Exemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
algoritmo "Olá mundo!"
// Isso é um comentário!
// Função: Demonstrar como é fácil utilizar o VisuALG!
// Autor: Andrey Smith
// Data: 01/05/2014
// Seção de Declarações
var
inicio
// Seção de Comandos
escreva ("Olá mundo!")
fimalgoritmo
Resultado do algoritmo:

6. Declaração
Consiste na definição dos nomes e valores das constantes e dos nomes e tipos das variáveis que
serão utilizadas pelos algoritmos, incluindo comentário, quando se fizerem necessários.
A declaração deve estar no início do algoritmo, antes das constantes e variáveis serem de fato
utilizadas no algoritmo.
Constante
As contantes são dados estáticos, o seu conteúdo pode ser acessado a qualquer momento. O
conteúdo de uma constante será atribuído no momento de sua criação e não poderá ser mais
alterado.
A atribuição de valores é feita com o operador. Exemplos: pi, polegada.
1
2
3
4
5
6
7
8
9
pi <- 3.14159265359
polegada <- 2.54
+-----------+------------+--------------+
| Constante | Atribuição | Conteúdo |
+-----------+------------+--------------+
|pi | <- |3.14159265359 |
|polegada | <- |2.54 |
+-----------+------------+--------------+
Variável
As variáveis armazenam dados em caráter temporário e tem conteúdo dinâmico, ou seja, podem ser
acessadas ou alteradas a qualquer momento.

7. Exemplos: Em um algoritmo que recebe um determinado raio, para calcular a área do círculo,
teremos duas variáveis: raio e área.
1
2
3
4
5
6
7
8
9
raio: real
area: real
+----------+------+
| Variável | Tipo |
|----------+------+
|raio | real |
|area | real |
+----------+------+
Tipos de dados
Em computação, existem os seguintes tipos básicos de dados, também conhecidos como tipos
primitivos: Numéricos (inteiro e real), caractere e lógico
Inteiro – Representa valores inteiros, ou seja, SEM CASAS DECIMAIS. Exemplos: 10, 5, -5, -10.
1
2
3
4
5
6
7
8
9
idade: inteiro
temperatura: inteiro
+------------+---------+
| Variável | Tipo |
|------------+---------+
|idade | inteiro |
|temperatura | inteiro |
|------------+---------+
Real – Representa valores reais, ou seja, COM CASAS DECIMAIS.
Exemplos: 10.555, 15.5, -14.67, -1000.000.
Obs.: Em nossos algoritmos vamos assumir que o separador decimal sempre será o . (ponto) e não
a, (vírgula). E nunca vamos inserir o separador do milhar. Exemplo: 1500 em vez de 1.500.
1
2
3
4
5
6
7
8
9
altura: real
peso: real
+--------+----+
|Variável|Tipo|
|--------+----+
|altura |real|
|peso |real|
+--------+----+
Caractere – Representa uma seqüência de um ou mais caracteres.

8. Exemplos: “O resultado da soma é: “, “B”, “1234”, “Seleção Brasileira”.
Obs.: Os caracteres devem estar sempre entre ” ” (aspas duplas)
1
2
3
4
5
6
7
8
9
nome: caractere
endereço: caractere
+--------+---------+
|Variável| Tipo |
|--------+---------+
|nome |caractere|
|endereço|real |
+--------+---------+
Lógico – Representa valores lógicos, os quais possuem apenas 2 estados: Verdadeiro e falso.
Abaixo temo um exemplo de algoritmo que, solicita o raio de um círculo para então calcular sua
área:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
algoritmo "Área do círculo"
// Função: Área do círculo
// Autor: Andrey Smith
// Data: 02/05/2014
// Seção de Declarações
var
raio, area: real // Estes são exemplos de variáveis.
inicio
pi <- 3.14159265359 // Este é um exemplo de constante.
// Seção de Comandos
escreva ("Informe o raio do círculo: ")
leia (raio)
area <- pi * raio ^ 2
escreval ("A área do círculo é: ", area)
fimalgoritmo
Resultado do algoritmo:

9. Conclusão
Algoritmo é a lógica de um programa computacional, ou seja, são as instruções que o homem
fornece ao computador para que determinadas tarefas sejam executadas. Portanto, se um programa
não está funcionando corretamente, não culpe o computador. = )
Até o próximo!
:wq!
Andrey Smith
https://andreysmith.wordpress.com/2014/05/02/visualg-2-algoritmo/

10. VisuALG #3 – Operadores
Introdução
Para falarmos sobre operadores, precisamos primeiramente entender o funcionamento das
expressões aritméticas no ambiente computacional.
Linearização de Expressões
Para a construção de algoritmos que realizam cálculo matemáticos, todas as expressões aritméticas
devem ser linearizadas, ou seja, colocadas em linhas, devendo também ser feito o mapeamento dos
operadores da aritmética tradicional para os do Português Estruturado.
Operadores Aritméticos

11. 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
algoritmo "Operadores Aritméticos"
// Função: Operadores Aritméticos
// Autor: Andrey Smith
// Data: 03/05/2014
// Seção de Declarações
var
numero1, numero2: inteiro
resultado: real
inicio
// Seção de Comandos
numero1 <- 14
numero2 <- 4
resultado <- numero1 + numero2
escreval (numero1, " +", numero2, " =", resultado)
escreval ("")
resultado <- numero1 - numero2
escreval (numero1, " -", numero2, " =", resultado)
escreval ("")
resultado <- numero1 * numero2
escreval (numero1, " *", numero2, " =", resultado)
escreval ("")
resultado <- numero1 / numero2
escreval (numero1, " /", numero2, " =", resultado)
escreval ("")
resultado <- numero1 numero2
escreval (numero1, " DIV", numero2, " =", resultado)
escreval ("")
resultado <- numero1 % numero2
escreval (numero1, " MOD", numero2, " =", resultado)
escreval ("")
resultado <- numero1 ^ numero2
escreval (numero1, " EXP", numero2, " =", resultado)
fimalgoritmo
Resultado do algoritmo:

12. Precedência entre operadores aritméticos
1
2
3
4
5
6
7
8
+------------+--------------------------------------------+
| Prioridade | Operadores |
+------------+--------------------------------------------+
|1º | Parênteses internos |
|2º | ^ (Potenciação) e raiz (Quando disponível) |
|3º | * / div e mod |
|4º | + e - |
+------------+--------------------------------------------+
Os casos abaixo exemplificam a importância da precedência entre operadores aritméticos.
1º CASO: (2+2)/2=2
Solução (Certo)
1º. Resolvemos o que está entre parênteses (2+2), e encontramos 4 como resultado;
2º. Resolvemos a divisão 4/2, e encontramos 2 como resultado.
2º CASO: 2+2/2=3
Solução 01 (Certo)
1º. Resolvemos a divisão 2/2, e encontramos 1 como resultado;
2º. Resolvemos a adição 2+1, e encontramos 3 como resultado.
Solução 02 (Errado)
1º. Resolvemos a adição 2+2, e encontramos 4 como resultado;
2º. Resolvemos a divisão 4/2, e encontramos 2 como resultado.

13. Operadores Relacionais
Os operadores relacionais realizam a comparação entre dois operandos ou duas expressões, e
resultam em valores lógicos (VERDADEIRO ou FALSO).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
algoritmo "Operadores relacionais"
// Função: Operadores relacionais
// Autor: Andrey Smith
// Data: 03/05/2014
// Seção de Declarações
var
numero1, numero2: inteiro
resultado: logico
inicio
// Seção de Comandos
numero1 <- 14
numero2 <- 4
resultado <- numero1 > numero2
escreval (numero1, " > ", numero2, " ?", resultado)
resultado <- numero1 < numero2
escreval (numero1, " < ", numero2, " ?", resultado)
resultado <- numero1 >= numero2
escreval (numero1, " >=", numero2, " ?", resultado)
resultado <- numero1 <= numero2
escreval (numero1, " <=", numero2, " ?", resultado)
resultado <- numero1 = numero2
escreval (numero1, " = ", numero2, " ?", resultado)
resultado <- numero1 <> numero2
escreval (numero1, " <>", numero2, " ?", resultado)
fimalgoritmo
Resultado do algoritmo:

14. Operadores lógicos
Os operadores lógicos atuam sobre expressões e também resultam em valores lógicos
VERDADEIRO ou FALSO.

15. 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
algoritmo "Operadores lógicos - E, OU, NÃO"
// Função: Operadores lógicos - E, OU, NÃO
// Autor: Andrey Smith
// Data: 03/05/2014
// Seção de Declarações
var
numero1, numero2: inteiro
resultado: logico
inicio
// Seção de Comandos
numero1 <- 14
numero2 <- 4
escreval ("Testando o operador lógico E:")
resultado <- (numero1 > numero2) e (numero1 > numero2)
escreval (numero1, " >", numero2, " E",numero1, " >", numero2, "
=", resultado)
escreval ("Duas proposições VERDADEIRAS!")
escreval("")
escreval ("Testando o operador lógico OU:")
resultado <- (numero1 < numero2) ou (numero1 < numero2)
escreval (numero1, " <", numero2, " OU",numero1, " <", numero2, "
=", resultado)
escreval ("Duas proposições FALSAS!")
escreval("")
escreval ("Testando o operador lógico NÃO:")
resultado <- nao (numero1 > numero2)
escreval (numero1, " >", numero2, " =", resultado)
escreval ("O que é VERDADEIRO se torna FALSO!")
escreval("")
escreval ("Testando o operador lógico NÃO:")
resultado <- nao (numero1 < numero2)
escreval (numero1, " <", numero2, " =", resultado)
escreval ("O que é FALSO se torna VERDADEIRO!")
escreval("")
fimalgoritmo
Resultado do algoritmo:

16. Tabela verdade
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
algoritmo "Operadores lógicos - Tabela verdade"
// Função: Operadores lógicos - Tabela verdade
// Autor: Andrey Smith
// Data: 03/05/2014
// Seção de Declarações
var
numero1, numero2: inteiro
resultado: logico
inicio
// Seção de Comandos
numero1 <- 14
numero2 <- 4
escreval ("Testando o operador lógico E:")
resultado <- (numero1 > numero2) e (numero1 > numero2)

17. 18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
escreval (numero1, " >", numero2, " E",numero1, " >", numero2, "
=", resultado)
resultado <- (numero1 > numero2) e (numero1 < numero2)
escreval (numero1, " >", numero2, " E",numero1, " <", numero2, "
=", resultado)
resultado <- (numero1 < numero2) e (numero1 > numero2)
escreval (numero1, " <", numero2, " E",numero1, " >", numero2, "
=", resultado)
resultado <- (numero1 < numero2) e (numero1 < numero2)
escreval (numero1, " <", numero2, " E",numero1, " <", numero2, "
=", resultado)
escreval("")
escreval("")
escreval ("Testando o operador lógico OU:")
resultado <- (numero1 > numero2) ou (numero1 > numero2)
escreval (numero1, " >", numero2, " OU",numero1, " >", numero2, "
=", resultado)
resultado <- (numero1 > numero2) ou (numero1 < numero2)
escreval (numero1, " >", numero2, " OU",numero1, " <", numero2, "
=", resultado)
resultado <- (numero1 < numero2) ou (numero1 > numero2)
escreval (numero1, " <", numero2, " OU",numero1, " >", numero2, "
=", resultado)
resultado <- (numero1 < numero2) ou (numero1 < numero2)
escreval (numero1, " <", numero2, " OU",numero1, " <", numero2, "
=", resultado)
escreval("")
escreval("")
escreval ("Testando o operador lógico NÃO para A (Primeira
prosição):")
resultado <- nao (numero1 > numero2)
escreval (resultado)
resultado <- nao (numero1 > numero2)
escreval (resultado)
resultado <- nao (numero1 < numero2)
escreval (resultado)
resultado <- nao (numero1 < numero2)
escreval (resultado)
escreval("")
escreval("")
escreval ("Testando o operador lógico NÃO para B (Segunda
prosição):")
resultado <- nao (numero1 > numero2)
escreval (resultado)
resultado <- nao (numero1 < numero2)
escreval (resultado)
resultado <- nao (numero1 > numero2)

18. escreval (resultado)
resultado <- nao (numero1 < numero2)
escreval (resultado)
fimalgoritmo
Resultado do algoritmo:
Conclusão
Operadores são indispensáveis em nossos programas, mas para que possamos criar algoritmos
eficientes, precisamos atentar às particularidades dos operadores, bem como à ordem de
precedência de cada um.
Até o próximo!
:wq!
Andrey Smith
https://andreysmith.wordpress.com/2014/05/03/visualg-3-operadores/

19. VisuALG #4 – Desvio condicional simples (SE… ENTÃO…
FIMSE)
SE… ENTÃO… FIMSE
O desvio condicional simples tem por finalidade executar uma ou mais instruções SE uma
CONDIÇÃO for VERDADEIRA, ou seja, SE uma CONDIÇÃO for SATISFEITA. Uma
CONDIÇÃO é uma comparação que possui dois valores possíveis: VERDADEIRO ou FALSO.
Ao encontrar este comando, o VisuALG analisa a CONDIÇÃO, SE o seu resultado for
VERDADEIRO, todos os comandos da SEQUÊNCIA DE COMANDOS são executados. SE o
resultado for FALSO, os comandos da SEQUÊNCIA DE COMANDOS são desprezados e a
execução do algoritmo continua a partir da primeira linha depois do comando FIMSE.
Sintaxe:
1
2
3
4
5
se <condição> entao
<sequência de comandos>
fimse
Para facilitar o entendimento, vamos pensar na seguinte situação:
1
2
3
4
5
se <sua esposa pegar seu cartão de crédito> entao
<compras, compras, compras, compras...>
fimse
Entendeu? Vamos ao exemplo!

20. 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
algoritmo "Desvio condicional simples"
// Função: Demonstrar a utilização do desvio condicional simples.
// Autor: Andrey Smith
// Data: 17/05/2014
// Seção de Declarações
var
nome: caractere
nota1, nota2, media: real
inicio
// Seção de Comandos
escreva ("Informe o nome do aluno: ")
leia (nome)
escreva ("Informe a nota da P1: ")
leia (nota1)
escreva ("Informe a nota da P2: ")
leia (nota2)
media <- (nota1 + nota2) / 2
se ( media >= 7) entao
escreval ("A média do aluno ", nome, " é:", media)
fimse
escreval ("O aluno ", nome, " precisa comparecer na coordenação
do curso.")
fimalgoritmo
Resultado do algoritmo com a CONDIÇÃO VERDADEIRA:

21. Resultado do algoritmo com a CONDIÇÃO FALSA:
Observe que, como dito anteriormente, pelo fato do resultado ser FALSO, a SEQUÊNCIA DE
COMANDOS foi desprezada e a execução do algoritmo continuo a partir da primeira linha depois
do fimse.

22. Conclusão
Nunca deixe sua esposa (Noiva, namorada, filha, etc) pegar seu cartão de crédito, pois esta é uma
CONDIÇÃO que, SE SATISFEITA, pode trazer alguns problemas. =)
Até o próximo!
:wq!
Andrey Smith
https://andreysmith.wordpress.com/2014/05/18/visualg-4-desvio-condicional-simples-se-entao/

23. VisuALG #5 – Desvio condicional composto (SE… ENTÃO…
SENÃO… FIMSE)
SE… ENTÃO… SENÃO… FIMSE
O desvio condicional composto (SE… ENTÃO… SENÃO… FIMSE) funciona exatamente como
o desvio condicional simples (SE… ENTÃO… FIMSE), com apenas uma diferença. No desvio
condicional simples, somente podemos executar comandos SE a CONDIÇÃO for
VERDADEIRA.
No desvio condicional composto, os comandos sempre serão executados independente da
CONDIÇÃO, ou seja, SE a CONDIÇÃO for VERDADEIRA os COMANDOS DA
CONDIÇÃO VERDADEIRA serão executados, SENÃO (SE a CONDIÇÃO for FALSA) os
COMANDOS DA CONDIÇÃO FALSA serão executados.
Sintaxe:
1
2
3
4
5
6
7
8
9
se <condição> entao
<comandos da condição verdadeira>
senao
<comandos da condição falsa>
fimse
Para facilitar o entendimento, vamos pensar naquela situação do cartão de crédito que vimos no post
anterior:
1
2
3
4
5
6
7
8
9
se <sua esposa pegar seu cartão de crédito> entao
<compras, compras, compras, compras...>
senao
<fica na vontade>
fimse
Entendeu né? Vamos ao exemplo!

24. 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
algoritmo "Desvio condicional composto"
// Função: Demonstrar a utilização do desvio condicional
composto.
// Autor: Andrey Smith
// Data: 18/05/2014
// Seção de Declarações
var
nome: caractere
nota1, nota2, media: real
inicio
// Seção de Comandos
escreva ("Informe o nome do aluno: ")
leia (nome)
escreva ("Informe a nota da P1: ")
leia (nota1)
escreva ("Informe a nota da P2: ")
leia (nota2)
media <- (nota1 + nota2) / 2
se ( media >= 7) entao
escreval ("A média do aluno ", nome, " é:", media)
senao
escreval ("O aluno ", nome, " não alcançou a média.")
fimse
fimalgoritmo
Resultado do algoritmo com a CONDIÇÃO VERDADEIRA:

25. Resultado do algoritmo com a CONDIÇÃO FALSA:
Conclusão
O desvio de concional composto amplia as possibilidades do desvio condicional simples que vimos
no post anterior. No próximo post veremos desvio condicional encadeado (SE… ENTÃO…

26. SENÃO… SE… ENTÃO… SENÃO) que ampliara ainda mais nosso poder de fogo nos
algoritmos. =)
Até o próximo!
:wq!
Andrey Smith
https://andreysmith.wordpress.com/2014/05/18/visualg-5-desvio-condicional-composto-se-entao-senao-fimse/