Algoritmos computacionais: são passos a serem seguidos por um módulo processador e seus respectivos usuários que,

quando executados na ordem correta, conseguem realizar determinada tarefa. Módulo processador é tudo aquilo que
pode efetuar processamento, pode ser um computador portátil, pode ser um tablet, desktop, uma câmera, módulo
processador é tudo aquilo que pode ser programável. Usuário somos nós mesmos, quando desenvolvemos algoritmos,
queremos que outras pessoas utilizam esse programa, essas outras pessoas que utilizarão serão os usuários. Realizar
determinada tarefa, é a ação que o programa faz para resolver por exemplo um problema que o usuário tem, esse programa
vai utilizar o módulo processador para resolver esse problema. Exemplo quando você acessa seu internet banking e vê seus
saldos, extratos, tudo isso é controlado por algoritmo, tudo que você faz através do aplicativo internet banking desde
transferência, consulta de saldo e extrato, tudo é controlado por algoritmo. Quando você acessa twitter, facebook, intagram,
tudo isso são algoritmos computacionais que estão rodando em servidores de alta performance.
Como os algoritmos são criados? Todo algoritmo computacional é desenvolvido através de uma lógica de programação,
devemos desenvolver esse raciocínio lógico para programar. A partir do momento que construímos uma lógica de
programação, iremos escrever essa lógica em uma linguagem de programação, essa linguagem de programação será
utilizada para a criação de um sistema completo, que é o aplicativo, o software que o usuário irá utilizar. Todo o sistema
nasce na cabeça de um Analista de sistemas e de um programador, de uma equipe de desenvolvimento, onde desenvolvem
toda uma lógica de programação, a partir disso é escrito essa lógica em uma linguagem, essa lógica é estruturada em uma
linguagem de programação, dando origem assim a um sistema completo.
Para criar uma lógica de programação existem ferramentas que podem ser utilizadas, essas são fluxograma que são fluxo
de informações lógicas que vai de um ponto a outro. Outra ferramenta para criar uma lógica de programação é a Nassi-
Shneiderman também conhecido como diagrama de chapin, onde vai representar a lógica do programa através de blocos,
fluxograma e diagrama de Nassi-Shneiderman são antigos e poucos utilizados hoje em dia, o que é mais utilizado hoje em
dia para desenvolver uma lógica de programação é o Pseudocódigo ou o Portugol, pseudocódigo é a linguagem do
programa escrita na sua linguagem nativa, que no nosso caso por ser escrita em português, é o Portugol. Portugol não é
uma linguagem de programação, é uma maneira de representar a lógica de programação, antes de passar para uma
linguagem de programação, a ferramenta que se utiliza para escrever a lógica de programação, para escrever o algoritmo
em Portugol, é a Visualg.
Comando de saída Visualg: comando de saída é quando mostra algo na tela, quando mostra algo para mim, ex
Escreva(“Olá Mundo!”) irá aparecer na tela Olá Mundo!, isso é um comando de saída.
Escreva(“Qualquer coisa”) irá aparecer na tela “Qualquer coisa”, tudo que estiver entre aspas é considerado uma
mensagem, é considerado uma cadeia de caracteres.
Para aparecer Olá Mundo! na tela:
algoritmo “primeiro”
var
inicio
Escreva(“Olá Mundo!”), caso queira escrever outra coisa embaixo do olá mundo, como por exemplo me livrei da
maldição, deve escrever:
Escreval(“Olá Mundo!”) – Escreval o (l) fará com que pule de linha.
Escreva(“Me livrei da maldição!”)
fimalgoritmo
Além de inicio e fimalgoritmo, tem o campo var, que significa variável, variáveis são espaços vazios, esses espaços vazios
ficam na memória do computador, esses espaços podem ser preenchidos com valores. Podemos criar uma variável com o
nome BOLA que preencherá um espaço vazio da memória, se eu quiser nesse mesmo espaço colocar outro objeto um
SAPATO por exemplo eu não consigo, quando eu coloco um valor em uma variável simples, não consigo colocar outro
valor, se eu quiser colocar um sapato nesse espaço, terei que tirar essa bola e colocar o sapato no lugar. Na área de variáveis
do Visualg, temos sempre que colocar um identificador:tipo, exemplo BOLA é o identificador e Brinquedo é o tipo,
ficando BOLA: Brinquedo. Identificador identifica determinadas variáveis, existem 6 regras para nomeação de
identificadores dentro do Visualg, o identificador:
1- Identificador deve começar com uma letra, sempre começando com uma letra, ex A1, A2, A3, BOLA, SAPATO.
2- Em identificador os próximos caracteres podem ser letras ou números, ex AA1, AA2, A1, A2, BOLA, SAPATO,
Nota1.
3- Em identificador não pode utilizar nenhum símbolo, exceto _, então não pode utilizar @, #, %, $, só pode ser utilizado
_.
4- Em identificador não pode conter espaços em branco, ex salário bruto, o correto seria salariobruto ou salario_bruto,
Inicio_Algoritmo.
5- Em identificador não pode conter letras com acentos, ex Média, Salário,
6- Identificador não pode ser uma palavra reservada, no Visualg palavras reservadas aparecem sublinhada ou num tom de
azul, seria as palavras utilizadas em comandos como por exemplo Escreva, Escreval, algoritmo, var, inicio, fimalgoritmo,
essas palavras não podem ser utilizadas como identificadores.
Tipos primitivos
Na variável, acompanhado do identificador, vem o tipo primitivo (identificador:tipo), o tipo primitivos no Portugol são 4
tipos, o tipo primitivo inteiro, real, caracteres e lógico. O tipo primitivo inteiro só irá permitir que a variável guarde
números inteiros, números inteiros são 1, 3, -5 198 0, números inteiros são tipos de números que não são fracionários, seja
o número positivo, negativo ou nulo. O tipo primitivo real, são números fracionários como 0.5, 5.0, 9.8, -77.3, 3.1415. O
tipo primitivo caractere é tudo aquilo que é colocado entre aspas “ ” como “Gustavo”, “Algoritmo”, “123”, dentro de
aspas pode utilizar acento, pontos, no tipo não segue as 6 regras que são seguidas em identificadores, são conjunto de
caracteres que ficam entre aspas. Tipo primitivo logico guarda apenas 2 valores, esses são verdadeiro e falso.
algoritmo “primeiro”
var
msg: caractere //vai criar na memória um espaço na memória uma variável para guardar uma mensagem do tipo
caractere, podemos colocar a mensagem “olá mundo” dentro da variável, mas para isso precisamos entender o conceito de
atribuição.
inicio
fimalgoritmo
Atribuição
Algoritmo “primeiro”
var
msg: caractere
inicio
msg <- “Olá Mundo!” //variável msg recebe a mensagem “Olá Mundo!”, é como se você pegasse a mensagem
“Olá Mundo!” e jogasse dentro da variável msg, isso é atribuição, símbolo recebe é o sinal de menor e sinal de menos <-
msg <- “Olá Mundo!”
Escreva(msg) //a variável msg vai dentro do Escreva, mas sem aspas, porque msg é uma variável, se escrever
Escreva(“msg”) dentro de parênteses e aspas, irá aparecer na tela msg, mas se der o comando Escreva(msg) sem aspas, irá
aparecer na tela Olá Mundo!
fimalgoritmo
Se olhar nas áreas da variáveis do Visualg após criar essa linha de comando, aparecera nome da variável msg, tipo C que é
caractere, valor “Olá Mundo!” que é a mensagem que aparecerá na tela. Existe algumas formas de escrever o comando
Escreva no Visualg.
Escreva(“msg”) //irá aparecer na tela msg
Escreva(msg) //irá aparecer na tela o que tiver dentro da variável msg, como no exemplo acima msg <- “Olá Mundo!”, irá
aparecer na tela Olá Mundo!
Escreva(“mensagem”, msg) //vai escrever duas coisas na tela, vai escrever na tela a “mensagem”, + a variável msg. Ex:
algoritmo “primeiro”
var
msg: caractere
inicio
msg <- “Olá Mundo!”
Escreva(“Mensagem “, msg) //irá aparecer na tela Mensagem Olá Mundo!
fimalgoritmo
Comando de entrada Visualg: seria entrar de alguma forma com dados no computador, comando de entrada vai solicitar
algo ao usuário que está utilizando o sistema.
Algoritmo “MeuNome”
var
 Nome: caractere //na variável nome poderá ser guardado um conjunto de caracteres, tudo que estiver entre aspas será
guardado na variável Nome.
Inicio
Escreva(“Digite seu nome: “) //Aqui pedirá para o usuário escrever o nome dele, comando de saída
Leia(Nome) //Quando o usuário escrever o nome dele ex Igor, ficará salvo na variável Nome a string Igor, Leia é
o comando de entrada, o nome que for digitado, irá ficar armazenado na memória.
Escreva (“Muito prazer “, nome) //esse é um comando de saída, irá aparecer na tela Muito prazer Igor, Igor é o
conteúdo da variável Nome, que é o que foi digitado pelo usuário.
Fimalgoritmo
Com esses comando de entrada, podemos fazer algoritmos de cálculo
Algoritmo “calculo”
var
N1, N2, S: Inteiro //3 variáveis
Inicio
Escreval(“Digite um número: “)
Leia(N1)
Escreva(Digite outro número: “)
Leia(N2)
S <- N1 + N2 //variável S recebe N1 + N2, vai somar os valores digitados no Leia(N1) e Leia(N2).
Escreva("A soma entre", N1, " e" , N2, " é igual a", S) //vai aparecer na tela: A soma entre N1 e N2 é igual a S,
ex se eu digitar 5 e depois 6, vai ficar: A soma entre 5 e 6 é igual a 11.
Fimalgoritmo
Operadores aritméticos: no caso acima utilizamos o operador de soma (+) mas existem outros operadores aritméticos.
A <- 5 e B <- 2
+ Adição A+B 5+2=7
- Subtração A-B 5-2=3
* Multiplicação A*B 5*2=10
/ Divisão A/B 5/2=2.5 2 e 5 são números inteiros, mas dividindo, não
necessariamente terei um número inteiro, por isso existe
operadores de divisão inteira ( \ ). O dois e meio não é
2,5 mas sim 2.5 (dois ponto 5) o separador nos Estados
Unidos é o ponto.
\ Divisão Inteira A\B 5\2=2 Aqui a divisão inteira pegara o número inteiro do
resultado da divisão entre A e B, 5/2=2.5, porém pegará
o número inteiro 2.
^ Exponenciação A^B 5^2=5.5=2 Aqui seria a mesma coisa de 52=5.5=25
5
% Módulo A%B 5%2=1 Módulo pega a sobra da divisão 5 / 2
1 2
Ordem de precedência: sempre quando tiver uma expressão aritmética, teremos uma ordem de precedência, primeiro
iremos considerar os parênteses ( ), depois a exponenciação ( ^), depois multiplicação e divisão ( * / ), por último a adição
e subtração ( + -).

( ) Parênteses
^ Exponenciação
*e / Multiplicação e divisão
+e- Adição e subtração

Ex: 3 + 2 / 2= 3 + 1= 4
(3 + 2) / 2= (5) / 2= 2.5, então sempre quando for criar uma expressão, deve utilizar os parênteses ( ) para guiar a
ordem de execução das operações.
Algoritmo “calculo”
var
N1, N2: Inteiro //2 variáveis do tipo inteiro (números sem ponto, sem casa decimal).
M: Real // quando eu utilizo o operador de divisão, a linguagem não trabalha mais com número inteiro e sim apenas
com números reais, para arrumar o erro, vou declarar a variável M como Real, números reais são números que tem a parte
decimal ex 2.5, 5.7.
Inicio
Escreval(“Digite um número: “)
Leia(N1)
Escreva(Digite outro número: “)
 Leia(N2)
M <- (N1 + N2) / 2 //variável M recebe N1 + N2 / 2 (vai calcular a média de N1 + N2), vai somar os valores
digitados no Leia(N1) e Leia(N2) e dividir por 2. Se eu tirar os parênteses vai dar o valor errado, pois irá dividir depois
somar, por isso a importância da ordem de precedência.
Escreva("A média entre", N1, " e" , N2, " é igual a", M) //vai aparecer na tela: A média entre N1 e N2 é igual
a M, ex se eu digitar 5 e depois 4, vai ficar: A média entre 5 e 4 é igual a 4.5.
Fimalgoritmo
Funções aritméticas: as funções aritméticas que temos são

Abs Valor Absoluto ABS(-10) 10

Exp Exponenciação Exp(3.2)=3.3=9 9
Int Valor Inteiro Int(3.9) 3
RaizQ Raiz Quadrada RaizQ(25) 5
Pi Retorna Pi Pi 3.14...
Sen Seno (rad) Seno(0.523) 0.5
Cos Cosseno (rad) Cos(0.523) 0.86
Tan Tangente (rad) Tan(0.523) 0.57
GraupRad Graus para Rad GraupRad(30) 0.523

Operadores relacionais:: vão criar a relação entre variáveis, expressões e valores, gerando resultados verdadeiro ou falso,
então os operadores relacionais vão gerar como resultado, sempre um valor lógico, ou seja, sempre vai retornar verdadeiro
ou falso. Os operadores relacionais que existe em todas as linguagens de programação, inclusive do ambiente do Visualg
são:
> Maior que
< Menor que
>= Maior ou igual a
<= Menor ou igual a
= Igual a
<> Diferente de
Algoritmo “semnome”
var
A, B, C: inteiro
inicio
A <- 2
B <- 3
C <- 5
Escreva (A>B) //se A for maior que B, vai retornar verdadeiro ou falso, nesse caso A recebe 2 e B recebe 3,
portanto A não é maior que B, portanto retorna falso.
Escreva (A=B) //A vale 2 e B vale 3, portanto retorna falso.
Escreva (A<>B) //A vale 2 e B vale 3, portanto A é diferente de B, vai retornar verdadeiro.
Escreva (A>2) //Operadores relacionais vai criar relação entre variáveis, expressões e valores, podemos testar
variável A com um número, A vale 2, A não é maior que 2, portanto vai retornar falso.
Escreva (A>=2) //A vale 2, portanto A é maior igual a 2, vai retornar verdadeiro.
Escreva (C=A+B) //pode ser testado variável com , nesse caso podemos testar C com expressão A+B, C vale 5, A
vale 2 e B vale 3, A+B=5, portanto A+B é igual a C, vai retornar verdadeiro.
Escreva (C>=B^A) //C vale 5, B^A=32=3.3=9, C=5 então C não é maior ou igual a B expoente A, porque B^A=9,
portanto retorna falso.
Fimalgoritmo
Operadores Lógicos: os operadores lógicos faz com que retorne valores lógicos, verdadeiro e falso, mas operadores
lógicos não servem para comparar resultados de expressões ou números, serve para comparar um resultado lógico com
outro resultado lógico, não compara por exemplo C=A+B, ou C>B. Temos 3 operadores lógicos (E, OU e NÃO), E (a
condição é que os dois resultados lógicos sejam verdadeiro para que retorne verdadeiro, se um resultado for falso, ai tudo
será falso), OU (a condição é que pelo menos um resultado lógico seja verdadeiro, para que tudo seja verdadeiro, nesse
caso só vai ser falso se ambos resultados lógicos forem falso) e NÃO (se p for verdadeiro, NÃOp é falso, vai ocorrer a
inversão do resultado lógico).
Operador lógico E:
p q pEq
V V V
V F F
F V F
F F F
Operador lógico OU:
p q pOUq
V V V
V F V
F V V
F F F
Operador lógico NÃO:
p NÃOp
V F
F V
Algoritmo “semnome”
Var
A, B, C: inteiro
Inicio
A <- 2
B <- 3
C <- 5
Escreva(verdadeiro e falso) //se tem um valor verdadeiro e um falso no operador E, pela tabela verdade vai
retornar falso.
Escreva ((A=B) ou (C>A)) //A vale 2 e B vale 3, então A não é igual a B, então é falso, C vale 5 e A vale 2,
portanto C é maior que A, então verdadeiro, como na proposição OU uma das proposições tem que ser verdadeiro para ter
resultado verdadeiro, como deu (falso) OU (verdadeiro), então retorna resultado lógico verdadeiro.
Escreva (nao((A=B) ou (C>A))) //retorna falso, deve se atentar a ordem de precedência, deve verificar o valor
dentro dos parênteses e depois fora, (A=B é falso) OU (C>A é verdadeiro)=(falso ou verdadeiro=verdadeiro), o nao inverte
o resultado, portanto como deu verdadeiro o naoverdadeiro=falso, portanto vai retornar falso.
Fimalgoritmo
Ordem de precedência geral: primeiro resolve os operadores aritméticos como ( ), depois (^ exponenciação), * /, + -,
depois resolve os operadores relacionais que são >, <, >=, <=, =, <>, aqui a diferença é que os operadores relacionais não
tem ordem de precedência, a diferença é que será executado da esquerda para direita. Depois de serem resolvidas as
expressões aritméticas e as relacionais, executará todas as operações lógicas começando pelo E, depois OU e por fim NÃO,
essa é a ordem de execução dentro de um algoritmo.

Operadores Aritméticos ( ), ^, * /, + -
Operadores Relacionais >, <, >=, <=, =, <>
Operadores Lógicos E, OU, NÃO
Algoritmo “triângulos”
Var
L1, L2, L3: Real //o triangulo tem 3 lados, portanto variável L1, L2 e L3
EQ, ES, TRI: Logico //aqui vai verificar se o triangulo é equilátero(3 lados iguais) ou escaleno(3 lados diferentes) ou
se é um triângulo, resultando um teste lógico, verdadeiro ou falso.
Inicio
Escreva(“Digite o primeiro lado: “)
Leia(L1)
Escreva(“Digite o segundo lado: “)
Leia(L2)
Escreva(“Digite o terceiro lado: “)
Leia(L3)
TRI <- (L1 < L2 + L3) e (L2 < L1+ L3) e (L3 < L1 + L2) //para ser um triangulo um lado deve ser menor do que
a soma dos outros dois lados, exemplo para ser triangulo o lado1 deve ser menor que a soma do lado2 e lado3, se um lado
do triângulo for maior que a soma dos outros 2 lados, não forma o triangulo, porque esse lado é grande de mais para formar
um triangulo, se não forma um triângulo, tudo dará falso.
EQ <- (L1 = L2) e (L2 = L3) //Se L1 foi igual a L2 e L2 for igual a L3, é um triangulo equilátero(lados de
tamanhos iguais). Aqui se utiliza 3 resultados lógicos porque se L1 for igual L2 e L2 igual L3, consequentemente L1
também é igual a L3.
ES <- (L1 <> L2) e (L2 <> L3) e (L1 <> L3) //Se L1 for diferente de L2 e L2 for diferente de L3 e L1 for
diferente de L3, é um triangulo escaleno(lados de tamanhos diferentes). Aqui utiliza 3 resultados lógicos por serem
triângulos de lados diferentes, porque L1 deve ser diferente de L2 e L3.
Escreval(“Pode formar um TRIANGULO? “, TRI) //vai retornar verdadeiro ou falso
Escreval(“O triandgulo é EQUILATERO? “, EQ) //vai retornar verdadeiro ou falso dependendo do valor
digitado.
Escreva(“O triangulo é ESCALENO? “, ES) //vai retornar verdadeiro ou falso dependendo do valor digitado.
Fimalgoritmo
Exercício de conversão de Real para Dólar:
algoritmo "Conversão"
var
reais, dolares : Real
inicio
Escreva("Quantos Reais eu tenho? R$")
Leia(reais)
dolares <- reais/5.24 //vai pegar o valor digitado e dividir pelo valor da cotação atual do dólar.
Escreva("Posso comprar", dolares, " dólares!")
fimalgoritmo
Exercício de conversão de temperatura: para converter a temperatura de fahrenheit para graus ceusius a formula é (F –
32) / 1.8, como F – 32 é numerador, vai em cima da fórmula, deve colocar entre ( ) para que calcule primeiro o que está
dentro de parênteses e depois divida pelo denominador, se não colocar parênteses, o resultado vai dar errado, primeiro
calcula numerador e depois denominador, devido a ordem de precedência, deve colocar ( ) no numerador, portanto a
formula é (F - 32) / 1.8.
algoritmo "Creuza02"
var
F, C : Real
inicio
Escreva("Qual a temperatura? ")
Leia(F)
C <- (F - 32) / 1.8 //calcula primeiro denominador, por isso (F – 32) deve estar entre parênteses, depois divide pelo
denominador.
Escreva("No Brasil estaria", C:4:1,"ºC") //C:4:1 4 seria a quantidade de casas, 1 seria a quantidade de casas
após a vírgula.
Fimalgoritmo
Exercício de cálculo de porcentagem: para calcular a porcentagem a fórmula é (x.60)/100
algoritmo "Creuza02"
var
preco, imposto: Real
inicio
Escreva("Qual valor do produto? ")
Leia(preco)
imposto <- (preco * 60) / 100
Escreva("O imposto será de R$",imposto:5:2) //imposto:5:2, 5 é a quantidade de casas do valor, 2 é a
quantidade de casas decimais, casas após a vírgula.
Fimalgoritmo
Exercício envolvendo empréstimo, juros:
algoritmo "Creuza02"
var
emprestimo, juros, totalemprestimo, parcelas, valorparcela: Real
inicio
Escreva("Qual valor do emprestimo? ")
Leia(emprestimo)
juros <- (emprestimo * 20) / 100 //calculo de porcentagem
totalemprestimo <- emprestimo + juros //aqui é a soma do valor do empréstimo mais os juros
Escreval("O valor total do empréstimo com juros será R$",totalemprestimo)
Escreva("Pagará o emprestimo em quantas parcelas? ")
Leia(parcelas)
valorparcela <- (emprestimo + juros) / parcelas
Escreva("Pagará R$",valorparcela, " em", parcelas," vezes!")
Fimalgoritmo
Estruturas condicionais simples: Se eu tiver dinheiro, então vou fazer uma viagem para Disney, vou fazer uma viagem
para Disney é uma ação, deve ter uma delimitação nas estruturas condicionais, no visualg existe 3 delimitações que são o
comando, a expressão e a ação.
Se (expressão for verdadeira) entao
Executa um Bloco
FimSe
Outro exemplo de estrutura condicional simples
Se (dinheiro >= 10000) entao
 Escreva ("Partiu Disney")
FimSe
Estrutura condicional composta com a palavra reservada senao: estrutura condicional composta é utilizada quando tem
duas condições, a condição senao só será lida se a condição de cima Se e entao não for atendida. Em estrutura condicional
composta geralmente é feito a indentação dos códigos, indentação quer dizer deslocar a linha de comando para direita, por
exemplo o comando Escreva que está fora da estrutura condicional composta (Se, entao, senao e FimSe), não estão
alinhados com os comandos Escreva que está dentro da estrutura condicional composta, isso é indentação, basta apertar a
tecla tab que faz a indentação do comando
Algoritmo "CalculoIdade"
Var
ano, nasc, idade: inteiro
Inicio
Escreva("Em que ano estamos? ")
Leia(ano)
Escreva("Em que ano você nasceu? ")
Leia(nasc)
idade <- ano - nasc
Escreval("Sua idade é", idade, " anos")
Se (idade >= 21 ) então
Escreval ("Você atingiu a maioridade!") //aqui o comando escreva está indentado, deslocado para direita em
relação ao comando Escreva que está fora da estrutura condicional composta.
senao
Escreva ("Você não atingiu a maioridade!") //aqui o comando escreva está indentado, deslocado para direita em
relação ao comando Escreva que está fora da estrutura condicional composta.
FimSe
Fimalgoritmo
Calculo de IMC (Índice de Massa Corporal utilizando a estrutura condicional composta: para calcular o IMC é IMC
= Massa / Altura2, o peso ideal é o IMC entre 18,5 e 25.
Algoritmo "CalculoIMC"
Var
altura, peso, IMC: Real
Inicio
Escreva("Qual é o seu peso em kg? ")
Leia(peso)
Escreva("Qual é sua altura em metros? ")
Leia(altura)
IMC <- peso / (altura ^ 2)
Escreval("Seu Índice de Massa Corporal é: ", IMC:4:2)
Se (IMC >= 18.5) e (IMC <25) entao //nesse caso deve utilizar operadores lógicos, ao invés de fórumla
matemática
Escreval("Parabéns, você está no seu peso ideal")
senao
Escreval("Você não está na faixa de peso ideal")
FimSe
Fimalgoritmo
Estrutura condicional aninhada: temos 2 estruturas condicionais compostas, uma dentro da outra, essa estrutura
composta uma dentro da outra se chama estrutura condicional aninhada, mas pode haver mais do que 2 estruturas aninhadas
uma dentro da outra.
Se eu tiver muito dinheiro entao
Vou fazer uma viagem pra Disney
senao Se tiver uma graninha entao
vou visitar minha cidade natal
senao
vou ficar em casa
No visualg a estrutura fica assim
Se (situação 1 ocorre) entao
Executa Bloco A
senao
Se (situação 2 ocorre) entao
Executa Bloco B
senao
 Executa Bloco C
FimSe
FimSe
Como exemplo de condicional aninhada, tem o algoritmo para verificar se o aluno está aprovado, em recuperação
ou reprovado.
Algoritmo "AlunoAprovado"
Var
nota1, nota2, media: Real
Inicio
Escreva("Primeira nota: ")
Leia(nota1)
Escreva("Segunda nota: ")
Leia(nota2)
media <- (nota1 + nota2)/2
Escreval("Sua média é: ", media:4:2)
Se (media >= 7) entao
Escreva("ALUNO APROVADO!")
senao
Se (media >=5) e (media < 7) entao
Escreval ("Aluno em recuperação")
senao
Escreva("ALUNO REPROVADO!")
FimSe
Fimse
Fimalgoritmo
Existe mais do que 2 estruturas aninhada uma dentro da outra
Algoritmo "CalculoIMC"
Var
altura, peso, IMC: Real
Inicio
Escreva("Qual é o seu peso em kg?: ")
Leia(peso)
Escreva("Qual é sua altura?: ")
Leia(altura)
IMC <- peso / (altura ^ 2)
Escreval("Seu Índice de Massa Corporal é: ", IMC:4:2)
Se (IMC < 17) entao
Escreval ("Muito abaixo do Peso")
senao
Se (IMC >=17) e (IMC <= 18.5) entao
Escreval ("Abaixo do peso")
senao
Se (IMC >= 18.5) e (IMC <25) entao
Escreval ("Peso ideal")
senao
Se (IMC >= 25) e (IMC <=30) entao
Escreval ("Sobrepeso")
senao
Se (IMC >= 30) e (IMC < 35) entao
Escreval ("Obesidade")
senao
Se (IMC >= 35) e (IMC <40) entao
Escreval ("Obesidade severa")
senao
Escreval ("Obesidade Morbida")// nesse caso não precisa testar, automaticamente vai
identificar que a pessoa está acima dos 40 IMC
FimSe
FimSe
FimSe
FimSe
FimSe
 FimSe
Fimalgoritmo
Outra estrutura condicional é a condicional escolha caso: nesse caso somente um Bloco será executado, no final existe
um bloco outro caso que é se nenhum dos valores acima for exibido, esse ultimo Bloco será executado, o outro caso é uma
estrutura opcional, pode ser usada ou pode ser omitida. A estrutura de escolha não serve para testar faixa de valores, ou
seja, as estruturas que envolver maior ou igual (>=), menor ou igual (<=), no Visualg essa estrutura só funciona
basicamente para valores inteiros
Escolha (variável)
Caso valor
Executa Bloco A
Caso valor
Executa Bloco B
Caso valor
Executa Bloco C
OutroCaso
Executa Bloco D
FimEscolha
Exemplo estrutura condicional escolha caso:
Algoritmo "CriancaEsperanca"
Var
D, Valor: inteiro
Inicio
Escreval ("---------------------------")
Escreval (" CRIANCA ESPERANCA ")
Escreval ("---------------------------")
Escreval (" Muito obrigado por ajudar ")
Escreval (" [1] para doar R$10 ")
Escreval (" [2] para doar R$25 ")
Escreval (" [3] para doar R$50 ")
Escreval (" [4] para doar outros valores ")
Escreval (" [5] para cancelar")
leia (D)
Escolha D
Caso 1
Valor <- 10
Caso 2
Valor <- 25
Caso 3
Valor <- 50
Caso 4
Escreva ("Qual o valor da doação? R$")
Leia(valor)
Caso 5
Valor <- 0
FimEscolha
Escreval ("---------------------------")
Escreval ("Sua doação foi de R$", Valor)
Escreval (" Muito obrigado! ")
Fimalgoritmo
Outro exemplo de escolha caso: dá para colocar variáveis de outros tipos como inteiro, real e caractere junto, mas também
dá para colocar vários valores a serem digitados no escolha casa, bastando separar por vírgula.
Algoritmo "DependentesFuncionario"
Var
nome: caractere
salario, novosalario: Real
dependentes: inteiro
Inicio
Escreva ("Qual o nome do Funcionário? ")
Leia(nome)
Escreva ("Qual salário do Funcionário? R$")
Leia(salario)
 Escreva ("Qual é a quantidade de dependentes? ")
Leia(dependentes)
Escolha dependentes
Caso 0
novosalario <- salario + (salario*5/100)
Caso 1, 2, 3
novosalario <- salario + (salario*10/100)
Caso 4, 5, 6
novosalario <- salario + (salario*15/100)
outrocaso
novosalario <- salario + (salario*18/100)
FimEscolha
Escreval ("O novo salário de ", nome, " será de R$", novosalario:5:2)
Fimalgoritmo
Funçao Se com função Escolha:
Algoritmo "BanguXMadureira"
Var
golsb, golsm, diferencagol: inteiro
Inicio
Escreval("------------------------------")
Escreval(" Bangu x Madureira ")
Escreval("------------------------------")
Escreva("Quantos gols do Bangu?: ")
Leia(golsb)
Escreva("Quantos gols do Madureira?: ")
Leia(golsm)
Se (golsb > golsm) entao //aqui utilizou a função Se para fazer o calculo, porque se tivesse feito somente diferençagol
<- gols – gols, se colocasse um valor menor menos um maior, o resultado daria negativo.
diferencagol <- golsb - golsm
senao
diferencagol <- golsm - golsb
FimSe
Escreval("-------------------------------")
Escreval("Diferença de gol:", diferencagol)
Escolha diferencagol
Caso 0
Escreval("STATUS:EMPATE")
Caso 1,2,3
Escreval("STATUS:PARTIDA NORMAL")
Caso 4,5,6
Escreval("STATUS:GOLEADA")
OutroCaso
Escreval("STATUS: ALGO INCOMUM")
FimEscolha
Fimalgoritmo
Estrutura de repetição: é uma estrutura que permite executar mais de uma vez o mesmo comando ou conjunto de
comandos, de acordo com uma condição ou com um contador 1+1+1 ou 2+2+2, assim sucessivamente, enquanto as
condições do comando retornar verdadeiro, irá executar a estrutura de repetição, quando retornar falso, pula para o
FimEnquanto e sai da estrutura executando os outros algoritmos em sequência.
Mao <- 0 //aqui inicia com a mão fechada
Enquanto (Mao <= 5) faça // enquanto a mão estiver com menor ou igual a 5 dedos, quando chegar no comando troca, irá
trocar por exemplo de personagem como demonstrado na Aula 09
troca //aqui será feito a troca
Mao <- Mao +1 //aqui será acrescentado mais 1 dedo na mão, hora que chegar em 5 dedos na mão para de
executar o algoritmo.
FimEnquanto //ao chegar no FimEnquanto irá procurar o Enquanto relativo a ele que está logo acima, então o comando irá
voltar ao Enquanto acima e executar o comando novamente, até que chegue a menor ou igual a 5 vezes executado, irá fazer
com que troque por exemplo de personagem como no exemplo citado na Aula 9. A sintaxe ou estrutura do algoritmo é essa:
Enquanto (expressão) faca //Enquanto uma expressão for verdadeira, irá executar um bloco, pode ter quantas expressão
quiser, ao atingir o FimEnquanto, irá voltar para o Enquanto.
Bloco de instrução a ser executada enquanto for verdadeiro
FimEnquanto
OU
Enquanto não arrumar o quarto faca //Enquanto eu não arrumar o quarto vou ficar de castigo, ao chegar ao
FimEnquanto, a execução volta para o Enquanto para verificar se arrumei o quarto, enquanto eu não arrumar continuo de
castigo, quando eu arrumar o quarto a execução volta para o FimEnquanto e será executado os próximos algoritmos após
FimEnquanto, então nem sempre precisará contar quantas vezes será feito a repetição, não preciso ter uma limitação de
execução usando contador 1+1+1, o limite poderá ser uma condição como por exemplo eu arrumar o quarto.
castigo
FimEnquanto
Aqui no Exemplo abaixo essa estrutura irá contar até 10, clicando na opção executar com timer no visualg, irá aparecer 1,
2, 3, 4, 5, 6, 7, 8, 9, 10 na tela, porém o programa irá executar 11 vezes e irá finalizar a execução, porém na tela só irá
aparecer até o número 10
Algoritmo "ConteAte10"
Var
contador: inteiro
Inicio
contador <- 0 //aqui é definido qual número iniciará a contagem
Enquanto (contador <= 10) faca //Enquanto o valor da variável contador for menor ou igual a 10, irá retornar
verdadeiro e contar até 10, ao chegar no valor 10 irá retornar falso e parar de contar e a leitura sai da estrutura.
Escreval(contador)
contador <- contador + 1 //essa expressão é para acrescentar + 1 na contagem até chegar no número 10 que é a
condição do Enquanto menor ou igual a 10, se esquecer essa fórmula o contador vai ficar contando infinitamente mas só
aparecerá o valor 0, ao fechar a janela do visualg, continuará sendo executado, ou seja, fica em looping infinito, basta clicar
em algoritmo e parar ou pressionar ctrl + f2, esse é um erro comum de acontecer.
FimEnquanto
Fimalgoritmo
Nesse caso abaixo quando for executado 5 vezes o comando Enquanto, na próxima é executado o comando Escreval que
está fora da estrutura Enquanto FimEnquanto, ou seja, foi executado o próximo algoritmo.
Algoritmo "ConteAte10"
Var
contador: inteiro
Inicio
contador <- 0
Enquanto (contador <= 5) faca
Escreval(contador)
contador <- contador + 1
FimEnquanto
Escreval("Terminei de contar")
Fimalgoritmo
Contador de 10 até 0: o contador acima conta de 0 a 10 ou 0 a 5, o contador abaixo irá contar de 10 até 0, basta inverter o
valor do contador onde será 10, no Enquanto troca a expressão e o valor que era 10 substitui por 0, ficando contador >= 0,
no algoritmo contador <- contador ao invés de ser +1 troca por -1, ai o contador contará de 10 até 0, poderia também
colocar no contador para contar de -2 em -2, assim sucessivamente.
Algoritmo "Conte"
Var
contador: inteiro
Inicio
contador <- 10
Enquanto (contador >= 0) faca
Escreval(contador)
contador <- contador - 1
FimEnquanto
Escreval("Terminei de contar")
Fimalgoritmo
Contar de 0 até onde o usuário quiser
Algoritmo "ConteAte..."
Var
valor, contador: inteiro
Inicio
contador <- 0
Escreva("Quer contar até quanto? ")
 Leia(valor)
Enquanto (contador <= valor) faca
Escreval(contador)
contador <- contador + 1
FimEnquanto
Escreval("Terminei de contar")
Fimalgoritmo
Ou
Algoritmo "ConteAte..."
Var
valor, salto, contador: inteiro
Inicio
contador <- 0
Escreva("Quer contar até quanto? ")
Leia(valor)
Escreva("Qual será o valor do salto? ") //aqui seria contagem de 1+1, 2+2 assim sucessivamente.
Leia(salto)
Enquanto (contador <= valor) faca
Escreval(contador)
contador <- contador + salto //salto é o valor somado 1+1, 2+2 até chegar ao valor que o usuário quer que conte
FimEnquanto
Escreval("Terminei de contar")
Fimalgoritmo
Nesse caso abaixo ao invés do contador me mostrar um valor de 0 a 10 por exemplo, irei digitar 10 números e soma-
los usando o comando de repetição Enquanto
Algoritmo "somadorenumerico"
Var
cont, N, S, maior: inteiro
Inicio
cont <- 1
S <- 0
Enquanto (cont <= 5) faca
Escreva ("Digite o ", cont, "o. valor:") //vai aparecer digite o 1º valor, digite o 2º valor... até o valor Enquanto que
nesse caso é <=5
Leia(N)
Se (N > maior) entao //o maior número digitado será guardado na variável maior.
maior <- N //maior recebe o número maior digitado.
FimSe
S <- S + N //irá acumular os valores digitados, esses valores serão somados.
cont <- cont + 1
FimEnquanto
Escreval("A soma de todos os valores foi", S)
Escreval(“O maior número digitado foi “, maior) //irá mostrar o maior número digitado que foi guardado pela
função Se
Fimalgoritmo

Algoritmo "ConversorMoedas"
Var
R, D: Real
C, Q: inteiro
Inicio
C <- 1
Escreva("Quantas vezes você quer converter? ")
Leia(Q)
Enquanto (C <= Q) faca
Escreva("Qual valor em R$? ")
Leia(R)
D <- R/2.20 //2.20 cotação do dólar na época do curso
Escreval("O valor convertido e US$", D:5:2)
C <- C + 1
FimEnquanto
Fimalgoritmo
Função Enquanto dentro da função Se: nesse caso foi utilizado a função Se para fazer o calculo com valor inicio e fim,
para não dar negativo foi feito INICIO – FIM e FIM – INICIO.
algoritmo "contagemInteligente"
var
I, F, CONT: Inteiro
inicio
Escreval("CONTAGEM INTELIGENTE")
Escreval("--------------------")
Escreva ("Inicio: ")
Leia(I)
Escreva ("Fim: ")
Leia(F)
Escreval("--------------------")
Escreval(" C O N T A N D O ")
Escreval("--------------------")
Se (F > I) entao
CONT <- I
Enquanto (CONT <= F) faca
Escreva (CONT, ".. ")
CONT <- CONT + 1
FimEnquanto
senao
CONT <- I
Enquanto (CONT >= F) faca
Escreva (CONT, ".. ")
CONT <- CONT - 1
FimEnquanto
FimSe
fimalgoritmo
Nesse caso a função Se está dentro da função Enquanto: estrutura para identificar o melhor aluno.
algoritmo "detectaCDF"
var
tot, cont: Inteiro
nome, melhorAluno: Caractere
nota, maiorNota: Real
inicio
Escreval("------------------------")
Escreval(" Escola Santa Paciencia ")
Escreval("------------------------")
Escreva("Quantos alunos a turma tem? ")
Leia(tot)
cont <- 1
Enquanto (cont <= tot) faca
Escreval("---------------")
Escreval("ALUNO ", cont)
Escreva("Nome do aluno: ")
Leia(nome)
Escreva("Nota de ", nome, ": ")
Leia(nota)
Se (nota > maiorNota) entao
maiorNota <- nota
melhorAluno <- nome
FimSe
cont <- cont + 1
FimEnquanto
Escreval("-------------------")
Escreval("O melhor aproveitamento foi de ", melhorAluno, " com a nota ", maiorNota:3:1)
Fimalgoritmo
Comando Repita da estrutura de repetição: Repita um bloco até que uma expressão ocorra, a estrutura do repita é mais
ou menos parecida a estrutura do escolha, só que a expressão é logicamente inversa.
Repita
Bloco
Ate express
No caso utilizar o enquanto a estrutura ficará assim
Enquanto não arrumar o quarto faca //nesse caso utiliza o operador lógico “não”, diferente do repita onde não é
utilizado o operador lógico “não” (! Ou ~).
castigo
FimEnquanto
Liberado
No caso de utilizar o repita vai ser o inverso da estrutura enquanto: primeiro vai colocar a ação que é castigo, depois
vai colocar a condição, nesse caso não utiliza o operador lógico “não” e primeiro coloca a ação e depois a condição.
Repita
Castigo
Ate arrumar o quarto //fez o teste lógico e não arrumou o quarto, volta para o repita, a partir do momento que a expressão
arrumar o quarto for feita, a execução continua sendo liberado para executar outros algoritmos abaixo em sequência, nesse
caso não utiliza o operador lógico “não”, diferente do operador lógico enquanto)
Liberado
Algoritmo "Somador"
Var
N, S: inteiro
resp: caractere
Inicio
S <- 0
Repita
Escreva ("Digite o valor ==> ")
Leia(N)
S <- S + N
Escreva("Voce quer continuar? [S/N] ")
Leia(resp)
Ate (resp = "N")//aqui a condição fica depois do comando, quando a resposta for não, para de executar o calculo
Escreval("A soma de todos os valores digitados e ", S)
Fimalgoritmo
Exemplo de contador com a estrutura repita
Algoritmo "Conta1a10"
Var
contador: inteiro
Inicio
contador <- 1
Repita
Escreval(contador)
contador <- contador + 1
Ate (contador > 10)//vai contar até que o contador seja maior que 10, ou seja, vai contar até 10, diferente do outro
exemplo não precisará digitar (S/N)
Fimalgoritmo
Exemplo de multiplicação usando a estrutura repita automaticamente
Algoritmo "Conta1a10"
Var
contador, N: inteiro
Inicio
contador <- 1 //contador vai começar a partir do número 1
N <- 7 //valor a ser multiplicado
R <- N * contador //R vai receber o valor da variável N que é 7 e multiplicar pela variável contador
Escreval(N, "x", contador " = ", R) //vai aparecer 7 multiplicando pelo contador que é igual a variável R que vai
ser a multiplicação de N=7 vezes o contador 1, 2, 3, 4, 5...10.
contador <- contador + 1
Ate (contador > 10)//vai multiplicar até 10, ou seja, vai repetir essa estrutura até 10.
Fimalgoritmo
Exemplo de multiplicação usando a estrutura repita com o operador interagindo: só substituir o algoritmo N<-7 e
colocar a função Escreva(“Quer ver a tabuada de qual número?”), após Leia(N)
Algoritmo "Conta1a10"
Var
 contador, N: inteiro
Inicio
contador <- 1 //contador vai começar a partir do número 1
Escreva(“Quer ver a tabuada de qual número?”) //como eu quero que o Escreva seja lido somente uma vez, então
vai fora da estrutura repita, quando eu quiser que o comando escreva apareça várias vezes, ai coloco esse comando dentro
da estrutura repita, como no exemplo abaixo.
Leia(N)
Repita
R <- N * contador //R vai receber o valor da variável N que é 7 e multiplicar pela variável contador
Escreval(N, "x", contador " = ", R) //vai aparecer 7 multiplicando pelo contador que é igual a variável R que vai
ser a multiplicação de N=7 vezes o contador 1, 2, 3, 4, 5...10.
contador <- contador + 1
Ate (contador > 10)//vai multiplicar até 10, ou seja, vai repetir essa estrutura até 10.
Fimalgoritmo
Quantos números são negativos?
Algoritmo "Contanegativos"
Var
n, c, totalnegativos: inteiro
Inicio
c <- 1
totalnegativos <- 0 //zero números negativos
Repita
Escreva("Digite um número: ")//como eu quero que repita esse comando Escreva, coloco dentro da estrutura
Repita.
Leia(N)
Se (n<0) entao
totalnegativos <- totalnegativos + 1
FimSe
c <- c + 1
Ate (c > 5)
Escreval("Foram digitados ", totalnegativos, " valores negativos") //foram digitados 2 valores negativos
Fimalgoritmo
Calculo de fatorial de um número: exemplo de fatorial quer calcular fatorial de 5, então vai calcula 5x4x3x2x1, é
basicamente uma contagem regressiva.
Algoritmo "Fatorial"
Var
contador, numero, fatorial: inteiro
Inicio
Escreva("Digite um número: ")
Leia(numero)
contador <- numero //contador recebe o número digitado
fatorial <- 1
Repita
fatorial <- fatorial * contador
contador <- contador - 1
Ate (contador < 1)
Escreva("O valor do fatorial de ", numero, " é igual a ", fatorial)
FimAlgoritmo
Calculo de fatorial de um número com estrutura de repetição: aqui vai perguntar se o operador quer continuar a
calcular.
Algoritmo "Fatorial"
Var
contador, numero, fatorial: inteiro
r: caractere
Inicio
Repita
Escreva("Digite um número: ")
Leia(numero)
contador <- numero //contador recebe o número digitado
fatorial <- 1 //não se calcula 0 em fatorial, por isso recebe 1
Repita
 fatorial <- fatorial * contador
contador <- contador - 1 //por ser fatorial vai diminuir 1 número a ser multiplicado, exemplo quer calcular fatorial
de 5, vai ser 5x4x3x2x1
Ate (contador < 1)
Escreval("O valor do fatorial de ", numero, " é igual a ", fatorial)
Escreva("Quer continuar? [s/n]")//quer continuar e fazer mais calculos de fatorial?
Leia(r)
LimpaTela
Ate (r = "n")
FimAlgoritmo
Calculo de fatorial de um número e verificar se é ou não número primo: número primo é um número divisível por 1 e
ele mesmo, exemplo o número 3 é divisível por 1 e por ele mesmo
Algoritmo "semnome"
Var
contador, numero, contadordivisiveis: inteiro
Inicio
contador <- 1
contadordivisiveis <- 0
Escreva("Digite um número: ")
Leia(numero)
Repita
Escreva (contador)
Se (numero % contador = 0) entao
contadordivisiveis <- contadordivisiveis + 1
FimSe
contador <- contador + 1
Ate (contador > numero)
Se (contadordivisiveis > 2) entao //primo é divisível por 1 e ele mesmo, então para ser número primo tem que ser
divisível por 2 números, se for divisível por mais do que 2 números não é número primo
Escreval ("O valor ", numero, "não é primo!")
senao
Escreva ("O valor ", numero, "é número primo!")
FimSe
Fimalgoritmo.
Estrutura de repetição PARA: ela não será usada quando o operador quiser somar vários valores onde o programa
pergunta se quer continuar, porque não dá para saber de quanto a quanto será somado, porque na estrutura de repetição para
tem um início e fim, se não sabe quantas vezes vai repetir, o Para não é a estrutura para ser utilizada nesse momento.
Para variável <- inicio ate fim [passo salto] faca //Para uma variável de controle, recebe início até fim, segue um
parâmetro opcional que está representado por coxete que é o passo informando um salto para frente ou para trás e a palavra
faça, o bloco será executado e no FimPara ocorrerá o retorno.
Bloco
FimPara
Para C <- 1 até 10 passo 1 faca //irá contar até 10, o C vai receber 1 e vai até 10, para cada interação vai ter o passo 1, se
colocar passo 1 ou nada, vai considerar como passo 1, vai escrever o valor de C e vai chegar no FimPara, ao chegar no
FimPara vai voltar para linha Para, já que é o passo 1, automaticamente na variável C, vai somar o passo que nesse caso é
+1, o C que valia 1 vai somar com +1 e vai valer 2, esse processo vai se repetir até chegar a 10.
Escreval(C)
FimPara
Algoritmo "semnome"
Var
C: inteiro
Inicio
Para C <- 1 Ate 10 passo 1 faca //vai contar de 1 até 10 somando de 1 em 1, caso queira que conte de 2 em 2, só
colocar passo 2 que vai pular de 2 em 2, pode contar de trás para frente só inverter o 1 e o 10, colocando 10 ate 1 e mudar o
passo colocando passo -1
Escreva(C)
FimPara
Fimalgoritmo
Exibir números pares na estrutura Para: é só colocar para contar de um número par e colocar passo 2 que vai contar de
2 em 2 e mostrará somente os números pares na tela.
Algoritmo "semnome"
Var
conte, valor: inteiro
Inicio
Escreva("Digite um valor: ")
Leia(valor)
Para conte <- 0 ate valor passo 2 faca
Escreva(conte)
FimPara
Fimalgoritmo
Contagem regressiva com números pares: deve inverter o 0 e a variável “valor” de lugar e ao invés de passo 2, é passo -2
e fazer uma condicional “Se”, nada impede de usar uma estrutura Para dentro de uma condicional ou usar em combinação
como nesse caso abaixo.
Algoritmo "semnome"
Var
conte, valor: inteiro
Inicio
Escreva("Digite um valor: ")
Leia(valor)
Se(valor%2=1) entao
valor <- valor - 1 //vai tirar 1 da variável valor para que fique par
FimSe
Para conte <- valor ate 0 passo -2 faca
Escreva(conte)
FimPara
Fimalgoritmo
Exemplo quantos valores estão entre 0 e 10:
Algoritmo "semnome"
Var
C, valor, tot010: inteiro
Inicio
tot010 <- 0
Para C <- 1 ate 6 faca
Escreva("Digite um valor: ")
Leia(valor)
Se(valor >=0) e (valor<=10) entao
tot010 <- tot010 + 1
FimSe
FimPara
Escreval("Ao todo foram ", tot010, " valores entre 0 e 10")
Fimalgoritmo
Além de saber quantos valores estão entre 0 e 10, quer exibir a soma dos números ímpares que estão entre 0 e 10
Algoritmo "semnome"
Var
C, valor, tot010, somaimp: inteiro
Inicio
tot010 <- 0
Para C <- 1 ate 6 faca
Escreva("Digite um valor: ")
Leia(valor)
Se(valor >=0) e (valor<=10) entao
tot010 <- tot010 + 1
Se(valor%2=1) entao //vai pegar os valores ímpares entre 0 e 10 e somar
somaimp <- somaimp + valor
FimSe
FimSe
FimPara
Escreval("Ao todo foram ", tot010, " valores entre 0 e 10")
Escreval("Nesse intervalo, a soma de impares foi ", somaimp)
Fimalgoritmo
Combinações utilizando a estrutura para: combinação de números de 1 a 3, quer combinar os valores 1,2 e 3, dígito por
dígito utilizando 2 elementos, combinação de 1 com 1, 1 com 2 e assim sucessivamente até combinar todos, nesse caso vai
utilizar o aninhamento com estrutura de repetição utilizando a estrutura Para
Algoritmo "Combinações"
Var
C1, C2: inteiro
Inicio
Para C1 := 1 ate 3 faca
Para C2 := 1 ate 3 faca
Escreval(C1, C2)
FimPara
FimPara
Fimalgoritmo
Sequência de Fibonacci
Analisador de valores: exibir a soma dos valores, média entre os valores, quantos são divisíveis por 5, quantos são nulos,
soma dos pares.