Algoritmo

•
ESTÁCIO

Emi Stutz
22/09/2021
Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original
17/10/21 - Aulas 1 e 2
Lógica de Programação>Linguagem de Programação>Sistema Completo
Lógica de Programação: representada através Fluxograma, Nassi Shneiderman, *PORTUGOL*
>>PORTUGOL<<
- Se a tela aparecer em branco: digitar '!' + Ctrl + espaço
- Comando de saída: Escreva ("xxxxxxxx")
- Escrever e pular para linha de baixo: Escreval
- VARIÁVEIS: 
	identificador: tipo 
Regra identificador:
1. Deve começar com uma letra
2. Os próximos podem ser letras ou números
3. Não pode utilizar simbolos, exceto _
4. Não pode conter espaços em branco
5. Não pode letras com acento
6. Não pode ser uma palavra reservada(palavras em azul)
Ex: Nota1
 SalarioBruto
 Salario_Bruto
 Inicio_Algoritmo (com a junção, deixa de ser reservada)
- TIPOS PRIMITIVOS
Inteiro: 1 3 -5 198 0
Real(fracionarios): 0.5 5.0 9.8 -77.3 3.1415
Caractere(tudo aquilo colocado entre aspas): "Emi" "123" "Água" "Jornal"
Lógico: V/F
- ATRIBUIÇÃO:
	msg <- "Olá, Mundo!"
(msg recebe Olá, Mundo!)
- EXEMPLO ALGORITMO:
algoritmo "primeiro"
var
 msg: caractere
inicio
 msg <- "Olá, Mundo!" //atribuicao
 Escreval ("Mensagem: ", msg) //escreve o conteúdo da varial declarada
fimalgoritmo
>>AULA 3 - COMANDO DE ENTRADA E OPERADORES<<
-> comando de entrada: Leia
algoritmo "soma"
var
 N1, N2, S: Inteiro
inicio
 Escreva("Informe um número: ")
 Leia (N1)
 Escreva ("Informe outro número: ")
 Leia (N2)
 S <- N1 + N2
 Escreva ("A soma entre ", N1, " e ", N2, " é igual a ", S)
fimalgoritmo
- OPERADORES: + - * / \(DIVISÃO INTEIRA) ^(EXPONENCIAÇÃO) %(MÓDULO: resto da divisão) 
- ORDEM DE PRECEDÊNCIA: () -> ^ -> * / -> +- (ORDEM DE EXECUÇÃO do cálculo)
- FUNÇÕES ARITMÉTICAS:
Abs = Valor absoluto >> Abs(-10) = 10
Exp = Exponenciação >> Exp(3,2) = 9
Int = Inteiro >> Int(3,9) = 3
RaizQ = Raiz quadrada >> RaizQ(25) = 5
Pi = Retorna Pi >> Pi + 3.14..
Sen = Seno (rad) >> Sen(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.52
19/07/21 - Aula 4
- OPERADORES RELACIONAIS (criam relação entrem variáveis ou expressões)
> Maior que 
< Menor que 
>= Maior e igual a 
<= Menor ou igual a
= Igual a 
<> Diferente de
Código:
algoritmo "comparacao"
var
 A, B, C: Real
inicio
 A <- 7
 B <- 3
 C <- 5
 Escreva (C<=B*A)
fimalgoritmo
- OPERADORES LÓGICOS (comparam outros resultados lógicos)
E -> retorna VERDADEIRO quando todos forem V
OU -> retorna VERDADEIRO quando pelo menos um for V (ou, só retorna FALSO quando todos forem F)
NÃO -> retorna o contrário. Se for V, retorna F. Se for F, retona V
Código:
algoritmo "comparacao"
var
 A, B, C: Real
inicio
 A <- 7
 B <- 3
 C <- 5
 Escreva (NAO(A=B) OU (C>A))
fimalgoritmo
-ORDEM DE PRECEDÊNCIA (geral)
1. ARITMÉTICOS: (), ^, * /, + -
2. RELACIONAIS: Todos
3. LÓGICOS: E, OU, NAO
Código
algoritmo "triangulos"
var
 L1, L2, L3: Real
 EQ, ES: Logico
inicio
 Escreva ("Digite o primeiro lado: ")
 Leia (L1)
 Escreva ("Digite o segundo lado: ")
 Leia (L2)
 Escreva ("Digite o terceiro lado: ")
 Leia (L3)
 EQ <- (L1 = L2) E (L2 = L3)
 ES <- (L1 <> L2) E (L2 <> L3) E (L1 <> L3)
 Escreval ("O triangulo é EQUILATERO? ", EQ)
 Escreval ("O triangulo é ESCALENO? ", ES)
fimalgoritmo
- Aula 5 – Introdução ao Scratch
- Aula 6 – Exercícios de Algoritmo Resolvidos
algoritmo "BancoSolução"
var
 empres, jur, par, total: Real
inicio
 Escreval ("--------------------------")
 Escreval (" BOA TARDE ")
 Escreval ("--------------------------")
 Escreva ("Qual o valor do emprestimo? R$")
 Leia (empres)
 Escreval ("-------Só um minuto!-------")
 jur <- empres * 20/100
 Escreva ("Muito bem, você quer parcelar em quantas vezes? ")
 Leia (par)
 total <- (empres + jur)/ par
 Escreva ("Você pagará R$",total, " parcelado em", par, " vezes")
fimalgoritmo
algoritmo "emprestimo
var
 valor, parcela, juros, valor_total: real
inicio
 Escreva("Quanto você vai precisar? ")
 Leia(valor)
 juros <- valor * 20/100
 Escreva("Em quantas parcelas vai pagar? ")
 Leia(parcela)
 valor_total <- (valor+juros) / parcela
 Escreva("Pagamento em ", parcela, " parcelas de ", valor_total)
fimalgoritmo
- Aula 7 – Estruturas Condicionais 1
Se (expressão) entao
	Bloco
FimSe
Se (expressão) entao
	Bloco A
senao
	Bloco B
FimSe
- EXERCÍCIOS
algoritmo "Aula7DepTransito"
var
 ano_at, ano_nasc, idade: inteiro
 status, msg1, msg2: caractere
inicio
 Escreva ("Ano atual: ")
 Leia (ano_at)
 Escreva ("Ano de nascimento: ")
 Leia (ano_nasc)
 Escreval ("__________STATUS____________")
 idade <- ano_at - ano_nasc
 Escreval ("Idade: ", idade, " anos")
 Se (idade => 18) entao
 Escreval ("Apto a tirar carteira")
 Senao
 Escreval ("Inapto para tirar carteira")
 FimSe
 Escreval ("____________________________")
 
fimalgoritmo
algoritmo "Escola"
var
 nota1, nota2, media: real
inicio
 Escreval ("_____Escola_____")
 Escreva ("Primeira nota: ")
 Leia (nota1)
 Escreva ("Segunda nota: ")
 Leia (nota2)
 media <- (nota1 + nota2) /2
 Escreval ("Média: ", media)
 Se (media >= 6) entao
 Escreval ("Aluno aprovado")
 Senao (media < 6)
 Escreval ("Aluno reprovado")
 FimSe
fimalgoritmo
21/07/21 
-> Resolução de exercícios
6)
 algoritmo "semnome"
 var
 num, suc, antec: inteiro
 inicio
 Escreva ("Digite um número inteiro: ")
 Leia(num)
 antec <- (num - 1)
 suc <- (num + 1)
 Escreval ("O antecessor de ", (num), " é ", (antec), ". ")
 Escreval ("O sucessor de ", (num), " é ", (suc), ". ")
 fimalgoritmo
7)
algoritmo "Exec7"
var
 num, dobro, terca: real
inicio
 Escreva ("Digite um número real: ")
 Leia(num)
 dobro <- num * 2
 terca <- num / 3
 Escreval ("O dobro de ", num, " é ", dobro)
 Escreva ("A terça parte de ", num, " é ", terca:3:2)
 fimalgoritmo
8)
algoritmo "Exec8"
var
 m, km, hm, dam, dm, cm, mm: real
inicio
 Escreval ("Digite uma distância em metros: ")
 Leia(m)
 Escreval ("A distância de ", m, " corresponde a: ")
 km <- m / 1000
 hm <- m / 100
 dam <- m / 10
 dm <- m * 10
 cm <- m * 100
 mm <- m * 1000
 Escreval (km:5:3,"Km")
 Escreval (hm,"hm")
 Escreval (dam,"dam")
 Escreval (dm,"dm")
 Escreval (cm,"cm")
 Escreval (mm,"mm")
fimalgoritmo
- Aula 8 – Estruturas Condicionais 2
-- Condicional Aninhada --
Se (situação 1) entao
 Bloco A
senao
 Se (situação 2) entao
	Bloco B
 senao
	Bloco C
 FimSe
FimSe
Se (dinheiro >= 10000) entao
 Escreva ("Partiu Disney")
senao
 Se (dinheiro >= 5000) e (dinheiro < 10000) entao
	Escreva ("Visitar família")
 senao
	Escreva ("#chateado")
 FimSe
FimSe
- Prática 01
algoritmo "AlunoAula8"
var
 n1, n2, m: real
inicio
 Escreva ("Primeira nota: ")
 Leia (n1)
 Escreva("Segunda nota: ")
 Leia (n2)
 m <- (n1 + n2) / 2
 Escreval ("A media do aluno foi ", m:4:2)
 Se (m >= 7) entao
 Escreval ("Aluno APROVADO")
 senao
 Se (m>= 5) e (m<7) entao
 Escreval ("Aluno em RECUPERACAO")
 senao
 Escreval ("Aluno REPROVADO")
 FimSe
 FimSe
fimalgoritmo
- Pratica 02
algoritmo "CalculoIMC"
var
 M, A, IMC: Real
inicio
 Escreva("Massa (Kg): ")
 Leia(M)
 Escreva("Altura (m): ")
 Leia(A)
 IMC <- M / (A ^ 2)
 EscrevaL("IMC:
", IMC:5: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")
 FimSe
 FimSe
 FimSe
 FimSe
 FimSe
 FimSe
fimalgoritmo
- Prática 3 (Estrutura ESCOLHA)
* não serve para testar faixas de valores
** só funciona para valores inteiros 
algoritmo "CriancaEsperanca"
var
 D : Inteiro
 Valor: Real
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 doacao? R$")
 Leia (Valor)
 Caso 5
 Valor <- 0
 FimEscolha
 Escreval ("------------------------")
 Escreval (" SUA DOACAO FOI DE R$", Valor)
 Escreval (" MUITO OBRIGADO!")
 Escreval ("------------------------")
fimalgoritmo
algoritmo "DependentesFuncionario"
var
 Nome: Caractere
 Sal, NSal : Real
 Dep : Inteiro
inicio
 Escreva ("Qual o nome do Funcionario? ")
 Leia (Nome)
 Escreva ("Qual o salario do Funcionario? R$")
 Leia (Sal)
 Escreva ("Qual e a quantidade de dependentes? ")
 Leia (Dep)
 Escolha Dep
 Caso 0
 NSal <- Sal + (Sal*5/100)
 Caso 1, 2, 3
 NSal <- Sal + (Sal*10/100)
 Caso 4, 5, 6
 NSal <- Sal + (Sal*15/100)
 OutroCaso
 NSal <- Sal + (Sal*18/100)
 FimEscolha
 EscrevaL ("O novo salario de ", Nome, " sera de R$", NSal:5:2)
fimalgoritmo
22/07/21 - Exercícios
algoritmo "PartidaFutebol"
var
 p1, p2, dif: inteiro
inicio
 Escreval ("-----------------")
 Escreval ("Bangu x Madureira")
 Escreval ("-----------------")
 Escreva ("Placar Ban: ")
 Leia (p1)
 Escreva ("Placar Mad: ")
 Leia (p2)
 Se (p1 > p2) entao
 dif <- p1 - p2
 senao
 dif <- p2 - p1
 FimSe
 Escreval ("--------------------------------------------------")
 Escreval ("Diferença: ", dif)
 Escolha dif
 Caso 0
 Escreval ("Status: Empate")
 Caso 1, 2, 3
 Escreval ("Status: Partida Normal")
 Caso 4, 5, 6, 7
 Escreval ("Status: Goleada")
 OutroCaso
 Escreval (" Status: algo incomun. ")
 Escreval (" Você digitou os dados corretos? ")
 FimEscolha
 Escreval ("--------------------------------------------------")
 fimalgoritmo
28/07/2021
Exercícios
9)
algoritmo "Exec9"
var
 r, d: real
inicio
Escreva ("Quantos reais você tem? R$ ")
Leia(r)
d <- (r / 3.45)
Escreva ("Com R$ ", r, " você consegue comprar U$ ", d:5:2)
fimalgoritmo
10)
algoritmo "Exerc10"
var
 a, l, ar, t: real
inicio
 Escreva ("Informe a altura da parede: ")
 Leia(a)
 Escreva ("Informe a largura da parede: ")
 Leia(l)
 ar <- (a * l)
 Escreval ("A área a ser total é de: ", ar, "m")
 t <- (ar / 2)
 Escreval ("Vai precisar de ", t, " litros de tinta para pintar toda a área")
fimalgoritmo
12)
algoritmo "Exec11_preco_decont"
var
 p, q, d, np: real
inicio
 Escreva ("Informe o preço do produto: R$ ")
 Leia(p)
 Escreva ("Qual a quantidade do produto: ")
 Leia(q)
 Escolha q
 Caso 1, 2, 3
 np <- p - (p * 5/100)
 Caso 4, 5, 6
 np <- p - (p * 10/100)
 Caso 7, 8, 9
 np <- p - (p * 15/100)
 OutroCaso
 np <- p - (p * 20/100)
 FimEscolha
 Escreval ("O valor com desconto é: R$ ", np:5:2)
fimalgoritmo
13)
algoritmo "Exerc13_aumento_salario"
var
 s, ns, a: real
inicio
 Escreva ("Informe o seu salário: R$ ")
 Leia(s)
 Escreval ("-------------------------")
 Escreval (">>>>>AUMENTO DE 15% <<<<<")
 Escreval ("-------------------------")
 a <- s * 15/100
 ns <- s + a
 Escreva ("Seu novo salário é de: R$ ", ns:5:2)
fimalgoritmo
14)
algoritmo "Exerc14_locadora"
var
 k, d, p: real
inicio
 Escreva ("Qual a quilometragem percorrida? ")
 Leia(k)
 Escreva ("Quantas diárias? ")
 Leia(d)
 p <- (90.00 * d) + (0.20 * k)
 Escreva ("O valor a pagar: R$ ",p:5:2)
fimalgoritmo
15)
algoritmo "Exerc15_dias_trab"
var
 d, s: real
 m: caracter
inicio
 Escreva ("Informe o mês de referência: ")
 Leia(m)
 Escreva ("Informe o número de dias trabalhados: ")
 Leia(d)
 s <- d * 200.00
 Escreva ("O salário a ser pago no mês de ", m, " R$ ", s)
fimalgoritmo
>> Aula 9 – Estruturas de Repetição 1
Enquanto expressão faca
	bloco
FimEnquanto
Prática: Conte até 10
algoritmo "ConteAte10"
var
 contador: inteiro
inicio
 contador <- 0
 Enquanto (contador <= 10) faca
 Escreval (contador)
 contador <- contador + 1
 FimEnquanto
fimalgoritmo
 ------------------------------------------
algoritmo "ConteAte10"
var
 contador: inteiro
inicio
 contador <- 10
 Enquanto (contador >= 0) faca
 Escreval (contador)
 contador <- contador - 2
 FimEnquanto
 Escreval ("Terminei de contar!!!")
fimalgoritmo
---------------------------------
algoritmo "ConteAte10"
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
----------------------------
algoritmo "ConteAte10"
var
 valor, salto, contador: inteiro
inicio
 contador <- 0
 Escreva ("Quer contar até quanto? ")
 Leia(valor)
 Escreva ("Qual será o valor do salto? ")
 Leia(salto)
 Enquanto (contador <= valor) faca
 Escreval (contador)
 contador <- contador + salto
 FimEnquanto
 Escreval ("Terminei de contar!!!")
fimalgoritmo
-------------------------------------------
algoritmo "somador"
var
 cont, n, s: inteiro
inicio
 cont <- 1
 s <- 0
 Enquanto (cont <= 5) faca
 Escreva ("Digite o ", cont, "o. valor : ")
 Leia(n)
	 s <- s + n
 cont <- cont + 1
 FimEnquanto
 Escreval ("A soma de todos os alores foi ", s)
fimalgoritmo
-------------------------------------------------
algoritmo "somador"
var
 cont, n, s, maior: inteiro
inicio
 cont <- 1
 s <- 0
 Enquanto (cont <= 5) faca
 Escreva ("Digite o ", cont, "o. valor : ")
 Leia(n)
Se (n > maior) entao
 maior <- n
 FimSe
	 s <- s + n
 cont <- cont + 1
 FimEnquanto
 Escreval ("A soma de todos os alores foi ", s)
 Escreval ("O maior valor digitado foi ", maior)
fimalgoritmo
>>> ESCREVER O MENOR:
---------------------------------------
Conversor de Moedas com repetição
algoritmo "somador"
var
 r, d, c: real
inicio
 c <- 1
 Enquanto (c <= 4) faca
 Escreva ("Qual o valor em R$? ")
 Leia(r)
 d <- r/2.20
 Escreval ("O valor convertido é US$ ", d:5:2)
 c <- c + 1
 FimEnquanto
fimalgoritmo
--------------------------------------
algoritmo "somador"
var
 r, d: real
 c, q: inteiro
inicio
 c <- 1
 Escreva ("Quantas vezes vc quer converter? ")
 Leia (q)
 Enquanto (c <= q) faca
 Escreva ("Qual o valor em R$? ")
 Leia(r)
 d <- r/2.20
 Escreval ("O valor convertido é US$ ", d:5:2)
 c <- c + 1
 FimEnquanto
fimalgoritmo
EXERCÍCIOS: Contagem Inteligente
algoritmo "ContagemInteligenteRegres"
var
 c: inteiro
inicio
 C <- 8
 Enquanto (c >= 1) faca
 Escreval (c)
 c <- c - 1
 FimEnquanto
 Escreval ("Terminei a contagem!")
fimalgoritmo
-----------
algoritmo "SomadorNumerico"
var
 c, v, n, s, m: inteiro
inicio
 c <- 1
 s <- 0
 Escreva ("Informe um valor: ")
 Leia (v)
 Enquanto (c <= v) faca
 Escreva ("Digite o ", c, "o. valor: ")
 Leia (n)
 Se (n > m) entao
 m <- n
 FimSe
 s <- s + n
 c <- c + 1
 FimEnquanto
 Escreval ("A soma de todos os valores foi: ", s)
 Escreval ("O maior número foi: ", m)
fimalgoritmo
03/08/2021
>> AULA 10 - Estruturas de Repetição 2
algoritmo "Conta1a10"
var
 n, s, c: inteiro
inicio
 c <- 1
 Repita
 Escreval (c)
 c <- c + 1
 Ate (c > 10)
 Escreval ("A soma de todos os valores digitados e ", s)
fimalgoritmo
---------------
algoritmo "Tabuada"
var
 n, r, c, s: inteiro
inicio
 c <- 1
 n <- n
 Escreva ("Informe o número da tabuada: ")
 Leia(n)
 Repita
 r <- n * c
 Escreval (n, " x ", c, " = ", r)
 c <- c + 1
 Ate (c > 10)
fimalgoritmo
----------
algoritmo "ValoresNegativos"
var
 n: real
 c, tn: inteiro
inicio
 c <- 1
 Repita
 Escreva ("Digite um número: ")
 Leia(n)
 c <- c +1
 Se (n<0) entao
 tn <- tn + 1
 FimSe
 Ate (c > 5)
 Escreval ("Foram digitados ", tn, " valores negativos.")
fimalgoritmo
----------------
algoritmo "Fatorial"
var
 n, c, f: inteiro
 r: caractere
inicio
Repita
 Escreva ("Digite um número: ")
 Leia(n)
 c <- n
 f <- 1
 Repita
 f <- f * c
 c <- c - 1
 Ate (c < 1)
 Escreval ("O valor do fatorial de ", n, " é igual a ", f)
 Escreva ("Quer continuar? [S/N]")
 Leia(r)
Ate (r = "N")
fimalgoritmo
--------------
algoritmo "semnome"
var
 c, n, contdiv: inteiro
inicio
 c <- 1
 contdiv <- 0
 Escreva ("Digite um numero: ")
 Leia(n)
 Repita
 Se (n % c = 0) entao
 (contdiv <- contdiv + 1)
 FimSe
 c <- c + 1
 Ate (c > n)
 Se (contdiv > 2) entao
 Escreval ("O valor ", n, " não é primo!")
 senao
 Escreval ("O valor ", n, " é primo!")
 fimalgoritmo
-----------------
10/08/2021 - Revisão Aulas 9 e 10
Lembrete:
Repita
Ate
--------------------------------------
Escolha op
 Caso 1
 Cont <- 1
 Repita
 Escreva (Cont, "..")
 Cont <- Cont + 1
 Ate (Cont > 10)
 Caso 2
 Cont <- 10
 Repita
 Escreva (Cont, "..")
 Cont <- Cont - 1
 Ate (Cont < 1)
 Caso 3
 EscrevaL("SAINDO...")
 Caso 4
 EscrevaL("INVALIDO!")
FimEscolha
-----------------------------
algoritmo "SeletorPessoas_aula10"
var
 s: caractere
 i, c: inteiro
inicio
 Escreval ("-------------------------------")
 Escreval ("| SELETOR DE PESSOAS |")
 Escreval ("-------------------------------")
 EscrevaL (" Qual o sexo? [ F / M ]")
 Leia (s)
 Escreval ("Qual a idade?")
 Leia (i)
 Escreval ("Qual a cor do cabelo?")
 Escreval (" [1] Preto")
 Escreval (" [2] Castanho")
 Escreval (" [3] Loiro")
 Escreval (" [4] Ruivo")
 Leia (c)
 Escolha c
 c <- c
 Caso 1
 Escreva ("Preto")
 Caso 2
 Escreva ("Castanho")
 Caso 3
 Escreva ("Loiro")
 Caso 4
 Escreva ("Ruivo")
 FimEscolha
fimalgoritmo
>>>11/08/2021<<<
>>>AULA 11 - Estrutura de Repetição 3
Recapitulando: exemplo contador
Enquanto não arrumar o quarto faca
	castigo
FimEnquanto
liberado
c <- 1
Enquanto (c <= 10) faca
	Escreval(c)
	c <- c + 1
FimEnquanto
-----------
Repita
	castigo
Ate arrumar o quarto
liberado
c <- 1
Repita
	Escreval (c)
	c <- c + 1
Ate (c > 10)
-----------
Para variavel <- inicio ate fim [passo salto] faca
	Bloco
FimPara
Para c <- 1 ate 10 passo 1 faca
	Escreval(c)
FimPara
Para c <- 10 ate 1 passo -1 faca
	Escreval(c)
FimPara
---PRÁTICA---
1)
algoritmo "semnome"
var
 c, n, s: inteiro
inicio
s <- 0
Para c <- 1 ate 5 faca
	Escreval("Digite um valor: ")
	Leia(n)
	s <- s + n
FimPara
Escreval ("A soma dos valores e ", s)
fimalgoritmo
2)
algoritmo "ValoresPares"
var
 c, v: inteiro
inicio
Escreva ("Digite um valor : ")
Leia (v)
Para c <- 0 ate v passo 2 faca
 Escreval (c)
FimPara
fimalgoritmo
-----------
algoritmo "ValoresParesContagemRegressiva"
var
 c, v: inteiro
inicio
Escreva ("Digite um valor : ")
Leia (v)
Se (v%2=1) entao
 v <- v - 1
FimSe
Para c <- v ate 0 passo -2 faca
 Escreval (c)
FimPara
fimalgoritmo
-----------------
3)
algoritmo "QuantosEntre0e10"
var
 c, v, tot010: inteiro
inicio
tot010 <- 0
Para c<- 1 ate 6 faca
 Escreva ("Digite um valor: ")
 Leia(v)
 Se (v >= 0) e (c <= 10) entao
 tot010 <- tot010 + 1
 FimSe
FimPara
Escreval ("Ao todo foram ", tot010, " valores entre 0 e 10.")
fimalgoritmo
-----------------------
Adicional: exibir a soma entre os números ímpares digitados.
algoritmo "QuantosEntre0e10"
var
 c, v, tot010, simp: inteiro
inicio
tot010 <- 0
simp <- 0
Para c<- 1 ate 6 faca
 Escreva ("Digite um valor: ")
 Leia(v)
 Se (v >= 0) e (v <= 10) entao
 tot010 <- tot010 + 1
	 Se (v%2=1) entao // Se o resto da divisão de um número foi 1, ele é ÍMPAR
		 simp <- simp + v
	 FimSe
 FimSe
FimPara
Escreval ("Ao todo foram ", tot010, " valores entre 0 e 10.")
Escreval ("Nesse intervalo a soma de ímapares foi ", simp)
fimalgoritmo
>>>DESAFIO: Somar todos os ímpares, independente de intervalo.
algoritmo "QuantosEntre0e10"
var
 c, v, tot010, simp: inteiro
inicio
tot010 <- 0
simp <- 0
Para c<- 1 ate 6 faca
 Escreva ("Digite um valor: ")
 Leia(v)
 Se (v >= 0) entao
 tot010 <- tot010 + 1
	 Se (v%2=1) entao // Se o resto da divisão de um número foi 1,
ele é ÍMPAR
		 simp <- simp + v
	 FimSe
 FimSe
FimPara
Escreval ("Ao todo foram ", tot010, " valores entre 0 e 10.")
Escreval ("Nesse intervalo a soma de ímapares foi ", simp)
fimalgoritmo
---------------
4) Combinações
algoritmo "semnome"
var
 c1, c2: inteiro
inicio
 Para c1 := 1 ate 3 faca
 Para c2:= 1 ate 3 faca
 Escreval (c1, c2)
 FimPara
 FimPara
fimalgoritmo
------------
DESAFIO:
* Sequencia de Fibonacci (0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 --> 15 PRIMEIROS DA SEQUENCIA (ANTERIOR + ANTERIOR = N)
algoritmo "SequenciaFibonacci"
var
 C, T1, T2, T3 : Inteiro
inicio
 T1 <- 0
 Escreva (T1)
 T2 <- 1
 Escreva (T2)
 Para C := 3 ate 15 faca
 T3 := T1 + T2
 Escreva (T3)
 T1 := T2
 T2 := T3
 FimPara
fimalgoritmo
** Analisador de valores, Digitar 5 valores e exibir:
	- Soma dos valores
	- Média entre valores
	- Quantos são divisíveis por 5
	- Quantos são nulos
	- Soma dos pares
algoritmo "AnalisadorValores"
var
 V, C, S, DI5, NUL, SPAR: Inteiro
 M: Real
inicio
 S <- 0
 DI5 <- 0
 NUL <- 0
 SPAR <- 0
 Para C <- 1 ate 5 faca
 Escreva("Digite o ",C,"o. Valor: ")
 Leia(V)
 S <- S + V
 Se (V%5=0) entao
 DI5 <- DI5 + 1
 FimSe
 Se (V=0) entao
 NUL <- NUL + 1
 FimSe
 Se (V%2=0) entao
 SPAR <- SPAR + V
 FimSe
 FimPara
 M <- S / (C-1)
 EscrevaL("A soma entre os valores e ", S)
 EscrevaL("A media entre os valores e ", M:5:1)
 EscrevaL("Valores divisiveis por cinco: ", DI5)
 EscrevaL("Valores nulos: ", NUL)
 EscrevaL("A soma dos valores pares e ", SPAR)
 
 
fimalgoritmo
----------------------------------------
>>>24/08/21 - Aula 12 – Procedimentos
- PROCEDIMENTO: 
>>>Antes:
algoritmo "DetectorPesado"
var
i: inteiro
mai, p: real
n, pesado: caractere
inicio
LimpaTela
Escreval("-----------------------------------")
Escreval(" DETECTOR DE PESADO ")
Escreval(" Maior peso até agora: ", mai, "kg")
Escreval("-----------------------------------")
Para i <- 1 ate 5 faca
 Escreva("Digite o nome: ")
 Leia(n)
 Escreva("Digite o peso de ", n, ": ")
 Leia(p)
 Se (p>mai) entao
 mai <- p
 pesado <- n
 FimSe
 LimpaTela
 Escreval("-----------------------------------")
 Escreval(" DETECTOR DE PESADO ")
 Escreval(" Maior peso até agora: ", mai, "kg")
 Escreval("-----------------------------------")
FimPara
LimpaTela
 Escreval("-----------------------------------")
 Escreval(" DETECTOR DE PESADO ")
 Escreval(" Maior peso até agora: ", mai, "kg")
 Escreval("-----------------------------------")
 Escreval("A pessoa mais pesada foi ", pesado, ", com ", mai, " quilos.")
fimalgoritmo
>>> Depois
algoritmo "DetectorPesado"
var
i: inteiro
mai, p: real
n, pesado: caractere
Procedimento Topo ()
Inicio
LimpaTela
Escreval("-----------------------------------")
Escreval(" DETECTOR DE PESADO ")
Escreval(" Maior peso até agora: ", mai, "kg")
Escreval("-----------------------------------")
FimProcedimento
inicio
Topo ()
Para i <- 1 ate 5 faca
 Escreva("Digite o nome: ")
 Leia(n)
 Escreva("Digite o peso de ", n, ": ")
 Leia(p)
 Se (p>mai) entao
 mai <- p
 pesado <- n
 FimSe
 Topo ()
FimPara
Topo ()
 Escreval("A pessoa mais pesada foi ", pesado, ", com ", mai, " quilos.")
fimalgoritmo
---------------------------------
algoritmo "ParOuImparProcedimento"
Var
 n: inteiro
Procedimento ParOuImpar (v: inteiro)
inicio
 Se (v%2 = 0) entao
 Escreval ("O numero ", v, " é PAR")
 senao
 Escreval ("O numero ", v, " é ÍMPAR")
 FimSe
FimProcedimento
inicio
 Escreva ("Digite um número: ")
 Leia (n)
 ParOuImpar (n)
fimalgoritmo
----------------------------------
- ESCOPO LOCAL e GLOBAL
// INICIO escopo GLOBAL
algoritmo "TesteEscopo"
var
 n1, n2: inteiro
// INICIO escopo LOCAL
Procedimento Rotina(a, b: inteiro)
var
 x, y: inteiro
inicio
 x <- a
 y <- b
 Escreva(n1, n2, a, b, x, y)
FimProcedimento
// FIM escopo LOCAL
inicio
 n1 <- 5
 n2 <- 3
 Rotina(n1, n2)
 Escreva(n1, n2)
fimalgoritmo
// FIM escopo GLOBAL
-------------------------------------------
- PASSAGEM DE PARAMETRO
	TIPO 2: POR REFERENCIA
algoritmo "semnome"
Procedimento Soma(var A, B: inteiro)
Inicio
 A <- A + 1
 B <- B + 2
 Escreval("A soma vale", A+B)
FimProcedimento
inicio
 X <- 4
 Y <- 8
 Soma(X, Y)
 Escreval (X, Y)
fimalgoritmo
----------------------------
algoritmo "SomaParametrosReferencia"
var
 X, Y: inteiro
Procedimento Soma(var A, B: inteiro)
Inicio
 A <- A + 1
 B <- B + 2
 Escreval("Valor de A = ", A)
 Escreval("Valor de B = ", B)
 Escreval("A soma A + B = ", A+B)
FimProcedimento
inicio
 X <- 4
 Y <- 8
 Soma(X, Y)
 Escreval ("Valor de X = ", X)
 Escreval ("Valor de Y = ", Y)
fimalgoritmo
----------------------
algoritmo "FazSomaProcedimento"
var
 X, Y: Inteiro
Procedimento Soma(A, B: Inteiro)
inicio
 EscrevaL("Recebi o valor ",A)
 Escreval("Recebi o valor ",B)
 Escreval("A soma entre os dois e ", A + B)
FimProcedimento
inicio
 X <- 5
 Y <- 3
 Soma(X, Y)
fimalgoritmo
----------------------
algoritmo "Fibonacci"
var
 c, t1, t2, t3: inteiro
Procedimento ProximoFibonacci(var a, b: inteiro)
var c: inteiro
Inicio
 c := a + b // := recebe
 Escreva (c)
 a := b
 b := c
FimProcedimento
inicio
 t1 <- 0
 Escreva (t1)
 t2 <- 1
 Escreva (t2)
 Para c := 3 ate 10 faca
 ProximoFibonacci (t1, t2)
 FimPara
fimalgoritmo
-----------------------------
algoritmo "FibonacciProcedimento"
var I, T1, T2, T3: Inteiro
Procedimento ProximoFibonacci(var N1, N2: Inteiro)
Var
 N3: Inteiro
Inicio
 N3 <- N1 + N2
 EscrevaL(N3)
 N1 <- N2
 N2 <- N3
FimProcedimento
inicio
 T1 <- 0
 EscrevaL(T1)
 T2 <- 1
 EscrevaL(T2)
 Para I <- 3 ate 10 faca
 ProximoFibonacci(T1, T2)
 FimPara
fimalgoritmo
------------------------------
algoritmo "ParOuImparProcedimento"
var
 N: Inteiro
Procedimento ParOuImpar(V: Inteiro)
inicio
 Se (V%2 = 0) entao
 EscrevaL("O numero ", V, " e PAR")
 senao
 EscrevaL("O numero ", V, " e IMPAR")
 FimSe
FimProcedimento
inicio
 Escreva("Digite um numero: ")
 Leia (N)
 ParOuImpar(N)
fimalgoritmo
----------------------------------------
25/12/2021 
>>> EXERCÍCIOS
29)
algoritmo "Exerc29"
var
 n: caractere
 si, sa: real
 a: inteiro
inicio
 Escreva("Informe seu nome: ")
 Leia(n)
 Escreva
 Escreva("Informe o seu salário inicial: ")
 Leia(si)
 Escreva("Quantos anos de empresa: ")
 Leia(a)
 Escolha a
 Caso 1, 2
 sa <- si + (si * 3/100)
 Caso 3, 4, 5, 6, 7, 8, 9
 sa <- si + (si * 12.5/100)
 OutroCaso
 sa <- si + (si * 20/100)
 FimEscolha
 Escreva("Seu salário atual é de: R$ ", sa)
fimalgoritmo
30)
algoritmo "Exerc30"
var
 l1, l2, l3: inteiro
inicio
 Escreva("Informe o primeiro lado: ")
 Leia(l1)
 Escreva("Informe o segundo lado: ")
 Leia(l2)
 Escreva("Informe o terceiro lado: ")
 Leia(l3)
 Se (l1 = l2) E (l2 = l3) entao
 Escreva("O triângulo é EQUILATERO!")
 Senao
 Se (l1 <> l2) E (l2 <> l3) E (l1 <> l3) entao
 Escreva("O triângulo é ESCALENO!")
 Senao
 Se (l1 = l2) ou (l1 = l3) ou (l2 = l3) entao
 Escreva("O triângulo é ISÓCELES!")
FimSe
 FimSe
 FimSe
fimalgoritmo
31)
algoritmo "Exerc31"
var
 n1, n2: caractere
 a1, a2: inteiro
inicio
 Escreva("Nome jogador 1: ")
 Leia(n1)
 Escreva("Nome jogador 2: ")
 Leia(n2)
 Escreval(" ESCOLHA: ")
 Escreval(" [1] para PEDRA ")
 Escreval(" [2] para PAPEL ")
 Escreval(" [3] para TESOURA ")
 Escreva("Jogador 1: ")
 Leia(a1)
 Escreva("Jogador 2: ")
 Leia(a2)
 Se (a1 = a2) entao
 Escreva("Ninguém ganhou, jogue novamente!")
 Senao
 Se (a1 = 1) e (a2 = 3) entao
 Escreva("Jogador ", n2, " é o vencedor!")
 Senao
 Se (a1 = 2) e (a2 = 1) entao
 Escreva("Jogador ", n2, " é o vencedor!")
 Senao
 Se (a1 = 1) e (a2 = 2) entao
 Escreva("Jogador ", n2, " é o vencedor!")
 Senao
 Se (a1 = 2) e (a2 = 3) entao
 Escreva("Jogador ", n2, " é o vencedor!")
 Senao
 Se (a1 = 3) e (a2 = 1) entao
 Escreva("Jogador ", n1, " é o vencedor!")
 Senao
 Se (a1 = 3) e (a2 = 2) entao
 Escreva("Jogador ", n2, " é o vencedor!")
 FimSe
 FimSe
 FimSe
 FimSe
 FimSe
 FimSe
 FimSe
fimalgoritmo
>>> 26/08/2021
33)
algoritmo "Exerc33"
var
 vi, sc, p, s: real
 pa, a: inteiro
inicio
 Escreva("Informe o valor do imóvel: ")
 Leia(vi)
 Escreva("Informe o salário do comprador: ")
 Leia(sc)
 Escreval("")
 Escreva("Informe o número de anos para pagamento: ")
 Leia(a)
 Escreva("")
 pa <- a * 12
 p <- vi / pa
 s <- sc * 30/100
 Se P <= S entao
 Escreva("")
 Escreval("EMPRÉSTIMO APROVADO. O valor da prestação é: R$", p:5:2)
 Senao
 Escreval("EMPRÉSTIMO NEGADO. O valor da prestação é: R$", p:5:2")
 FimSe
 fimalgoritmo
>>> 31/08/2021
36)
algoritmo "Exerc36"
var
 ha, p: inteiro
 f: real
inicio
Escreva("Quantas horas de atividade realizou: ")
Leia(ha)
Se (ha < 10) entao
 p <- 2 * ha
Senao
 Se (ha >= 10) e (ha < 20) entao
 p <- 5 * ha
 Senao
 p <- 10 * ha
 FimSe
FimSe
f <- p * 0.05
Escreva("A pontuação é: ", p, " e o cliente faturou R$ ", f:5:2)
fimalgoritmo
37)
algoritmo "Exerc37"
var
 sa, ns: real
 a: inteiro
 g: caractere
inicio
Escreva("Informe o salário atual: ")
Leia(sa)
Escreva("Gênero [F - Fem] [M - Masc]: ")
Leia(g)
Escreva("Tempo trabalhado em anos: ")
Leia(a)
Escolha g
 Caso "f"
 Se (a < 15) entao
 ns <- (sa * 5/100) + sa
 Senao
 Se (a >= 15) e (a < 20) entao
 ns <- (sa * 12/100) + sa
 Senao
 ns <- (sa * 23/100) + sa
 FimSe
 FimSe
 Caso "m"
 Se (a < 20) entao
 ns <- (sa * 3/100) + sa
 Senao
 Se (a >= 20) e (a < 30) entao
 ns <- (sa * 13/100) + sa
 Senao
 ns <- (sa * 25/100) + sa
 FimSe
 FimSe
FimEscolha
Escreva("O novo salário é: ", ns:5:2)
fimalgoritmo
>>> EXERCÍCIOS PASSO 04 - REPETIÇÕES ENQUANTO <<<
38)
algoritmo "Exerc38"
var
 c: inteiro
inicio
c <- 6
Enquanto (c <= 11) faca
 Escreva(c)
 c <- c + 1
FimEnquanto
fimalgoritmo
39)
algoritmo "Exerc39"
var
 c: inteiro
inicio
c <- 10
Enquanto (c >= 3) faca
 Escreva(c)
 c <- c - 1
FimEnquanto
Escreval("Acabou!")
fimalgoritmo
40)
algoritmo "Exerc40"
var
 c: inteiro
inicio
c <- 0
Enquanto (c <= 18) faca
 Escreva(c)
 c <- c + 3
FimEnquanto
Escreval(" Acabou!")
fimalgoritmo
41)
algoritmo "Exerc41"
var
 c: inteiro
inicio
c <- 100
Enquanto (c >= 0) faca
 Escreva(c)
 c <- c - 5
FimEnquanto
Escreval(" Acabou!")
fimalgoritmo
42)
algoritmo "Exerc42"
var
 c, n: inteiro
inicio
Escreva("Informe um número inteiro e positivo: ")
Leia(n)
c <- 0
Enquanto (c <= n) faca
 Escreva(c)
 c <- c + 1
FimEnquanto
Escreval(" Acabou!")
fimalgoritmo
43)
algoritmo "Exerc43"
var
 c: inteiro
 n: real
inicio
c <- 30
Enquanto (c >= 1) faca
 Se (c%4=0) entao
 Escreval ("[",c:1,"]")
 Senao
 Escreval (c)
 FimSe
 c <- c - 1
FimEnquanto
fimalgoritmo
44)
algoritmo "Exerc44"
var
 v1, v2, i, c: inteiro
inicio
Escreva("Digite o primeiro valor: ")
Leia(v1)
Escreva("Digite o último valor: ")
Leia(v2)
Escreva("Digite o incremento: ")
Leia(i)
c <- v1
Enquanto (c < v2) faca
 Escreva(c)
 c <- c + i
FimEnquanto
fimalgoritmo
43)
algoritmo "Exerc43"
var
 c, v: inteiro
inicio
Escreva("Digite um valor: ")
Leia(v)
Se (v%2=1) entao
 v <- v -1
FimSe
Para c <- v ate 0 passo -2 faca
 Escreval(c)
FimPara
fimalgoritmo
44 e 45)
algoritmo "Exerc45"
var
 v1, v2, i, c: inteiro
inicio
Escreva("Digite o primeiro valor: ")
Leia(v1)
Escreva("Digite o último valor: ")
Leia(v2)
Escreva("Digite o incremento: ")
Leia(i)c
c <- v1
Enquanto (c < v2) faca
 Escreva(c)
 c <- c + i
FimEnquanto
Se v1 > v2 entao
c <- v1
Enquanto (c > v2) faca
 Escreva(c)
 c <- c - i
FimEnquanto
FimSe
fimalgoritmo
46) 
algoritmo "Exerc46"
var
 c, v, soma, s, val: inteiro
inicio
v <- 6
Para c <- v ate 100 passo 2 faca
 Escreva(val)
 soma <- soma + c
 s <- soma
 Escreva("A soma tota dos numeros é: ", s)
FimPara
fimalgoritmo
47)
algoritmo "Exerc47"
var
 cont, soma, n, v: inteiro
inicio
 n <- 500
 soma <- 0
 Enquanto (n >= 0) faca
 Escreva(n)
 soma <- soma + n
 n <- n - 50
 FimEnquanto
 Escreva(soma)
fimalgoritmo
49)
algoritmo "Exerc49"
var
 c, v, tot, tot2: inteiro
inicio
 Para c <- 1 ate 6 faca
 Escreva("Digite um valor: ")
 Leia(v)
 Se (v%2=0) entao
 tot <- tot + 1
 FimSe
 Se (v%2=1) entao
 tot2 <- tot2 + 1
 FimSe
 FimPara
 Escreva("Ao todo ", tot, " são par e ", tot2, " são ímpar")
fimalgoritmo
50)
algoritmo "Exerc50"
var
 v, c, a, n, totn, totd: inteiro
inicio
 n <- 1
 Enquanto (n <= 20) faca
 aleatorio 0, 10 // gera número aleatório
 Leia(a)
 aleatorio off
 n <- n + 1
 Se (a > 5) entao
 totn <- totn + 1 // informa quantidade de a > 5
 FimSe
 Se (a%3=0) entao
 totd <- totd + 1 // informa a quantidade de divisiveis por 3
 FimSe
 FimEnquanto
 Escreval(totn," estão acima de 5.")
 Escreval(totd," são divisíveis por 3.")
fimalgoritmo
51)
algoritmo "Exerc51"
var
 cont, p, menor, maior: inteiro
inicio
 cont <- 1
 Enquanto (cont <= 8) faca
 Escreva("O preço do ", cont, ".o produto: ")
 Leia(p)
 Se (p > maior) entao
 maior <- p
 FimSe
 cont <- cont + 1
 FimEnquanto
 Escreval("O menor valor digitado: ", menor)
 1
fimalgoritmo
-->> 22/09/2021
52)
algoritmo "Exerc52"
var
 cont, i, maior, contm, contme, s: inteiro
 m: real
inicio
cont <- 1
Enquanto (cont <= 10) faca
 Escreva(cont,"- Informe a sua idade: ")
Leia(i)
 cont <- cont + 1
 s <- s + i
 m <- s / (cont-1)
 Se (i > maior) entao
 maior <- i
 FimSe
 Se (i > 18) entao
 contm <- contm + 1
 FimSe
 Se (i < 5) entao
 contme <- contme + 1
 FimSe
FimEnquanto
Escreval("A maior idade foi ", maior)
Escreval(contm, " pessoas são maiores de 18 anos.")
Escreval(contme, " pessoas são menores de 5 anos.")
Escreval("A média das idades foi ", m)
fimalgoritmo
>>> ASSISTIR AULAS 12 e 13