Last active
May 16, 2024 00:39
-
-
Save PedroBrantes/0aa437fcfa16821d8bc570559e5ac0b4 to your computer and use it in GitHub Desktop.
Exercícios de Algoritmo no VisuAlg
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "AlunoAP" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio Aula 07 "ALUNO APROVADO OU REPROVADO?" | |
| // Autor(a) : Brantes | |
| // Data atual : 28/04/2023 | |
| Var | |
| nota1, nota2, media: real | |
| //nota1: Primeira Nota, nota2: Segunda Nota, media: media das notas | |
| Inicio | |
| Escreval("--------------------------") | |
| Escreval(" ESCOLA MUNICIPAL ") | |
| Escreval("--------------------------") | |
| Escreva("Primeira Nota:") | |
| Leia(nota1) | |
| Escreva("Segunda Nota:") | |
| Leia(nota2) | |
| //Formula | |
| media <- (nota1 + nota2) / 2 | |
| //Define que a nota minima para ser aprovado é 5 | |
| se (media) >= 5 entao | |
| Escreval("") | |
| Escreval("--------------------------") | |
| Escreval("MÉDIA:", media) | |
| Escreval("RESULTADO: APROVADO!") | |
| senao | |
| Escreval("MÉDIA:", media) | |
| Escreval("RESULTADO: REPROVADO!") | |
| fimse | |
| Escreval("--------------------------") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "AlunoAP2" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio Aula 08 | |
| // Autor(a) : Brantes | |
| // Data atual : 28/04/2023 | |
| Var | |
| nota1, nota2, media: real | |
| //nota1: Primeira Nota, nota2: Segunda Nota, media: media das notas | |
| Inicio | |
| Escreval("--------------------------") | |
| Escreval(" ESCOLA MUNICIPAL ") | |
| Escreval("--------------------------") | |
| Escreva("Primeira Nota:") | |
| Leia(nota1) | |
| Escreva("Segunda Nota:") | |
| Leia(nota2) | |
| Escreval("--------------------------") | |
| //Formula | |
| media <- (nota1 + nota2) / 2 | |
| //Define que a nota minima para ser aprovado é 5 | |
| se (media) >= 7 entao | |
| Escreval("MÉDIA:", media:4:1) //formatação do valor depois do "." | |
| Escreval("RESULTADO: APROVADO!") | |
| senao // ------ | |
| se (media > 5) e (media < 7) entao // -------- | |
| Escreval("MÉDIA:", media:4:1) // ---------- | |
| Escreval("RESULTADO: RECUPERAÇÂO!") // Identação | |
| senao // do | |
| Escreval("MÉDIA:", media:4:1) // código | |
| Escreval("RESULTADO: REPROVADO!") // ---------- | |
| fimse // -------- | |
| fimse // ------ | |
| Escreval("--------------------------") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "Analisadordevalores" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio 2 aula 11, Somasr os valores, dizer a média, | |
| // se é divisivel por 5, Valores nulos e a soma dos pares. | |
| // Autor(a) : Brantes | |
| // Data atual : 04/05/2023 | |
| Var | |
| S, D5, D, N0, Sp, N, A, B, P1, M: Real | |
| N1, C: Inteiro | |
| Inicio | |
| C <- 1 | |
| Escreval("--------------------------------------") | |
| Escreval(" ANALISADOR DE VALORES ") | |
| Escreval("--------------------------------------") | |
| escreva("Digite quantas vezes quer: ") | |
| leia(N1) | |
| Repita | |
| se (N1 <= 0) entao | |
| escreval("Número Invalido") | |
| escreva("Digite Novamente quantas vezes quer: ") | |
| leia(N1) | |
| senao | |
| se (N1 > 10) entao | |
| escreval("Proibido mais de 10 Vezes") | |
| escreva("Digite Novamente quantas vezes quer: ") | |
| leia(N1) | |
| fimse | |
| fimse | |
| Ate(N1 > 0) e (N1 <= 10) | |
| Repita | |
| Escreva("Digite um número: ") | |
| Leia(N) | |
| Se (N = 0) entao | |
| N0 <- N0 + 1 //numeros nulos | |
| Senao | |
| Se (N % 2 = 0) entao | |
| P1 <- N | |
| Sp <- P1 + Sp //Soma dos Pares | |
| Fimse | |
| Fimse | |
| D <- N | |
| A <- N | |
| S <- A + S //Soma de Números | |
| Se (D % 5 = 0) entao | |
| D5 <- D5 + 1 //Divisivel por 5 | |
| Fimse | |
| C <- C + 1 | |
| Ate (C > N1) | |
| M <- S / N1 //Média dos valores somados | |
| Escreval("--------------------------------------") | |
| Escreval("SOMA DOS NÚMEROS: ", S) | |
| Escreval("MÉDIA DA SOMA: ", M:4:2) | |
| Escreval("DIVISIVEIS POR 5: ", D5) | |
| Escreval("VALORES NULOS: ", N0) | |
| Escreval("SOMA DOS PARES: ", Sp) | |
| Escreval("--------------------------------------") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "AnalisadorStrings" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Funçoes de tratamento de String do Visualg | |
| // Autor(a) : Brantes | |
| // Data atual : 01/06/2023 | |
| Var | |
| N, R, P: Caractere //Strings | |
| C, D: inteiro | |
| Inicio | |
| // N <- "cursoEmVideo" | |
| // Compr(N) 12 | Retorna a quantidade de caracteres da String | |
| // Copia(N, 6, 2) Em | Retorna o sexto (6) caractere e apartir dele 2 caracteres | |
| // Maiusc(N) CURSOEMVIDEO | Converte a String para Maiucula | |
| // Minusc(N) cursoemvideo | Converte a String para Minuscula | |
| // Pos("Video", N) 8 | Procura a palavra "Video" dentro da String (N) e conta quantos caracteres até chegar em "Video" | |
| // Asc("C") 67 | Retorna o valor do código da Tecla C | |
| // Carac(67) C | Retorna o valor da Tecla corresponde ao código 67 | |
| Escreva("Digite uma Palavra: ") | |
| Leia(N) | |
| Escreval("A palavra é: ", N) | |
| Escreval("Quantidade de letras é: ", Compr(N)) | |
| Escreval("A primeira letra é: ", Maiusc(Copia(N, 1, 1))) | |
| Escreval("A Ultima letra é: ", Maiusc(Copia(N, Compr(N), 1))) | |
| Escreval("Letras Maiusculas: ", maiusc(N)) | |
| Escreval("Letras Minusculas: ", minusc(N)) | |
| Escreval("Voce quer selecionar uma") | |
| Escreva("palavra nesse nome? ") | |
| Leia(R) | |
| R <- Maiusc(R) | |
| Se (R="SIM") ou (R="SS") ou (R="S") entao | |
| Escreva("Digite a palavra: ") | |
| Leia(P) | |
| Escreval("A Palavra ", Maiusc(P), " está na posição", Pos(Minusc(P), minusc(N))) | |
| Fimse | |
| Escreva("Todas as Letras e códigos: ") | |
| Para C := 1 ate Compr(N) faca | |
| Escreval(Maiusc(Copia(N, C, 1)), "(cod", Asc(Maiusc(Copia(N, C, 1))), ") ") | |
| FimPara | |
| Escreva("Voce quer digitar um código? ") | |
| Leia(R) | |
| R <- Maiusc(R) | |
| Se (R="SIM") ou (R="SS") ou (R="S") entao | |
| Escreva("Digite o código: ") | |
| Leia(D) | |
| Escreval("O código", D, " é: ", Carac(D)) | |
| Fimse | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "AproveitamentoF" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio Aula 08 "APROVEITAMENTO DE UM ALUNO" | |
| // Autor(a) : Brantes | |
| // Data atual : 29/04/2023 | |
| Var | |
| N1, N2, media: Real | |
| Inicio | |
| Escreval("--------------------------") | |
| Escreval(" ESCOLA MUNICIPAL ") | |
| Escreval("--------------------------") | |
| Escreva("Primeira Nota:") | |
| Leia(N1) | |
| //Estrutura de repetição #1 | |
| enquanto (N1 > 10) faca | |
| Escreval("Nota máxima 10!") | |
| Escreva("Digite a Primeira Nota Novamente: ") | |
| Leia(N1) | |
| fimenquanto | |
| Escreva("Segunda Nota:") | |
| Leia(N2) | |
| //Estrutura de repetição #2 | |
| enquanto (N2 > 10) faca | |
| Escreval("Nota máxima 10!") | |
| Escreva("Digite a Segunda Nota Novamente: ") | |
| Leia(N2) | |
| fimenquanto | |
| Escreval("--------------------------") | |
| //Formula | |
| media <- (N1 + N2) / 2 | |
| // A - 10 e 9 | |
| // B - 9 e 8 | |
| // C - 8 e 7 | |
| // D - 7 e 6 | |
| // E - 6 e 5 | |
| // F - < 5 | |
| Se (media >= 9) e (media <= 10) entao | |
| Escreval("MEDIA: ", media:3:1) | |
| Escreval("APROVEITAMENTO: A") | |
| senao | |
| Se (media >= 8) e (media < 9) entao | |
| Escreval("MEDIA: ", media:3:1) | |
| Escreval("APROVEITAMENTO: B") | |
| senao | |
| Se (media >= 7) e (media < 8) entao | |
| Escreval("MEDIA: ", media:3:1) | |
| Escreval("APROVEITAMENTO: C") | |
| senao | |
| Se (media >= 6) e (media < 7) entao | |
| Escreval("MEDIA: ", media:3:1) | |
| Escreval("APROVEITAMENTO: D") | |
| senao | |
| Se (media >= 5) e (media < 6) entao | |
| Escreval("MEDIA: ", media:3:1) | |
| Escreval("APROVEITAMENTO: E") | |
| senao | |
| Se (media < 5) entao | |
| Escreval("MEDIA: ", media:3:1) | |
| Escreval("APROVEITAMENTO: F") | |
| FimSe | |
| Fimse | |
| Fimse | |
| Fimse | |
| Fimse | |
| Fimse | |
| Escreval("--------------------------") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "CalculoIMC2" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio | |
| // Autor(a) : Brantes | |
| // Data atual : 26/04/2023 | |
| Var | |
| M, A, IMC: Real | |
| Inicio | |
| Escreval("CALCULO DO IMC") | |
| Escreval("(Índice de Massa Corporal)") | |
| Escreval() | |
| Escreva("Massa (Kg): ") | |
| Leia(M) | |
| Escreva("Altura (m): ") | |
| Leia(A) | |
| //Formula | |
| IMC <- M / (A ^ 2) | |
| Escreval("IMC: ", IMC:5:2) | |
| se (IMC < 17) entao | |
| Escreva("Muito abaixo do Peso!") | |
| senao | |
| se (IMC >= 17) e (IMC < 18.5) entao | |
| Escreva("Abaixo do Peso!") | |
| senao | |
| se (IMC >= 18.5) e (IMC < 25) entao | |
| Escreva("Peso Normal!") | |
| senao | |
| se (IMC >= 25) e (IMC < 30) entao | |
| Escreva("Acima do Peso") | |
| senao | |
| se (IMC >= 30) e (IMC < 35) entao | |
| Escreva("Obesidade I") | |
| senao | |
| se (IMC >= 35) e (IMC < 40) entao | |
| Escreva("Obesidade II (Sevéra)") | |
| senao | |
| Escreva("Obesidade III (Mórbida)") | |
| fimse | |
| fimse | |
| fimse | |
| fimse | |
| fimse | |
| fimse | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "CalculoIMCideal" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio | |
| // Autor(a) : Brantes | |
| // Data atual : 26/04/2023 | |
| 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! Você esta no seu peso ideal!") | |
| senao | |
| escreva("Você não está na faixa de peso ideal") | |
| fimse | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "CNH18" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio da Aula 07 "ESTÁ APITO PARA DIRIGIR?" | |
| // Autor(a) : Brantes | |
| // Data atual : 28/04/2023 | |
| Var | |
| ano_nasc, ano_atual, idade: inteiro | |
| //ano_nasc: Ano de Nascimento | |
| Inicio | |
| //Representação do orgão emissor | |
| Escreval("------------------------------") | |
| Escreval(" DEPARTAMENTO DE TRANSITO ") | |
| Escreval("------------------------------") | |
| //Perguntas | |
| Escreva("Ano Atual (yyyy):") | |
| Leia(ano_atual) | |
| Escreva("Ano de Nascimento (yyyy):") | |
| Leia(ano_nasc) | |
| //Formula | |
| idade <- ano_atual - ano_nasc | |
| //Status da Consulta | |
| Escreval("") | |
| Escreval("------------STATUS------------") | |
| Escreval("IDADE:", idade," ANOS") | |
| //Condição | |
| se (idade) >= 18 entao | |
| Escreval("APTO PARA TIRAR A CARTEIRA!") | |
| senao | |
| Escreval("NÃO ESTÁ APTO PARA TIRAR A CARTEIRA!") | |
| fimse | |
| Escreval("------------------------------") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "contagemInteligente" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio Aula 9 | |
| // Autor(a) : Brantes | |
| // Data atual : 30/04/2023 | |
| Var | |
| N1, N2, Freq, valor: inteiro | |
| Inicio | |
| Escreval("-------------------------------------") | |
| Escreval(" CONTAGEM INTELIGENTE ") | |
| Escreval("-------------------------------------") | |
| Escreval("Digite um número para o") | |
| Escreval("Começo e o Fim!") | |
| Escreva("Número Inicial: ") | |
| Leia(N1) | |
| Escreva("Número Final: ") | |
| Leia(N2) | |
| Escreval("Você quer contar em que frequencia?") | |
| Escreval("-------------------------------------") | |
| Escreval("[1]+1 [2]Par [3]+10 [Enter]Outro") | |
| Escreval("-------------------------------------") | |
| Escreva("Digite: ") | |
| leia(Freq) | |
| Escreval("-------------------------------------") | |
| //Estrutura de Condição | |
| Escolha Freq | |
| Caso 1 | |
| valor <- 1 | |
| Caso 2 | |
| valor <- 2 | |
| Caso 3 | |
| valor <- 10 | |
| Outrocaso | |
| Escreva("Digite a frequencia: ") | |
| leia(valor) | |
| Fimescolha | |
| //Mensagem de Erro e Repetição | |
| Se (valor > (valor + N1)) ou (valor > (valor + N2)) entao | |
| Escreval("Frequencia Invalida") | |
| enquanto (valor > (valor + N1)) ou (valor > (valor + N2)) faca | |
| Escreva("Digite Novamente a Frequencia: ") | |
| Leia(valor) | |
| fimenquanto | |
| Fimse | |
| //Estrutura de Repetição e Condição Juntas | |
| se (N1 <= N2) entao | |
| Escreval("Contando...") | |
| Escreval(N1, "..") | |
| enquanto (N1 < N2) faca | |
| N1 <- N1 + valor | |
| se (N1 = N2) entao | |
| //Lógica em branco, pois não preciso usar | |
| senao | |
| se (N2 % valor) > (N1 % N2) entao | |
| N1 <- N1 + (valor % N1) | |
| fimse | |
| fimse | |
| Escreval(N1, "..") | |
| fimenquanto | |
| senao | |
| Escreval("Contando...") | |
| Escreval(N2, "..") | |
| enquanto (N2 < N1) faca | |
| N2 <- N2 + valor | |
| se (N2 = N1) entao | |
| senao | |
| se (N1 % valor) > (N2 % N1) entao | |
| N2 <- N2 + (valor % N1) | |
| fimse | |
| fimse | |
| Escreval(N2, "..") | |
| fimenquanto | |
| fimse | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "contaNegativos" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Um contador de numeros negativos | |
| // Autor(a) : Brantes | |
| // Data atual : 01/05/2023 | |
| Var | |
| // Seção de Declarações das variáveis | |
| Cont, T, N, V: inteiro | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Cont <- 1 | |
| Escreva("Quantas vezes quer digitar? ") | |
| Leia(V) | |
| Repita | |
| Escreva("Digite um número: ") | |
| Leia(N) | |
| Se (N < 0) entao | |
| T <- T + 1 | |
| Fimse | |
| Cont <- Cont + 1 | |
| ate (Cont > V) | |
| Escreval("No total, foram registrados", T, " de números negativos") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "conteAteX" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Contar até X | |
| // Autor(a) : Brantes | |
| // Data atual : 01/05/2023 | |
| Var | |
| // Seção de Declarações das variáveis | |
| Cont, N: inteiro | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Cont <- 1 | |
| Escreva("Você quer contar até? ") | |
| leia(N) | |
| repita | |
| Escreval(Cont) | |
| Cont <- Cont + 1 | |
| ate (Cont > N) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "conteComRepita" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Contar até 10 | |
| // Autor(a) : Brantes | |
| // Data atual : 01/05/2023 | |
| Var | |
| // Seção de Declarações das variáveis | |
| Cont, S, N: inteiro | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Cont <- 1 | |
| repita | |
| Escreval(Cont) | |
| Cont <- Cont + 1 | |
| ate (Cont > 10) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "conversor" | |
| Var | |
| angulo, S: Real | |
| Inicio | |
| Escreva("Informe um angulo: ") | |
| Leia(angulo) | |
| S <- Sen(GraupRad(angulo)) | |
| Escreva("o seno de", angulo, " graus e: ", S) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "creusa01" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio Scratch Creusa 1 | |
| // Autor(a) : Brantes | |
| // Data atual : 21/04/2023 | |
| Var | |
| ano_atual, ano_nasc, idade: Inteiro //ano_atual: Ano Atual, ano_nasc: Ano de Nascimento | |
| Inicio | |
| Escreval("Oi! eu não me lembro de nada") | |
| Escreval("Que óculos bonito você tem") | |
| Escreval("Em que ano estamos?") | |
| Leia(ano_atual) | |
| Escreval("Essa e minha certidão de nascimento...") | |
| Escreval("CERTIDÃO DE NASCIMENTO") | |
| Escreval("Nome: Creusa da Silva") | |
| Escreval("Data de nascimento: 01/01/20.. (coincidentemente somente alguem de óculos consegue ler)") | |
| Escreval("Mãe: (o restante do documento está apagado!)") | |
| Escreval("Qual é o ano da data embaçada?") | |
| Leia(ano_nasc) | |
| idade <- ano_atual - ano_nasc | |
| Escreva("Se estamos em", ano_atual, " e eu nasci em", ano_nasc, "... Então eu tenho", idade, " anos") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "creusa02" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio Scratch 02 | |
| // Autor(a) : Brantes | |
| // Data atual : 14/04/2023 | |
| Var | |
| // Sessão de Declarações das variaveis | |
| reais, dolares: Real | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Escreva("Quantos R$ eu tenho? ") | |
| Leia(reais) | |
| dolares <- reais/5.05 | |
| Escreva("Posso trocar por US$", dolares) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "Criança_Esperança" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio Aula 08 | |
| // Autor(a) : Brantes | |
| // Data atual : 28/04/2023 | |
| Var | |
| D, Valor: Inteiro | |
| Inicio | |
| Escreval("---------------------------") | |
| Escreval(" CRIANÇA ESPERANÇA ") | |
| Escreval("---------------------------") | |
| Escreval("[1] Para doar R$10") | |
| Escreval("[2] Para doar R$25") | |
| Escreval("[3] Para doar R$50") | |
| Escreval("[4] Para doar outro valor!") | |
| Escreval("[5] Para cancelar!") | |
| Leia(D) | |
| Escreval("---------------------------") | |
| Escolha D | |
| Caso 1 | |
| Valor <- 10 | |
| Caso 2 | |
| Valor <- 25 | |
| Caso 3 | |
| Valor <- 50 | |
| Caso 4 | |
| Escreva("Digite o Valor: ") | |
| Leia(Valor) | |
| enquanto (Valor <= 5) faca | |
| Escreval("Valor deve ser maior do que R$5") | |
| Leia(Valor) | |
| fimenquanto | |
| Caso 5 | |
| Valor <- 1 | |
| FimEscolha | |
| Se (D > 5) ou (D < 1) entao | |
| Escreval("Opção Invalida") | |
| senao | |
| Se (Valor = 1) entao | |
| Escreval("Ok! Doação cancelada :(") | |
| senao | |
| Escreval("VOCÊ DOOU R$", Valor) | |
| Escreval("Muito Obrigado!") | |
| Escreval("---------------------------") | |
| Fimse | |
| Fimse | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "DetectorPesado" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Primeiro uso de Procedimento | |
| // Autor(a) : Brantes | |
| // Data atual : 05/05/2023 | |
| Var | |
| I: inteiro | |
| N, Pesado: Caractere | |
| P, Mai: Real | |
| Procedimento Tela() | |
| Inicio | |
| Limpatela | |
| Escreval("---------------------------------------") | |
| Escreval(" DETECTOR DE PESADO ") | |
| EscrevaL(" Maior Peso ate agora: ", Mai, "Kg") | |
| Escreval("---------------------------------------") | |
| FimProcedimento | |
| Inicio | |
| Tela() | |
| 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 | |
| Tela() | |
| FimPara | |
| Tela() | |
| Escreval("A pessoa mais pesada foi ", Pesado, ", com ", Mai, " quilos.") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "entre0e10-impares" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Dizer quantos número entre 0 e 10 e somar todos | |
| // os impares neste intervalo | |
| // Autor(a) : Brantes | |
| // Data atual : 02/05/2023 | |
| Var | |
| C, V, tot010, SImp: Inteiro | |
| Inicio | |
| 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 for 1, quer dizer que o número é impar | |
| SImp <- SImp + V //soma e armazena V | |
| fimse | |
| Fimse | |
| fimPara | |
| Escreval("Ao todo foram ", tot010, " valores entre 0 e 10") | |
| Escreval("Nesse intervalor, a soma de impares foi", SImp) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "EscolhendoPessoas" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Homens com mais de 18 anos e cabelo castanho | |
| // Mulheres entre 25 e 30 anos de cabelo loiro | |
| // | |
| // Autor(a) : Brantes | |
| // Data atual : 01/05/2023 | |
| Var | |
| G, R: caractere | |
| Cab, I, H, M: inteiro | |
| Bo, C_Cas, C_Rui, C_Loi, C_Pre: logico | |
| Inicio | |
| Escreval("=======================================") | |
| Escreval(" ESCOLHENDO PESSOAS ") | |
| Escreval("=======================================") | |
| Repita | |
| Repita | |
| Bo <- falso | |
| Escreva("Qual o genero? [M/F] ") | |
| leia(G) | |
| Se (G = "M") ou (G = "m") entao | |
| senao | |
| Se (G = "F") ou (G = "f") entao | |
| senao | |
| Escreval("Error: Opção Invalida") | |
| Bo <- verdadeiro | |
| fimse | |
| fimse | |
| Ate (Bo = falso) | |
| Repita | |
| Bo <- falso | |
| Escreva("Qual é a idade? ") | |
| leia(I) | |
| Se (I < 100) e (I > 1) entao | |
| senao | |
| Escreval("Error: Idade Invalida") | |
| Bo <- verdadeiro | |
| fimse | |
| Ate (Bo = falso) | |
| Escreval("Qual a cor do cabelo?") | |
| Escreval("=======================================") | |
| Escreval("[1] Preto ") | |
| Escreval("[2] Loiro ") | |
| Escreval("[3] Castanho ") | |
| Escreval("[4] Ruivo ") | |
| Escreval("=======================================") | |
| leia(Cab) | |
| Escreval("=======================================") | |
| Escolha Cab | |
| Caso 1 | |
| C_Pre <- verdadeiro | |
| Caso 2 | |
| C_Loi <- verdadeiro | |
| Caso 3 | |
| C_Cas <- verdadeiro | |
| Caso 4 | |
| C_Rui <- verdadeiro | |
| Fimescolha | |
| Se (G = "M") ou (G = "m") e (I >= 18) e (C_Cas = verdadeiro) entao | |
| H <- H + 1 | |
| senao | |
| Se (G = "F") ou (G = "f") e (I >= 25) e (I <= 30) e (C_Loi = verdadeiro) entao | |
| M <- M + 1 | |
| fimse | |
| fimse | |
| C_Pre <- falso | |
| C_Loi <- falso | |
| C_Cas <- falso | |
| C_Rui <- falso | |
| Escreva("Voce quer repetir? [S/N] ") | |
| Leia(R) | |
| se (R = "S") ou (R = "s") entao | |
| Bo <- Falso | |
| senão | |
| Escreval("=======================================") | |
| Escreval("Total de Homens com mais de 18 anos") | |
| Escreval("e de Cabelo Castanho é", H) | |
| Escreval("=======================================") | |
| Escreval("Total de Mulheres com idade entre") | |
| Escreval("25 e 30 anos com cabelo Loiro é", M) | |
| Escreval("=======================================") | |
| Bo <- verdadeiro | |
| fimse | |
| Ate(Bo = verdadeiro) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "Exer1" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio 1 | |
| // Escreva um programa que mostre na tela a mensagem "Olá, Mundo!" | |
| // | |
| // Autor(a) : Brantes | |
| // Data atual : 03/02/2023 | |
| Var | |
| // Seção de Declarações das variaveis | |
| N: caractere | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Escreva("Ola, Mundo!") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "EXER2" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio 2 | |
| // Faça um programa que leia o nome de uma pessoa e mostre uma | |
| // mensagem de boasvindas para ela: | |
| // Ex: | |
| // João da Silva | |
| // Olá João da Silva, é um prazer te conhecer! | |
| // | |
| // Autor(a) : Brantes | |
| // Data atual : 03/02/2023 | |
| Var | |
| // Seção de Declarações das variaveis | |
| N: caractere //N - Nome | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Escreva("Qual é o seu nome? ") | |
| Leia(N) | |
| Escreva("Olá ", N, ", é um prazer te conhecer!") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "Exer3" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio 3 | |
| // Crie um programa que leia o nome e o salario de um funcionario, | |
| // mostrando no final uma mensagem. | |
| // Ex: | |
| // Nome do Funcionario: Maria do Carmo | |
| // Salario: 1850,45 | |
| // O funcionario Maria do Carmo tem um salário de R$1850,45 em Junho. | |
| // Autor(a) : Brantes | |
| // Data atual : 03/02/2023 | |
| Var | |
| // Seção de Declarações das variáveis | |
| N: caractere // N - Nome | |
| Sal: real // Sal - Salario | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Escreva("Nome do Funcionario: ") | |
| Leia(N) | |
| Escreva("Salario: ") | |
| Leia(Sal) | |
| Escreva("O funcionario ", N, " tem um salario de R$", Sal, " em Junho") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "exer4" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio 4 | |
| // Desenvolva um algoritmo que leia dois números inteiros | |
| // e mostre o somatório entre eles. | |
| // Ex: | |
| // Digite um valor: 8 | |
| // Digite outro valor: 5 | |
| // A soma entre 8 e 5 é igual a 13. | |
| // Autor(a) : Brantes | |
| // Data atual : 03/02/2023 | |
| Var | |
| // Seção de Declarações das variaveis | |
| N1, N2, S: inteiro // N1 e N2 - Primeiro e segundo valor, S - Soma | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Escreva("Digite o primeiro: ") | |
| Leia(N1) | |
| Escreva("Digite o segundo numero: ") | |
| Leia(N2) | |
| S <- N1 + N2 | |
| Escreva("A soma entre", N1, " e", N2, " é igual a:", S) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "exer5" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exrcicio 5 | |
| // Faça um programa que leia as duas notas de um | |
| // aluno em uma matéria e mostre | |
| // na tela a sua média na disciplina. | |
| // Ex: | |
| // Nota 1: 4.5 | |
| // Nota 2: 8.5 | |
| // A média entre 4.5 e 8.5 é igual a 6.5 | |
| // | |
| // Autor(a) : Brantes | |
| // Data atual : 03/02/2023 | |
| Var | |
| // Seção de Declarações das variáveis | |
| N1, N2, M: real // N1, N2 - Notas das Matérias 1 e 2 M - Média | |
| N: caractere //N - Nome aluno | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Escreva("Nome do Aluno: ") | |
| Leia(N) | |
| N1 <- 4.5 | |
| N2 <- 8.5 | |
| M <- (N1 + N2)/2 | |
| Escreval("sua nota em Portugues: ", N1) | |
| Escreval("sua nota em Matematica: ", N2) | |
| Escreval("Média final é:", M) | |
| Escreva("Parabens! ", N, ", voce passou!") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "exer6" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio 6 | |
| // Faça um programa que leia um número inteiro e | |
| // mostre o seu antecessor e seu sucessor. | |
| // Ex: | |
| // Digite um numero: 9 | |
| // O antecessor de 9 é 8 | |
| // O sucessor de 9 é 10 | |
| // | |
| // Autor(a) : Brantes | |
| // Data atual : 03/02/2023 | |
| Var | |
| // Seção de Declarações das variáveis | |
| N1, Na1, Ns1: inteiro // N1 - Numero, Na1 - Antessessor de N1, Ns1 - Sucessor de N1 | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Escreva("Digite um numero: ") | |
| Leia(N1) | |
| Na1 <- N1 - 1 | |
| Ns1 <- N1 + 1 | |
| Escreval("O antecessor de", N1, " é", Na1) | |
| Escreva("O sucessor de", N1, " é", Ns1) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "exer7" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio 7 | |
| // Crie um algoritmo que leia um número real e mostre na tela | |
| // o seu dobro e a sua terça parte. | |
| // Ex: | |
| // Digite um número: 3.5 | |
| // O dobro de 3.5 e 7.0 | |
| // A terça parte de 3.5 é 1.16666 | |
| // | |
| // Autor(a) : Brantes | |
| // Data atual : 03/02/2023 | |
| Var | |
| // Seção de Declarações das variáveis | |
| N1, Nd1, Nt1: real // N1 - numero, Nd1 - Dobro de N1, Nt1 - Terça parte de N1 | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Escreva("Digite um numero: ") | |
| Leia(N1) | |
| Nd1 <- N1*2 | |
| Nt1 <- N1/3 | |
| Escreval("O dobro de", N1, " é", Nd1) | |
| Escreva("A terça parte de", N1, " é", Nt1) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "Fatorial" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Criar uma calculadora de Fatorial | |
| // Autor(a) : Brantes | |
| // Data atual : 01/05/2023 | |
| Var | |
| C, F, N: inteiro | |
| //C: Contador, F: fatorial, N: numero | |
| R: caractere | |
| Inicio | |
| Repita | |
| Escreva("Digite um número: ") | |
| Leia(N) | |
| C <- N | |
| F <- 1 //Recebe 1 porque será usado para multiplicar | |
| Se (N > 10) entao //condição de erro | |
| Repita | |
| Escreval("Valor maximo é 10, para evitar sobrecarga") | |
| Escreva("Digite Novamente ") | |
| Leia(N) | |
| ate(N <= 10) | |
| senao | |
| Repita //fórmula do Fatorial | |
| F <- F * C | |
| C <- C - 1 | |
| ate (C < 1) | |
| fimse | |
| Escreval("O valor do fatorial de", N, " é de", F) | |
| Escreva("Quer continuar? [S/N][Sim/Não] ") | |
| Leia(R) | |
| Limpatela | |
| ate (R = "N") ou (R = "Nao") ou (R = "n") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "FatorialFuncao" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Fatorial com Função | |
| // Autor(a) : Brantes | |
| // Data atual : 15/05/2023 | |
| 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 | |
| Repita | |
| Escreva("Digite um número: ") | |
| Leia(N) | |
| Se (N > 10) entao | |
| Escreval("Erro: Proibido mais de 10") | |
| FimSe | |
| Ate (N <= 10) | |
| F <- Fatorial(N) | |
| Escreval("O valor de", N, "!(fatorial) é igual a", F) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "Fibonacci" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Sequencia de fibonacci | |
| // Autor(a) : Brantes | |
| // Data atual : 02/05/2023 | |
| Var | |
| F1, F2, Sf1, Sf2, C, R: Inteiro | |
| Inicio | |
| Repita | |
| Escreva("Digite quantas sequencias de Fibonacci quer: ") | |
| Leia(R) | |
| //Mensagem de Erro | |
| Se (R < 3) entao | |
| Escreval("Somente 3 ou mais") | |
| Escreva("Digite Novamente: ") | |
| Leia(R) | |
| Senao | |
| Se (R > 20) entao | |
| Escreval("Proibido mais de 20 para evitar sobrecarga") | |
| Escreva("Digite Novamente: ") | |
| Leia(R) | |
| Fimse | |
| fimse | |
| Ate (R >= 3) e (R <= 20) | |
| F2 <- 1 | |
| escreva(F1, F2) | |
| C <- 1 | |
| Sf1 <- F1 + F2 | |
| Escreva(Sf1) | |
| Sf2 <- Sf1 + F2 | |
| Escreva(Sf2) | |
| Repita | |
| Sf1 <- Sf2 + Sf1 | |
| Escreva(Sf1) | |
| Sf2 <- Sf2 + Sf1 | |
| Escreva(Sf2) | |
| C <- C + 1 | |
| ate (C > R) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "FibonacciProcedimento" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Sequencia de fibonacci | |
| // Autor(a) : Brantes | |
| // Data atual : 08/05/2023 | |
| Var | |
| F1, F2, Sf1, Sf2, C, R: Inteiro | |
| Procedimento Fibo(var A, B: Inteiro) | |
| Inicio | |
| A <- B + A | |
| Escreva(A) | |
| B <- B + A | |
| Escreva(B) | |
| Fimprocedimento | |
| Inicio | |
| Repita | |
| Escreva("Digite quantas sequencias de Fibonacci quer: ") | |
| Leia(R) | |
| //Mensagem de Erro | |
| Se (R < 3) entao | |
| Escreval("Somente 3 ou mais") | |
| Escreva("Digite Novamente: ") | |
| Leia(R) | |
| Senao | |
| Se (R > 20) entao | |
| Escreval("Proibido mais de 20 para evitar sobrecarga") | |
| Escreva("Digite Novamente: ") | |
| Leia(R) | |
| Fimse | |
| fimse | |
| Ate (R >= 3) e (R <= 20) | |
| F2 <- 1 | |
| escreva(F1, F2) | |
| C <- 1 | |
| Sf1 <- F1 + F2 | |
| Escreva(Sf1) | |
| Sf2 <- Sf1 + F2 | |
| Escreva(Sf2) | |
| Repita | |
| Fibo(Sf1, Sf2) | |
| C <- C + 1 | |
| ate (C > R) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "futCronograma" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Organizar Confrontos entre times de futebol | |
| // Autor(a) : Brantes | |
| // Data atual : 12/06/2023 | |
| Var | |
| time: vetor[1..4] de Caractere | |
| i, j: inteiro | |
| Inicio | |
| Escreval("--------------------") | |
| Escreval("TABELA DE FUTEBOL") | |
| Escreval("--------------------") | |
| Para i de 1 ate 4 faca | |
| Escreva("Digite o", i, "o Time: ") | |
| Leia(time[i]) | |
| Fimpara | |
| LimpaTela | |
| Escreval("--------------------------") | |
| Escreval("PARTIDAS PROGRAMADAS") | |
| Escreval("--------------------------") | |
| Para i de 1 ate 4 faca | |
| Para j de 1 ate 4 faca | |
| Se (i <> j) entao | |
| Escreval(time[i]:10, " [] x [] ", time[j]:10) | |
| FimSe | |
| FimPara | |
| FimPara | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "ImparOuParFuncao" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Impar ou Par com Funções | |
| // Autor(a) : Brantes | |
| // Data atual : 15/05/2023 | |
| Var | |
| N: inteiro | |
| R: caractere | |
| Funcao ParOuImpar(V: inteiro) :caractere | |
| inicio | |
| Se (V % 2 = 0) entao | |
| Retorne "PAR" | |
| Senao | |
| Retorne "IMPAR" | |
| Fimse | |
| Fimfuncao | |
| Inicio | |
| Escreval("-------------------------------") | |
| Escreval(" IMPAR OU PAR ") | |
| Escreval("-------------------------------") | |
| Escreva("digite um número: ") | |
| Leia(N) | |
| R <- ParOuImpar(N) | |
| Escreval("O número", N, " é ", R, "!") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "lerMatriz" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Ler a Matriz | |
| // Autor(a) : Brantes | |
| // Data atual : 14/06/2023 | |
| Var | |
| mat: vetor[1..3, 1..2] de inteiro | |
| l, c: inteiro | |
| Inicio | |
| para l de 1 ate 3 faca | |
| para c de 1 ate 2 faca | |
| Escreva("Digite o valor da posição [", l, ",", c, " ]: ") | |
| Leia(mat[l,c]) | |
| fimpara | |
| fimpara | |
| para l de 1 ate 3 faca | |
| para c de 1 ate 2 faca | |
| Escreva(mat[l,c]:4) | |
| fimpara | |
| Escreval() | |
| fimpara | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "matrizIdentidade" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Identifica Matriz Identidade | |
| // Autor(a) : Brantes | |
| // Data atual : 14/06/2023 | |
| Var | |
| matID: vetor[1..3, 1..3] de inteiro | |
| i, j: inteiro | |
| Inicio | |
| Para i de 1 ate 3 faca | |
| Para j de 1 ate 3 faca | |
| Se (i=j) entao | |
| matID[i,j] <- 1 | |
| Senao | |
| matID[i,j] <- 0 | |
| FimSe | |
| FimPara | |
| FimPara | |
| Para i de 1 ate 3 faca | |
| Para j de 1 ate 3 faca | |
| Escreva(matID[i,j]:3) | |
| FimPara | |
| Escreval() | |
| FimPara | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "matrizPar" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exibir valores Par em uma Matriz | |
| // Autor(a) : Brantes | |
| // Data atual : 14/06/2023 | |
| Var | |
| valores: vetor[1..3, 1..3] de inteiro | |
| l, c, P: inteiro | |
| Inicio | |
| para l de 1 ate 3 faca | |
| para c de 1 ate 3 faca | |
| Escreva("Digite o valor da posição [", l, ",", c, " ]: ") | |
| Leia(valores[l,c]) | |
| fimpara | |
| fimpara | |
| Escreval() | |
| Escreval("MATRIZ PAR ([ ]):") | |
| Escreval("---------------------------------------------") | |
| para l de 1 ate 3 faca | |
| para c de 1 ate 3 faca | |
| Se (valores[l,c] % 2 = 0) entao | |
| Escreva("[", valores[l,c]:4, "]") | |
| P <- P + 1 | |
| Senao | |
| Escreva(valores[l,c]:5) | |
| Fimse | |
| fimpara | |
| Escreval() | |
| fimpara | |
| Escreval("O Total de matrizes Par, é:", P) | |
| Escreval("---------------------------------------------") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "mediaTurma" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Listar nomes dos Alunos e exibir a média | |
| // Autor(a) : Brantes | |
| // Data atual : 12/06/2023 | |
| Var | |
| nome: vetor[1..4] de Caractere | |
| n1, n2, m: vetor[1..4] de Real | |
| mm: Real | |
| top: Caractere | |
| i: inteiro | |
| Inicio | |
| Escreval("--------------------------") | |
| Escreval(" TURMA 211 - NOTAS ") | |
| Escreval("--------------------------") | |
| Para i de 1 ate 4 faca | |
| Escreva("Digite o nome do aluno: ") | |
| Leia(nome[i]) | |
| Escreva("Digite a primeira nota: ") | |
| Leia(n1[i]) | |
| Escreva("Digite a segunda nota: ") | |
| Leia(n2[i]) | |
| Escreval("------------------------") | |
| m[i] <- n1[i]+n2[i]/2 //Média | |
| Se (m[i] > mm) entao | |
| mm <- m[i] //melhor média | |
| top <- nome[i] //melhor aluno | |
| FimSe | |
| FimPara | |
| Escreval(" Média de todos os Alunos ") | |
| Para i de 1 ate 4 faca | |
| Escreval("ALUNO:", maiusc(nome[i])) | |
| Escreval("Média:", m[i]:15:1) | |
| Escreval("-------------------------") | |
| FimPara | |
| Escreval("Melhor aluno: ", maiusc(top), " com a melhor média de: ", mm:3:1) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "melhorALUNO2" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio 2 Aula 09 | |
| // Autor(a) : Brantes | |
| // Data atual : 01/05/2023 | |
| Var | |
| Alu, Me_alu: caractere //Alu: Nome dos Alunos, Me_alu: Melhor Aluno | |
| contador, Nu_alu: inteiro //Nu_alu: Numero de alunos | |
| MaN, Nota: real | |
| Inicio | |
| contador <- 1 | |
| Escreval("---------------------------------") | |
| Escreval(" ESCOLA MUNICIPAL ") | |
| Escreval("---------------------------------") | |
| // | |
| Escreva("Quantos alunos? ") | |
| leia(Nu_alu) | |
| enquanto (contador <= Nu_alu) faca | |
| Escreva("Nome do Aluno: ") | |
| leia(Alu) | |
| Escreva("Nota de ", Alu, ": ") | |
| leia(Nota) | |
| Escreval("---------------------------------") | |
| se (Nota > MaN) entao | |
| MaN <- Nota | |
| Me_alu <- Alu | |
| fimse | |
| contador <- contador + 1 | |
| fimenquanto | |
| Escreval("---------------------------------") | |
| Escreval("O melhor Aluno foi ", Me_alu) | |
| Escreval("com a maior nota: ", MaN:3:1) | |
| Escreval("---------------------------------") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "MeuNome" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Aqui voce descreve o que o programa faz! (função) | |
| // Autor(a) : Brantes | |
| // Data atual : 03/02/2023 | |
| Var | |
| // Seção de Declaraçães das variáveis | |
| Nome: caractere | |
| Inicio | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| Escreva("Digite seu nome: ") | |
| Leia(Nome) | |
| Escreval("Olá,", Nome) | |
| Escreval("Seja bem vindo!") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "notasProva" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Cadastra o gabarito e no final exibir a nota dos alunos | |
| // Autor(a) : Brantes | |
| // Data atual : 12/06/2023 | |
| Var | |
| gab, rp, aluno: vetor[1..5] de caractere | |
| nal: vetor[1..5] de real | |
| i, j: inteiro | |
| mt: real | |
| Inicio | |
| Escreval("-------------------------") | |
| Escreval(" Cadastre o GABARITO:") | |
| Escreval("-------------------------") | |
| Para i de 1 ate 5 faca | |
| Escreva("Questão", i, ": ") | |
| Leia(gab[i]) | |
| gab[i] <- Maiusc(Copia(gab[i], 1, 1)) | |
| Enquanto (gab[i] = "") faca | |
| Escreva("Nota Invalida, digite novamente: ") | |
| Leia(gab[i]) | |
| gab[i] <- Maiusc(Copia(gab[i], 1, 1)) | |
| Fimenquanto | |
| FimPara | |
| LimpaTela | |
| Para i de 1 ate 5 faca | |
| Escreval("-----------------------") | |
| Escreval(" ALUNO", i) | |
| Escreval("-----------------------") | |
| Escreva("Nome: ") | |
| Leia(aluno[i]) | |
| Para j de 1 ate 5 faca | |
| Escreva("Resposta Questão", j, ": ") | |
| Leia(rp[j]) | |
| rp[j] <- Maiusc(Copia(rp[j], 1, 1)) | |
| Se (rp[j] = gab[j]) entao | |
| nal[i] <- nal[i] + 2.0 | |
| mt <- mt + nal[i] | |
| Fimse | |
| FimPara | |
| FimPara | |
| mt <- mt/5 | |
| Para i de 1 ate 5 faca | |
| Escreval("-----------------------") | |
| Escreval(" ALUNO", i) | |
| Para j de i ate i faca | |
| Escreval(aluno[i]:9, "Nota: ", nal[i]:4:1) | |
| FimPara | |
| FimPara | |
| Escreval("-----------------------") | |
| Escreval("Média da Turma: ", mt:4:1) | |
| Escreval("-----------------------") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "numeroPrimo" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Dizer se o número é Primo | |
| // Autor(a) : Brantes | |
| // Data atual : 01/05/2023 | |
| Var | |
| C, N, D: inteiro | |
| //C: contador, N: Numero, D: Contador da Divisão | |
| Inicio | |
| escreval("-------------------------------------") | |
| escreval(" NUMEROS PRIMOS ") | |
| escreval("-------------------------------------") | |
| C <- 1 | |
| escreva("Digite um numero: ") | |
| leia(N) | |
| escreval("-------------------------------------") | |
| Repita | |
| //Se o resto da diferença da Divisão for 0 retorna 1 em D | |
| Se (N % C = 0) entao | |
| D <- D + 1 | |
| Fimse | |
| C <- C + 1 | |
| Ate(C > N) | |
| Se (D > 2) ou (N <= 1) entao | |
| Escreval("O número", N, " não é primo") | |
| senao | |
| Escreval("O número", N, " é primo") | |
| fimse | |
| escreval("-------------------------------------") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "ordenarVetor" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Ordenação de Vetores | |
| // Autor(a) : Brantes | |
| // Data atual : 12/06/2023 | |
| Var | |
| vet: vetor[1..5] de inteiro | |
| i, j, aux: inteiro | |
| Inicio | |
| Escreva("Digite um numero: ") | |
| Leia(vet[1]) | |
| Para i de 2 ate 5 faca | |
| Escreva("Digite outro número: ") | |
| Leia(vet[i]) | |
| FimPara | |
| Para i de 1 ate 4 faca | |
| Para j de i+1 ate 5 faca | |
| Se (vet[i] > vet[j]) entao | |
| aux <- vet[j] | |
| vet[j] <- vet[i] //Com uma variavel auxiliar | |
| vet[i] <- aux //realiza a troca | |
| Fimse | |
| FimPara | |
| FimPara | |
| Para i de 1 ate 5 faca | |
| Escreva("(", vet[i], " )") | |
| FimPara | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "primeiraLetra" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Somente nomes com a primeira Letra Desejada | |
| // Autor(a) : Brantes | |
| // Data atual : 12/06/2023 | |
| Var | |
| nome, pl: caractere | |
| i, tn: inteiro | |
| npl: vetor[1..10] de Caractere | |
| Inicio | |
| Escreva("Exibir apenas nomes com a inicial: ") | |
| Leia(pl) | |
| pl <- Copia(Maiusc(pl), 1, 1) | |
| Para i de 1 ate 10 faca | |
| Escreval("Digite o nome: ") | |
| Leia(nome) | |
| Se (Maiusc(copia(nome, 1, 1)) = pl) entao | |
| tn <- tn + 1 | |
| npl[tn] <- Maiusc(nome) | |
| Fimse | |
| FimPara | |
| Escreval("APENAS NOMES COM ", pl) | |
| Escreval("-----------------------") | |
| Para i de 1 ate tn faca | |
| Escreval(npl[i]) | |
| FimPara | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| algoritmo "primeiro" | |
| var | |
| msg: caractere | |
| inicio | |
| msg <- "Ola, Mundo!" | |
| Escreval(msg) | |
| fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "qualseunome" | |
| Var | |
| I: inteiro | |
| N: caractere | |
| Inicio | |
| Escreva("Qual é o seu nome? ") | |
| Leia(N) | |
| Escreval("Ola ", N, " que nome bonito!") | |
| Escreva("Quantos anos voce tem? ") | |
| Leia(I) | |
| Escreval("aah ", I, " anos de idade") | |
| Escreval("eu me chamo Pedro, tenho 19 anos") | |
| Escreva("prazer em te conhecer") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "reservarCinema" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Reservar Cadeiras em uma Fileira de Cinema | |
| // Autor(a) : Brantes | |
| // Data atual : 12/06/2023 | |
| Var | |
| B: vetor[1..10] de Caractere | |
| cad: Inteiro | |
| res: Caractere | |
| Procedimento FB() | |
| 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 | |
| FB() | |
| Repita | |
| Escreva("Reservar a cadeira: B") | |
| Leia(cad) | |
| Se (cad > 10) ou (cad < 1) entao | |
| LimpaTela | |
| Escreval("Cadeira Invalida!") | |
| FB() | |
| Fimse | |
| Ate (cad <= 10) e (cad > 0) | |
| Se (B[cad] = "") entao | |
| B[cad] <- "Reservada" | |
| EscrevaL("Cadeira B", cad, " RESERVADA!") | |
| Senao | |
| EscrevaL("ERRO: Lugar Ocupado!") | |
| FimSe | |
| Escreva("Quer reservar outro? [S/N] ") | |
| Leia(res) | |
| Ate (res = "N") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "SomaFuncao" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Soma Simples com Função | |
| // Autor(a) : Brantes | |
| // Data atual : 15/05/2023 | |
| Var | |
| V1, V2, S: inteiro | |
| Funcao Soma(X, Y: Inteiro): inteiro | |
| Inicio | |
| Retorne X + Y | |
| Fimfuncao | |
| Inicio | |
| Escreva("digite um número: ") | |
| Leia(V1) | |
| Escreva("digite o segundo número: ") | |
| Leia(V2) | |
| S <- Soma(V1, V2) | |
| Escreval("A soma entre", V1, " e",V2, " é igual a", S) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "SomaParametrosReferencia" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : procedimento | |
| // Autor(a) : Brantes | |
| // Data atual : 08/05/2023 | |
| Var | |
| X, Y: Inteiro | |
| Procedimento Soma (var A, B: Inteiro) //sem "var": Passagem por valor (Apenas copia o valor) | |
| //com "var": A passagem por referencia | |
| //o parametro tem uma referencia automatica ao | |
| //valor da variavel original, qualquer alteração | |
| //vai afetar o valor da variavel de origem. | |
| 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 | |
| // Seção de Comandos, procedimento, funções, operadores, etc... | |
| X <- 4 | |
| Y <- 8 | |
| Soma (X, Y) | |
| Escreval("Valor de X = ", X) | |
| Escreval("Valor de Y = ", Y) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "Supercontador" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio da Aula 10 "Super Contador" | |
| // Autor(a) : Brantes | |
| // Data atual : 01/05/2023 | |
| Var | |
| N, C: inteiro | |
| R: caractere | |
| NR: logico | |
| Inicio | |
| Escreval("==================") | |
| Escreval("| MENU |") | |
| Escreval("==================") | |
| Escreval("|[1] De 1 a 10 |") | |
| Escreval("|[2] De 10 a 1 |") | |
| Escreval("|[3] Sair |") | |
| Escreval("==================") | |
| Repita | |
| Escreva("Digite um número ") | |
| leia(N) | |
| Escolha N | |
| Caso 1 | |
| C <- 1 | |
| repita | |
| Escreva(C, "..") | |
| C <- C + 1 | |
| ate(C > 10) | |
| Caso 2 | |
| C <- 10 | |
| repita | |
| Escreva(C, "..") | |
| C <- C - 1 | |
| ate(C < 1) | |
| outrocaso | |
| Se (N > 3) entao | |
| Escreval("Error: opção invalida!") | |
| senao | |
| fimalgoritmo | |
| fimse | |
| Fimescolha | |
| Escreval() | |
| Escreva("Voce quer repetir? [S/N] ") | |
| Leia(R) | |
| se (R = "S") ou (R = "s") entao | |
| NR <- Falso | |
| senão | |
| Fimalgoritmo | |
| fimse | |
| ate (NR = verdadeiro) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "Tabuada" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Tabuada com Repita ate | |
| // Autor(a) : Brantes | |
| // Data atual : 01/05/2023 | |
| Var | |
| Cont, N, X, P: inteiro | |
| //N: Numero da Tabuada, X: Multiplicador, P: Produto | |
| Inicio | |
| Escreval("---------------------------------------") | |
| Escreval(" TABUADA ") | |
| Escreval("---------------------------------------") | |
| Cont <- 1 | |
| Escreva("Você quer a Tabuada de qual número? ") | |
| Leia(N) | |
| //Mensagem de erro e repetição caso "N" seja maior que 10 | |
| Se (N > 10) entao | |
| repita | |
| Escreval("Error: somente até 10") | |
| Escreva("Você quer a Tubuada de qual número? ") | |
| leia(N) | |
| ate (N <= 10) | |
| fimse | |
| Escreval("---------------------------------------") | |
| X <- 1 | |
| repita | |
| P <- N * X | |
| Escreval(N, " x", X, " =", P) | |
| Cont <- Cont + 1 | |
| X <- X + 1 | |
| ate (Cont > 10) | |
| Escreval("---------------------------------------") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "TimesBR" | |
| // Autor(a) : Brantes | |
| // Data atual : 29/04/2023 | |
| // Descrição: Seleção de Times de Futebol Brasileirão Série A 2023 | |
| Var | |
| team: inteiro | |
| Inicio | |
| Escreval("------------------------------------------------------") | |
| Escreval(" SOMENTE TIMES DO ") | |
| Escreval(" BRASILEIRÂO 2023 ") | |
| Escreval(" SÉRIE A ") | |
| Escreval("------------------------------------------------------") | |
| escreval("[1]Flamengo [2]Palmeiras [3]Fluminense") | |
| Escreval("[4]São Paulo [5]Corinthians [6]Atrético-MG") | |
| Escreval("[7]Vasco [8]Atrético-PR [9]Fortaleza") | |
| Escreval("[10]Bragantino [11]Internacional [12]Grêmio") | |
| Escreval("[13]Botafogo [14]Goiás [15]Cruzeiro") | |
| Escreval("[16]Coritiba [17]Cuiabá [18]Santos") | |
| Escreval("[19]Bahia [20]América-MG") | |
| Escreva("Selecione o seu Time: ") | |
| Leia(team) | |
| Escreval("------------------------------------------------------") | |
| Escreval() | |
| Escolha team | |
| Caso 1 | |
| Escreval("Flamengo") | |
| Escreval("O Flamengo é um dos clubes mais") | |
| Escreval("bem-sucedidos do Brasil e tem muitos títulos oficiais.") | |
| Escreval() | |
| Escreval("Alguns dos títulos nacionais incluem") | |
| Escreval("- 8 Campeonatos Brasileiros") | |
| Escreval("(1980, 1982, 1983, 1987, 1992, 2009, 2019 e 2020)") | |
| Escreval("- 4 Copas do Brasil (1990, 2006, 2013 e 2022)") | |
| Escreval("- 2 Supercopas do Brasil (2020 e 2021)") | |
| Escreval() | |
| Escreval("Alguns dos títulos internacionais incluem") | |
| Escreval("- Copa Intercontinental (1981)") | |
| Escreval("- Taça Libertadores da América (1981, 2019 e 2022)") | |
| Escreval("- Copa Mercosul (1999)") | |
| Escreval("- Copa de Ouro Nicolás Leoz (1996)") | |
| Escreval("- Recopa Sul-Americana (2020)") | |
| Caso 2 | |
| Escreval("Palmeiras") | |
| Caso 3 | |
| Escreval("Fluminense") | |
| Caso 4 | |
| Escreval("São Paulo") | |
| Caso 5 | |
| Escreval("Corinthians") | |
| Caso 6 | |
| Escreval("Atrético-MG") | |
| Caso 7 | |
| Escreval("Vasco") | |
| Caso 8 | |
| Escreval("Atrético-PR") | |
| Caso 9 | |
| Escreval("Fortaleza") | |
| Escreval("Titulos OFICIAIS") | |
| Escreval() | |
| Escreval("Liga Metropolitana de Fortaleza: 1919 (primeiro torneio),") | |
| Escreval("Taça 15 de Novembro: 1931,") | |
| Escreval("Torneio Quadrangular Silvio Pacheco: 1957,") | |
| Escreval("Copa Cearense Master: 2016") | |
| Escreval("Copa Cearense de Futebol Cinquentão Masters 50: 2017.") | |
| Escreval("Além disso, o Fortaleza foi destaque no G-10 do Brasileirão") | |
| Escreval("de pontos corridos por três vezes (2019, 2021 e 2022") | |
| Caso 10 | |
| Escreval("Bragantino") | |
| Caso 11 | |
| Escreval("Internacional") | |
| Caso 12 | |
| Escreval("Grêmio") | |
| Caso 13 | |
| Escreval("Botafogo") | |
| Caso 14 | |
| Escreval("Goias") | |
| Caso 15 | |
| Escreval("Cruzeiro") | |
| Caso 16 | |
| Escreval("Coritiba") | |
| Caso 17 | |
| Escreval("Cuiabá") | |
| Caso 18 | |
| Escreval("Santos") | |
| Caso 19 | |
| Escreval("Bahia") | |
| Caso 20 | |
| Escreval("América-MG") | |
| FimEscolha | |
| Escreval() | |
| Escreval("Fonte: Wikipédia") | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "triangulos" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Exercicio Operadores Lógicos e Relacionais | |
| // Autor(a) : Brantes | |
| // Data atual : 14/04/2023 | |
| Var | |
| // Sessão de Declarações das variaveis | |
| L1, L2, L3: Real // L1, L2 e L3 - Lados do Triangulo | |
| EQ, ES, TRI: Logico // EQ - Equilatero, ES - Escaleno , TRI - Triangulo | |
| Inicio | |
| // Sessão de Comandos, procedimento, funções, operadores, etc... | |
| Escreva("Digite o primeiro lado: ") | |
| Leia(L1) | |
| Escreva("Digite o segundo lado: ") | |
| Leia(L2) | |
| Escreva("Digite o terceiro lado: ") | |
| Leia(L3) | |
| TRI <- (L1 < L2 + L3) e (L2 < L1 + L3) e (L3 < L1 + L2) | |
| EQ <- (L1 = l2) e (L2 = L3) | |
| ES <- (L1 <> L2) e (L2 <> L3) e (L1 <> L3) | |
| Escreval("Pode ser um TRIANGULO?: ", TRI) | |
| Escreval("O triangulo é EQUILATERO?: ", EQ) | |
| Escreval("O triangulo é ESCALENO?: ", ES) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "valores" | |
| Var | |
| N1, N2, S: Inteiro | |
| Inicio | |
| Escreva("Digite um numero: ") | |
| Leia(N1) | |
| Escreva("Digigte outro numero: ") | |
| Leia(N2) | |
| S <- N1 + N2 | |
| Escreva("o resultado da soma entre", N1, " e", N2, " e:", S) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "valoresMatriz" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Ler e realizar operações em Matrizes | |
| // Autor(a) : Brantes | |
| // Data atual : 22/06/2023 | |
| Var | |
| m: vetor[1..4, 1..4] de inteiro | |
| l, c, sDP, p2l, m3c: inteiro | |
| Inicio | |
| Para l de 1 ate 4 faca | |
| Para c de 1 ate 4 faca | |
| Escreva("Digite o valor da posição [", l, ",", c, "]: ") | |
| leia(m[l,c]) | |
| Se (l = c) entao | |
| sDP <- sDP + m[l,c] | |
| Fimse | |
| Fimpara | |
| Fimpara | |
| p2l <- 1 | |
| Para c de 1 ate 4 faca | |
| p2l <- p2l * m[2,c] | |
| FimPara | |
| para l de 1 ate 4 faca | |
| Se (m3c < m[l, 3]) entao | |
| m3c <- m[l, 3]) | |
| Fimse | |
| Fimpara | |
| Para l de 1 ate 4 faca | |
| Para c de 1 ate 4 faca | |
| Escreva(m[l,c]:4) | |
| Fimpara | |
| Escreval() | |
| Fimpara | |
| Escreval("A soma da Diagonal Principal é: ", sDP) | |
| Escreval("O produto da Segunda Linha é: ", p2l) | |
| Escreval("O maior valor da 3o Coluna é: ", m3c) | |
| Fimalgoritmo |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Algoritmo "ValParesEImpares" | |
| // Disciplina : [Linguagem e Lógica de Programação] | |
| // Professor : Gustavo Guanabara | |
| // Descrição : Valores Pares e Impares com Vetores | |
| // Autor(a) : Brantes | |
| // Data atual : 09/06/2023 | |
| Var | |
| val: vetor[1..7] de Inteiro | |
| IP: vetor[1..7] de caractere | |
| i, par, imp: inteiro | |
| Inicio | |
| Para i de 1 ate 7 faca | |
| Escreva("Digite um número: ") | |
| Leia(val[i]) | |
| Se (val[i]%2=0) entao | |
| IP[i] <- "PAR" | |
| par <- par + 1 | |
| Senao | |
| IP[i] <- "IMPAR" | |
| imp <- imp + 1 | |
| FimSe | |
| FimPara | |
| Para i de 1 ate 7 faca | |
| Escreval(val[i], " é ", IP[i]) | |
| Fimpara | |
| Escreval("TOTAL DE NÚMEROS:", imp + par) | |
| Escreval("Foram", par, " números Pares") | |
| Escreval("e", imp, " números Impares") | |
| Fimalgoritmo |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment