Vinícius V.

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.

... 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.