Ir ao conteúdo
  • Cadastre-se

Vinícius Werneck

Membros Plenos
  • Total de itens

    49
  • Registro em

  • Última visita

  • Qualificações

    0%

Reputação

28

Sobre Vinícius Werneck

  • Data de Nascimento 08-12-1995 (22 anos)

Informações gerais

  • Cidade e Estado
    São Gonçalo/Rj
  • Sexo
    Prefiro não dizer
  1. 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á
  2. ... 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.
  3. 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
  4. 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
  5. 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
  6. 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á.
  7. 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
  8. 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
  9. 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.
  10. 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
  11. 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
  12. 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
  13. 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

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×