Baixe o app para aproveitar ainda mais
Leia os materiais offline, sem usar a internet. Além de vários outros recursos!
cursoemvideo-algoritmos-1
Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original
algoritmos-cursoemvideo/.DS_Store
__MACOSX/algoritmos-cursoemvideo/._.DS_Store
algoritmos-cursoemvideo/aplicativos/.DS_Store
__MACOSX/algoritmos-cursoemvideo/aplicativos/._.DS_Store
algoritmos-cursoemvideo/aplicativos/visualgv25.exe
algoritmos-cursoemvideo/exercicios/aula12/.DS_Store
algoritmos-cursoemvideo/exercicios/aula12/aula-pratica/02 - SomaProcedimento.alg
algoritmo "FazSomaProcedimento"
// =============================================================
// Algoritmo para somar dois valores usando procedimentos.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
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
algoritmos-cursoemvideo/exercicios/aula12/aula-pratica/05 - FibonacciProcedimento.alg
algoritmo "FibonacciProcedimento"
// =============================================================
// Algoritmo para exibir os 10 primeiros elementos de uma serie de
// Fibonacci usando procedimentos com passagem de parametros por
// referencia.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
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
algoritmos-cursoemvideo/exercicios/aula12/aula-pratica/04 - SomaReferencia.alg
algoritmo "SomaParametrosReferencia"
// =============================================================
// Algoritmo para somar dois valores usando procedimentos com
// passagem de parametros por referencia.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
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("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
algoritmos-cursoemvideo/exercicios/aula12/aula-pratica/03 - ParImparProcedimento.alg
algoritmo "ParOuImparProcedimento"
// =============================================================
// Algoritmo para verificar se um valor e par ou impar usando
// rotinas internas.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
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
algoritmos-cursoemvideo/exercicios/aula12/aula-pratica/01 - DetectorPesado.alg
algoritmo "DetectorPesado"
// =============================================================
// Algoritmo para detectar qual e a pessoa mais pesada, utilizando
// rotinas em algoritmos.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
I: Inteiro
N, Pesado: Caractere
P, Mai: Real
inicio
LimpaTela
EscrevaL("------------------------------------")
EscrevaL(" D E T E C T O R DE P E S A D O ")
EscrevaL(" Maior Peso ate agora: ", Mai, "Kg")
EscrevaL("------------------------------------")
Teste()
Para I <- 1 ate 5 faca
Escreva("Digite o nome: ")
Leia(N)
Escreva("Digite o peso de ", N, ": ")
Se (P>Mai) entao
MAI <- P
Pesado <- N
FimSe
LimpaTela
EscrevaL("------------------------------------")
EscrevaL(" D E T E C T O R DE P E S A D O ")
EscrevaL(" Maior Peso ate agora: ", Mai, "Kg")
EscrevaL("------------------------------------")
FimPara
LimpaTela
EscrevaL("------------------------------------")
EscrevaL(" D E T E C T O R DE P E S A D O ")
EscrevaL(" Maior Peso ate agora: ", Mai, "Kg")
EscrevaL("------------------------------------")
EscrevaL("A pessoa mais pesada foi ", Pesado, ", com ", Mai, " quilos.")
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula12/aula12-leia.txt
==================================
SEJA BEM-VINDO AO CURSOEMVIDEO.COM
Cursos GRATIS feitos com QUALIDADE
==================================
Essa aula faz parte de um pacote do Curso de Algoritmos, criado pelo Prof. Gustavo Guanabara.
A chave para o bom aprendizado e sempre a PRATICA, entao pratique muito e nao deixe de acompanhar todas as aulas disponiveis no site abaixo:
------------------------------------------------
www.cursoemvideo.com/course/curso-de-algoritmos/
------------------------------------------------
Todas as aulas sao gratuitas, mas possuem o direito autoral reservado ao autor, Gustavo Guanabara.
Todos os testes praticos feitos durante a aula estao na pasta AULA-PRATICA.
Todos os exercicios propostos pelo professor estao na pasta EXERCICIOS-PROPOSTOS.
Abra o VISUALG e clique em Arquivo > Abrir ou pressione Ctrl+A. Em seguida, localize o arquivo desejado em sua respectiva pasta.
BONS ESTUDOS!
__MACOSX/algoritmos-cursoemvideo/exercicios/aula12/._aula12-leia.txt
algoritmos-cursoemvideo/exercicios/aula15/aula-pratica/02-paresMatriz.alg
algoritmo "matrizPar"
// =============================================================
// Algoritmo para preencher uma matriz de terceira ordem e mostrar
// quais sao as posicoes que possuem valores pares.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
valores: vetor[1..3, 1..3] de Inteiro
l, c, totPar: Inteiro
inicio
Para l <- 1 ate 3 faca
Para c <- 1 ate 3 faca
Escreva ("Digite o valor da posicao [", l, ",", c, "]: ")
Leia(valores[l, c])
FimPara
FimPara
EscrevaL()
EscrevaL("MATRIZ:")
EscrevaL("-------------")
TotPar <- 0
Para l <- 1 ate 3 faca
Para c <- 1 ate 3 faca
Se(valores[l,c] % 2 = 0) entao
Escreva("{", valores[l, c]:2, "}")
TotPar <- TotPar + 1
senao
Escreva(valores[l, c]:4)
fimSe
FimPara
Escreval()
FimPara
EscrevaL("Ao todo foram digitados ", TotPar, " valores PARES")
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula15/aula-pratica/03-matrizIdentidade.alg
algoritmo "matrizIdentidade"
// =============================================================
// Algoritmo para gerar automaticamente uma matriz identidade
// de terceira ordem.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
mID: vetor[1..3, 1..3] de Inteiro
i, j: Inteiro
inicio
Para i <- 1 ate 3 faca
Para j <- 1 ate 3 faca
Se (i = j) entao
mID[i,j] <- 1
senao
mID[i,j] <- 0
FimSe
FimPara
FimPara
Para i <- 1 ate 3 faca
Para j <- 1 ate 3 faca
Escreva (mID[i,j]:3)
FimPara
EscrevaL()
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula15/aula-pratica/01-preencheMatriz.alg
algoritmo "lerMatriz"
// =============================================================
// Algoritmo para preencher uma matriz 3x2 pelo teclado.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
mat: vetor[1..3, 1..2] de Inteiro
l, c: Inteiro
inicio
Para l <- 1 ate 3 faca
Para c <- 1 ate 2 faca
Escreva ("Digite o valor da posicao [", l, ",", c, "]: ")
Leia(mat[l,c])
FimPara
FimPara
Para l <- 1 ate 3 faca
Para c <- 1 ate 2 faca
Escreva (mat[l,c]:5)
FimPara
EscrevaL()
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula15/aula-pratica/04-valoresMatriz.alg
algoritmo "valoresMatriz"
// =============================================================
// Algoritmo para ler uma matriz de quarta ordem e mostrar no final:
// - A soma dos valores da diagonal principal
// - O produto dos valores da segunda linha
// - O maior valor da terceira coluna
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
m: vetor[1..4, 1..4] de Inteiro
l, c, sDP, p2L, mai3C: Inteiro
inicio
sDP <- 0
p2L <- 1
Para l <- 1 ate 4 faca
Para c <- 1 ate 4 faca
Escreva("Digite o valor da Posicao [", l, ",", c, "]: ")
Leia(m[l,c])
Se (l = c) entao
sDP <- sDP + m[l,c]
FimSe
FimPara
FimPara
Para l <- 1 ate 4 faca
Para c <- 1 ate 4 faca
Escreva(m[l,c]:4)
FimPara
EscrevaL()
FimPara
Para c <- 1 ate 4 faca
p2L <- p2L * m[2,c]
FimPara
Para l <- 1 ate 4 faca
Se (m[l,3] > mai3C) entao
mai3C <- m[l,3]
FimSe
FimPara
EscrevaL("A soma dos valores da Diagonal Principal e ", sDP)
EscrevaL("O produto dos valores da Segunda Linha e ", p2L)
EscrevaL("O maior valor da Terceira Coluna e ", mai3C)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula15/aula15-leia.txt
==================================
SEJA BEM-VINDO AO CURSOEMVIDEO.COM
Cursos GRATIS feitos com QUALIDADE
==================================
Essa aula faz parte de um pacote do Curso de Algoritmos, criado pelo Prof. Gustavo Guanabara.
A chave para o bom aprendizado e sempre a PRATICA, entao pratique muito e nao deixe de acompanhar todas as aulas disponiveis no site abaixo:
------------------------------------------------
www.cursoemvideo.com/course/curso-de-algoritmos/
------------------------------------------------
Todas as aulas sao gratuitas, mas possuem o direito autoral reservado ao autor, Gustavo Guanabara.
Todos os testes praticos feitos durante a aula estao na pasta AULA-PRATICA.
Todos os exercicios propostos pelo professor estao na pasta EXERCICIOS-PROPOSTOS.
Abra o VISUALG e clique em Arquivo > Abrir ou pressione Ctrl+A. Em seguida, localize o arquivo desejado em sua respectiva pasta.
BONS ESTUDOS!
__MACOSX/algoritmos-cursoemvideo/exercicios/aula15/._aula15-leia.txt
algoritmos-cursoemvideo/exercicios/aula15/exercicios-prontos/01-dissecandoMatriz.alg
algoritmo "dissecandoMatrizes"
// =============================================================
// Algoritmo para preencher uma matriz de quarta ordem e mostrar:
// - Os elementos da diagonal principal
// - Os elementos do triangulo superior
// - Os elementos do triangulo inferior
// - A matriz completa
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
m: vetor[1..4, 1..4] de Inteiro
l, c, op: Inteiro
Procedimento MostraMatriz()
inicio
Para l <- 1 ate 4 faca
Para c <- 1 ate 4 faca
Escreva(m[l,c]:4)
FimPara
EscrevaL()
FimPara
FimProcedimento
Procedimento DiagonalPrincipal()
var t: inteiro
inicio
Para l <- 1 ate 4 faca
EscrevaL(m[l,l]:4)
Para t <- 1 ate l faca
Escreva(" ")
FimPara
FimPara
FimProcedimento
Procedimento TrianguloSuperior()
var t: Inteiro
inicio
Para l <- 1 ate 3 faca
Escreva(" ")
Para c <- l+1 ate 4 faca
Escreva(m[l,c]:4)
FimPara
EscrevaL()
Para t <- 1 ate l faca
Escreva(" ")
FimPara
FimPara
EscrevaL()
FimProcedimento
Procedimento TrianguloInferior()
inicio
Para l <- 2 ate 4 faca
EscrevaL()
Para c <- 1 ate l-1 faca
Escreva(m[l,c]:4)
FimPara
FimPara
EscrevaL()
FimProcedimento
inicio
Para l <- 1 ate 4 faca
Para c <- 1 ate 4 faca
Escreva("Digite valor para a posicao [", l, ",", c, "]: ")
Leia(m[l,c])
FimPara
FimPara
LimpaTela
Repita
EscrevaL()
EscrevaL("MENU DE OPCOES")
EscrevaL("====================")
EscrevaL("[1] Mostrar a Matriz")
EscrevaL("[2] Diagonal Principal")
EscrevaL("[3] Triangulo Superior")
EscrevaL("[4] Triangulo Inferior")
EscrevaL("[5] Sair")
Repita
EscrevaL("===== OPCAO: ")
Leia(op)
Ate (op >=1) e (op <=5)
LimpaTela
Escolha op
Caso 1
MostraMatriz()
Caso 2
DiagonalPrincipal()
Caso 3
TrianguloSuperior()
Caso 4
TrianguloInferior()
Caso 5
EscrevaL("ENCERRANDO...")
FimEscolha
Ate (op = 5)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula15/exercicios-prontos/02-velha.alg
algoritmo "jogoVelha"
// =============================================================
// Algoritmo para criar um jogo da velha.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
v: vetor[1..3, 1..3] de Caractere
L, C, Cont, Po: Inteiro
Simb : Caractere
R: Logico
Procedimento mostraVelha()
Inicio
EscrevaL("+---+---+---+")
Para L <- 1 ate 3 faca
Para C <- 1 ate 3 faca
Escreva("| ", v[L,C]:1)
FimPara
Escreva("|")
EscrevaL()
EscrevaL("+---+---+---+")
FimPara
FimProcedimento
Procedimento mudaJogador()
inicio
Se (Simb = "X") entao
Simb <- "O"
senao
Simb <- "X"
FimSe
FimProcedimento
Funcao Jogar(S: Caractere; P: Inteiro): Logico
Var mudou: logico
inicio
mudou <- falso
Para L <- 1 ate 3 faca
Para C <- 1 ate 3 faca
Se(v[L,C] = NumpCarac(P)) entao
v[L,C] <- S
mudou <- verdadeiro
FimSe
FimPara
FimPara
Retorne mudou
FimFuncao
Funcao TerminouVelha(): Logico
Var
terminou: Logico
ocorr: Inteiro
inicio
terminou <- falso
// Jogos em linha
Para L <- 1 ate 3 faca
Se (v[L,1] = v[L,2]) e (v[L,2] = v[L,3]) entao
terminou <- verdadeiro
FimSe
FimPara
// Jogos em coluna
Para C <- 1 ate 3 faca
Se (v[1,C] = v[2,C]) e (v[2,C] = v[3,C]) entao
terminou <- verdadeiro
FimSe
FimPara
// Jogos em diagonal
Se (v[1,1] = v[2,2]) e (v[2,2] = v[3,3]) entao
terminou <- verdadeiro
FimSe
Se (v[1,3] = v[2,2]) e (v[2,2] = v[3,1]) entao
terminou <- verdadeiro
FimSe
// Jogos em VELHA
ocorr <- 0
Para L <- 1 ate 3 faca
Para C <- 1 ate 3 faca
Se (v[L,C] <> "X") e (v[L,C] <> "O") entao
ocorr <- ocorr + 1
FimSe
FimPara
FimPara
Se (ocorr = 0) entao
terminou <- verdadeiro
FimSe
// Retorna se o jogo acabou ou nao
Retorne terminou
FimFuncao
inicio
Cont <- 1
Simb <- "X"
Para L <- 1 ate 3 faca
Para C <- 1 ate 3 faca
v[L,C] <- NumpCarac(Cont)
Cont <- Cont + 1
FimPara
FimPara
MostraVelha()
Repita
Repita
EscrevaL("Vai jogar [", simb:1, "] em qual posicao? ")
Leia(Po)
R <- Jogar(Simb, Po))
Se (R = falso) entao
EscrevaL("JOGADA INVALIDA!")
FimSe
Ate (R = verdadeiro)
MudaJogador()
LimpaTela
MostraVelha()
Ate (terminouVelha() = verdadeiro)
EscrevaL("JOGO FINALIZADO!!!")
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula14/aula-pratica/p01-TotalPares.alg
algoritmo "TotalPares"
// =============================================================
// Algoritmo para preencher um vetor e mostrar os que sao pares.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
n: vetor[1..7] de Inteiro
i, TotPar: Inteiro
inicio
Para i <- 1 ate 7 faca
Escreva("Digite o ", i, "o. valor: ")
Leia(n[i])
FimPara
LimpaTela
Para i <- 1 ate 7 faca
Se (n[i] % 2 = 0) entao
TotPar <- TotPar + 1
EscrevaL("Valor ", n[i], " na posicao ", i, " e PAR!")
FimSe
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula14/aula-pratica/p03-SoComC.alg
algoritmo "SoComC"
// =============================================================
// Algoritmo para mostrar uma listagem com nomes que comecem com C
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
nome: Caractere
soC: vetor[1..10] de Caractere
c, tot: Inteiro
inicio
tot <- 0
Para c <- 1 ate 10 faca
Escreva("Digite seu nome: ")
Leia(nome)
Se (copia(maiusc(nome), 1, 1) = "C") entao
tot <- tot + 1
soC[tot] <- nome
FimSe
FimPara
LimpaTela
EscrevaL("LISTAGEM FINAL")
Para c <- 1 ate tot faca
EscrevaL(soC[c])
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula14/aula-pratica/p04-OrdenaVetor.alg
algoritmo "OrdenaVetor"
// =============================================================
// Algoritmo para ordenar um vetor.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
v: vetor[1..10] de Inteiro
c: Inteiro
Procedimento OrdenaVetor()
var
i, j, aux: Inteiro
inicio
Para i <- 1 ate 9 faca
Para j <- i+1 ate 10 faca
Se (v[i] > v[j]) entao
aux <- v[i]
v[i] <- v[j]
v[j] <- aux
FimSe
FimPara
FimPara
FimProcedimento
inicio
Para c <- 1 ate 10 faca
Escreva("Digite o ", c, "o. valor: ")
Leia(v[c])
FimPara
OrdenaVetor()
EscrevaL("-------------------------------")
EscrevaL("Vetor Ordenado: ")
EscrevaL("-------------------------------")
Para c <- 1 ate 10 faca
Escreva (v[c], " ")
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula14/aula-pratica/p02-ListagemAlunos.alg
algoritmo "ListagemAlunos"
// =============================================================
// Algoritmo para mostrar uma listagem de alunos.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
nome: vetor[1..5] de Caractere
nota1: vetor[1..5] de Real
nota2: vetor[1..5] de Real
media: vetor[1..5] de Real
SMed, MTurma: Real
i: Inteiro
inicio
Para i <- 1 ate 5 faca
EscrevaL("--------------------")
EscrevaL("DADOS DO ALUNO ", i)
EscrevaL("--------------------")
Escreva("Nome: ")
Leia(nome[i])
Escreva("Nota 1: ")
Leia(nota1[i])
Escreva("Nota 2: ")
Leia(nota2[i])
Escreva("Media: ")
media[i] <- (nota1[i] + nota2[i])/2
EscrevaL(media[i]:4:1)
SMed <- SMed + media[i]
FimPara
// ----- HORA DE CALCULAR A SAIDA -----
LimpaTela
MTurma <- Smed / 5
EscrevaL ("A media da turma e ", MTurma:4:1)
EscrevaL("-----------------------------------")
EscrevaL("Alunos que ficaram acima da media")
EscrevaL("-----------------------------------")
Para i <- 1 ate 5 faca
Se (media[i] > MTurma) entao
EscrevaL(nome[i]:20, media[i]:4:1)
FimSe
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula14/exercicios-prontos/e01-TorneioFutebol.alg
algoritmo "TorneioFutebol"
// =============================================================
// Algoritmo para verificar o resultado de uma partida de futebol
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
time: vetor[1..3] de Caractere
l, c: Inteiro
inicio
EscrevaL("------------------")
EscrevaL("CAMPEONATO FUTEBOL")
EscrevaL("------------------")
Para c <- 1 ate 3 faca
Escreva ("Nome do ", c, "o. time: ")
Leia(time[c])
FimPara
LimpaTela
EscrevaL("-------------------")
EscrevaL(" TABELA DE PARTIDAS")
EscrevaL("-------------------")
Para l <- 1 ate 3 faca
Para c <- 1 ate 3 faca
Se (l <> c) entao
EscrevaL(time[l]:12, " [ ] x [ ] ", time[c]:12)
FimSe
FimPara
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula14/exercicios-prontos/e02-CorrigeProvas.alg
algoritmo "CorrigeProvas"
// =============================================================
// Algoritmo para corrigir uma prova, a partir de um gabarito.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
gab: vetor[1..5] de Caractere
prova: vetor[1..5] de Caractere
nome: vetor[1..3] de Caractere
nota: vetor[1..3] de Real
a: Inteiro
s, m: Real
Procedimento CadastroGabarito()
var
c: Inteiro
inicio
EscrevaL("PASSO 1 - Cadastro de Gabarito ")
EscrevaL("-------------------------------")
Para c <- 1 ate 5 faca
Escreva("Questao ", c, ": ")
Leia(gab[c])
FimPara
FimProcedimento
Funcao CadastraProva(): Real
var
c: Inteiro
notaFinal: Real
inicio
notaFinal <- 0
EscrevaL("RESPOSTAS DADAS")
Para c <- 1 ate 5 faca
Escreva("Questao ", c, ": ")
Leia(prova[c])
Se (Maiusc(prova[c]) = Maiusc(gab[c])) entao
notaFinal <- notaFinal + 2
FimSe
FimPara
Retorne notaFinal
FimFuncao
inicio
CadastroGabarito()
Para a <- 1 ate 3 faca
LimpaTela
EscrevaL("------------------------")
EscrevaL("ALUNO ", a)
EscrevaL("------------------------")
Escreva("Nome: ")
Leia(nome[a])
nota[a] <- CadastraProva()
s <- s + nota[a]
FimPara
LimpaTela
EscrevaL("NOTAS FINAIS ")
EscrevaL("-----------------------------")
Para a <- 1 ate 3 faca
EscrevaL(nome[a]:10, nota[a]:4:1)
FimPara
m <- s / 3
EscrevaL("-----------------------------")
EscrevaL("Media da Turma: ", M:4:1)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula14/exercicios-prontos/e03-LugaresCinema.alg
algoritmo "LugaresCinema"
// =============================================================
// Algoritmo para reservar lugares em uma sala de cinema.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
B: vetor[1..19] de Caractere
l, cad: Inteiro
r: Caractere
Procedimento MostraFileira()
var i: Inteiro
inicio
Para i <- 1 ate 10 faca
Se (B[i] = "") entao
Escreva ("[ B", i:2, " ]")
senao
Escreva ("[ --- ]")
FimSe
FimPara
EscrevaL()
EscrevaL("------------------------------------------------------------------------")
FimProcedimento
inicio
Repita
LimpaTela
MostraFileira()
Escreva("Reservar a cadeira: B")
Leia(cad)
Se (B[cad]="") entao
B[cad] <- "X"
EscrevaL("Cadeira B", cad, " RESERVADA!")
Senao
EscrevaL("ERRO: Lugar Ocupado!")
FimSe
Escreva("Quer reservar outro? [S/N] ")
Leia(r)
Ate (r = "N")
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula13/.DS_Store
algoritmos-cursoemvideo/exercicios/aula13/aula-pratica/02-ParImparFuncao.alg
algoritmo "ParImpar"
// =============================================================
// Algoritmo para criar uma funcao que verifica se um determinado
// numero passado como parametro e PAR ou IMPAR.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
N: Inteiro
R: Caractere
Funcao ParOuImpar(V: Inteiro): Caractere
inicio
Se (V%2 = 0) entao
Retorne "PAR"
senao
Retorne "IMPAR"
FimSe
FimFuncao
inicio
Escreva("Digite um numero: ")
Leia(N)
R <- ParOuImpar(N)
Escreva ("O numero ", N, " e um valor ", R)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula13/aula-pratica/01-SomaFuncao.alg
algoritmo "SomaFuncao"
// =============================================================
// Algoritmo para somar dois valores usando funcao com passagem
// de parametros por valor.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
V1, V2, S: Inteiro
Funcao Soma(X, Y: Inteiro): Inteiro
Inicio
Retorne X + Y
FimFuncao
inicio
Escreva("Digite o primeiro valor: ")
Leia(V1)
Escreva("Digite o segundo valor: ")
Leia(V2)
S <- Soma(V1, V2)
EscrevaL("A soma entre ", V1, " e ", V2, " e igual a ", S)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula13/aula-pratica/05-AnalisadorStrings.alg
algoritmo "AnalisadorStrings"
// =============================================================
// Algoritmo para demonstrar as principais funcoes de manipulacao
// de strings do visualg.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
N: Caractere
C: Inteiro
inicio
Escreva("Digite seu nome: ")
Leia(N)
EscrevaL("Total de letras do seu nome: ", Compr(N))
EscrevaL("Seu nome em maiusculas e ", Maiusc(N))
EscrevaL("Seu nome em minusculas e ", Minusc(N))
EscrevaL("A primeira letra do seu nome e ", Copia(N, 1, 1))
EscrevaL("A ultima letra do seu nome e ", Copia(Maiusc(N), Compr(N), 1))
EscrevaL("Seu nome tem a letra A na posicao ", Pos("A", Maiusc(N)))
EscrevaL("O codigo da letra A e ", Asc("A"))
EscrevaL("A letra de codigo 65 e ", Carac(65))
Para C <- Compr(N) ate 1 passo -1 faca
Escreva(Copia(Maiusc(N),C,1))
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula13/aula-pratica/04-FibonacciFuncao.alg
algoritmo "FibonacciFuncao"
// =============================================================
// Algoritmo para criar uma serie de Fibonacci utilizando uma
// funcao com passagem de parametros por referencia.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
I, T1, T2, T3: Inteiro
Funcao ProximoFibonacci(var N1, N2: Inteiro): Inteiro
Var
N3: Inteiro
Inicio
N3 <- N1 + N2
N1 <- N2
N2 <- N3
Retorne N3
FimFuncao
inicio
T1 <- 0
EscrevaL(T1)
T2 <- 1
EscrevaL(T2)
Para I <- 3 ate 5 faca
T3 <- ProximoFibonacci(T1, T2)
EscrevaL(T3)
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula13/aula-pratica/03-FatorialFuncao.alg
algoritmo "FatorialFuncao"
// =============================================================
// Algoritmo com funcao para calcular o fatorial de um numero.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
N, F: Inteiro
Funcao Fatorial(V: Inteiro):Inteiro
Var
C, R: Inteiro
Inicio
R <- 1
Para C <- 1 ate V faca
R <- R * C
FimPara
Retorne R
FimFuncao
inicio
Escreva("Digite um numero: ")
Leia(N)
F <- Fatorial(N)
EscrevaL("O valor de ", N, "! e igual a ", F)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula13/aula13-leia.txt
==================================
SEJA BEM-VINDO AO CURSOEMVIDEO.COM
Cursos GRATIS feitos com QUALIDADE
==================================
Essa aula faz parte de um pacote do Curso de Algoritmos, criado pelo Prof. Gustavo Guanabara.
A chave para o bom aprendizado e sempre a PRATICA, entao pratique muito e nao deixe de acompanhar todas as aulas disponiveis no site abaixo:
------------------------------------------------
www.cursoemvideo.com/course/curso-de-algoritmos/
------------------------------------------------
Todas as aulas sao gratuitas, mas possuem o direito autoral reservado ao autor, Gustavo Guanabara.
Todos os testes praticos feitos durante a aula estao na pasta AULA-PRATICA.
Todos os exercicios propostos pelo professor estao na pasta EXERCICIOS-PROPOSTOS.
Abra o VISUALG e clique em Arquivo > Abrir ou pressione Ctrl+A. Em seguida, localize o arquivo desejado em sua respectiva pasta.
BONS ESTUDOS!
__MACOSX/algoritmos-cursoemvideo/exercicios/aula13/._aula13-leia.txt
algoritmos-cursoemvideo/exercicios/aula09/.DS_Store
algoritmos-cursoemvideo/exercicios/aula09/aula-pratica/05-moedas.alg
algoritmo "conversorMoedas"
var
C, Q: Inteiro
R, D: Real
inicio
C <- 1
Escreva ("Quantas vezes voce quer convernter? ")
Leia(Q)
Enquanto (C <= Q) faca
Escreva("Qual o valor em R$? ")
Leia(R)
D <- R/2.20
EscrevaL("O valor convertido e US$", D:5:2)
C <- C + 1
FimEnquanto
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula09/aula-pratica/03-contador.alg
algoritmo "conteAte10"
var
valor, salto, contador : Inteiro
inicio
contador <- 0
Escreva("Quer contar ate quanto? ")
Leia(valor)
Escreva("Qual sera o valor do salto? ")
Leia(salto)
Enquanto (contador <= valor) faca
EscrevaL(contador)
contador <- contador + salto
FimEnquanto
Escreval("Terminei de contar")
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula09/aula-pratica/04-maior.alg
algoritmo "somadorNumerico"
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 valores foi ", S)
EscrevaL("O maior valor digitado foi ", maior)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula09/aula-pratica/01-0a10.alg
algoritmo "conteAte10"
var
contador : Inteiro
inicio
contador <- 0
Enquanto (contador <= 10) faca
EscrevaL(contador)
contador <- contador + 1
FimEnquanto
Escreval("Terminei de contar")
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula09/aula-pratica/02-10a0.alg
algoritmo "conteAte10"
var
contador : Inteiro
inicio
contador <- 10
Enquanto (contador >= 0) faca
EscrevaL(contador)
contador <- contador - 2
FimEnquanto
Escreval("Terminei de contar")
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula09/aula09-leia.txt
==================================
SEJA BEM-VINDO AO CURSOEMVIDEO.COM
Cursos GRATIS feitos com QUALIDADE
==================================
Essa aula faz parte de um pacote do Curso de Algoritmos, criado pelo Prof. Gustavo Guanabara.
A chave para o bom aprendizado e sempre a PRATICA, entao pratique muito e nao deixe de acompanhar todas as aulas disponiveis no site abaixo:
------------------------------------------------
www.cursoemvideo.com/course/curso-de-algoritmos/
------------------------------------------------
Todas as aulas sao gratuitas, mas possuem o direito autoral reservado ao autor, Gustavo Guanabara.
Todos os testes praticos feitos durante a aula estao na pasta AULA-PRATICA.
Todos os exercicios propostos pelo professor estao na pasta EXERCICIOS-PROPOSTOS.
Abra o VISUALG e clique em Arquivo > Abrir ou pressione Ctrl+A. Em seguida, localize o arquivo desejado em sua respectiva pasta.
BONS ESTUDOS!
__MACOSX/algoritmos-cursoemvideo/exercicios/aula09/._aula09-leia.txt
algoritmos-cursoemvideo/exercicios/aula09/exercicios-propostos/01 - contador.alg
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
algoritmos-cursoemvideo/exercicios/aula09/exercicios-propostos/02 - melhoraluno.alg
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
algoritmos-cursoemvideo/exercicios/aula07/aula-pratica/02-parimpar.alg
algoritmo "ParOuImpar"
// =============================================================
// Algoritmo para verificar se um valor e PAR ou IMPAR
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
N: Inteiro
inicio
Escreva("Digite um numero qualquer: ")
Leia(N)
Se (N % 2 = 0) entao
EscrevaL("O numero ", N, " e PAR")
senao
EscrevaL("O numero ", N, " e IMPAR")
FimSe
fimalgoritmo
__MACOSX/algoritmos-cursoemvideo/exercicios/aula07/aula-pratica/._02-parimpar.alg
algoritmos-cursoemvideo/exercicios/aula07/aula-pratica/01-idade.alg
algoritmo "CalculoIdade"
// =============================================================
// Algoritmo para verificar se uma pessoa ja atingiu a maioridade
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
ano, nasc, idade: Inteiro
inicio
Escreva("Em que ano estamos? ")
Leia(ano)
Escreva("Em que ano voce nasceu? ")
Leia(nasc)
idade <- ano - nasc
Escreva ("Em ", ano, " voce tera ", idade, " anos")
Se (idade >= 21) entao
EscrevaL (" e ja tera atingido a maioridade. ")
FimSe
fimalgoritmo
__MACOSX/algoritmos-cursoemvideo/exercicios/aula07/aula-pratica/._01-idade.alg
algoritmos-cursoemvideo/exercicios/aula07/aula-pratica/03-imc.alg
algoritmo "CalculoIMC"
// =============================================================
// Algoritmo para calcular o Indice de Massa Corporal de uma pessoa
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
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 >= 18.5) e (IMC < 25) entao
Escreva("Parabens! Voce esta no seu peso ideal")
senao
Escreva("Voce nao esta na faixa de peso ideal")
FimSe
fimalgoritmo
__MACOSX/algoritmos-cursoemvideo/exercicios/aula07/aula-pratica/._03-imc.alg
algoritmos-cursoemvideo/exercicios/aula07/aula07-leia.txt
==================================
SEJA BEM-VINDO AO CURSOEMVIDEO.COM
Cursos GRATIS feitos com QUALIDADE
==================================
Essa aula faz parte de um pacote do Curso de Algoritmos, criado pelo Prof. Gustavo Guanabara.
A chave para o bom aprendizado e sempre a PRATICA, entao pratique muito e nao deixe de acompanhar todas as aulas disponiveis no site abaixo:
------------------------------------------------
www.cursoemvideo.com/course/curso-de-algoritmos/
------------------------------------------------
Todas as aulas sao gratuitas, mas possuem o direito autoral reservado ao autor, Gustavo Guanabara.
Todos os testes praticos feitos durante a aula estao na pasta AULA-PRATICA.
Todos os exercicios propostos pelo professor estao na pasta EXERCICIOS-PROPOSTOS.
Abra o VISUALG e clique em Arquivo > Abrir ou pressione Ctrl+A. Em seguida, localize o arquivo desejado em sua respectiva pasta.
BONS ESTUDOS!
__MACOSX/algoritmos-cursoemvideo/exercicios/aula07/._aula07-leia.txt
algoritmos-cursoemvideo/exercicios/aula07/exercicios-propostos/02-aluno.alg
algoritmo "SituacaoAluno"
// =============================================================
// Algoritmo para verificar se um aluno esta APROVADO ou REPROVADO
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
nota1, nota2, media: Real
inicio
EscrevaL("-----------------------")
EscrevaL(" ESCOLA JAVALI CANSADO ")
EscrevaL("-----------------------")
Escreva("Primeira Nota: ")
Leia(nota1)
Escreva("Segunda Nota: ")
Leia(nota2)
media <- (nota1 + nota2)/2
EscrevaL("-----------------------")
EscrevaL(" MEDIA: ", media:3:1)
Se (media >= 7) entao
EscrevaL(" ALUNO APROVADO ")
senao
EscrevaL(" ALUNO REPROVADO ")
FimSe
EscrevaL("-----------------------")
fimalgoritmo
__MACOSX/algoritmos-cursoemvideo/exercicios/aula07/exercicios-propostos/._02-aluno.alg
algoritmos-cursoemvideo/exercicios/aula07/exercicios-propostos/01-detran.alg
algoritmo "AptoDirigir"
// =============================================================
// Algoritmo para verificar se uma pessoa ja pode tirar carteira de motorista
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
ano, nasc, idade: Inteiro
apto: Logico
inicio
EscrevaL("--------------------------")
EscrevaL(" DEPARTAMENTO DE TRANSITO ")
EscrevaL("--------------------------")
Escreva("Ano Atual (yyyy): ")
Leia(ano)
Escreva("Ano de Nascimento (yyyy): ")
Leia(nasc)
idade <- ano - nasc
Se (idade >= 18) entao
apto <- verdadeiro
senao
apto <- falso
FimSe
EscrevaL
EscrevaL ("-------- STATUS --------")
EscrevaL (" IDADE: ", idade, " ANOS")
Se (apto) entao
EscrevaL (" APTO A TIRAR CARTEIRA ")
senao
EscrevaL (" INAPTO A TIRAR CARTEIRA ")
FimSe
EscrevaL ("------------------------")
fimalgoritmo
__MACOSX/algoritmos-cursoemvideo/exercicios/aula07/exercicios-propostos/._01-detran.alg
algoritmos-cursoemvideo/exercicios/aula08/aula-pratica/02 - ImcCompleto.alg
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 so 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
algoritmos-cursoemvideo/exercicios/aula08/aula-pratica/04 - Dependentes Funcionario.alg
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
algoritmos-cursoemvideo/exercicios/aula08/aula-pratica/03 - CriancaEsperanca.alg
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
algoritmos-cursoemvideo/exercicios/aula08/aula-pratica/01 - NotasAluno.alg
algoritmo "Aluno"
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
algoritmos-cursoemvideo/exercicios/aula08/aula08-leia.txt
==================================
SEJA BEM-VINDO AO CURSOEMVIDEO.COM
Cursos GRATIS feitos com QUALIDADE
==================================
Essa aula faz parte de um pacote do Curso de Algoritmos, criado pelo Prof. Gustavo Guanabara.
A chave para o bom aprendizado e sempre a PRATICA, entao pratique muito e nao deixe de acompanhar todas as aulas disponiveis no site abaixo:
------------------------------------------------
www.cursoemvideo.com/course/curso-de-algoritmos/
------------------------------------------------
Todas as aulas sao gratuitas, mas possuem o direito autoral reservado ao autor, Gustavo Guanabara.
Todos os testes praticos feitos durante a aula estao na pasta AULA-PRATICA.
Todos os exercicios propostos pelo professor estao na pasta EXERCICIOS-PROPOSTOS.
Abra o VISUALG e clique em Arquivo > Abrir ou pressione Ctrl+A. Em seguida, localize o arquivo desejado em sua respectiva pasta.
BONS ESTUDOS!
__MACOSX/algoritmos-cursoemvideo/exercicios/aula08/._aula08-leia.txt
algoritmos-cursoemvideo/exercicios/aula08/exercicios-propostos/01-AproveitamentoAluno.alg
algoritmo "SituacaoAluno"
var
nota1, nota2, media: Real
inicio
EscrevaL("-----------------------")
EscrevaL(" ESCOLA JAVALI CANSADO ")
EscrevaL("-----------------------")
Escreva("Primeira Nota: ")
Leia(nota1)
Escreva("Segunda Nota: ")
Leia(nota2)
media <- (nota1 + nota2)/2
EscrevaL("-----------------------")
EscrevaL(" MEDIA: ", media:3:1)
Se (media >=9) e (media <= 10) entao
EscrevaL(" APROVEITAMENTO: A ")
senao
Se (media >= 8) e (media < 9) entao
EscrevaL (" APROVEITAMENTO: B ")
senao
Se (media >= 7) e (media < 8) entao
EscrevaL (" APROVEITAMENTO: C ")
senao
Se (media >= 6) e (media < 7) entao
EscrevaL (" APROVEITAMENTO: D ")
senao
Se (media >= 5) e (media < 6) entao
EscrevaL (" APROVEITAMENTO: E ")
senao
EscrevaL(" APROVEITAMENTO: F ")
FimSe
FimSe
FimSe
FimSe
FimSe
EscrevaL("-----------------------")
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula08/exercicios-propostos/02-TimesFutebol.alg
algoritmo "PartidaFutebol"
var
gols1, gols2, dif: Real
inicio
EscrevaL("-----------------------")
EscrevaL(" BANGU x MADUREIRA ")
EscrevaL("-----------------------")
Escreva("Quantos gols do BANGU? ")
Leia(gols1)
Escreva("Quantos gols do MADUREIRA? ")
Leia(gols2)
Se (gols1 > gols2) entao
dif <- gols1 - gols2
senao
dif <- gols2 - gols1
FimSe
EscrevaL("-----------------------")
EscrevaL(" DIFERENCA: ", 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 INCOMUM. ")
EscrevaL(" Voce digitou os dados corretos? ")
FimEscolha
EscrevaL("-----------------------")
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula11/.DS_Store
algoritmos-cursoemvideo/exercicios/aula11/aula11-leia.txt
==================================
SEJA BEM-VINDO AO CURSOEMVIDEO.COM
Cursos GRATIS feitos com QUALIDADE
==================================
Essa aula
faz parte de um pacote do Curso de Algoritmos, criado pelo Prof. Gustavo Guanabara.
A chave para o bom aprendizado e sempre a PRATICA, entao pratique muito e nao deixe de acompanhar todas as aulas disponiveis no site abaixo:
------------------------------------------------
www.cursoemvideo.com/course/curso-de-algoritmos/
------------------------------------------------
Todas as aulas sao gratuitas, mas possuem o direito autoral reservado ao autor, Gustavo Guanabara.
Todos os testes praticos feitos durante a aula estao na pasta AULA-PRATICA.
Todos os exercicios propostos pelo professor estao na pasta EXERCICIOS-PROPOSTOS.
Abra o VISUALG e clique em Arquivo > Abrir ou pressione Ctrl+A. Em seguida, localize o arquivo desejado em sua respectiva pasta.
BONS ESTUDOS!
__MACOSX/algoritmos-cursoemvideo/exercicios/aula11/._aula11-leia.txt
algoritmos-cursoemvideo/exercicios/aula11/aula-pratica/01 - contador.alg
algoritmo "contador1a10"
// =============================================================
// Algoritmo para contar de 0 a 10 usando a estrutura PARA.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
C: Inteiro
inicio
Para C <- 10 ate 1 passo -1 faca
EscrevaL(C)
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula11/aula-pratica/02 - valorespares.alg
algoritmo "valoresPares"
// =============================================================
// Algoritmo para mostrar uma contagem regressiva de valores pares
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
CONT, V: Inteiro
inicio
Escreva("Digite um valor: ")
Leia(V)
Se(V%2=1) entao
V <- V - 1
FimSe
Para CONT <- V ate 0 passo -2 faca
EscrevaL(CONT)
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula11/aula-pratica/03 - entre0e10.alg
algoritmo "QuantosEntre0e10"
// =============================================================
// Algoritmo para verificar quantos valores digitados estao no
// intervalo entre 0 e 10, incluindo a soma dos valores impares
// que estiverem dentro desse intervalo.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
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
SImp <- SImp + V
FimSe
FimSe
FimPara
EscrevaL("Ao todo foram ", Tot010, " valores entre 0 e 10")
EscrevaL("Nesse intervalo, a soma de impares foi ",SImp)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula11/aula-pratica/04 - combinacoes.alg
algoritmo "Combinacoes"
// =============================================================
// Algoritmo para mostrar combinacoes possiveis entre os valores
// 1, 2 e 3.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
C1, C2 : Inteiro
inicio
Para C1 := 1 ate 3 faca
Para C2 := 1 ate 3 faca
EscrevaL (C1, C2)
FimPara
FimPara
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula11/exercicios-prontos/02 - analisador.alg
algoritmo "AnalisadorValores"
// =============================================================
// Algoritmo para ler cinco numeros e mostrar no final:
// - A soma e a media de todos os valores
// - Quantos valores sao divisiveis por 5 e quantos sao nulos
// - A soma de todos os valores pares digitados
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
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
algoritmos-cursoemvideo/exercicios/aula11/exercicios-prontos/01 - fibonacci.alg
algoritmo "Fibonacci"
// =============================================================
// Algoritmo para mostrar os 15 primeiros termos de uma serie de
// Fibonacci (0,1,1,2,3,5,8,...)
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
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
algoritmos-cursoemvideo/exercicios/aula10/.DS_Store
algoritmos-cursoemvideo/exercicios/aula10/aula10-leia.txt
==================================
SEJA BEM-VINDO AO CURSOEMVIDEO.COM
Cursos GRATIS feitos com QUALIDADE
==================================
Essa aula faz parte de um pacote do Curso de Algoritmos, criado pelo Prof. Gustavo Guanabara.
A chave para o bom aprendizado e sempre a PRATICA, entao pratique muito e nao deixe de acompanhar todas as aulas disponiveis no site abaixo:
------------------------------------------------
www.cursoemvideo.com/course/curso-de-algoritmos/
------------------------------------------------
Todas as aulas sao gratuitas, mas possuem o direito autoral reservado ao autor, Gustavo Guanabara.
Todos os testes praticos feitos durante a aula estao na pasta AULA-PRATICA.
Todos os exercicios propostos pelo professor estao na pasta EXERCICIOS-PROPOSTOS.
Abra o VISUALG e clique em Arquivo > Abrir ou pressione Ctrl+A. Em seguida, localize o arquivo desejado em sua respectiva pasta.
BONS ESTUDOS!
__MACOSX/algoritmos-cursoemvideo/exercicios/aula10/._aula10-leia.txt
algoritmos-cursoemvideo/exercicios/aula10/aula-pratica/.DS_Store
algoritmos-cursoemvideo/exercicios/aula10/aula-pratica/01-tabuada.alg
algoritmo "Tabuada"
// =============================================================
// Algoritmo para mostrar a tabuada de um determinado numero.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
Cont, N, R: Inteiro
inicio
Cont <- 1
Escreva("Quer ver a tabuada de qual numero? ")
Leia(N)
Repita
R <- N * Cont
EscrevaL(N, " x ", Cont, " = ", R)
Cont <- Cont + 1
Ate (Cont > 10)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula10/aula-pratica/04-fatorial.alg
algoritmo "Fatorial"
// =============================================================
// Algoritmo para calcular o Fatorial de um numero.
// Ex: 5! = 5 x 4 x 3 x 2 x 1 = 120
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
C, N, F: Inteiro
R: Caractere
inicio
Repita
Escreva("Digite um numero: ")
Leia(N)
C <- N
F <- 1
Repita
F <- F * C
C <- C - 1
Ate (C < 1)
EscrevaL ("O valor do fatorial de ", N, " e igual a ", F)
Escreva ("Quer continuar? [S/N]")
Leia(R)
LimpaTela
Ate (R = "N")
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula10/aula-pratica/03-somador.alg
algoritmo "Somador"
// =============================================================
// Algoritmo para somar varios valores informados pelo usuario.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
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")
EscrevaL("A soma de todos os valores digitados e ", S)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula10/aula-pratica/02-conta-negativos.alg
algoritmo "ContaNegativos"
// =============================================================
// Algoritmo para contar quantos valores digitados foram negativos.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
N, C, TotN: Inteiro
inicio
C <- 1
TotN <- 0
Repita
Escreva("Digite um numero: ")
Leia (N)
Se (N<0) entao
TotN <- TotN + 1
FimSe
C <- C + 1
Ate (C > 5)
EscrevaL("Foram digitados ", TotN, " valores negativos.")
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula10/aula-pratica/05-primo.alg
algoritmo "NumeroPrimo"
// =============================================================
// Algoritmo para verificar se um determinado numero e PRIMO ou nao.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
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, " nao e primo!")
senao
EscrevaL ("O valor ", N, " e primo!")
FimSe
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula10/exercicios-prontos/02-seletor-pessoas.alg
algoritmo "SeletorPessoas"
// =============================================================
// Algoritmo para ler Sexo, Idade e Cor de Cabelo de diversas pessoas
// e ao final, mostrar:
// = Total de HOMENS com mais de 18 ANOS e cabelos CASTANHOS.
// = Total de MULHERES entre 25 e 30 ANOS e cabelos LOIROS.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
sexo, resp: caractere
idade, cabelo, TotH18, TotM25: inteiro
inicio
Repita
LimpaTela
EscrevaL("==========================")
EscrevaL(" SELETOR DE PESSOAS ")
EscrevaL("==========================")
Escreva("Qual o Sexo? [M/F] ")
Leia(sexo)
Escreva("Qual a idade? ")
Leia(idade)
EscrevaL("Qual a cor do Cabelo?")
EscrevaL("---------------------")
EscrevaL("[1] Preto")
EscrevaL("[2] Castanho")
EscrevaL("[3] Loiro")
EscrevaL("[4] Ruivo")
Leia(cabelo)
Se (sexo = "M") e (idade > 18) e (cabelo = 2) entao
TotH18 <- TotH18 + 1
FimSe
Se (sexo = "F") e ((idade >= 25) e (idade <= 30)) e (cabelo = 3) entao
TotM25 <- TotM25 + 1
FimSe
Escreva("Quer continuar? [S/N] ")
Leia(resp)
Ate (resp = "N")
LimpaTela
EscrevaL("------------------------------------")
EscrevaL(" RESULTADO FINAL ")
EscrevaL("------------------------------------")
EscrevaL("Total de homens com mais de 18 e cabelos castanhos ", TotH18)
EscrevaL("Total de mulheres entre 25 e 30 e cabelos loiros ", TotM25)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula10/exercicios-prontos/01-contador-menu.alg
algoritmo "SuperContador"
// =============================================================
// Algoritmo para criar um contador atraves de menus.
//
// AUTOR: Gustavo Guanabara
// Curso COMPLETO disponivel GRATIS no site www.cursoemvideo.com
// =============================================================
var
op, Cont: Inteiro
inicio
Repita
EscrevaL("")
EscrevaL("=================")
EscrevaL("| M E N U |")
EscrevaL("=================")
EscrevaL("| [1] De 1 a 10 |")
EscrevaL("| [2] De 10 a 1 |")
EscrevaL("| [3] Sair |")
EscrevaL("=================")
Leia(op)
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
Ate (op = 3)
fimalgoritmo
algoritmos-cursoemvideo/exercicios/aula10/exercicios-prontos/.DS_Store
algoritmos-cursoemvideo/livros/visualg.pdf
.: NAPRO :. NÚCLEO DE APOIO APRENDIZAGEM DE PROGRAM AÇÃO
ELABORADO POR BRUNO TONET & CRISTIAN KOLIVER
Introdução aos Introdução aos Introdução aos Introdução aos
algoritmosalgoritmosalgoritmosalgoritmos
Bruno Tonet
Cristian Koliver
.: NAPRO :. NÚCLEO DE APOIO APRENDIZAGEM DE PROGRAM AÇÃO
ELABORADO POR BRUNO TONET & CRISTIAN KOLIVER
SUMÁRIO
INTRODUÇÃO AOS ALGORITMOS .......................... ......................1
1 - ALGORITMOS NÃO COMPUTACIONAIS ...................... ................3
2 - ALGORITMOS COMPUTACIONAIS .......................... ................4
3 - LINEARIZAÇÃO DE EXPRESSÕES ......................... ................5
4 - FORMA GERAL DE UM ALGORITMO ........................ ................7
5 - VARIÁVEIS .......................................... ................8
7 - LINHAS DE COMENTÁRIO ............................... ...............10
8 - COMANDOS DE E/S (ENTRADA/SAÍDA) .................... ...............10
9 - CONSTRUINDO OS PRIMEIROS ALGORITMOS: ESTRUTURAS SEQÜENCIAIS ......13
10 - ESTRUTURA CONDICIONAL .............................. .............15
11 - TESTANDO O ALGORITMO ............................... .............19
12 - ESTRUTURA DE REPETIÇÃO ............................. .............20
13 - COMANDO REPITA...ATE ............................... .............21
14 - COMANDO ENQUANTO..FACA ............................. .............24
15 - COMANDO PARA..FACA ................................. .............25
16 - VARIÁVEIS COMPOSTAS HOMOGÊNEAS ..................... .............27
16. A VARIÁVEIS I NDEXADAS UNIDIMENSIONAIS (V ETORES) ............................27
16. B VARIÁVEIS I NDEXADAS BIDIMENSIONAIS (MATRIZES) ............................28
17 - SUBALGORITMOS ...................................... .............30
17. A FUNÇÕES................................................... ........30
Funções Predefinidas do Visualg .....................................30
Criando Funções .....................................................32
17. B PROCEDIMENTO (S UB_ROTINAS)...........................................33
18 - FUNÇÕES DEFINIDAS RECURSIVAMENTE ................... .............34
19 - REFERÊNCIAS ........................................ .............37
CAPITULO 1 – 8 EXERCÍCIOS .......................... .....................38
CAPITULO 9 EXERCÍCIOS .............................. .....................40
CAPITULO 10 E 11 EXERCÍCIOS ........................ .....................42
CAPITULO 12 E 15 EXERCÍCIOS ........................ .....................43
CAPITULO 16 VETOR EXERCÍCIOS ....................... .....................44
CAPITULO 16 MATRIZ EXERCÍCIOS ...................... .....................45
CAPITULO 17 SUBALGORITMO EXERCÍCIOS ................ .....................46
CAPITULO 18 RECURSÃO EXERCÍCIOS .................... .....................48
.: NAPRO :. NÚCLEO DE APOIO APRENDIZAGEM DE PROGRAM AÇÃO
ELABORADO POR BRUNO TONET & CRISTIAN KOLIVER
3
1 - Algoritmos Não Computacionais
Um algoritmo é uma seqüência de instruções finita e ordenada de forma lógica para a
resolução de uma determinada tarefa ou problema. São exemplos de algoritmos instruções de
montagem, receitas, manuais de uso, etc. Um algoritmo não é a solução do problema, pois, se
assim fosse, cada problema teria um único algoritmo; um algoritmo é um caminho para a
solução de um problema. Em geral, existem muitos (senão infinitos) caminhos que levam a
uma solução satisfatória.
Um algoritmo não computacional é um algoritmo cuja seqüência de passos, a princípio,
não pode ser executada por um computador. Abaixo é apresentado um algoritmo não
computacional cujo objetivo é usar um telefone público. Provavelmente você “executou” o
algoritmo deste exemplo diversas vezes. O termo algoritmo está muito ligado à Ciência da
Computação, mas, na realidade, ele pode ser aplicado a qualquer problema cuja solução possa
ser decomposta em um grupo de instruções.
Exemplo 1.1
Um outro exemplo típico de algoritmo é uma receita culinária, como no exemplo abaixo.
Exemplo 1.2
Algoritmo para fritar um ovo
1. Colocar um ovo na frigideira
2. Esperar o ovo ficar frito
3. Remover o ovo da frigideira
O algoritmo acima, no entanto, poderia ser mais detalhado e completo. Uma versão
mais aceitável seria:
.: NAPRO :. NÚCLEO DE APOIO APRENDIZAGEM DE PROGRAM AÇÃO
ELABORADO POR BRUNO TONET & CRISTIAN KOLIVER
4
Exemplo 1.3
Algoritmo para fritar um ovo
1. Retirar um ovo da geladeira
2. Colocar a frigideira no fogo
3. Colocar óleo
4. Esperar até o óleo ficar quente
5. Quebrar o ovo separando a casca
6. Colocar o conteúdo do ovo na frigideira
7. Esperar um minuto
8. Retirar o ovo da frigideira
9. Apagar o fogo
Essa segunda versão é mais completa e detalhada que a anterior. Nela, várias ações
que estavam subentendidas foram explicitadas. No entanto, para que o algoritmo possa ser
útil, é necessário ainda que quem faz uso dele conheça os termos utilizados nas instruções. O
algoritmo do exemplo só será útil para alguém que seja fluente na língua portuguesa e
conheça o significado dos verbos Retirar , Colocar , Esperar assim como dos substantivos
utilizados no contexto de uma receita culinária. Em outras palavras, é preciso que a linguagem
utilizada no algoritmo seja conhecida tanto por quem o escreveu quanto por quem vai
executá-lo.
Para que o algoritmo possa ser executado por uma máquina é importante que as
instruções sejam corretas e sem ambigüidades. Portanto, a forma especial de linguagem que
utilizaremos é bem mais restrita que o Português e com significados bem definidos para todos
os termos utilizados nas instruções. Essa linguagem é conhecida como Português
Estruturado (às vezes também chamada de Portugol). O português estruturado é, na verdade,
uma simplificação extrema do Português, limitada a umas poucas palavras e estruturas que
têm um significado muito bem definido. Ao conjunto de palavras e regras que definem o
formato das sentenças válidas chamamos sintaxe da linguagem. Durante este texto, a
sintaxe do Português Estruturado será apresentada progressivamente e a utilizaremos em
muitos exercícios de resolução de problemas.
Aprender as palavras e regras que fazem parte dessa sintaxe é fundamental; no
entanto, não é o maior objetivo deste curso. O que realmente exigirá um grande esforço por
parte do estudante é aprender a resolver problemas utilizando a linguagem. Para isso, há
somente um caminho: resolver muitos problemas. O processo é semelhante ao de tornar-se
competente em um jogo qualquer: aprender as regras do jogo (a sintaxe) é só o primeiro
passo, tornar-se um bom jogador (programador) exige tempo, muito exercício e dedicação.
Embora o Português Estruturado seja uma linguagem bastante simplificada, ela possui
todos os elementos básicos e uma estrutura semelhante à de uma linguagem típica para
programação de computadores. Além disso, resolver problemas com português estruturado,
pode ser uma tarefa tão complexa quanto a de escrever um programa em uma linguagem de
programação qualquer. Portanto, neste curso, estaremos na verdade procurando desenvolver
as habilidades básicas que serão necessárias para adquirir-se competência na programação de
computadores.
Para praticar nossa sintaxe e testar nossos problemas, utilizaremos o software Visualg
desenvolvida por Cláudio Morgado de Souza. E-mail: cmorgado@apoioinformatica.com.br.
2 - Algoritmos Computacionais
O computador, a princípio, não executa nada. Para que ele faça uma determinada tarefa -
calcular uma folha de pagamento, por exemplo -, é necessário que ele execute um programa.
Um programa é um conjunto de milhares de instruções que indicam ao computador, passo a
passo, o que ele tem que fazer. Logo, um programa nada mais é do que um algoritmo
computacional descrito em uma linguagem de programação. Uma linguagem de programação
contém os comandos que fazem o computador escrever algo na tela, realizar cálculos
.: NAPRO :. NÚCLEO DE APOIO APRENDIZAGEM DE PROGRAM AÇÃO
ELABORADO POR BRUNO TONET & CRISTIAN KOLIVER
5
aritméticos, receber uma entrada de dados via teclado, e milhares de outras coisas, mas estes
comandos precisam estar em uma ordem lógica.
O termo processamento de dados é muitas vezes utilizado em conjunto com
computadores, pois, em geral, é isto o que eles fazem: processar dados. Daí podem extrair os
dois componentes básicos de um algoritmo computacional (de agora em diante, esta palavra
sempre utilizada no contexto de algoritmos computacionais): dados e código. Dados são os
valores (números, nomes, etc.) de que precisamos para resolver o problema, e código são os
comandos ou instruções que usaremos para manipular e "processar" os dados.
3 - Linearização de Expressões
Para a construção de algoritmos que realizam cálculo matemáticos, todas as expressões
aritméticas devem ser linearizadas, ou seja, colocadas em linhas, devendo também ser feito o
mapeamento dos operadores da aritmética tradicional para os do Português Estruturado.
Exemplo 3.1
( )2 5 3 1 .5
3
− − +
((2/3-(5-3))+1)*5
Tradicional Computacional
As tabelas seguintes mostram os operadores aritméticos disponíveis no Português
Estruturado.
OPERADORES ARITMÉTICOS PORTUGUÊS ESTRUTURADO
Adição +
Subtração -
Multiplicação *
Divisão /
Divisão Inteira \
Exponenciação ^ ou Exp (<base>,<expoente>)
Módulo (resto da divisão) %
Os operadores relacionais realizam a comparação entre dois operandos ou duas
expressões e resultam em valores lógicos (VERDADEIRO ou FALSO).
OPERADORES RELACIONAIS PORTUGUÊS ESTRUTURADO
Maior >
Menor <
Maior ou igual >=
Menor ou igual <=
Igual =
Diferente <>
.: NAPRO :. NÚCLEO DE APOIO APRENDIZAGEM DE PROGRAM AÇÃO
ELABORADO POR BRUNO TONET & CRISTIAN KOLIVER
6
Exemplo 3.2
2+5>4 resulta VERDADEIRO
3<>3 resulta FALSO
Os operadores lógicos atuam sobre expressões e também resultam em valores lógicos
VERDADEIRO ou FALSO.
OPERADORES
LÓGICOS
PORTUGUÊS
ESTRUTURADO SIGNIFICADO
Multiplicação
lógica
E Resulta VERDADEIRO se ambas as partes forem verdadeiras.
Adição lógica Ou Resulta VERDADEIRO se uma das partes é verdadeira.
Negação Nao
Nega uma afirmação, invertendo o seu valor lógico: se for
VERDADEIRO torna-se FALSO, se for FALSO torna-se VERDADEIRO.
A tabela abaixo
– chamada tabela-verdade – mostra os resultados das aplicações dos
operadores lógicos conforme os valores dos operadores envolvidos.
A B A E B A OU B NÃO A NÃO B
VERDADEIRO VERDADEIRO VERDADEIRO VERDADEIRO FALSO FALSO
VERDADEIRO FALSO FALSO VERDADEIRO FALSO VERDADEIRO
FALSO VERDADEIRO FALSO VERDADEIRO VERDADEIRO FALSO
FALSO FALSO FALSO FALSO VERDADEIRO VERDADEIRO
De acordo com a necessidade, as expressões podem ser unidas pelos operadores
lógicos.
Exemplo 3.3
(2+5>4) e (3<>3) resulta FALSO, pois VERDADEIRO e FALSO resulta FALSO.
A modularização é a divisão de uma expressão em partes, proporcionando maior
compreensão e definindo prioridades para a resolução da mesma. Como pôde ser observado
no exemplo anterior, em expressões computacionais utilizamos somente parênteses "()" para
modularização. Na sintaxe do Português Estruturado podemos ter parênteses dentro de
parênteses, como seriam os colchetes e as chaves na matemática.
Os parênteses indicam quais sub-expressões, dentro de uma expressão, serão
executados primeiro. A princípio, a execução é da esquerda para direita, mas além dos
parênteses, existem prioridades entre os operadores envolvidos na expressão. Tais prioridades
são mostradas nas tabelas seguintes.
OPERADOR ARITMÉTICO PRIORIDADE
Exponenciação 3 (maior)
Multiplicação 2
Divisão 2
Adição 1
Subtração 1 (menor)
.: NAPRO :. NÚCLEO DE APOIO APRENDIZAGEM DE PROGRAM AÇÃO
ELABORADO POR BRUNO TONET & CRISTIAN KOLIVER
7
Exemplo 3.4
(2 + 2)/2 resulta 2 e 2 + 2/2 resulta 3
OPERADOR LÓGICO PRIORIDADE
e 3
ou 2
nao 1
Exemplo 3.5
(2>3) ou (3<2) e (2<3) //resultado seria Falso
(2>3) e (3<2) ou (2<3) //resultado seria Verdadeiro
Entre as categorias de operadores também há prioridades, conforme mostrado na
tabela abaixo.
OPERADOR PRIORIDADE
Operadores aritméticos 3
Operadores relacionais 2
Operadores lógicos 1
Lembrete:
O software VisuAlg não possui relacionamento de categorias.
2*5>3 ou 5+1<2 e 2<7-2 // resulta em erro.
(2*5>3) ou (5+1<2) e (2<7-2) // certo seria assim.
4 - Forma Geral de um ALGORITMO
Nessa seção vamos conhecer os primeiros elementos que compõem o Português
Estruturado e escrever alguns algoritmos.
A estrutura geral de um algoritmo é:
Algoritmo "<nome do algoritmo>"
var
< declaração de variáveis>
inicio
< lista de comandos>
fimalgoritmo
onde as palavras algoritmo e fimalgoritmo fazem parte da sintaxe da linguagem e
sempre delimitam o inicio e fim de um algoritmo; a < declaração de variáveis > é a
seção ou parte do algoritmo onde descrevemos os tipos de dados que serão usados na lista de
comandos. Por exemplo, poderíamos definir que fruta é um tipo de dado que pode assumir
apenas os valores maçã, pêra, banana, abacaxi e outras frutas, sobre os quais podemos
.: NAPRO :. NÚCLEO DE APOIO APRENDIZAGEM DE PROGRAM AÇÃO
ELABORADO POR BRUNO TONET & CRISTIAN KOLIVER
8
efetuar as operações comparar, comprar, comer e servir; inicio indica o fim das declarações
e o início da seção de comandos; < lista de comandos > é apenas uma indicação de que
entre as palavras inicio e fimalgoritmo podemos escrever uma lista com uma ou mais
instruções ou comandos. É importante salientar que, quando um algoritmo é “executado”, as
instruções ou comandos de um algoritmo são sempre executados na ordem em que aparecem
no mesmo.
As palavras que fazem parte da sintaxe da linguagem são palavras reservadas, ou
seja, não podem ser usadas para outro propósito em um algoritmo que não seja aquele
previsto nas regras de sintaxe. A palavra algoritmo , por exemplo, é uma palavra reservada.
Neste texto, as palavras reservadas sempre aparecerão em negrito.
5 - Variáveis
Uma variável pode ser vista como uma caixa com um rótulo ou nome colado a ela,
que num dado instante guarda um determinado objeto. O conteúdo desta caixa não é algo
fixo, permanente. Na verdade, essa caixa pode ter seu conteúdo alterado diversas vezes.
Contudo, o conteúdo deve ser sempre do mesmo tipo.
Na figura abaixo, a caixa (variável) rotulada com FATOR contém o valor 5. Como seu
tipo é numérico, em um determinado instante essa caixa poderá conter qualquer valor
numérico (inteiro ou fracionário; positivo, negativo ou zero). Entretanto, em um determinado
instante, ela conterá um, e somente um, valor.
Variáveis são palavras que tem um significado bem específico em um algoritmo. Para
que o computador possa executar comandos que envolvem variáveis da maneira correta, ele
deve conhecer os detalhes das variáveis que pretendemos usar. Esses detalhes são: o
identificador desta variável e o tipo de valores que essa variável irá conter. Precisamos assim,
de uma maneira de especificar esses detalhes e comunicá-los ao computador. Para isso
devemos declarar nossas variáveis logo abaixo da expressão “VAR” que tem a seguinte forma:
VAR
<identificador 1>, <identificador 2>, ..., <identif icador n>: <tipo das
variáveis>
onde <identificador i > é o nome (identificador) de uma variável e <tipo das variáveis>
determina que tipo de valor as variáveis poderão receber.
Os identificadores das variáveis são usados para referenciá-las dentro do algoritmo.
Tais identificadores devem ser claros e precisos, dando uma idéia do “papel” da variável no
algoritmo.
.: NAPRO :. NÚCLEO DE APOIO APRENDIZAGEM DE PROGRAM AÇÃO
ELABORADO POR BRUNO TONET & CRISTIAN KOLIVER
9
A identificação ou nomeação de variáveis segue algumas regras:
a. nomes de variáveis não podem ser iguais a palavras reservadas;
b. nomes de variáveis devem possuir como primeiro caractere uma letra ou
sublinhado '_' (os outros caracteres podem ser letras, números e sublinhado);
c. nomes de variáveis devem ter no máximo 127 caracteres;
d. Nomes de variáveis não podem conter espaços em branco;
e. na sintaxe do Português Estruturado, não há diferença entre letras maiúsculas de
minúsculas (NOME é o mesmo que noMe).
Exemplo 5.1
Identificadores válidos: NOME, TELEFONE, IDADE_FILHO, IdadeFilho, NOTA1,
Est_Civil
Identificadores inválidos: 3Endereco, Estado Civil, PARA, algoritmo,
numero/complemento
Você deve estar se perguntando por que a palavra “PARA e algoritmo” são
identificadores inválidos. Eles são inválidos, pois são palavras reservadas da linguagem, veja
outras palavras que você não deve utilizar como identificadores de variáveis.
PALAVRAS RESERVADAS
aleatorio e grauprad passo
abs eco inicio pausa
algoritmo enquanto int pi
arccos entao interrompa pos
arcsen escolha leia procedimento
arctan escreva literal quad
arquivo exp log radpgrau
asc faca logico raizq
ate falso logn rand
caracter fimalgoritmo maiusc randi
caso fimenquanto mensagem repita
compr fimescolha minusc se
copia fimfuncao nao sen
cos fimpara numerico senao
cotan fimprocedimento numpcarac timer
cronometro fimrepita ou tan
debug fimse outrocaso verdadeiro
declare função para xou
Em Português Estruturado, só existem três tipos de dados, conforme a tabela abaixo.
TIPO DESCRIÇÃO
INTEIRO
Representa valores inteiros.
Exemplos: 10, 5, -5, -10
REAL ou
NUMERICO
Representa valores reais (com ponto separador da parte decimal).
Exemplos: 10, 15.5, -14.67
LITERAL ou
CARACTERE
Representa texto (seqüência ou cadeia de caracteres) entre aspas duplas.
Exemplo "Esta é uma cadeia de caracteres", “B”, “1234”
.: NAPRO :. NÚCLEO DE APOIO APRENDIZAGEM DE PROGRAM AÇÃO
ELABORADO POR BRUNO TONET & CRISTIAN KOLIVER
10
LOGICO Representa valores lógicos (VERDADEIRO ou FALSO).
6 - Operador de Atribuição
Para “colocar” um valor em uma variável dentro de um algoritmo, utilizamos o
operador de atribuição. O operador de atribuição é representado por uma setaCompartilhar
Continue navegando
Materiais relacionados
Perguntas relacionadas
Compartilhar