Ir ao conteúdo
  • Cadastre-se

Vinícius V.

Membro Pleno
  • Posts

    47
  • Cadastrado em

  • Última visita

Reputação

30
  1. 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á
  2. 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.
  3. 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á
  4. ... 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.
  5. 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
  6. 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
  7. 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
  8. 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á.
  9. 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
  10. 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
  11. 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.
  12. 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
  13. 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
  14. 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

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades 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

×
×
  • Criar novo...