Vinícius V.

Olá, estava lendo sobre conversões do tipo widening e sobre a opção Option Strict On no site da Microsoft na linguagem VB.NET e não entendi na parte que fala de conversão de Integer para Single .. Mas, de acordo com este artigo que fala sobre tipos de dados, Inteiros podem armazenar de -2.147.483.648 até 2.147.483.647 Single de 1,401298E-45 até 3,4028235E+38 para números positivos e de -3,4028235E + 38 até - 1,401298E-45 para números negativos então Single podem armazenar muito mais números do que Integer. Assim, alguém poderia me explicar o que seria essa perda de precisão e em qual caso a perda de precisão de Integer para Single aconteceria? Obrigado desde já

Oi pessoal, sou novo aqui no fórum. Gostei bastante da sintaxe do VB.Net, e gostaria de saber se vale a pena estudá-la em 2019. Pretendo criar aplicativos desktop e para Android e trabalhar em uma compania, e também trabalhar como freelance por conta própria. Obrigado a todos.

Olá pessoal, poderiam me dar algumas dicas? Eu gostei da sintaxe do Delphi e da simplicidade para criar aplicações com interface gráfica, mas ainda vale a pena aprender Delphi. Há mercado? Tenho vontade de trabalhar com aplicações Desktop para Windows. Agradeço desde já

... nome do arquivo? Olá, eu quero criar um comando executável para gerar um arquivo. Por exemplo, se eu tiver o arquivo teste.exe. Quando eu clicar nele, vai rodar o seguinte comando no cmd: pyuic5.exe -x teste.ui -o teste.py Ou seja, quero usar o nome do arquivo, no caso teste, como próprio argumento do comando. Alguém poderia me ajudar com isso. Agradeço muito! Abraços.

Oi, fiz as correções. Não tinha percebido. Também coloquei a descrição do programa e resumi mais para não repetir comandos. Também coloquei dica de palavra para facilitar rs Algoritmo "Jogo da Forca" // Descrição : Jogo da Forca. // Para mostrar a parte oculta, o programa usa um vetor parteDescoberta, [i] que recebe underline // ("_") no início da execução. // // Também usa uma matriz palavraDisponivel[x,y] que contém as palavras // aleatórias. A variável x informa o tipo da palavra, e y é a identi- // -ficação da palavra. // // Ex.: palavraDisponivel[1,1] = gato (x = 1 (de animal)) // palavraDisponivel[2,1] = sandália (x = 2 (de roupa)) // // Vai sortear uma das palavras de palavraDisponivel[x,y] e armaze- // -nar no string palavraAleatoria. // // Depois disso vai desenhar a forca, a dica do tipo da palavra // , o vetor parteDescoberta[i] e vai pedir uma letra. Se acertar, // o vetor "parteDescoberta[i] recebe a letra na posição certa. // Se errar, a variável "quadro" recebe a letra errada. // // Vai limpar a tela e desenhar a forca, parte descoberta, o quadro // e a dica. Irá pedir outra letra. O procedimento vai se repetir // até o boneco estiver completo (n_Tentativas_Erradas = 7) ou // quando "parteDescoberta" estiver completo, ou seja, quando // quando não houver mais underlines no vetor. (n_Tracinhos = 0) // // Autor(a) : Vinícius Viana Werneck procedimento pulaLinha(linha:inteiro) var i: inteiro inicio Para i de 1 ate linha faca EscrevaL() FimPara fimprocedimento procedimento sortear(var palavraAleatoria: caractere; var Dicax: inteiro) var palavraDisponivel: vetor[0..2,0..4] de caractere palavra:inteiro inicio palavraDisponivel[0,0] <- "gato" palavraDisponivel[0,1] <- "cachorro" palavraDisponivel[0,2] <- "papagaio" palavraDisponivel[0,3] <- "tartaruga" palavraDisponivel[0,4] <- "rato" palavraDisponivel[1,0] <- "sandalia" palavraDisponivel[1,1] <- "sapato" palavraDisponivel[1,2] <- "camisa" palavraDisponivel[1,3] <- "bermuda" palavraDisponivel[1,4] <- "calca" palavraDisponivel[2,0] <- "Estados Unidos" palavraDisponivel[2,1] <- "Brasil" palavraDisponivel[2,2] <- "Angola" palavraDisponivel[2,3] <- "Mocambique" palavraDisponivel[2,4] <- "Inglaterra" palavra <- Randi(4) Dicax <- Randi(2) palavraAleatoria <- palavraDisponivel[Dicax,palavra] fimprocedimento procedimento desenhaForca() inicio EscrevaL("---+") EscrevaL(" |") EscrevaL(" |") fimprocedimento procedimento desenhaBoneco(n_erros: inteiro) var contador: inteiro inicio Escolha n_erros Caso 1 EscrevaL(" o ") Caso 2 EscrevaL(" o ") EscrevaL(" / ") Caso 3 EscrevaL(" o ") EscrevaL(" /| ") Caso 4 EscrevaL(" o ") EscrevaL(" /|\ ") Caso 5 EscrevaL(" o ") EscrevaL(" /|\ ") EscrevaL(" | ") Caso 6 EscrevaL(" o ") EscrevaL(" /|\ ") EscrevaL(" | ") EscrevaL(" / ") Caso 7 EscrevaL(" o ") EscrevaL(" /|\ ") EscrevaL(" | ") EscrevaL(" / \ ") FimEscolha //Deixando sempre o mesmo espaçamento entre a forca e os tracinhos: Escolha n_erros Caso 1 pulaLinha(6) Caso 2,3,4 pulaLinha(5) Caso 5 pulaLinha(4) Caso 6 , 7 pulaLinha(3) OutroCaso pulaLinha(7) FimEscolha fimprocedimento procedimento MostrarDica(dica:inteiro) inicio Escolha dica Caso 0 EscrevaL(" Dica: Animal") Caso 1 EscrevaL(" Dica: Roupa") Caso 2 EscrevaL(" Dica: País") FimEscolha fimprocedimento procedimento Pedir(var Letra: caractere) inicio EscrevaL(" Chute uma letra: ") Leia(Letra) fimprocedimento funcao ehCaracterValido(Letra: caractere): logico var Resultado: logico TamLetra: inteiro inicio TamLetra <- Compr(Letra) Se (maiusc(Letra) >= "A") e (maiusc(Letra) <= "Z") e (TamLetra = 1) então Resultado <- verdadeiro Senao Resultado <- falso Fimse Retorne Resultado fimfuncao procedimento msg(mensg: caractere ; atraso: inteiro) inicio EscrevaL(mensg) timer atraso timer 0 fimprocedimento funcao jafoiDita(Letra:caractere):logico var Resultado: logico contador: inteiro Inicio Resultado <- falso Para contador de 1 ate compr(LetrasJaDitas) faca Se (Letra = Copia(LetrasJaDitas,contador,1)) então Resultado <- verdadeiro Fimse Fimpara Se (Resultado = falso) então LetrasJaDitas <- LetrasJaDitas + Letra Fimse Retorne Resultado fimfuncao funcao verificao_deAcerto(Letra:caractere):logico var i: inteiro Resultado : logico CaracterePosicaoI: caractere inicio Resultado <- falso Para i de 1 ate compr(palavraAleatoria) faca CaracterePosicaoI <- Copia(palavraAleatoria,i,1) Se (Letra = CaracterePosicaoI) então ParteDescoberta[i] <- CaracterePosicaoI n_Tracinhos <- n_Tracinhos - 1 Resultado <- verdadeiro Fimse FimPara Retorne Resultado fimfuncao procedimento EscreverParteQueJaSabe() var cont: inteiro inicio Escreva(" ") Para cont de 1 ate TamMaiorPalavra faca Escreva(parteDescoberta[cont], " ") Fimpara EscrevaL() fimprocedimento procedimento Desenhae_Escreve(quadrox,letra: caractere) inicio Se (quadrox <> "") então EscrevaL(" +-------+") EscrevaL(" |",quadrox:7,"|") EscrevaL(" +-------+") EscrevaL() Fimse fimprocedimento const TamMaiorPalavra = 14 Var // Seção de Declarações das variáveis palavraAleatoria: caractere quadro: caractere ParteDescoberta: vetor[1..TamMaiorPalavra] de caractere contador: inteiro Letra: caractere LetrasJaDitas: caractere esperarTempo: inteiro tipo_dePalavra: inteiro n_Tracinhos: inteiro n_Tentativas_Erradas: inteiro Inicio sortear(palavraAleatoria, tipo_dePalavra) //Atribui valores à parteDescoberta[i] e escrever: Para contador de 1 ate compr(palavraAleatoria) faca ParteDescoberta[contador] <- "__" FimPara n_Tracinhos <- compr(palavraAleatoria) n_Tentativas_Erradas <- 0 esperarTempo <- 750 Repita EscrevaL("+----------------+") Escreval("| JOGO DA FORCA! |") EscrevaL("+----------------+") DesenhaForca() DesenhaBoneco(n_Tentativas_Erradas) Se (quadro <> "") então Desenhae_Escreve(quadro,letra) Fimse EscreverParteQueJaSabe() //Escreve vetor ParteDescoberta[i] pulaLinha(2) MostrarDica(tipo_dePalavra) Pedir(Letra) Escolha ehCaracterValido(Letra) Caso verdadeiro Se (jafoiDita(Letra)) então msg("Letra já foi dita!",esperarTempo) Senao Escolha verificao_deAcerto(Letra)) Caso verdadeiro msg("Acertou!",esperarTempo) Caso falso msg("'Errooou'",esperarTempo) n_Tentativas_Erradas <- n_Tentativas_Erradas + 1 quadro <- quadro + Letra FimEscolha Fimse Caso falso msg("Entrada Inválida! Não pode ter espaços nem símbolos.",2000) FimEscolha Limpatela Ate (n_Tracinhos = 0) ou (n_Tentativas_Erradas = 7) DesenhaForca() DesenhaBoneco(n_Tentativas_Erradas) Desenhae_Escreve(quadro,letra) EscreverParteQueJaSabe() fimalgoritmo

Oi pessoal, fiz meu primeiro jogo, jogo da forca. Amei o resultado. Poderiam avaliar meu algoritmo :)? Algoritmo "Jogo da Forca" // Disciplina : [Linguagem e Lógica de Programação] // Professor : Antonio Carlos Nicolodi // Descrição : Jogo da Forca // Autor(a) : Vinícius Viana Werneck // Data atual : 30/01/2018 funcao Caract(palavra: caractere; posicao: inteiro): caractere var R : caractere inicio R <- copia(palavra, posicao,1) Retorne R fimfuncao procedimento sortear(var palavraAleatoria:caractere) var palavraDisponivel: vetor[0..15] de caractere ind: inteiro inicio palavraDisponivel[0] <- "reflexao" palavraDisponivel[1] <- "interrupcao" palavraDisponivel[2] <- "necessarios" palavraDisponivel[3] <- "ambulantes" palavraDisponivel[4] <- "humanidade" palavraDisponivel[5] <- "juventude" palavraDisponivel[6] <- "shopping" palavraDisponivel[7] <- "supermercado" palavraDisponivel[8] <- "proporcionar" palavraDisponivel[9] <- "sensatez" palavraDisponivel[10] <- "incidente" palavraDisponivel[11] <- "administracao" palavraDisponivel[12] <- "paralelepipedo" palavraDisponivel[13] <- "abacaxizeiro" palavraDisponivel[14] <- "autocentrado" palavraDisponivel[15] <- "acidente" ind <- Randi(15) palavraAleatoria <- palavraDisponivel[6] fimprocedimento procedimento desenhaForca() inicio EscrevaL("---+") EscrevaL(" |") EscrevaL(" |") fimprocedimento procedimento desenhaBoneco(n_parteBoneco: inteiro) var contador: inteiro inicio Se (n_partesBoneco = 1) então EscrevaL(" o ") Fimse Se (n_partesBoneco = 2) então EscrevaL(" o ") EscrevaL(" / ") Fimse Se (n_partesBoneco = 3) então EscrevaL(" o ") EscrevaL(" /| ") Fimse Se (n_partesBoneco = 4) então EscrevaL(" o ") EscrevaL(" /|\ ") Fimse Se (n_partesBoneco = 5) então EscrevaL(" o ") EscrevaL(" /|\ ") EscrevaL(" | ") Fimse Se (n_partesBoneco = 6) então EscrevaL(" o ") EscrevaL(" /|\ ") EscrevaL(" | ") EscrevaL(" / ") Fimse Se (n_partesBoneco = 7) então EscrevaL(" o ") EscrevaL(" /|\ ") EscrevaL(" | ") EscrevaL(" / \ ") Fimse Para contador de n_partesBoneco ate 6 faca EscrevaL() Fimpara fimprocedimento procedimento Pedir(var Letra: caractere) inicio EscrevaL() EscrevaL("Chute uma letra: ") EscrevaL() Leia(Letra) fimprocedimento funcao ehRealmenteLetra(Letra: caractere): logico var Resultado: logico inicio Se (maiusc(Letra) >= "A") e (maiusc(Letra) <= "Z") então Resultado <- verdadeiro Senao Resultado <- falso Fimse Retorne Resultado fimfuncao funcao jafoiDita(Letra:caractere):logico var Resultado: logico contador: inteiro Inicio Resultado <- falso Para contador de 1 ate compr(LetrasJaDitas) faca Se (Caract(Letra,contador) = Caract(LetrasJaDitas,contador)) então Resultado <- verdadeiro Fimse Fimpara Se (Resultado = falso) então LetrasJaDitas <- LetrasJaDitas + Letra Fimse Retorne Resultado fimfuncao funcao acertou(Letra:caractere):logico var contador: inteiro Resultado : logico inicio contador <- 1 Resultado <- falso Para contador de 1 ate compr(palavraAleatoria) faca Se (Letra = Caract(palavraAleatoria,contador)) então ParteDescoberta[contador] <- Letra Resultado <- verdadeiro Fimse Fimpara Retorne Resultado fimfuncao procedimento EscreverVetor() var cont: inteiro inicio Escreva(" ") Para cont de 1 ate TamMaiorPalavra faca Escreva(parteDescoberta[cont], " ") Fimpara fimprocedimento procedimento Desenhae_Escreve(quadro,letra: caractere) inicio EscrevaL("+-------+") EscrevaL("|",quadro:7,"|") EscrevaL("+-------+") EscrevaL() fimprocedimento funcao revelouTudo():logico var i: inteiro letrasDescobertas: inteiro JogoFinalizou : logico inicio i<-1 letrasDescobertas <- 0 Para i de 1 ate compr(palavraAleatoria) faca Se (parteDescoberta[i] = copia(palavraAleatoria,i,1)) então letrasDescobertas <- letrasDescobertas + 1 Fimse FimPara Se (letrasDescobertas = compr(palavraAleatoria)) então JogoFinalizou <- verdadeiro Fimse Retorne JogoFinalizou fimfuncao const TamMaiorPalavra = 46 Var // Seção de Declarações das variáveis palavraAleatoria: caractere quadro: caractere n_partesBoneco: inteiro ParteDescoberta: vetor[1..TamMaiorPalavra] de caractere contador: inteiro Letra: caractere LetrasJaDitas: caractere Boneco_esta_Completo: logico Inicio // Seção de Comandos, procedimento, funções, operadores, etc... sortear(palavraAleatoria) //Ok DesenhaForca() DesenhaBoneco(n_partesBoneco) //Atribui valores a parteDescoberta e escreve: Escreva(" ") Para contador de 1 ate compr(palavraAleatoria) faca ParteDescoberta[contador] <- "__" Escreva(ParteDescoberta[contador]) Escreva(" ") FimPara EscrevaL() //----------- n_partesBoneco <- 0 Boneco_esta_Completo <- falso Repita Pedir(Letra) Se ehRealmenteLetra(Letra) então Se jafoiDita(Letra) então LimpaTela DesenhaForca() DesenhaBoneco(n_partesBoneco) Desenhae_Escreve(quadro,letra) EscreverVetor() Senao LimpaTela DesenhaForca() Se acertou(Letra) então //Vai atribuir letra às posições correspondente na função acertou() Senao n_partesBoneco <- n_partesBoneco + 1 Se (n_partesBoneco = 7) então Boneco_esta_Completo <- verdadeiro Fimse quadro <- quadro + Letra Fimse DesenhaBoneco(n_partesBoneco) Desenhae_Escreve(quadro,letra) EscreverVetor() Fimse Senao LimpaTela DesenhaForca() DesenhaBoneco(n_partesBoneco) Desenhae_Escreve(quadro,letra) EscreverVetor() Fimse Ate revelouTudo() ou (Boneco_esta_Completo) Fimalgoritmo

Obrigado pela atenção. Poderia indicar um livro de lógica de programação para iniciantes. Só fiz lógica pelas vídeo aulas e tudo na prática. Att

Oi pessoal. Já estudo Lógica de programação há um tempo, mas ainda não muito seguro para começar a estudar uma linguagem do mercado. Eu posso dizer que tenho todos os conceitos básicos da criação de algoritmos usando VisualG mas não sei se isso já é o suficiente para começar a aprender um linguagem do mercado. Alguém poderia me aconselhar? Agradeço desde já.

Obrigado Ok

Olá.. Não entendi sobre verificar individualmente. Da forma que fiz, tive que colocar para i percorrer o comprimento do maior nome. Defini uma variável R de retorno, N1 e N2 que são os parâmetros para os nomes. A variável R vai retornar 3 situações: maior se N1 vier depois que N2, menor se N1 vier antes que N2, ou igual se N1 for igual a N2. O i vai variar de 1 até o comprimento do maior nome. Em cada repetição do Repita, a função vai comparar os caracteres na posição i em cada um dos nomes. Ex.: N1 = "NOME" e N2="NOMEB". A variável R vai começar vazia e continuar vazia até i chegar no valor 4. Quando i chega na valor 5, a função vai ver que "" (caractere da posição 5 em N1) vai vir antes de "B" (caractere na posição 5 de N2) Se eu fizesse para verificar pelo comprimento do menor nome, i só iria até 4, então R continuaria vazio. Por isso, fiz a variável i mudar de valor até chegar ao comprimento do maior nome.. No VisualG: algoritmo "comparanomes" funcao comparanome(N1,N2: caractere):caractere var R : caractere compri_maior_nome: inteiro i: inteiro inicio R <- "" Se (N1 = N2) então R <- "igual" Senao Se (compr(N1) > compr(N2)) então compri_maior_nome <- compr(N1) Senao compri_maior_nome <- compr(N2) Fimse i <- 1 Repita Se (copia(N1,i,1) > copia(N2,i,1)) então R <- "maior" Fimse Se (copia(N1,i,1) < copia(N2,i,1)) então R <- "menor" Fimse i <- i + 1 Ate (i > compri_maior_nome) ou (R <> "") Fimse Retorne R fimfuncao var nome1, nome2, a: caractere inicio a <- compara(nome1,nome2) fimalgoritmo

Oi. No caso eu fiz uma função para comparar qual conjunto de strings vem na frente. A função ia percorrendo o texto pela variável i, que vai de 1 ate o comprimento do maior nome. Ex.: Se tivesse nome1 = "palavra" (7 caractere) e nome2 = "palavraA" (8 caracteres). Então i vai de 1 ate 8. Na hora que chega para comparar A de nome1 com "" de nome2, a função retornou para mim nome1 vemantes que nome2. Então "" só pode ser o caractere 0, mesmo... Eu fiquei curioso em saber qual era o código para "" porque no meu livro a tabela começa com código 32 e não 0 Abraços

Oi pessoal. Estou com curiosidade em saber se o Espaço vazio ("") possui código ANSI, pois quero comparar palavras para ver quem vem primeiro . Abraços.

Eu usei parâmetro em Verificar_se_inteiro porque para mim fica claro em quem vai verificar o valor e posso usar para outras variáveis em programas maiores. Eu gosto mais de usar nomes diferentes para não me confundir rs Boa ideia. Vou usar x também . Aí quando precisar fazer outro algoritmo é só eu copiar a função Muito obrigado pela ajuda Aqui vai o código: Algoritmo "Programa que diz o maior número" const MAX = 20 procedimento leiavetorA(var num: real) var i : inteiro R: logico inicio Repita EscrevaL("Digite a quantidade de números para comparar [Máx: 20]: ") {aleatorio -10,40} Leia(num) Se (num<1) ou (num>20) então EscrevaL("Entrada Inválida. [Mín.: 1], [Máx.: 20]") Senao R <- Verificar_se_inteiro(num) Se (R = falso) então EscrevaL("Entrada inválida. Só são aceitos números inteiros.") Fimse Fimse Ate (R = verdadeiro) e (num>=1) e (num<=20) aleatorio 0,99 para i de 1 ate Int(num) faca escreva("Digite um valor (", i:1 , " de ", num:1, "): ") leia(vetorA[i]) fimpara aleatorio off fimprocedimento funcao Verificar_se_inteiro(x: real): logico var NumeroValido: logico Quociente: real inicio Quociente <- 0 Se (x <> 0) então //Dá erro se tentar dividir por Zero. Quociente <- x/Int(x) Fimse //0 é valido: é inteiro Se (Quociente = 1) ou (Quociente = 0) então // Ex.: 5.0/5 = 1 --> número é válido: é inteiro. NumeroValido <- verdadeiro Senao NumeroValido <- falso // Ex.: 5.1/5 = 5,02 = 1,02 --> não é valido: não é inteiro. Fimse Retorne NumeroValido fimfuncao funcao retorna_maior_numero (num: real): real var a: real i: inteiro inicio a := vetorA[1] para i de 2 ate Int(num) faca se (a < vetorA[i]) então a <- vetorA[i] fimse fimpara retorne a fimfuncao var vetorA : vetor[1..MAX] de real n : real inicio EscrevaL("----------------------------") EscrevaL(" Maior Número ") EscrevaL("----------------------------") EscrevaL() leiavetorA(n) EscrevaL("----------------------------") EscrevaL("O maior valor é:", retorna_maior_numero(n)) EscrevaL("----------------------------") Fimalgoritmo

Por que n é usado em duas funções: retorna_maior_numero e leiavetorA(). Acho que precisa ser global. Não vi outro jeito de fazer como local. Tirou o on. Valeu a dica! Mas tentei colocar i:2 mas no VisualG ficou assim ( 1de 5) ( 2de 5) no caso da quantidade ser 5. O VisualG deu um espaço para trás em vez de para frente rs Para também não repetir a funcao numero_eh_soh_inteiro duas vezes dei uma modificada . Na parte do contador, coloquei Int(n) para não dar problema e declarei n como variável global como você disse para aceitar a entrada de números reais. Na hora de ver se n é inteiro, na parte que faz n%Int(n), se eu coloco um número quebrado como 5.3 , o resto também é 0. Não entendi por que :/ Código : Algoritmo "Programa que diz o maior número" const MAX = 20 procedimento leiavetorA() var i : inteiro R: logico inicio Repita EscrevaL("Digite a quantidade de números para comparar [Máx: 20]: ") {aleatorio -10,40} Leia(n) R <- Verificar_se_inteiro(n) Se (R = falso) então EscrevaL("Entrada inválida. Só são aceitos números inteiros.") Senao Se (n<=1) ou (n>=20) então EscrevaL("Entrada Inválida. [Mín.: 1], [Máx.: 20]") Fimse Fimse Ate (R = verdadeiro) e (n>=1) e (n<=20) aleatorio 0,99 para i de 1 ate Int(n) faca escreva("Digite um valor (", i:1 , " de ", n:1, "): ") leia(vetorA[i]) fimpara aleatorio off fimprocedimento funcao Verificar_se_inteiro(num: real): logico var NumeroValido: logico Quociente: real inicio Quociente <- 0 Se (N <> 0) então //Dá erro se tentar dividir por Zero. Quociente <- num/Int(num) Fimse //0 é valido: é inteiro Se (Quociente = 1) ou (Quociente = 0) então // Ex.: 5.0/5 = 1 --> número é válido: é inteiro. NumeroValido <- verdadeiro Senao NumeroValido <- falso // Ex.: 5.1/5 = 5,02 = 1,02 --> não é valido: não é inteiro. Fimse Retorne NumeroValido fimfuncao funcao retorna_maior_numero (): real var a: real i: inteiro inicio a := vetorA[1] para i de 2 ate Int(n) faca se (a < vetorA[i]) então a <- vetorA[i] fimse fimpara retorne a fimfuncao var vetorA : vetor[1..MAX] de real n : real inicio EscrevaL("----------------------------") EscrevaL(" Maior Número ") EscrevaL("----------------------------") EscrevaL() leiavetorA() EscrevaL("----------------------------") EscrevaL("O maior valor é:", retorna_maior_numero()) EscrevaL("----------------------------") Fimalgoritmo

Obrigado pela atenção. Eu também gostaria de colocar uma opção de inválido quando o usuário digitasse um número real. Mas não achei em nenhum lugar ainda se há uma função para isso.. Resolvi fazer: Chamada: Se (numero_eh_soh_inteiro(n)) então Senao EscrevaL("Entrada inválida. São são aceitos números inteiros.") Fimse _____________________________ funcao numero_eh_soh_inteiro(num): logico var NumeroValido: logico inicio NumeroValido <- falso Se n%Int(n) = 0 então // Ex.: 5.1/5 não dá valido pois o resto <> 0. 5.0/5 é valido pois o resto é = 0 NumeroValido <- verdadeiro Fimse Retorne NumeroValido fimfuncao

Oi. Achei legal em vez de colocar opção inválida no caso de ter duplo espaço ou espaço vazio no início é fazer uma função que retira os espaços do início, outra que tira os espaços consecutivos. Também achei legal alinhar as notas a partir do nome de maior largura. Segue: algoritmo "Corrigindo provas" const MAX = 35 var gabarito: vetor[1..5] de caractere total: inteiro tamanho_maiornome: inteiro aluno_n: inteiro nome: vetor[1..MAX] de caractere questao: inteiro Resposta: vetor[1..MAX, 1..5] de caractere Acerto: logico nota: vetor[1..MAX] de real SomaNotas, MediaTurma: real procedimento CadastrarGabarito(var GAB: caractere) inicio EscrevaL("----------------------------------") EscrevaL(" Passo 1 - Cadastro de Gabarito ") EscrevaL("----------------------------------") Repita EscrevaL("Digite a resposta da ", questao:1 , "º questão: ") Leia(GAB) Se (compr(GAB) = 1) então Se nao ((maiusc(GAB)>= "A") e (maiusc(GAB)<="E")) então EscrevaL("Opção inválida!") Fimse Senao EscrevaL("Opção inválida!") Fimse Ate (maiusc(GAB)>="A") e (maiusc(GAB)<="E") e (compr(GAB)=1) LimpaTela fimprocedimento procedimento CadastrarQuantidadeAlunos(var total: inteiro) var continuar : logico inicio Repita continuar := falso Escreva("Digite a quantidade de alunos: ") Leia(total) Se (total > 35) ou (total < 1) então EscrevaL("Quantidade de alunos inválida. [Mín: 1, Máx: 35]") Senao continuar := verdadeiro Fimse Ate continuar Limpatela fimprocedimento procedimento VerificarSeNome_eh_o_maior(nomealuno: caractere; var largura_maior_nome:inteiro ) inicio Se (compr(nomealuno) > largura_maior_nome) então largura_maior_nome <- compr(nomealuno) Fimse fimprocedimento procedimento CadastraNomes(var nome: caractere) var continuar, nomevalido : logico Inicio EscrevaL("-------------------------------") EscrevaL(" Passo 2 - Cadastro de Nomes ") EscrevaL("-------------------------------") Repita EscrevaL(" Aluno ", aluno_n:1) Escreva("Nome: ") nomevalido <- falso Leia(nome) Se ApenasEspacos_ou_EspacoVazio(nome) = verdadeiro então EscrevaL("Entrada inválida! Nome em branco.") Senao Se (Conferir_setem_ApenasConsoante_e_Espaco(nome) = verdadeiro) então nomevalido <- verdadeiro Se (Conferir_setem_EspacoInicio_ou_EspacoFim(nome) = verdadeiro) então nome <- Retirar_EspacoInicio_e_ou_EspacoFim(nome) Fimse Se (Conferir_DoisEspacosConsecutivos(nome) = verdadeiro) então nome <- Retirar_EspacoConsecutivo(nome) Fimse Senao EscrevaL("Nome inválido. Só são permitidos letras e espaços.") Fimse Fimse Ate nomevalido = verdadeiro LimpaTela fimprocedimento funcao ApenasEspacos_ou_EspacoVazio(nomealuno: caractere): logico var i: inteiro apenas_espaco: logico Q_espacos: inteiro inicio Q_espacos <- 0 Para i de 1 ate compr(nomealuno) faca Se (copia(nomealuno,i,1) = " ") então Q_espacos <- Q_espacos + 1 Fimse FimPara Se (Q_espacos = compr(nomealuno)) então apenas_espaco <- verdadeiro Fimse Retorne apenas_espaco fimfuncao funcao Conferir_setem_ApenasConsoante_e_Espaco(nomealuno: caractere): logico var caracter_valido: inteiro i: inteiro nomevalido: logico inicio nomevalido <- falso Para i <- 1 ate compr(nomealuno) faca //Vai verificar quantos caracteres são validos: Se (copia(maiusc(nomealuno),i,1) >= "A") e (copia(maiusc(nomealuno),i,1) <= "Z") então caracter_valido <- caracter_valido + 1 Fimse Se (copia(nomealuno,i,1) = " ") então caracter_valido <- caracter_valido + 1 Fimse Fimpara Se (caracter_valido = compr(nomealuno)) então nomevalido <- verdadeiro Fimse Retorne nomevalido fimfuncao funcao Conferir_setem_EspacoInicio_ou_EspacoFim(nomealuno:caractere): logico var precisa_retirar_espaco: logico inicio precisa_retirar_espaco <- falso Se (Copia(nomealuno,1,1) = " ") então //Verifica se tem espaço no início precisa_retirar_espaco <- verdadeiro Senao Se (Copia(nomealuno,compr(nomealuno),1) = " ") então //Verifica se tem espaço //no fim precisa_retirar_espaco <- verdadeiro Fimse Fimse Retorne precisa_retirar_espaco fimfuncao funcao Retirar_EspacoInicio_e_ou_EspacoFim(nomealuno:caractere): caractere var nomecorrigido: caractere i: inteiro posicao_primeira_letra, posicao_ultima_letra: inteiro inicio i <- 1 posicao_primeira_letra <- 0 posicao_ultima_letra <- 0 Repita //Primeiro vai procurar onde está a primeira letra da direita para //esquerda. Se (copia(nomealuno,i,1) = " ") então //Se a posição estiver vazia.. i<-i+1 //...Vai procurar na próxima posição à direita Senao //Quando encontrar a primeira letra: posicao_primeira_letra <- i Fimse Ate (i> compr(nomealuno)) ou (posicao_primeira_letra <> 0) i<-compr(nomealuno) Repita //Por último vai procurar onde está a última letra, verificando //da esquerda para direita: Se (copia(nomealuno,i,1) = " ") então i<-i-1 Senao posicao_ultima_letra <- i Fimse Ate (i<1) ou (posicao_ultima_letra <> 0) //Corrigindo nome: nomecorrigido <- copia(nomealuno, posicao_primeira_letra, posicao_ultima_letra) Retorne nomecorrigido fimfuncao funcao Conferir_DoisEspacosConsecutivos(nomealuno: caractere): logico var i: inteiro precisa_tirar1espaco : logico inicio i <- 1 Repita Se Copia(nomealuno,i,1) = " " então Se Copia(nomealuno,i+1,1) = " " então precisa_tirar1espaco <- verdadeiro Fimse Fimse i <- i + 1 Ate (i>compr(nomealuno)) ou (precisa_tirar1espaco = verdadeiro) Retorne precisa_tirar1espaco fimfuncao funcao Retirar_EspacoConsecutivo(nomealuno:caractere):caractere var nomecorrigido: caractere i: inteiro inicio nomecorrigido <- "" i<-1 Repita Se copia(nomealuno,i,1) = " " então Se (Copia(nomecorrigido, compr(nomecorrigido),1) <> "") e (Copia(nomecorrigido, compr(nomecorrigido),1) <> " ") então nomecorrigido <- nomecorrigido + copia(nomealuno,i,1) Fimse Senao nomecorrigido <- nomecorrigido + copia(nomealuno,i,1) Fimse i <- i + 1 Ate i>compr(nomealuno) Retorne nomecorrigido fimfuncao procedimento RecebeResposta(var R: caractere) Inicio EscrevaL("-----------------------------------") EscrevaL(" Passo 3 - Cadastro de Respostas ") EscrevaL("-----------------------------------") Repita EscrevaL(" Aluno nº ", aluno_n:1, ": ", nome[aluno_n]) Escreva (" Questão", questao, ": ") Leia(R) Se nao ((maiusc(R)>="A") e (maiusc(R)<= "E")) então EscrevaL("Opção inválida! O gabarito vai de A até E.") Fimse Ate (maiusc(R)>="A") e (maiusc(R)<="E") LimpaTela fimprocedimento funcao ComparaResposta(RESP :caractere; GAB: caractere): logico var AC: logico inicio AC <- falso Se (maiusc(RESP) = maiusc(GAB)) então AC <- verdadeiro Fimse Retorne AC fimfuncao procedimento AtribuirNota(var notaAluno: inteiro; AC: logico) inicio Se (AC = verdadeiro) então notaAluno <- notaAluno + 2 FimSe fimprocedimento procedimento SomarNotaDosAlunos() inicio Para aluno_n de 1 ate total faca SomaNotas := SomaNotas + nota[aluno_n] FimPara fimprocedimento procedimento FazerMediaDaTurma() inicio MediaTurma := SomaNotas/total fimprocedimento procedimento MostraNotasDeCadaAluno() inicio EscrevaL("----------------------") EscrevaL(" Notas Finais ") EscrevaL("----------------------") Para aluno_n de 1 ate total faca EscrevaL("Nome: ", nome[aluno_n]:tamanho_maiornome+2, Nota[aluno_n]:3:2) FimPara fimprocedimento procedimento MostraMediaDaTurma() inicio EscrevaL("------------------------") EscrevaL(" Média da turma: ", MediaTurma:3:2) EscrevaL("------------------------") fimprocedimento inicio //Tela 1: Para questao de 1 ate 5 faca CadastrarGabarito(gabarito[questao]) Fimpara //Tela 2: CadastrarQuantidadeAlunos(total) //Tela 3: tamanho_maiornome <- 10 //Para alinhar as notas no final. Pelo menos vai ter 10 espaços. Para aluno_n de 1 ate total faca CadastraNomes(nome[aluno_n]) VerificarSeNome_eh_o_maior(nome[aluno_n], tamanho_maiornome) //Vai ser utilizado para alinhar as notas no final Fimpara //Tela 4: Para aluno_n de 1 ate total faca Para questao de 1 ate 5 faca RecebeResposta(resposta[aluno_n, questao]) Acerto <- ComparaResposta(resposta[aluno_n, questao], gabarito[questao]) AtribuirNota(nota[aluno_n], Acerto) //Se Acerto for verdadeiro o aluno_n recebe dois pontos Fimpara FimPara SomarNotaDosAlunos() FazerMediaDaTurma() LimpaTela //TELA 5: MostraNotasDeCadaAluno() MostraMediaDaTurma() fimalgoritmo

O novo. Legal. Já já posto Abraços.

Oi, Eu fiz os testes e não deu problema O único detalho que tive que ainda não sei resolver é na parte de cadastrar os Nomes, se eu der dois espaços ao em vez 1 de um, em vez de dar nome inválido ele cadastra o nome e a parte do código : Repita EscrevaL(" Aluno ", A) Escreva("Nome: ") Leia(N) Se N = "" então EscrevaL("Opção inválida!") Fimse Ate N <> "" .. só funciona para quando aperta enter. Se der dois espaços e dar enter o programa cadastra o nome como vazio rs O código completo: algoritmo "Aula 14 - Corrigindo provas" const MAX = 35 var gabarito: vetor[1..5] de caractere total: inteiro aluno_n: inteiro nome: vetor[1..MAX] de caractere questao: inteiro Resposta: vetor[1..MAX, 1..5] de caractere Acerto: logico nota: vetor[1..MAX] de real SomaNotas, MediaTurma: real procedimento CadastrarGabarito(var GAB: caractere) var ind: inteiro letras: vetor[0..8] de caractere inicio EscrevaL("----------------------------------") EscrevaL(" Passo 1 - Cadastro de Gabarito ") EscrevaL("----------------------------------") Repita EscrevaL("Digite a resposta da ", questao:1 , "º questão: ") //Testator: Gerador de caracteres aleatórios para GAB que vai de A até I letras[0] <- "a" letras[1] <- "b" letras[2] <- "c" letras[3] <- "d" letras[4] <- "e" letras[5] <- "f" letras[6] <- "g" letras[7] <- "h" letras[8] <- "i" ind <- Randi(9) GAB <- maiusc(letras[ind]) //Leia(GAB) Se nao ((maiusc(GAB)>= "A") e (maiusc(GAB)<="E")) então EscrevaL("Opção inválida") Fimse Ate (maiusc(GAB)>="A") e (maiusc(GAB)<="E") LimpaTela fimprocedimento procedimento CadastrarQuantidadeAlunos(var total: inteiro) var continuar : logico inicio Repita continuar := falso Escreva("Digite a quantidade de alunos: ") aleatorio 1,40 Leia(total) Se (total > 35) ou (total < 1) então EscrevaL("Quantidade de alunos inválida. [Mín: 1, Máx: 35]") Senao continuar := verdadeiro Fimse Ate continuar Limpatela fimprocedimento procedimento CadastraNomes(var nome: caractere) var continuar : logico Inicio EscrevaL("-------------------------------") EscrevaL(" Passo 2 - Cadastro de Nomes ") EscrevaL("-------------------------------") Repita EscrevaL(" Aluno ", aluno_n:1) Escreva("Nome: ") Leia(nome) Se nome = "" então EscrevaL("Opção inválida!") Fimse Ate nome <> "" LimpaTela fimprocedimento procedimento RecebeResposta(var R: caractere) var letras:vetor[0..8] de caractere ind: inteiro Inicio EscrevaL("-----------------------------------") EscrevaL(" Passo 3 - Cadastro de Respostas ") EscrevaL("-----------------------------------") Repita EscrevaL(" Aluno nº ", aluno_n:1, ": ", nome[aluno_n]) Escreva (" Questão", questao, ": ") //Testator: Gerador de caracteres aleatórios para GAB que vai de A até I letras[0] <- "a" letras[1] <- "b" letras[2] <- "c" letras[3] <- "d" letras[4] <- "e" letras[5] <- "f" letras[6] <- "g" letras[7] <- "h" letras[8] <- "i" ind <- Randi(9) R <- maiusc(letras[ind]) //Leia(R) se nao ((maiusc(R)>="A") e (maiusc(R)<= "E")) então EscrevaL("Opção inválida! O gabarito vai de A até E.") Fimse Ate (maiusc(R)>="A") e (maiusc(R)<="E") LimpaTela fimprocedimento funcao ComparaResposta(RESP :caractere; GAB: caractere): logico var AC: logico inicio AC <- falso Se (maiusc(RESP) = maiusc(GAB)) então AC <- verdadeiro Fimse Retorne AC fimfuncao procedimento AtribuirNota(var notaAluno: inteiro; AC: logico) inicio Se (AC = verdadeiro) então notaAluno <- notaAluno + 2 FimSe fimprocedimento procedimento SomarNotaDosAlunos() inicio Para aluno_n de 1 ate total faca SomaNotas := SomaNotas + nota[aluno_n] FimPara fimprocedimento procedimento FazerMediaDaTurma() inicio MediaTurma := SomaNotas/total fimprocedimento procedimento MostraNotasDeCadaAluno() inicio EscrevaL("----------------------") EscrevaL(" Notas Finais ") EscrevaL("----------------------") Para aluno_n de 1 ate total faca EscrevaL("Nome: ", nome[aluno_n]:10, Nota[aluno_n]:3:2) FimPara fimprocedimento procedimento MostraMediaDaTurma() inicio EscrevaL("------------------------") EscrevaL(" Média da turma: ", MediaTurma:3:2) EscrevaL("------------------------") fimprocedimento inicio Aleatorio on //Tela 1: Para questao de 1 ate 5 faca CadastrarGabarito(gabarito[questao]) Fimpara //Tela 2: CadastrarQuantidadeAlunos(total) //Tela 3: Para aluno_n de 1 ate total faca CadastraNomes(nome[aluno_n]) Fimpara //Tela 4: Para aluno_n de 1 ate total faca Para questao de 1 ate 5 faca RecebeResposta(resposta[aluno_n, questao]) Acerto <- ComparaResposta(resposta[aluno_n, questao], gabarito[questao]) AtribuirNota(nota[aluno_n], Acerto) //Se Acerto for verdadeiro o aluno_n recebe dois pontos Fimpara FimPara SomarNotaDosAlunos() FazerMediaDaTurma() LimpaTela //TELA 5: MostraNotasDeCadaAluno() MostraMediaDaTurma() aleatorio off fimalgoritmo Também removi parâmetros que não serviam para nada em RecebeResposta, Acerto e AtribuirNota

Oi! Considerem esta versão: algoritmo "Aula 14 - Corrigindo provas" var gabarito: vetor[1..5] de caractere aluno_n: inteiro nome: vetor[1..3] de caractere questao: inteiro Resposta: vetor[1..3, 1..5] de caractere Acerto: logico nota: vetor[1..3] de real SomaNotas, MediaTurma: real procedimento CadastrarGabarito(var GAB: caractere; Q: inteiro) inicio EscrevaL("----------------------------------") EscrevaL(" Passo 1 - Cadastro de Gabarito ") EscrevaL("----------------------------------") Repita Escreva("Digite a resposta da ", Q , "º questão: ") Leia(GAB) Se nao(maiusc(GAB)>= "A" e maiusc(GAB)<="E") então EscrevaL("Opção inválida") Fimse LimpaTela Ate (maiusc(GAB)>="A") e (maiusc(GAB)<="E") fimfuncao funcao CadastraNomes(A: inteiro): caractere var N: caractere Inicio EscrevaL("-------------------------------") EscrevaL(" Passo 2 - Cadastro de Nomes ") EscrevaL("-------------------------------") Repita EscrevaL(" Aluno ", A) Escreva("Nome: ") Leia(N) Se N = "" então EscrevaL("Opção inválida!") Fimse Ate N <> "" LimpaTela Retorne N fimfuncao procedimento RecebeResposta(var R: caractere) var R: caractere Inicio EscrevaL("-----------------------------------") EscrevaL(" Passo 3 - Cadastro de Respostas ") EscrevaL("-----------------------------------") Repita EscrevaL(" Aluno nº ", A, ":", nome[A]) Escreva (" Questão", Q, ": ") Leia(R) Se nao(maiusc(GAB) >= "A" e maiusc(GAB) <= "E") então EscrevaL("Opção inválida! O gabarito vai de A até E.") Fimse Ate (maiusc(R)>="A") e (maiusc(R)<="E") LimpaTela fimfuncao funcao ComparaResposta(A,Q:inteiro; GAB: caractere): logico var AC: logico inicio AC <- falso Se (maiusc(Resposta[A,Q]) = maiusc(GAB)) então AC <- verdadeiro Fimse Retorne AC fimfuncao funcao AtribuirNota(A: inteiro; Q: inteiro; AC: logico) inicio Se (AC = verdadeiro) então nota[aluno_n] <- nota[aluno_n] + 2 FimSe fimfuncao procedimento MostraNotasDeCadaAluno() inicio EscrevaL("----------------------") EscrevaL(" Notas Finais ") EscrevaL("----------------------") Para aluno_n de 1 ate 3 faca EscrevaL("Nome: ", nome[aluno_n]:10, Nota[aluno_n]:3:2) FimPara fimprocedimento procedimento MostraMediaDaTurma() inicio EscrevaL("------------------------") EscrevaL(" Média da turma: ", MediaTurma:3:2) EscrevaL("------------------------") fimprocedimento inicio //Tela 1: Para questao de 1 ate 5 faca CadastrarGabarito(gabarito[questao], questao) Fimpara //Tela 2: Para aluno_n de 1 ate 3 faca CadastraNomes(nome[aluno_n]) Fimpara Para aluno_n de 1 ate 3 faca Para questao de 1 ate 5 faca RecebeResposta(resposta[aluno_n, questao]) Acerto <- ComparaResposta(aluno_n, questao, gabarito[questao]) nota[aluno_n] <- AtribuirNota(aluno_n, questao, Acerto) //Se Acerto for verdadeiro o aluno_n recebe dois pontos Fimpara SomaNotas <- SomaNotas + nota[aluno_n] FimPara MediaTurma <- (SomaNotas/3) LimpaTela //TELA 3: MostraNotasDeCadaAluno() MostraMediaDaTurma() fimalgoritmo

Isso estava me dando dor de cabeça rs. Coloquei n:1 Não pude colocar a n pois ela é necessária como variável global Algoritmo "Programa que diz o maior número" const MAX = 20 procedimento leiavetorA() var i : inteiro inicio Repita EscrevaL("Digite a quantidade de números para comparar [Máx: 20]: ") aleatorio on aleatorio 3,25 Leia(n) Se (n>=20) ou (n<=1) então EscrevaL("Opção Inválida!") Fimse Ate (n>=1) e (n<=20) para i de 1 ate n faca escreva("Digite um valor (", i , " de ", n:1, "): ") leia(vetorA[i]) fimpara aleatorio off fimprocedimento funcao retorna_maior_numero (): real var a: real i: inteiro inicio a := vetorA[1] para i de 2 ate n faca se (a < vetorA[i]) então a <- vetorA[i] fimse fimpara retorne a fimfuncao var vetorA : vetor[1..MAX] de real n : inteiro inicio EscrevaL("----------------------------") EscrevaL(" Maior Número ") EscrevaL("----------------------------") EscrevaL() leiavetorA() EscrevaL("----------------------------") EscrevaL("O maior valor é:", retorna_maior_numero()) EscrevaL("----------------------------") Fimalgoritmo

Oi, eu fiz umas mudanças no código, colocando tudo em funções e procedimentos e vendo os detalhes que faltavam.. Mas quando rodo e chego na linha 22 aparece a mensagem: Coloquei colocar mais parênteses mas também não foi. Me deem uma ajuda rs algoritmo "Aula 14 - Corrigindo provas" var gabarito: vetor[1..5] de caractere aluno_n: inteiro nome: vetor[1..3] de caractere questao: inteiro Resposta: vetor[1..3, 1..5] de caractere Acerto: logico nota: vetor[1..3] de real SomaNotas, MediaTurma: real funcao CadastrarGabarito(Q: inteiro):caractere var GAB: caractere inicio EscrevaL("----------------------------------") EscrevaL(" Passo 1 - Cadastro de Gabarito ") EscrevaL("----------------------------------") Repita Escreva("Digite a resposta da ", Q , "º questão: ") Leia(GAB) Se nao(maiusc(GAB)>= "A" e maiusc(GAB)<="E") então EscrevaL("Opção inválida") Fimse LimpaTela Ate (maiusc(GAB)>="A") e (maiusc(GAB)<="E") Retorne GAB fimfuncao funcao CadastraNomes(A: inteiro): caractere var N: caractere Inicio EscrevaL("-------------------------------") EscrevaL(" Passo 2 - Cadastro de Nomes ") EscrevaL("-------------------------------") Repita EscrevaL(" Aluno ", A) Escreva("Nome: ") Leia(N) Se N = "" então EscrevaL("Opção inválida!") Fimse Ate N <> "" LimpaTela Retorne N fimfuncao funcao RecebeResposta(A, Q: inteiro): caractere var R: caractere Inicio EscrevaL("-----------------------------------") EscrevaL(" Passo 3 - Cadastro de Respostas ") EscrevaL("-----------------------------------") Repita EscrevaL(" Aluno nº ", A, ":", nome[A]) Escreva (" Questão", Q, ": ") Leia(R) Se nao(maiusc(GAB) >= "A" e maiusc(GAB) <= "E") então EscrevaL("Opção inválida! O gabarito vai de A até E.") Fimse Ate (maiusc(R)>="A") e (maiusc(R)<="E") LimpaTela Retorne R fimfuncao funcao ComparaResposta(A,Q:inteiro; GAB: caractere): logico var AC: logico inicio AC <- falso Se (maiusc(Resposta[A,Q]) = maiusc(GAB)) então AC <- verdadeiro Fimse Retorne AC fimfuncao procedimento MostraNotasDeCadaAluno() inicio EscrevaL("----------------------") EscrevaL(" Notas Finais ") EscrevaL("----------------------") Para aluno_n de 1 ate 3 faca EscrevaL("Nome: ", nome[aluno_n]:10, Nota[aluno_n]:3:2) FimPara fimprocedimento procedimento MostraMediaDaTurma() inicio EscrevaL("------------------------") EscrevaL(" Média da turma: ", MediaTurma:3:2) EscrevaL("------------------------") fimprocedimento inicio //Tela 1: Para questao de 1 ate 5 faca gabarito[questao] <- CadastrarGabarito(questao) Fimpara //Tela 2: Para aluno_n de 1 ate 3 faca nome[aluno_n] <- CadastraNomes(aluno_n) Fimpara Para aluno_n de 1 ate 3 faca Para questao de 1 ate 5 faca Resposta[aluno_n, questao] <- RecebeResposta(aluno_n, questao) Acerto <- ComparaResposta(aluno_n, questao, gabarito[questao]) //ATRIBUIR NOTA: Se (Acerto = verdadeiro) então nota[aluno_n] <- nota[aluno_n] + 2 FimSe Fimpara SomaNotas <- SomaNotas + nota[aluno_n] FimPara MediaTurma <- (SomaNotas/3) LimpaTela //TELA 3: MostraNotasDeCadaAluno() MostraMediaDaTurma() fimalgoritmo

Isso é bem legal Já pode fechar o tópico Abraços!

Opa, desculpa a demora Segue o algoritmo agora: Algoritmo "Programa que diz o maior número" const MAX = 20 procedimento leiavetorA() inicio EscrevaL("Digite a quantidade de números para comparar [Máx: 20]: ") Leia(n) para i de 1 ate n faca escreva("Digite um valor (", i , " de ", n, "): ") leia(vetorA[i]) fimpara fimprocedimento funcao dizer_maior_numero (): real var a : real inicio a := vetorA[1] para i de 2 ate n faca se (a < vetorA[i]) então a <- vetorA[i] fimse fimpara retorne a fimfuncao var vetorA : vetor[1..MAX] de real i, n : inteiro inicio EscrevaL("----------------------------") EscrevaL(" Maior Número ") EscrevaL("----------------------------") EscrevaL() leiavetorA() EscrevaL("----------------------------") EscrevaL("O maior valor é:", dizer_maior_numero()) EscrevaL("----------------------------") Fimalgoritmo

Olá pessoal ... funciona assim, a primeira tela é para cadastrar o gabarito. Vai ter um contador j que vai de 1 a 5 que vai lendo as notas e armazenando as notas em um vetor de 5 posições (gab[x]). Vai limpar a tela. A segunda tela é a tela de cadastrar o nome e a nota dos alunos. São 3 alunos. A resposta da resposta de cada aluno é armazenada é armazenada temporariamente em outro vetor de 5 posições(resp[x]). Se o valor das posição respectiva do vetor gabarito e resp[x] forem iguais, o aluno ganha dois pontos, que são armazenados em nota[x]. Na terceira tela, mostra o resultado, com a nota de cada aluno e a média da turma. algoritmo "Aula 14 - Corrigindo provas" var nome: vetor[1..3] de caractere Gab, Resp: vetor[1..5] de caractere Nota: vetor[1..3] de real NotasTurma, MediaTurma: real i, j: inteiro funcao CalcularPontos(gabarito, resposta: real):real var N: real Inicio Se (maiusc(gabarito) = maiusc(resposta)) então N:= 2 Fimse Retorne N fimfuncao inicio //--------------------------------------------// //Tela 1: //Cadastro de Gabarito: EscrevaL(" Passo 1 - Cadastro de Gabarito ") EscrevaL("----------------------------------") Para j de 1 ate 5 faca EscrevaL("Questão ", j, ":") Leia(Gab[j]) Fimpara LimpaTela //--------------------------------------------// //Tela 2: //Cadastro de Nome: Para i de 1 ate 3 faca EscrevaL("--------------------") EscrevaL(" Aluno ", i) EscrevaL("--------------------") Escreva("Nome: ") Leia(nome[i]) //Cadastro da Notas e cálculo da nota //de cada aluno: Para j de 1 ate 5 faca EscrevaL("RESPOSTAS DADAS") Escreva("Questão ", j, ":") Leia(Resp[j]) nota[i]:= nota[i] + CalcularPontos(Gab[j], Resp[j]) FimPara //-----------------------------------------// NotasTurma:= NotasTurma + Nota[i] LimpaTela Fimpara MediaTurma:= NotasTurma/3 LimpaTela //--------------------------------------------// //Tela 3: //Resultado com notas finais e média da turma: EscrevaL("Notas Finais") EscrevaL("------------------------") Para i de 1 ate 3 faca EscrevaL("Nome: ", nome[i]:10, Nota[i]:3:1) FimPara EscrevaL("------------------------") EscrevaL("Média da turma: ", MediaTurma) //--------------------------------------------// fimalgoritmo Alguém poderia avaliar?

Obrigado pelo comentário. Falta de atenção mesmo rs Eu sabia, só esqueci de tirar . Naquela vez que indentei tentei usar um código que vi na Internet em que se alinhava o código pelas funções. Por exemplo, colocar "escreva" todos alinhados. Mas vi agora que não ficou muito bom.. Segue o código agora: algoritmo "SuperContador" // ============================================================= // Algoritmo que dá 3 opções: // [1] Contar de 1 até 10 // [2] Contar de 10 até 1 // [3] Terminar programa // - Caso usuário escolha [1] ou [2] , no final vai perguntar // se quer executar de novo. Caso responda [S], vai limpar a tela // e voltar para o Menu Principal. Caso escolha outra tecla, // a variável PARAR receberá verdadeiro e o programa não vai repetir // no próximo loop. // - Caso Escolha [3], a variável PARAR receberá verdadeiro e no // próximo loop o programa não vai repetir. // ============================================================= // AUTOR: Vinícius V. // 18/11/2017 // ============================================================= //Procedimentos: procedimento MSG_QuerExecutarDenovo() inicio EscrevaL("Deseja executar o programa de novo?") EscrevaL("Responda [S] para continuar.") EscrevaL("Responda com qualquer outra tecla para terminar o programa.") Escreva("Resposta: ") fimprocedimento procedimento contador (I, F, S: inteiro) var C : inteiro inicio Para C de I ate F passo S faca Escreva(C) FimPara EscrevaL() fimprocedimento procedimento MSG_Carregando() inicio EscrevaL("Carregando..") timer 250 timer <off> fimprocedimento procedimento MSG_Saindo() inicio EscrevaL("Saindo..") timer 600 timer <off> fimprocedimento var Resposta : caractere op : Inteiro parar : logico inicio Repita //Menu Principal: EscrevaL("-------------------------") EscrevaL("| SuperContador |") EscrevaL("-------------------------") EscrevaL("|[1] Contar de 1 ate 10 |") EscrevaL("|[2] Contar de 10 ate 1 |") EscrevaL("|[3] Sair --------- |") EscrevaL("-------------------------") Escreva("| Digite uma opção: ") //--------------- Leia(op) Escolha op Caso 1 contador(1,10,1) //Contar de 1 a 10 //Menu Executar de novo: MSG_QuerExecutarDenovo() Leia(Resposta) Se Resposta = "S" então MSG_Carregando() Senao MSG_Saindo() parar <- verdadeiro Fimse //--------------------- Caso 2 contador(1,10,-1) //Contar de 10 a 1 //Menu Executar de novo: MSG_QuerExecutarDenovo() Leia(Resposta) Se Resposta = "S" então MSG_Carregando() Senao MSG_Saindo() parar <- verdadeiro Fimse //---------------------- Caso 3 MSG_Saindo() parar <- verdadeiro OutroCaso EscrevaL("Opção inválida") timer 600 timer <off> FimEscolha LimpaTela Ate parar = verdadeiro fimalgoritmo