Videoulas de algoritmos e lógica de programação

Vídeo Aulas de Algoritmos e Lógica de programação
Prof Neri A. Neitzke -- www.informaticon.com.br
Problema:
Mostrar o nome de 3 pessoas
Algoritmo mostra_nome
Inicio
Mostre “O nome da pessoa é Neri”;
Mostre “O nome da pessoa é Lisi”;
Mostre “O nome da pessoa é Giulia”;
Ou
Mostre “Os nomes são:Neri, Lisi e Giulia”;
Fim.
Teste de Mesa
O nome da pessoa é Neri
O nome da pessoa é Lisi
O nome da pessoa é Giulia

Problema:
Calcular a media de 2 notas e mostrar essa média
Algoritmo media;
var nota1, nota2, calc_media de Real;
Inicio
nota1  5; //nota1 recebe o valor de 5
nota2  7;
calc_media  (nota1 + nota2) / 2;
Mostrar “A média é “+calc_media;
Fim.
Teste de Mesa:
nota1 = 5
nota2 = 7
media = (5 + 7) / 2 = 6
A Média é 6

INICIO
Nota1, Nota2
Media 
(nota1+nota2)/2
Media
Fim

Problema:
Ler duas notas, calcular a media e mostrar essa média
Algoritmo media;
var nota1, nota2, calc_media de Real;
Inicio
Mostrar “Digite a primeira nota”;
Ler(nota1); //nota1 recebe o valor de 5
Mostrar “Digite a segunda nota”;
Ler(nota2);
calc_media  (nota1 + nota2) / 2;
Mostrar “.......Final do Sistema ....”;
Fim.

Tipos de Dados. Problema:
Ler o nome de uma pessoa, a sua idade e o seu salário, e mostrar essas informações;
Algoritmo tipos_dados;
var idade de Inteiro;
salario de Real;
nome de caracter;
Inicio
Mostrar “Digite o nome”;
Ler(nome);
Mostrar “digite a idade”;
Ler(idade);
Mostrar “digite o salário”;
Ler(salário);
mostrar “O nome é “+nome;
mostrar “A idade é “+idade
mostrar “O salário é”+salário;
Fim.

Problema: (Operadores Matemáticos)
Ler 2 números, efetuar as 4 operações matemáticas e
mostrar os resultados.
Algoritmo operações;
var num1, num2, soma, multiplicacao, divisao, subtracao de real;
Inicio
num1  10;
num2  5;
soma  num1 + num2;
multiplicacao  num1 * num2;
divisao  num / num2;
subtracao  num1 – num2;
mostrar “A multiplicacao = “+multiplicacao;
mostrar “A divisao = “+divisao;
mostrar “A Subtracao = “+subtracao;
mostrar “A soma =”+soma;
Fim.
Inicio
Mostrar “Digite o numero 1.:”;
Ler(num1)
Ler(num2);
Fim.

Problema: Duas variáveis (A e B) possuem valores distintos (A:=5 e B:= 10), Crie um
algoritmo que armazene esses dois valores nessas duas variáveis, e efetue a troca dos valores de
forma que a variável A passe a possuir o valor da variável B e que a variável B passe a possuir
o valor da variável A. Por fim, apresentar os valores trocado;
Var A, B, Auxiliar de Inteiro;
Inicio
A  5;
B  10;
Auxiliar  A;
A  B;
B  Auxiliar;
Mostre “B = “+B;
Mostre “A = “+A;
Fim.
Teste de Mesa
A=10
B=5
Auxiliar=5
B = 5
A = 10

Problema: O custo ao consumidor de um carro novo, é a soma do custo de fábrica com
a percentagem do revendedor e com o custo dos impostos (aplicados ao custo de fábrica).
Supondo que a percentagem do revendedor seja de 25% do custo de fábrica e que os
impostos custam 45 % do custo de fábrica, faça um algoritmo que leia o valor de custo de
fábrica e determine o preço final do automóvel (custo ao consumidor).
Algoritmo automovel;
Var custo_fabrica, perc_revendedor, impostos, preco_final de real;
Inicio
Mostrar “Digite o valor do custo de fabrica deste automóvel.: “;
Ler(custo_fabrica); //custo_fabrica  40000;
perc_revendedor  (25 * custo_fabrica) / 100;
impostos  (45 * custo_fabrica) / 100;
preco_final  custo_fabrica + perc_revendedor + impostos;
mostrar “Custo de Fábrica ..........: “+custo_fabrica;
mostrar “Percentual revendedor .: “+perc_revendedor;
mostrar “impostos .........................: “+impostos;
mostrar “O preço Final é ..............: “+preco_final;
Fim.
Teste de Mesa
custo_fabrica = 20000
perc_revendedor = (25 * 20000) / 100 = 5000
impostos = (45 * 20000) / 100 = 9000
preco_final = 20000 + 5000 + 9000 = 34000

Problema: O sistema de avaliação de determinada disciplina, é composto por três
provas. A primeira prova tem peso 2, a Segunda tem peso 3 e a terceira prova tem
peso 5. Faça um algoritmo para calcular a média final de um aluno desta disciplina.
Algoritmo avaliacao;
Var prova1, prova2, prova3, media de numérico; //numérico = real
Inicio
Mostrar “digite a nota1”;
Ler(prova1);
Ler(prova2);
Ler(prova3);
Prova1  prova1 * 2 /10;
Media  (prova1 + prova2 + prova3);
Mostrar “A media final = “+media;
Fim.
Teste de Mesa
Prova1 = 6 --------- 6 * 2 / 10 = 1,2
Prova2 = 8 --------- 8 * 3 /10 = 2,4
Prova3 = 4 ---------- 4 * 5 / 10 = 2,0
Media = (1.2 + 2.4 + 2) / 3 = 5.6
A media final = 5.6

1. Problema: Um cliente de um banco tem um saldo positivo de R$ 500,00. Fazer
um algoritmo que leia um cheque que entrou e calcule o saldo, mostrando
(escrevendo) o saldo na tela.
Algoritmo saldo;
Var valor_saldo, cheque_entrou de numérico; //numérico = real
Inicio
Valor_Saldo  500;
Mostrar “digite o valor do cheque que entrou”;
Ler(cheque_entrou);
Valor_saldo  valor_saldo – cheque_entrou;
Mostrar “O saldo atual = “+valor_saldo;
Fim.
Teste de Mesa
Saldo = 500 ---500-200=300
Cheque_entrou=200
O saldo atual = 300

Problema.:Uma Empresa de vendas de softwares paga a seu vendedor um fixo de R$
800,00 por mês, mais uma comissão de 15% pelo seu valor de vendas no mês. Faça
uma algoritmo que leia o valor da venda e determine o salário total do funcionário.
Mostre as informações que você achar necessário.
Algoritmo vendas;
Var fixo, comissao, vendas_mes, salario_total de numérico; //numérico = real
Inicio
Fixo  800;
Mostrar “Digite o valor da venda no mês”;
Ler(vendas_mes);
Comissão  (vendas_mes * 15) / 100;
Salário_total  fixo + comissao;
Mostrar “O salário fixo = “+fixo;
Mostrar “o valor de comissao = “+comissao;
Mostrar “o salário total = “+salario_total;
Fim.
Teste de Mesa
Fixo = 800
Comissao = (500 * 15) /100 = 75
vendas_mes = 500
salario_total = 800 + 75 = 875

Problema.: Uma Empresa de desenvolvimento de softwares paga a seu vendedor um
fixo de R$ 500,00 por mês, mais um bônus de R$ 50,00 por sistema vendido. Faça
uma algoritmo que leia quantos softwares o funcionário vendeu e determine o salário
total do funcionário. Mostre as informações que você achar necessário.
Algoritmo vendas2;
Var fixo, bonus, qtd_softw_vend, salario_total de numérico; //numérico = real
Inicio
Fixo  500;
Mostrar “Digite quantidade software vendido”;
Ler(qtd_softw_vend);
bonus  qtd_softw_vend * 50;
Salário_total  fixo + bonus;
Mostrar “O salário fixo = “+fixo;
Mostrar “o valor de bonus = “+bonus;
Mostrar “o salário total = “+salario_total;
Fim.
Teste de Mesa
Fixo = 500
Bonus = 3 * 50 = 150
qtd_softw_vend = 3
salario_total = 500 + 150 = 650
O salário fixo = 500
O valor de bonus = 150
O salário total = 650

Crie um algoritmo para calcular o salário líquido de um funcionário, considerando que seu
salário bruto, incide um desconto de 9% em inss para a previdência. O algoritmo deve
mostrar o nome do funcionário, o seu salário bruto, o valor de desconto de inss e o seu
salário líquido.(dica.: Você deverá pedir (ler) o nome do funcionário e o valor do salário
bruto)
Algoritmo salario;
Var salario_liquido, salario_bruto, inss de numérico; //(Real)
Nome de Caracter;
Inicio
Mostrar “Digite o nome do funcionário”;
Ler(nome);
Mostrar “Digite o valor do salario bruto”;
Ler(salario_bruto);
Inss  (salario_bruto * 9) / 100;
Salario_liquido salario_bruto – inss;
Mostrar “O salario bruto = “+salario_bruto;
Mostrar “O desconto de inss = “+inss;
Mostrar “O salario liquido = “+salario_liquido;
Fim.
Teste de Mesa
PASSO A PASSO
Salario_liquido = 2000 – 180 = 1820
Salario_bruto = 2000
Inss = (2000 * 9) /100 = 180
Nome = Neri
O salario bruto = 2000
O desconto de inss = 180
O salario liquido = 1820

Problema: Considerando que para um consórcio, sabe-se o número total de prestações, a
quantidade de prestações pagas e o valor atual da prestação, escreva um algoritmo que
determine o total pago pelo consorciado e o saldo devedor.
Algoritmo consorcio;
Var valor_prest, total_pago, saldo_devedor de Real;
total_prest, qtd_prest_pagas de Inteiro;
Inicio
mostre “Digite o total das prestacoes.: “;
ler(Total_prest);
mostre “digite a quantidade de prestacoes pagas”;
ler(qtd_prest_pagas);
mostre “digite o valor de cada prestacao”;
ler(valor_prest);
total_pago  qtd_prest_pagas * valor_prest;
saldo_devedor  valor_prest * (total_prest - qtd_prest_pagas);
mostre “O total pago = “+total_pago;
mostre “O saldo devedor =”+saldo_devedor;
Fim.
Teste de Mesa
total_prest = 20
qtd_prest_pagas = 5
valor_prest = 200
total_pago= 5 * 200 = 1000
saldo_devedor=200*(20-5)=3000
O total pago = 1000
O saldo devedor = 3000

Problema: Analisando a fórmula " Prestação = valor + (valor * (taxa/100) * tempo)", crie um
algoritmo para efetuar o cálculo do valor de uma prestação em atraso. (Você deverá ler o VALOR
da prestação, a TAXA de juros imposta pelo banco, e o número de dias em ATRASO.
Algoritmo prestacao;
Var prestacao, valor_prest, taxa de Real;
Dias_atraso de Inteiro;
Inicio
Mostre “Digite o valor da prestacao”;
Ler(valor_prest);
Mostre “digite a taxa de juros”;
Ler(taxa);
Mostre “digite o numero de dias em atraso”;
Ler(dias_atraso);
prestacao  valor_prest + (valor_prest * (taxa/100)*dias_atraso);
Mostre “O valor corrigido da prestacao = “+prestacao;
Fim.
Teste de Mesa
Prestacao=200+(200*(2/100)*10=240
valor_prest = 200
taxa=2
Dias_atraso=10
O valor corrigido da prestacao = 240

Problema: Crie 2 variáveis (A e B) e leia 1 valor para cada um deles. Disponibilize eles
de forma crescente.
Algoritmo crescenteAB;
Var a,b de inteiro;
Inicio
Mostre “digite o valor para A”
Ler(a)
Mostre “digite o valor para B”
Ler(b)
Se A > B entao
Mostre “ Em ordem crescente “+ B +” – “+A
Senao
Mostre “ Em ordem crescente “+ A +” – “+B
Fim.
Teste de Mesa
A = 2
B =7
Em ordem crescente 2 - 7

Problema: Crie 2 variáveis (A e B) e leia 1 valor para cada um deles. Disponibilize eles
de forma crescente.
INICIO
A, B
Fim
Em ordem crescente “+
B +” – “+A
A > B VF
Em ordem
crescente “+ A
+” – “+B

Problema: O sistema de avaliação de determinada disciplina, é composto por três
provas. A primeira prova tem peso 2, a Segunda tem peso 3 e a terceira prova tem
peso 5. Faça um algoritmo para calcular a média final de um aluno desta disciplina.
Caso a media seja maior ou igual a 6 mostre APROVADO, se a media for entre 4
e 6, mostre em RECUPERAÇÃO, e se for menor do que 4 mostre REPROVADO.
Algoritmo avaliacao;
Var prova1, prova2, prova3, media de numérico; //numérico = real
Inicio
Ler(prova1);
Ler(prova2);
Ler(prova3);
Se media >= 6 entao
Mostrar “Aprovado com media “+media;
Se media >= 4 entao
Mostrar “recuperacao com media “+media;
Senao
Mostrar “Reprovado com media “+media;
Fim.
Teste de Mesa
Prova1 = 6 --------- 6 * 2 / 10 = 1,2
Prova2 = 8 --------- 8 * 3 /10 = 2,4
Prova3 = 4 ---------- 4 * 5 / 10 = 2,0
Media = (1.2 + 2.4 + 2) / 3 = 5.6
Recuperacao com media 5.6

Fluxograma do exercíco anterior.
INICIO
Prova1, prova2,
prova3
Fim
“Aprovado com media
“+media;
Media >=6 VF
“Reprovado com
media “+media;
MEDIA >= 4
“recuperacao com
media “+media;
V
F

Problema: Uma loja oferece para os seus clientes, um determinado desconto de acordo com o
valor da compra efetuada. O desconto é de 10%, se o valor da compra for até R$200.00, 15% se for
maior que R$ 200 e menor ou igual a R$ 500,00 e 20% se for acima de R$ 500,00. Crie um algoritmo
que leia o nome do cliente e o valor da compra. Mostre ao final o nome do cliente, o valor da
compra, o percentual de desconto e o seu valor e valor total a pagar deste cliente.
Algoritmo compra_desconto;
Var valor_compra, valor_desconto, valor_pagar de real;
Desconto de inteiro;
Nome de caracter;
Inicio
Mostrar “digite o nome do cliente”;
Ler(nome);
Mostrar “digite o valor da compra”;
Ler(valor_compra);
Se valor_compra <= 200 entao
Desconto  10;
Senao se valor_compra <= 500 entao
Desconto  15;
Senao
Desconto  20;
Faça Valor_desconto  (valor_compra * desconto) / 100;
Faça valor_pagar  valor_compra – valor_desconto;
Mostre “Nome do Cliente .: “+nome;
Mostre “Valor da Compra .: “+valor_compra;
Mostre “O percentual de desc: “+desconto;
Mostre “Valor do desconto .: “+valor_desconto;
Mostre “Valor a pagar .:” + valor_pagar;
Fim.
Teste de Mesa
Valor_compra = 300
Valor_desconto = (300 * 15) / 100 = 45
Valor_pagar = 300 – 45 = 255
Desconto = 15
Nome = Neri Neitzke
Nome do Cliente .: Neri Neitzke
Valor da Compra .: 300
O percentual desc .: 15
Valor do desconto .: 45
Valor a pagar .: 255

INICIO
Nome,
valor_compra
Fim
Valor_compra <= 200
VF
Valor_desconto  (valor_compra *
desconto) / 100;
valor_pagar  valor_compra –
desconto;
Valor_compra
<= 500
V
F
Mostre “O percentual de desc: “+desconto;
Desconto  15
Desconto  10
Desconto  20

Problema: Uma loja oferece para os seus clientes, um determinado desconto de acordo com o
valor da compra efetuada. O desconto é de 10%, se o valor da compra for até R$200.00, 15% se for
maior que R$ 200 e menor ou igual a R$ 500,00 e 20% se for acima de R$ 500,00. Crie um algoritmo
que leia o nome do cliente e o valor da compra. Mostre ao final o nome do cliente, o valor da
compra, o valor do desconto e valor total a pagar deste cliente.
Algoritmo compra_desconto1;
Var valor_compra, valor_desconto, valor_pagar de real;
Nome de caracter;
Inicio
Mostrar “digite o nome do cliente”;
Ler(nome);
Mostrar “digite o valor da compra”;
Ler(valor_compra);
Se valor_compra <= 200 entao
Valor_desconto  (valor_compra * 10) / 100;
Senao se valor_compra <= 500 entao
Senao
Faça valor_pagar  valor_compra – valor_desconto;
Fim.
Teste de Mesa
Valor_compra = 300
Valor_desconto = (300 * 15) / 100 = 45
Valor_pagar = 300 – 45 = 255
Nome = Neri Neitzke
Nome do Cliente .: Neri Neitzke
Valor da Compra .: 300
Valor do desconto .: 45
Valor a pagar .: 255

INICIO
Nome,
valor_compra
Fim
Valor_compra <= 200
VF
valor_pagar  valor_compra –
desconto;
Valor_compra
<= 500
V
F
Valor_desconto 
(valor_compra * 15) /
100;
Valor_desconto 
100;
Valor_desconto 
100;

Problema: Fazer um algoritmo que leia o saldo inicial de cliente do banco e leia
também um cheque que entrou e ANALISE se o cheque poderá ser descontado ou não ,
já que este cliente não possui limite. Se o cheque não poderá ser descontado, mostre
essa informação, caso contrário, desconte o cheque e informe o saldo na tela.
Algoritmo saldo_se;
Var valor_saldo, cheque_entrou de numérico; //numérico = real
Inicio
Mostre “Digite o saldo inicial .: “;
Ler(valor_saldo); //Valor_Saldo  500;
Mostrar “digite o valor do cheque que entrou”;
Ler(cheque_entrou);
Se cheque_entrou <= valor_saldo entao
Valor_saldo  valor_saldo – cheque_entrou;
Mostrar “seu novo saldo .: “+valor_saldo;
Senao
Mostrar “este cheque não pode ser descontado”;
Mostrar “seu saldo continua “+valor_saldo;
Fim_se
Fim.
Teste de Mesa
valor_saldo =
cheque_entrou =

INICIO
valor_saldo,
cheque_entrou
Fim
cheque_entrou
<= valor_saldo
VF
Valor_saldo 
valor_saldo –
cheque_entrou
“seu novo saldo .:
“+valor_saldo;
“este cheque não pode ser
descontado”;
“seu saldo continua
“+valor_saldo;

Problema: Fazer um algoritmo que analize 3 valores inteiros
(através das variáveis n1, n2 e n3), e informa qual o maior e qual
o menor deles.
Algoritmo maior_menor;
Var n1, n2, n3 de inteiro;
Inicio
Mostre “digite o valor para n1”;
Ler(n1);
Ler(n2);
Ler(n3);
Se (n1 >= n2) e (n1 >= n3) entao
Mostre “o maior é o .: “+n1;
Senao Se (n2 >= n1) e (n2 >= n3) entao
Senao
Se (n1 <= n2) e (n1 <= n3) entao
Mostre “o menor é o .: “+n1;
Senao Se (n2 <= n1) e (n2 <= n3) entao
Senao
Fim.
Teste de Mesa
N1 = 10
N2 = 10
N3 = 20
O MAIOR É O 20
O MENOR É O 10

(através das variáveis n1, n2 e n3), e informa qual o maior e qual
o menor deles.
Algoritmo maior_menor;
Var n1, n2, n3 de inteiro;
Inicio
Ler(n1);
Ler(n2);
Ler(n3);
Se (n1 >= n2) e (n1 >= n3) entao
inicio
Se (n2 <= n3) entao
Senao
Fim_se
Senao Se (n2 >= n1) e (n2 >= n3) entao
inicio
Se (n1 <= n3) entao
Senao
Fim_se
Senao
inicio
Se (n2 <= n1) entao
Senao
Fim_se
Fim
Teste de Mesa
N1 = 15
N2 = 10
N3 = 20
O MAIOR É O 20
O MENOR É O 10

INICIO
n1, n2, n3
Fim
(n1 >= n2) e
(n1 >= n3)
FV
“o maior é o .: “+n1;
n2 <= n3
“o menor é o .:
“+n2;
“o menor é o .: “+n3;
(n2 >= n1) e
(n2 >= n3
V
F
V
n1 <= n3
“o menor é o .:
“+n3;
“o menor é o .:
“+n1;V
F
n2 <= n1F
V
“o menor é o .:
“+n1;
“o menor é o .:
“+n2;

Problema: Crie um algoritmo que leia três valores le,ld,li e verifique se eles podem ser os
comprimentos dos lados de um triângulo, e se forem, verificar se é um triângulo equilátero, isósceles ou
escaleno. Se eles não formarem um triângulo, escrever a mensagem "Não é um triângulo".
Antes da elaboração do algoritmo, torna-se necessária a revisão de algumas propriedades e definições.
Propriedade - O comprimento de cada lado de um triângulo é menor do que a soma dos comprimentos dos
outros dois lados, fora desta condição as medidas não são consideradas de um triângulo.
Definição 1 - Chama-se triângulo equilátero os que tem os comprimentos dos três lados iguais,
Definição 2 - Chama-se triângulo isósceles ao triângulo que tem os comprimentos de dois lados guais.
Definição 3 - Chama-se triângulo escaleno ao triângulo que tem os comprimentos dos três lados diferentes.
Algoritmo triangulo;
Var le, ld, li de real;
Inicio
Mostre “digite o comprimento de LE.: ”
Ler(le);
Mostre “digite o comprimento de LD.: ”
Ler(ld);
Mostre “digite o comprimento de LI.: ”
Ler(li);
Se (li < (le + ld)) e (le < (ld + li)) e (ld < (li + le)) entao
Se (le = ld) e (le = li) entao
Mostrar “triangulo equilatero”;
Senao se ((li = ld) ou (li = le) ou (le = ld)) then
Mostrar “triangulo isosceles”;
Senao // se ((ld <> le) e (ld <> li) e (li <> le)) entao
Mostrar “triangulo escaleno”;
Senao
Mostre “não é um triangulo”;
Fim
Teste de Mesa
Le = 20
Ld = 15
Li = 15
Triangulo isosceles
15
15
20

INICIO
le, ld, li
Fim
((li < (le + ld) e (le < (ld + li) e
(ld < (li + le))
F V
“não é um triangulo”;
(le = ld) e (le
= li)
“triangulo equilátero” V
“triangulo
isosceles”;
F
((li = ld) ou (li = le) ou
(le = ld))
V
“triângulo escaleno”
F

Problema: Ler 3 valores INTEIROS para as variáveis A, B,
C. Apresentar os valores dispostos em ordem crescente.
Algoritmo abc_crescente;
Var a, b, c de inteiro;
Inicio
Mostre “digite o valor para A.:”;
Ler(a);
Mostre “digite o valor para B.:”;
Ler(b);
Mostre “digite o valor para C.:”;
Ler(c);
Se (A <=B) e (A <= C) entao
Se (B <= C) entao
Mostre “Em ordem crescente ficou.: “+A+”-“+B+”-”+C;
Senao
Mostre “Em ordem crescente ficou.: “+A+”-“+C+”-”+B;
fim_se
fim_se
Senao Se (B <=A) e (B <= C) entao
Se (A<= C) entao
Mostre “Em ordem crescente ficou.: “+B+”-“+A+”-”+C;
Senao
Mostre “Em ordem crescente ficou.: “+B+”-“+C+”-”+A;
fim_se
fim_se
senao
Se (A <= B) entao
Mostre “Em ordem crescente ficou.: “+C+”-“+A+”-”+B;
Senao
Mostre “Em ordem crescente ficou.: “+C+”-“+B+”-”+A;
fim_se
fim_se
Fim
Teste de Mesa
A=9
B=6
C=7
Ordem 6 7 9

INICIO
A, b, c
Fim
(A <=B) e (A <= C)
V F
“Em ordem crescente
ficou.: “+A+”-“+C+”-”+B
(B <=A) e (B
<= C)
F
Em ordem crescente
ficou.:
“+B+”-“+A+”-”+C
V
A<= C
V
Em ordem crescente ficou.:
“+B+”-“+C+”-”+A
B <= C
“Em ordem crescente
ficou.: “+A+”-“+B+”-”+C
V
F
A <= B
“+C+”-“+A+”-”+B
“+C+”-“+B+”-”+A
F
V
F

Problema: Ler para uma variável INTEIRA um número de 1
a 12 e mostrar o nome do mês correspondente. Caso o mês
não existir, mostrar essa informação.
Algoritmo mes_se;
Var mes de inteiro;
Inicio
Mostrar “digite o mês de 1 a 11 “;
Ler(mês);
Se (mes = 1) então Mostrar “Janeiro”;
Senao Se (mes = 2) então Mostrar “Fevereiro”;
Senao Se (mes = 3) então Mostrar “Marco”;
Senao Se (mes = 4) então Mostrar “Abril”;
Senao Se (mes = 5) então Mostrar “Maio”;
Senao Se (mes = 6) então Mostrar “Junho”;
Senao Se (mes = 7) então Mostrar “Julho”;
Senao Se (mes = 8) então Mostrar “Agosto”;
Senao Se (mes = 9) então Mostrar “Setembro”;
Senao Se (mes = 10) então Mostrar “Outubro”;
Senao Se (mes = 11) então Mostrar “Novembro”;
Senao Se (mes = 12) então Mostrar “Dezembro”;
Senao “Esse mês não existe”;
Fim
Teste de Mesa
Mês = 2
Fevereiro

Problema: Ler para uma variável INTEIRA um número de 1
a 12 e mostrar o nome do mês correspondente. Caso o mês
não existir, mostrar essa informação.
Algoritmo mes_case;
Var mes de inteiro;
Inicio
Mostrar “digite o mês de 1 a 11 “;
Ler(mês);
Caso mês seja
1: Mostrar “Janeiro”;
2: Mostrar “Fevereiro”;
3: Mostrar “Marco”;
4: Mostrar “Abril”;
5: Mostrar “Maio”;
6: Mostrar “Junho”;
7: Mostrar “Julho”;
8: Mostrar “Agosto”;
9: Mostrar “Setembro”;
10: Mostrar “Outubro”;
11: Mostrar “Novembro”;
12: Mostrar “Dezembro”;
Senao modtrsr “Esse mês não existe”;
Fim_caso
Fim
Teste de Mesa
Mês = 2
Fevereiro

Problema: Ler uma variável de numero inteiro e mostre se ele
é par ou se ele é impar.
Algoritmo par_impar;
Var numero de inteiro;
Inicio
Mostre “digite um numero qualquer”;
Ler(numero);
Se (numero mod 2 = 0) entao
Mostre “esse numero é par”;
Senao
Mostre “esse numero não é par”;
Fim
Teste de Mesa

Problema: Ler uma variável de numero inteiro e mostrar a
tabuada desse número.
Algoritmo tabuada;
Var numero de inteiro;
Inicio
Mostre “digite um número para a tabuada”;
Ler(numero);
Mostre numero + “ x 1 = “+(numero * 1);
Fim
Teste de Mesa
6 x 1 = 6
6 x 2 = 12
6 x 3 = 18
6 x 4 = 24
6 x 5 = 30
.....

tabuada desse número. Usando o laço de repetição Para
Algoritmo tabuada_para;
Var numero, i de inteiro;
Inicio
Ler(numero);
Para i de 1 até 9 passo 1 faça
Mostre numero + “ x “ + i + “ = “+(numero * i);
Fim
//outras maneiras de fazer esse laço
Para i  1 até 9 faça
Para i = 1 até 9 faça
Para i = 1 até 9 passo 1 faça
Teste de Mesa
Numero = 4
I = 1,2,3,4,5,6,7,8,9,10
4 x 1 = 4
4 x 2 = 8
4 x 3 = 12
....
4 x 9 = 36

tabuada desse número. Usando o laço de repetição enquanto
Algoritmo tabuada_enquanto;
Inicio
Ler(numero);
I  1;
Enquanto(i <= 9)
inicio
i++; // igual ao i=i+1
Fim_enquanto
Fim
Teste de Mesa
Numero = 7
I = 1
7 x 1 = 7
7 x 1 = 7
7 x 1 = 7
7 x 1 = 7
7 x 1 = 7
7 x 1 = 7

tabuada desse número. Usando o laço de repetição repita
Algoritmo tabuada_repita;
Inicio
Ler(numero);
I  15;
Repita
Inicio
I++; //i=i+1
Fim
Até que (i > 9); // Enquanto(i <= 9)
Fim
Teste de Mesa
Numero = 9
I = 15
9 x 15 = 135

Problema: Faça um algoritmo que gere a seguinte série: 10,
20, 30, 40, ..... 980, 990, 1000.
Algoritmo serie_para;
Var i de inteiro;
Inicio
Mostrar i;
Fim Teste de Mesa
I=10, 20
10, 20, 30, 40

Problema:Ler a nota de 10 alunos, calcular a media e
mostrar essa média.
Algoritmo media_para;
var nota, calc_media, soma_notas de Real;
i de inteiro;
Inicio
Soma_notas  0;
Para i de 1 até 10 faça
inicio
Mostrar “Digite a “+i+”º de 10 notas”;
Ler(nota);
Soma_notas  soma_notas + nota;
Fim_para
calc_media  soma_notas / 10;
Fim.
Teste de Mesa
Nota=7,8,6
Calc_media = 9
Soma_notas=90
I=10

Problema:Ler a nota de 10 alunos, calcular a media e
mostrar essa média. Aceitar somente notas de 0 a 10.
Algoritmo media_para;
var nota, calc_media, soma_notas de Real;
i de inteiro;
Inicio
Soma_notas  0;
inicio
Mostrar “Digite a “+i+”º de 10 notas”;
Ler(nota);
Se ((nota >=0) e (nota <= 10)) entao
Soma_notas  soma_notas + nota;
Senao
Inicio
Mostrar “Nota Invaálida, digite apenas notas de 0 a 10”);
i=i-1;
fim_se
Fim_para
Fim.
Teste de Mesa
Nota=7,8,6
Calc_media = 9
Soma_notas=90
I=10

Problema: Mostre os 10 primeiros números pares.
Problema: Ler dois números (inicial e final). Escreva quantos
número pares e quantos numeros impares encontran-se entre
os dois números fornecidos pelo usuário.
Algoritmo pares_10;
Var numero, conta_pares de inteiro;
Inicio
Conta_pares  0;
Numero  1;
enquanto(conta_pares < 10)
Inicio_enquanto
Se (numero mod 2 = 0) entao
Inicio_se
Mostre “o numero “+numero+” = par;
Conta_pares  conta_pares + 1;
Fim_se
Numero  numero + 1;
Fim_enquanto
Fim
Teste de Mesa
Numero=1,2,3
Conta_pares=1
O numero 2 .: par

Problema: Ler dois números (inicial e final, o numero final
não pode ser menor do que o numero inicial). Escreva
quantos número pares e quantos numeros impares encontran-
se entre os dois números fornecidos pelo usuário.
Algoritmo par_impar_conta;
Var numero_inicial, numero_final, numeros_pares, numeros_impares,i de inteiro;
Inicio
Numeros_pares  0;
Numeros_impares  0;
Mostre “Digite o número inicial.: “;
Ler(numero_inicial);
I  numero_inicial;
Mostre “Digite o número final.: “;
Ler(numero_final);
Enquanto(i <= numero_final) faça
Inicio_enquanto
Se (i mod 2 = 0) entao
Numeros_pares  Numeros_pares + 1;
Senao
Numeros_impares  Numeros_impares + 1;
i  i + 1;
Fim_enquanto
Mostrar “Entre o numero “+numero_inicial+” e o numero “+numero_final+” existem
“+numeros_pares+” pares e “+numeros_impares+” impares”;
Fim
Teste de Mesa
Numeros_pares=0,1,2
Numeros_impares=0,1,2,3
Numero_inicial=23
Numero_final=27
I = 23,24,25,26,27,28
Entre o numero 23 e o
numero 27 existem 2
pares e 3 impares

Algoritmo par_impar_conta;
Var numero_inicial, numero_final, numeros_pares, numeros_impares,i de inteiro;
Inicio
Numeros_pares  0;
Numeros_impares  0;
numero_final  0;
Mostre “Digite o número inicial.: “;
Ler(numero_inicial);
I  numero_inicial;
Repita
Inicio_repita
Mostre “Digite o número final maior que o inicial.: “;
Ler(numero_final);
Se (numero_final < numero_inicial) entao
Mostrar “Número final inválido, deve ser maior do que o inicial”)
Final_repita
Até que(numero_final >= numero_inicial);
Enquanto(i <= numero_final) faça
Inicio_enquanto
Se (i mod 2 = 0) entao
Numeros_pares  Numeros_pares + 1;
Senao
Numeros_impares  Numeros_impares + 1;
i  i + 1;
Fim_enquanto
Mostrar “Entre o numero “+numero_inicial+” e o numero “+numero_final+” existem
“+numeros_pares+” pares e “+numeros_impares+” impares”;
Fim
Teste de Mesa
Numeros_pares=0,1,2
Numeros_impares=0,1,2,3
Numero_inicial=23
Numero_final=27
I = 23,24,25,26,27,28
Entre o numero 23 e o
numero 27 existem 2
pares e 3 impares

Problema: Crie um algoritmo que leia um numero inteiro, e
diga se ele é um numero primo ou não.
Problema: Crie um algoritmo que leia um numero inteiro, e
diga se ele é um numero primo ou não.
Algoritmo primo;
Var numero,contador,i de inteiro;
Inicio
Contador  0;
I  2;
Mostrar “Digite um número .: “;
Ler(numero);
Enquanto(i < (numero/2))
Inicio_enquanto
Se (numero mod i = 0)
Contador  Contador +1;
I  I + 1;
Fim_enquanto
Se contador > 0 entao
Mostrar “O numero “+numero+” não é primo”;
Senao
Mostrar “O numero “+numero+” é primo”;
Fim
Teste de Mesa
Contador = 0
I = 2,
Numero = 5
O numero 5 é primo

Algoritmo primo_logico;
Var numero,i de inteiro;
Num_primo de logico; // verdadeiro ou falso -> boolean
Inicio
Num_primo  verdadeiro;
I  2;
Mostrar “Digite um número .: “;
Ler(numero);
Enquanto((i < (numero/2) e (num_primo = verdadeiro)) faça
Inicio_enquanto
Se (numero mod i = 0)
Num_primo  falso;
I  I + 1;
Fim_enquanto
Se Num_primo = falso entao
Mostrar “O numero “+numero+” não é primo”;
Senao
Mostrar “O numero “+numero+” é primo”;
Fim
Teste de Mesa

Problema: Crie um algoritmo que mostre os 10 primeiros
números primos.
Algoritmo primo_10;
Var contador, numero,i de inteiro;
num_primo de logico;
begin
numero  1;
contador  0;
enquanto (contador < 10) faça
inicio
num_primo  verdadeiro;
numero  numero + 1;
I  2;
enquanto((i <= (numero/2)) e (num_primo = verdadeiro)) faça
inicio
se (numero mod i = 0) entao
inicio
num_primo  falso;
fim
I  I + 1;
Fim_segundo_enquanto;
se num_primo = verdadeiro then
inicio
contador  contador + 1;
escreva(“O numero “+numero+” e o “+contador+”. numero primo');
fim
fim_primeiro_enquanto;
fim.
Teste de Mesa

Problema: Mostrar os 10 primeiros numeros da sequencia
Fibonacci. Ex: 1 1 2 3 5 8 13 21 34 55 89 .....
Algoritmo fibonacci;
Var i, num_anterior, num_atual, novo_numero de inteiro;
Inicio
Num_anterior  0;
Num_atual  1;
Mostre “o 1. numero fibonaccci é 1”;
Inicio
Novo_numero  num_atual + num_anterior;
Num_anterior  num_atual;
Num_atual  novo_numero;
Mostre “o “+i+”. numero fibonaccci é ”+novo_numero;
Fim;
Fim
Teste de Mesa
Num_anterior=0,1,1,2,3,5
Num_atual=1,1,2,3,5,8
Novo_numero=1,2,3,5,8
I=2,3,4,5,6
O 1. numero fibonacci é 1
................

Problema:Ler a nota de 5 alunos, calcular a media e mostrar
essa média e mostrar também quantos alunos ficaram com a
sua nota igual ou acima da média.
Algoritmo media_media;
var nota1, nota2, nota3, nota4, nota5, calc_media, soma_notas de real;
contador de inteiro;
inicio
contador  0;
mostrar “digite a 1. nota.: ”;
ler(nota1);
ler(nota2);
ler(nota3);
ler(nota4);
ler(nota5);
soma_notas  nota1 + nota2 + nota3 + nota4 + nota5;
se (nota1 > calc_media) entao
mostrar “a média é “+calc_media;
mostrar contador + “ alunos ficaram com a nota acima da media”;
mostrar “.......final do sistema ....”;
Fim.
Teste de Mesa
nota1=6
nota2=4
nota3 =9
nota4 =5
nota5 =7
soma_notas=31
calc_media= 31/5=6.2
contador = 0,1,2
A media é 6.2
2 alunos ficaram com
a nota acima da
media

sua nota igual ou acima da média. (usando vetores)
Algoritmo media_media_vetor;
var notas:vetor [1..5] de real;
calc_media, soma_notas de real;
contador de inteiro;
inicio
contador  0;
//notas[1]  5;
//notas[2]  9;
//notas[3]  7;
//notas[4]  3;
//notas[5]  6;
ler(notas[1]);
ler(notas[2]);
ler(notas[3]);
ler(notas[4]);
ler(notas[5]);
soma_notas 
notas[1]+notas[2]+notas[3]+notas[4]+ notas[5];
se (notas[1] >= calc_media) entao
mostrar contador + “ alunos ficaram com a nota acima da media”;
Fim.
Teste de Mesa
Notas (no pascal)
Posição 1 2 3 4 5
valor 5 9 7 3 6
Calc_media=30/5=6
Soma_notas=5+9+7+3+6 = 30
Contador=0,1,2,3
Notas (no C e no Java)
Posição 0 1 2 3 4
valor 5 9 7 3 6

sua nota igual ou acima da média. (usando vetores)
Algoritmo media_media_vetor_correto;
var notas:vetor [1..5] de real;
calc_media, soma_notas de real;
i, contador de inteiro;
inicio
soma_notas  0;
contador  0;
para i de 1 até 5 faça
inicio_para
mostrar “digite a “+i+”. nota.: ”;
ler(notas[i]);
soma_notas  soma_notas + notas[i];
fim_para
para i de 1 até 5 faça
inicio_para
se (notas[i] >= calc_media) entao
fim_para
mostrar contador + “ alunos ficaram com a
nota acima da media”;
Fim.
Teste de Mesa
Notas (no pascal)
Posição 1 2 3 4 5
valor 8 5 7 9 7
Calc_media=36/5=7.2
Soma_notas=0,8,13,20,29,36
Contador=0,1,2
I = 1,2,3,4,5,6,1,2,3,4,5,6
Notas (no C e no Java)
Posição 0 1 2 3 4
valor
A media é 7.2
2 alunos ficaram com a nota
acima da media

informa qual o maior e qual o menor deles.
Algoritmo maior_menor_vetor;
Var maior_menor:vetor [1..10] de inteiro;
I, maior, menor de inteiro;
Inicio
Maior  0;
Menor  99999;
Maior_menor[]  {2,3,7,8,5,9,1,0,6,4};
Inicio
Se maior_menor[i] > maior entao
maior  maior_menor[i];
se maior_menor[i] < menor entao
menor  maior_menor[i];
fim
Mostre “o maior valor .: “+maior;
Mostre “o menor valor .: “+menor;
Fim.
Teste de Mesa
Maior_menor
P 1 2 3 4 5 6 7 8 9 10
V 2 3 7 8 5 9 1 0 6 4
Maior=0,2,3,7
Menor=99999,2
I=1,2,3,4 ...........

Problema: Crie um algoritmo que leia um vetor de 5
elementos. Calcule e mostre a soma desses elementos, a media,
quantos elementos são iguais ou maiores do que a média, o
percentual dos elementos que são maiores ou iguais a media e
mostrar quantos desses elementos são positivos e quantos são
negativos.
Algoritmo complexo_vetor ;
Var vetor5 :vetor [1..5] de inteiro;
Media, soma, perc_maior de real;
I, iguais_maior, , qtd_pos, qtd_neg de inteiro;
Inicio
Media 0;
Soma  0;
iguais_maior  0;
perc_maior  0;
qtd_pos  0;
qtd_neg 0;
vetor5[ ]  {9,3,7,8,5};
Soma  soma + vetor5[i];
Media  soma / 5;
inicio
Se vetor5[i] > media entao
iguais_maior = iguais_maior + 1;
se vetor5[i] >= 0 entao
qtd_pos  qtd_pos + 1;
senao
qtd_neg  qtd_neg + 1;
fim
perc_maior  (iguais_maior * 100) / 5;
mostrar “ A soma foi .: “+soma;
mostrar “a media foi .: “+media;
mostrar perc_maior+”% são maiores ou iguais a média”;
mostrar iguais_maior +”são iguais ou maiores do que a media”;
mostrar qtd_pos +” são positivos”;
mostrar qtd_neg + “são negativos”;
Fim.

Problema: Crie um algoritmo lendo um vetor A de 3
elementos do tipo inteiro. Mostre esses elementos do vetor A.
Reordene os elementos em ordem crescente, atualize o vetor A
com os elementos na ordem crescente e mostre novamente o
vetor A.
Algoritmo vetor_crescente;
Var A:vetor [1..3] de inteiro;
i, j, aux de inteiro;
Inicio
A[ ]  {9,3,7};
Mostrar “O valor de A[1] =”+A[1];
Para j de 1 até 2 passo 1 faça
Se A[i] > A[i+1] entao
Inicio_se
Aux  A[i];
A[i]  A[i+1];
A[i+1]  aux;
Fim_se;
Fim
Teste de Mesa
A = Vetor
Posicao 1 2 3
valor 50 21 14
Posicao 1 2 3
valor 14 21 50
I=1,2,3,1,2,3
Aux=50,50,21
J=1,2,3

Reordene os elementos em ordem crescente, atualize o vetor A
com os elementos na ordem crescente e mostre novamente o
vetor A.
Algoritmo vetor_crescente_15;
Inicio
A[ ]  {9,3,7,6,21,50,45,36,2,8,7,9,42,32,18};
Mostrar “O valor Original de A[“+i+”] =”+A[i];
Se A[i] > A[i+1] entao
Inicio_se
Aux  A[i];
A[i]  A[i+1];
A[i+1]  aux;
Fim_se;
Mostrar “O valor atualizado de A[“+i+”] =”+A[i];
Fim

Reordene os elementos em ordem decrescente, atualize o vetor
A com os elementos na ordem decrescente e mostre
novamente o vetor A.
Algoritmo vetor_decrescente_15;
Inicio
A[ ]  {9,3,7,6,21,50,45,36,2,8,7,9,42,32,18};
Se A[i] < A[i+1] entao
Inicio_se
Aux  A[i];
A[i]  A[i+1];
A[i+1]  aux;
Fim_se;
Mostrar “O valor atualizado de A[“+i+”] =”+A[i];
Fim

Problema: Crie um algoritmo lendo dois vetores (A e B) de 5
elementos cada do tipo inteiro, liste os elementos destes dois
vetores. Faça com que os elementos do vetor A passem para o
vetor B, e os elementos do vetor B passem para o vetor A.
Mostre os 2 vetores atualizados.
Algoritmo vetores_troca_5;
Var A,B, C:vetor [1..5] de inteiro;
I de inteiro;
Inicio
A[ ]  {9,3,7,6,21};
B[ ]  {50,45,36,2,14};
inicio
Mostrar “O valor Original de B[“+i+”] =”+A[i];
Fim;
Inicio_se
C[i]  A[i];
A[i]  B[i];
B[i  C[i];
Fim_se;
inicio
Mostrar “O valor Atualizado de A[“+i+”] =”+A[i];
Mostrar “O valor Atualizado de B[“+i+”] =”+A[i];
Fim;
Fim

Problema: Crie um algoritmo que gere uma matriz
exerc_matriz 3x3, inserir dados nos elementos dessa matriz,
por fim, mostre os dados contidos na matriz.
Algoritmo matriz_3x3;
Var exerc_matriz:matriz [1..3,1..3] de inteiro;
l, c de inteiro;
Inicio
Para l de 1 até 3 faça
Para c de 1 até 3 faça
Inicio
Mostrar “Digite valor para exerc_matriz[“+l+”,”+c+”].: ”;
Ler(exerc_matriz[l,c]);
Fim;
Mostrar “O valor de exerc_matriz[“+l+”,”+c+”].: ”+exerc_matriz[l,c];
Fim
Teste de Mesa
Exerc_matriz
C1 C2 C3
L1 6 9 7
L2 6 6 7
L3 5 3 7
L=1,2
C=1,2,3,4,1

Problema: Crie um algoritmo que gere uma matriz
exerc_matriz 3x3, inserir dados nos elementos dessa matriz,
por fim, mostre os dados contidos na matriz e mostre qual é o
maior e qual é o menor valor da matriz.
Algoritmo matriz_maior_menor;
Var exerc_matriz:matriz [1..3,1..3] de inteiro;
l, c, maior, menor de inteiro;
Inicio
Maior  0; menor  99999;
Inicio
Mostrar “Digite valor para exerc_matriz[“+l+”,”+c+”].: ”;
Ler(exerc_matriz[l,c]);
Fim;
Inicio_para
Mostrar “O valor de exerc_matriz[“+l+”,”+c+”].: ”+exerc_matriz[l,c];
Se exerc_matriz[l,c] > maior entao
maior  exerc_matriz[l,c];
Se exerc_matriz[l,c] < menor entao
menor  exerc_matriz[l,c];
Fim_para
Mostrar “O maior valor da matriz .: “+maior;
Mostrar “O menor valor da matriz .: “+menor;
Fim

Problema: Crie uma matriz 4x4 chamada Mat4 e leia os valores para todos os
elementos da matriz e :
1) mostre essa matriz;
2) Calcule a soma dos elementos e mostre a soma;
3) calcule e mostre a média dos elementos da matriz;
4) mostre os elementos da diagonal principal;
5) que mostre os elementos da diagonal secundária;
6) mostre os elementos da linha 3;
7) mostre os elementos da Coluna 2;
8) calcule e mostre quantos elementos são números maiores que a média (e mostre esses
elementos);
9) mostre em que posição se encontra o maior e o menor elemento da matriz;
10) crie uma segunda matriz MatNeri de 4x4 e armazene o conteúdo de cada elemento da
matriz multiplicado por 2, mostre os elementos dessa nova matriz;
11) Que mostre os elementos pares e Impares da matriz, e dizer também quantos são pares e
quantos são impares;
12) Crie um vetor chamado Vetor_neri que contenha os elementos da 2º linha e mostre este
vetor
Algoritmo matriz_12questoes;

Var Mat4:matriz [1..4,1..4] de inteiro;
MatNeri:matriz [1..4,1..4] de inteiro;
Vetor_neri:vetor[1..4] de inteiro;
l, c, maior, menor,soma, media, com_media, conta_pares, conta_impares de
inteiro;
elem_vert,elem_sec, elem_l3, elem_c2, mostra_com_media, pos_maior, pos_menor,
mostra_pares, mostra_impares, vetNeri de caracter;
Inicio
Maior  0; menor  99999; soma  0; com_media  0; conta_pares  0;
conta_impares  0;
elem_vert  “”; elem_sec  “”; elem_l3 ””; elem_c2 ””; mostra_com_media  “”;
pos_maior  “”;pos_menor  “”; mostra_pares  “”; mostra_impares  “”;
vetNeri  “”;
Inicio
Mostrar “Digite valor para Mat4[“+l+”,”+c+”].: ”;
Ler(mat4[l,c]);
Soma  soma + mat4[l,c];
Fim;
Media  soma / 16;
Inicio_para
Mostrar “O valor de mat4[“+l+”,”+c+”].: ”+mat4[l,c];
Se l = c entao Elem_vert  elem_vert + mat4[l,c];
Se c = (5-l) entao Elem_sec  elem_sec + mat4[l,c];
Se l = 3 entao Elem_l3  elem_l3 + mat4[l,c];
Se c = 2 entao Elem_c2  elem_c2 + mat4[l,c];
Se mat4[l,c] >= media entao
inicio
com_media  com_media + 1;
mostra_com_media  mostra_com_media + mat4[l,c];
fim;
Se mat4[l,c] > maior entao Pos_maior  “mat4[“+l+”,”+c+”]”;
Se mat4[l,c] < menor entao Pos_menor  “mat4[“+l+”,”+c+”]”;
MatNeri[l,c]  Mat4[l,c] * 2;
Se mat4[l,c] mod 2 = 0 então
Inicio
Conta_pares  conta_pares + 1;
Mostra_pares  mostra_pares + mat4[l,c];
Fim
Senao Inicio
Conta_impares  conta_impares + 1;

Mostra_impares  mostra_impares + mat4[l,c];
Fim
Se l = 2 então
inicio
Vetor_neri[c]  mat4[l,c];
VetNeri  vetNeri + mat4[l,c];
Fim;
Fim_para
Mostrar “A soma dos elementos da matriz .: “+soma;
Mostrar “A media dos valores da matriz .: “+media;
Mostrar “Elementos da diagonal principal .: “+Elem_vert;
Mostrar “Elementos da diagonal secundaria .: “+Elem_sec;
Mostrar “Elementos da linha 3 .: “+Elem_l3;
Mostrar “Elementos da Coluna 2 .: “+Elem_c2;
Mostrar com_media “ elementos atingiram a media, eles são.: “+mostra_com_media;
Mostrar “o maior valor está em “+pos_maior+” e o menor valor está em “+pos_menor;
inicio
Mostrar “O valor de matNeri[“+l+”,”+c+”].: ”+matNeri[l,c];
Fim;
Mostrar conta_pares+” são pares, são eles .: “+mostra_pares;
Mostrar conta_impares+” são impares, são eles .: “+mostra_impares;
Mostrar “O Vetor_neri possui os elementos.: “+vetNeri;
End.

Crie um algoritmo que leia para um cadastro de cliente, o seu nome, sua
idade e o seu salário. E por fim, mostre os valores.
Algoritmo cadastro_cliente;
Tipo cadastro = registro
Nome de caracter;
Idade de inteiro;
Salario de real;
Fim;
Var dados_cliente, dados_funcionario de cadastro;
Inicio
Mostre “Digite o nome do cliente”;
Ler(dados_cliente.nome);
Mostre “Digite a idade do cliente”;
Ler(dados_cliente.idade);
Mostre “Digite o salário do cliente”;
Ler(dados_cliente.salario);
Mostre “O nome do cliente .: “+dados_cliente.nome;
Mostre “A idade do cliente .: “+dados_cliente.idade;
Mostre “O salario do cliente .: “+dados_cliente.salario;
Mostre “Digite o nome do funcionario”;
Ler(dados_funcionario.nome);
Mostre “Digite a idade do Funcionario”;
Ler(dados_funcioanrio.idade);
Mostre “Digite o salário do Funcionario”;
Ler(dados_funcionario.salario);
Mostre “O nome do funcionario .: “+dados_funcionario.nome;
Mostre “A idade do funcionario .: “+dados_funcionario.idade;
Mostre “O salario do funcionario .: “+dados_funcionario.salario;
Fim.

Problema: subalgoritmos - modularização
Algoritmo operações_subalgoritmos;
procedimento leitura
inicio
Ler(num1)
Ler(num2);
Fim
Procedimento calculos
Inicio
fim
procedimento imprimir
inicio
fim;
Inicio
Leitura;
Calculos;
Imprimir;
Fim.

Problema: subalgoritmos – modularização – procedimentos c/
parâmetros
Algoritmo operações_subalgoritmos_parametros;
inicio
Ler(num1)
Ler(num2);
Fim
procedimento calculos(pn1, pn2 de real)
Inicio
soma  pn1 + pn22;
multiplicacao  pn2 * pn22;
divisao  pn1 / pn2;
subtracao  pn1 – pn2;
fim
procedimento imprimir(mult, div, sub, som)
inicio
mostrar “A multiplicacao = “+mult;
mostrar “A divisao = “+div;
mostrar “A Subtracao = “+sub;
mostrar “A soma =”+som;
fim;
Inicio
Leitura;
Calculos(num1, num2);
Imprimir(multiplicacao,divisao, subtracao, soma);
Fim.

Problema: subalgoritmos – modularização – FUNÇÕES
Algoritmo subalgoritmos_funcoes;
inicio
Ler(num1)
Ler(num2);
Fim
função somar(pn1, pn2 de real) de real;
Inicio
soma  pn1 + pn22;
retorna soma;
fim
função multiplicar(pn1, pn2 de real) de real;
Inicio
multiplicacao  pn1 * pn22;
retorna multiplicacao;
fim
função dividir(pn1, pn2 de real) de real;
Inicio
divisao  pn1 / pn22;
retorna divisao;
fim
função subtrair(pn1, pn2 de real) de real;
Inicio
subtracao  pn1 - pn22;
retorna subtracao;
fim
Inicio
Leitura;
Mostre “A soma .: “+ somar(num1, num2);
Mostre “A multiplicacao .: “+ multiplicar(num1, num2);
Mostre “A subtração .: “+ subtrair(num1, num2);
Mostre “A divisão .: “+ dividir(num1, num2);
Fim.

Videoulas de algoritmos e lógica de programação

Mais conteúdo relacionado

Mais procurados

Semelhante a Videoulas de algoritmos e lógica de programação

Videoulas de algoritmos e lógica de programação