Ir ao conteúdo
  • Comunicados

    • Gabriel Torres

      Seja um moderador do Clube do Hardware!   12-02-2016

      Prezados membros do Clube do Hardware, Está aberto o processo de seleção de novos moderadores para diversos setores ou áreas do Clube do Hardware. Os requisitos são:   Pelo menos 500 posts e um ano de cadastro; Boa frequência de participação; Ser respeitoso, cordial e educado com os demais membros; Ter bom nível de português; Ter razoável conhecimento da área em que pretende atuar; Saber trabalhar em equipe (com os moderadores, coordenadores e administradores).   Os interessados deverão enviar uma mensagem privada para o usuário @Equipe Clube do Hardware com o título "Candidato a moderador". A mensagem deverá conter respostas às perguntas abaixo:   Qual o seu nome completo? Qual sua data de nascimento? Qual sua formação/profissão? Já atuou como moderador em algo outro fórum, se sim, qual? De forma sucinta, explique o porquê de querer ser moderador do fórum e conte-nos um pouco sobre você.   OBS: Não se trata de função remunerada. Todos que fazem parte do staff são voluntários.
    • DiF

      Poste seus códigos corretamente!   21-05-2016

      Prezados membros do Fórum do Clube do Hardware, O Fórum oferece um recurso chamado CODE, onde o ícone no painel do editor é  <>     O uso deste recurso é  imprescindível para uma melhor leitura, manter a organização, diferenciar de texto comum e principalmente evitar que os compiladores e IDEs acusem erro ao colar um código copiado daqui. Portanto convido-lhes para ler as instruções de como usar este recurso CODE neste tópico:  
Vinícius Werneck

VisualG Dizer qual é o maior número

Recommended Posts

Olá pessoal, poderiam dar uma olhada no meu código para avaliar como está? Segue:

É no VisualG:

 

Algoritmo "Dizer o maior número"

//-----------------------------------
funcao dizer_maior_numero (x,y: inteiro): inteiro

var
vetorA: vetor[1..5] de inteiro
j : inteiro
inicio

para j de 1 ate 5 faca
leia(vetorA[j])
fimpara

repita
  y := y + 1
se vetorA[x] > vetorA[y] então
  y := y
  x := x
senao
  x := y
fimse
ate y = 5

retorne vetorA[x]
fimfuncao
//-----------------------------------

var
a, n : inteiro
inicio

a := 1
n := 1

escreva(dizer_maior_numero(a,n))

Fimalgoritmo

Agradeço desde ja.

Editado por DiF
  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Olá.

 

Tem vários pontos que precisam ser revistos... vamos lá:

 

1) Utilização de parâmetros sem necessidade ou justificativa.

4 horas atrás, viniciusv21 disse:

a:=1
n:=1
escreva(dizer_maior_numero(a,n))

 

Você está passando os valores 1 e 1... logo, não faz sentido usar parâmetros... simplesmente use esses valores lá dentro da função.

 

 


2) "Cada um no seu quadrado"
Você está lendo os dados do vetor dentro da função que verificará qual o maior... deveria separar uma coisa dá outra...ou seja, a função deveria servi apenas para "retornar o maior". Ou fazia um outro procedimento para ler os dados, ou leria na parte principal do programa...

 

 

 

3) Leitura dos dados

4 horas atrás, viniciusv21 disse:

   para j de 1 ate 5 faca
      leia(vetorA[j])

 

Ao executar o programa, apenas fica uma tela piscando.. não tem iteração com o usuário... seria necessário escrever algo na tela solicitado os dados necessários.

 

 

 

4) Instrução desnecessária

 

4 horas atrás, viniciusv21 disse:

      se vetorA[x]>vetorA[y] ENTÃO
         y:=y
         x:=x

 

Dizer que algo é igual a si mesmo não tem alguma função... ou seja, esse se não está servindo para nada.

 

...

 

Por enquanto é isso..  qualquer coisa tenta corrigir e posta o novo código aqui.

 

No aguardo.

  • Curtir 2

Compartilhar este post


Link para o post
Compartilhar em outros sites
  • Autor do tópico
  • achei um pouco rude a resposta, mas obrigado ...

    adicionado 1 minuto depois
    16 minutos atrás, Simon Viegas disse:

    Olá.

     

    Tem vários pontos que precisam ser revistos... vamos lá:

     

    1) Utilização de parâmetros sem necessidade ou justificativa.

     

    Você está passando os valores 1 e 1... logo, não faz sentido usar parâmetros... simplesmente use esses valores lá dentro da função.

     

     


    2) "Cada um no seu quadrado"
    Você está lendo os dados do vetor dentro da função que verificará qual o maior... deveria separar uma coisa dá outra...ou seja, a função deveria servi apenas para "retornar o maior". Ou fazia um outro procedimento para ler os dados, ou leria na parte principal do programa...

     

     

     

    3) Leitura dos dados

     

    Ao executar o programa, apenas fica uma tela piscando.. não tem iteração com o usuário... seria necessário escrever algo na tela solicitado os dados necessários.

     

     

     

    4) Instrução desnecessária

     

     

    Dizer que algo é igual a si mesmo não tem alguma função... ou seja, esse se não está servindo para nada.

     

    ...

     

    Por enquanto é isso..  qualquer coisa tenta corrigir e posta o novo código aqui.

     

    No aguardo.

    .

    Editado por viniciusv21
    • Curtir 1

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
    3 horas atrás, viniciusv21 disse:

    achei um pouco rude a resposta, mas obrigado ...

    adicionado 1 minuto depois

     

    Desculpe... não foi a intenção...

    • Curtir 2

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    @viniciusv21    você colocou alguns comandos que não precisa e outros no lugar errado, então apenas coloquei comentário no lugar desses comandos, veja como ficaria seu código :

    Algoritmo "Dizer o maior número"
    var
     a,n : inteiro
    //-----------------------------------
    funcao dizer_maior_numero (x,y: inteiro): inteiro
    var
      vetorA : vetor[1..5] de inteiro
      j      : inteiro
    inicio
      para j de 1 ate 5 faca
        escreva("Digite O",j,"º Número ")
        leia(vetorA[j])
      fimpara
      repita
        //y := y + 1
        //x := vetorA[y]
        se y = 1 ENTÃO
          x := vetorA[y]
        fimse
        se vetorA[y] > x ENTÃO//vetorA[y] ENTÃO
          x := vetorA[y]
          //y := y
          //x := x
        //senao
          //x := y
        fimse
        y := y+1
      ate y > 5
      retorne x
    fimfuncao
    //-----------------------------------
    inicio
    //var
      //a, n : inteiro
    //inicio
      a := 1
      n := 1
      escreva("O Maior Número é --> ",dizer_maior_numero(a,n))
    Fimalgoritmo

     

    • Curtir 1

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Olá todos.

     

    15 horas atrás, devair1010 disse:

    @viniciusv21    você colocou alguns comandos que não precisa e outros no lugar errado, então apenas coloquei comentário no lugar desses comandos, veja como ficaria seu código :

    
    Algoritmo "Dizer o maior número"
    var
     a,n : inteiro
    //-----------------------------------
    funcao dizer_maior_numero (x,y: inteiro): inteiro
    var
      vetorA : vetor[1..5] de inteiro
      j      : inteiro
    inicio
      para j de 1 ate 5 faca
        escreva("Digite O",j,"º Número ")
        leia(vetorA[j])
      fimpara
      repita
        //y := y + 1
        //x := vetorA[y]
        se y = 1 ENTÃO
          x := vetorA[y]
        fimse
        se vetorA[y] > x ENTÃO//vetorA[y] ENTÃO
          x := vetorA[y]
          //y := y
          //x := x
        //senao
          //x := y
        fimse
        y := y+1
      ate y > 5
      retorne x
    fimfuncao
    //-----------------------------------
    inicio
    //var
      //a, n : inteiro
    //inicio
      a := 1
      n := 1
      escreva("O Maior Número é --> ",dizer_maior_numero(a,n))
    Fimalgoritmo

     

     

    Pelo que citei no comentário anterior, alguns pontos estão com os mesmo critérios...

     

     

    Baseado nesse código, sugeriria algo assim:

    Algoritmo "Dizer o maior número"
    
    //Função que retorna o maior número dentre os números do vetor
    funcao maiorNumero(): inteiro
      var
         vetorA :vetor[1..5] de inteiro
         i      :inteiro
         maior  :inteiro
    inicio
       para i de 1 ate 5 faca
          escreva("Digite o",i,"º número ")
          leia(vetorA[i])
       fimpara
    
       repita
          se i = 1 ENTÃO //se primeira posição
             maior:=vetorA[i] //atualiza o maior (será o primeiro)
          senao
             se vetorA[i] > maior ENTÃO //se posição atual é maior que o maior
                maior:=vetorA[i] //atualiza o maior (será o atual)
             fimSe
          fimSe
          i:=i+1
       ate i > 5
       retorne maior
    fimfuncao
    
    inicio
    escreva("O Maior Número é --> ",maiorNumero())
    fimAlgoritmo

     

     

    Como o laço é fixo, poderia substituir tb o repita por para... e outros detalhes, ex.:
     

    Algoritmo "Dizer o maior número"
    
    const
      MAX = 10 //máximo de números do vetor
    
    //Função que retorna o maior número dentre os números do vetor
    funcao maiorNumero(): inteiro
       var
          i      :inteiro //obs.: esse "i" não é o mesmo lá do programa principal!
          maior  :inteiro //maior númer do vetor
       inicio
       maior:=vetorA[1] //inicializa o maior com o primeiro
       para i de 2 ate MAX faca //do segundo em diante
          se vetorA[i] > maior ENTÃO //se posição atual é maior que o maior
             maior:=vetorA[i] //atualiza o maior (será o atual)
          fimSe
       fimPara
       retorne maior
    fimfuncao
    
    var
       vetorA :vetor[1..MAX] de inteiro //vetor que armazenará os números
       i      :inteiro                //variável auxiliar para percorrer o vetor
          
    inicio
    ALEATORIO ON  //recurso utilizado para gerar número automaticamente
       ALEATORIO 1,99 //faixa de número que será sorteado
       //leitura dos dados (preencher o vetor)
       para i de 1 ate MAX faca
          escreva("Digite o ",i:2,"º número ")
          leia(vetorA[i]) //obs.: se tiver com o ALETORIO ON, será preenchido automaticamente!
       fimpara
    ALEATORIO OFF //desabilita o gerador do dados (caso não queeira, remova as linhas ALEATORIO)
    escreva("O Maior Número é --> ",maiorNumero())
    fimAlgoritmo


    Caso queria também colocar a leitura num procedimento... sugeriria algo assim:

    Algoritmo "Dizer o maior número"
    const
      MAX = 5 //máximo de números do vetor
    
    var
       vetorA :vetor[1..MAX] de inteiro //vetor que armazenará os números
    
    //Procedimento para efetuar a leitura dos dados (preencher o vetor)
    procedimento lerDados()
       var
          i :inteiro //auxiliar para percorrer o vetor
       inicio
       para i de 1 ate MAX faca
          escreva("Digite o ",i:2,"º número ")
          leia(vetorA[i])
       fimpara
    fimProcedimento
    
    //Função que retornar o maior número dentre os números do vetor
    funcao maiorNumero(): inteiro
       var
          i      :inteiro //auxiliar para percorrer o vetor (osb.: não é o mesmo do procedimento acima)
          maior  :inteiro //maior número do vetor
       inicio
       maior:=vetorA[1] //inicializa o maior com o primeiro
       para i de 2 ate MAX faca //do segundo em diante
          se vetorA[i] > maior ENTÃO //se posição atual é maior que o maior
             maior:=vetorA[i] //atualiza o maior (será o atual)
          fimSe
       fimPara
       retorne maior
    fimfuncao
    
    inicio
    lerDados()
    escreva("O Maior Número é --> ",maiorNumero())
    fimAlgoritmo

    obs.: No Procedimento eu não consegui fazer funcionar o comando "ALEATORIO"... ai, para testar, tem que ser na mão dura...
     

     

     

    A ideia seria comparar os códigos e analisar as mudanças... o que acham? As minhas principais argumentações estão meio que lá no primeiro comentário...

     

     

    No aguardo.

    • Curtir 2

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • Em 27/08/2017 às 16:14, viniciusv21 disse:

     

     

    Em 27/08/2017 às 16:14, viniciusv21 disse:
    Em 27/08/2017 às 16:00, Simon Viegas disse:

    2) "Cada um no seu quadrado"
    Você está lendo os dados do vetor dentro da função que verificará qual o maior... deveria separar uma coisa dá outra...ou seja, a função deveria servi apenas para "retornar o maior". Ou fazia um outro procedimento para ler os dados, ou leria na parte principal do programa...

    Olá tentei colocar o procedimento lervetor para ler os dados, mas não funciona porque quando passa pelo fimprocedimento os dados somem e não podem ser aproveitados na função dizer_maior_numero. Veja: 

     

    Algoritmo "Dizer o maior número"
    procedimento lervetor (b : inteiro)
    var
    vetorA: vetor[1..5] de inteiro
    p : inteiro
    inicio
    para p de 1 ate 5 faca
    escreva("Digite um valor:", "[" , p , "de 5]")
    leia(vetorA[p])
    fimpara
    fimprocedimento
    //-----------------------------------
    funcao dizer_maior_numero (): inteiro
    var
    x, y : inteiro
    inicio
    
    x := 1
    para y de 2 ate 5 faca
    se lervetor(x) < lervetor(y) então // Verifica o número da frente. Se x menor que
      x := y                       // Se x menor q y, x recebe o valor de y
    fimse                          // e continua verificando o próximo da frente
    fimpara                        // até chegar ao último.
    
    retorne vetorA[x]
    fimfuncao
    //-----------------------------------
    
    var
    
    inicio
    
    escreva("O maior número é:", dizer_maior_numero())
    
    Fimalgoritmo

     

     

    Em 27/08/2017 às 16:14, viniciusv21 disse:
    Em 27/08/2017 às 16:00, Simon Viegas disse:

     

     

     

    • Curtir 1

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Olá @viniciusv21.

     

    1) ESCOPO DE VARIÁVEIS

    22 horas atrás, viniciusv21 disse:
    
    procedimento lervetor (b : inteiro)
       var
          vetorA: vetor[1..5] de inteiro
          p : inteiro

     

    Ao declarar o vetor vetorA dentro do procedimento lervetor() você estipulou o seu escopo como local, ou seja, é só "enxergada" para quem está dentro do procedimento. É a famosa "variável local".

     

    Para que o vetor seja utilizável em outros procedimentos ou funções é necessário que a variável esteja declarada como "variável global".

     

    Para que uma variável global interaja nos procedimentos tem pelo menos 2 formas:

     

    1) passa a variável pelo parâmetro;

    2) usa ela diretamente, aproveitando do escopo global.

     

    Então, como no seu contexto está utilizando vetores, a primeira opção não é válida... ou pelo menos eu não sei como faz para declarar uma variável lá nos parâmetros do procedimento...

     

    Para a segunda opção, basta que a declaração da variável, lá no var, esteja acima do procedimento, ou seja, a declaração dessa variável que vai ser usada dentro dos procedimentos deve ser declara antes da declaração do procedimento em si.

     

     

    Esse trecho poderia ficar mais ou menos assim:

    Algoritmo "Dizer o maior número"
    
    var //variáveis em escopo GLOBAL
       vetorA: vetor[1..5] de inteiro 
    
    //Procedimento para efetuar a leitura dos dados (preencher o vetor)
    procedimento lervetor()
       var //variáveis em escopo local ("só existem" dentro do procedimento)
          {vetorA: vetor[1..5] de inteiro} //passou a ser global
          {p : inteiro} //por convenção, é comum utilizar o "i" para essa atividade
          i :inteiro //auxiliar para percorrer o vetor
       inicio
       para i de 1 ate 5 faca
          {escreva("Digite um valor:", "[" , p , "de 5]")} //abaixo pequenos ajustes...
          escreva("Digite um valor: [",i," de 5 ]: ")
          leia(vetorA[i])
       fimpara
    fimprocedimento
    
    inicio
    lerVetor()
    Fimalgoritmo

     

    Já na função:

    23 horas atrás, viniciusv21 disse:
    
    funcao dizer_maior_numero (): inteiro
       var
          x, y : inteiro
       inicio
       x := 1
       para y de 2 ate 5 faca
          se lervetor(x) < lervetor(y) então // Verifica o número da frente. Se x menor que
            x:=y                             // Se x menor q y, x recebe o valor de y
          fimse                              // e continua verificando o próximo da frente
       fimpara                               // até chegar ao último.
       retorne vetorA[x]
    fimfuncao

     

     

    Você está usando o procdimento letvetor() de forma incompatível de como ela foi projetada... então, como o letvetor() funciona? A "assinatura" do seu procedimento estava assim:

     

    22 horas atrás, viniciusv21 disse:
    
    procedimento lervetor (b : inteiro)

     

    Ou seja, b recebe um valor inteiro de fora... mas perceba que em nenhum momento você está utilizando b dentro da função. Na prática essa informação não está tendo utilidade.

     

    Ainda nesse procedimento, como o restante do procedimento se comporta?

     

    Lá tem:

     

    23 horas atrás, viniciusv21 disse:
    
    para p de 1 ate 5 faca
       escreva("Digite um valor:", "[" , p , "de 5]")
       leia(vetorA[p])
    fimpara

    Ou seja, vai preencher todo as 5 posições do vetor... a funcionalidade do letvetor() seria ler os 5 números que o vetor conterá... resumindo: ao fim do procedimento, o vetor estará com as 5 posições preenchidas.

     

    Mas lá na função você tenta usar:

    23 horas atrás, viniciusv21 disse:
    
    se lervetor(x) < lervetor(y) então

     

    Ou seja, como se lervetor() estivesse retornando o valor da posição, mas como citado acima, ela não foi programada para funcionar assim!

     

    Para esse contexto poderia usar algo assim:
     

    se vetorA[x] < vetorA[y]) ENTÃO

    Percebeu a diferença?

     

     

    RESUMINDO:

    - lervetor() irá preencher o vetorA.

    - dizer_maior_numero() irá retornar o maior valor do vetorA.

     

    Logo, para usar o segundo, tem que antes usar o primeiro.

     

     

    No aguardo.

    • Curtir 1

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • Olá, dessa vez eu refiz o algoritmo e ficou assim:

    Algoritmo "Programa que diz o maior número"
    //-----------------------------------
    procedimento leiavetorA()
    var
    inicio
          para i de 1 ate 5 faca
               escreva("Digite um valor (", i , " de 5 ): ")
               leia(vetorA[i])
          fimpara
    fimprocedimento
    //-----------------------------------
    funcao dizer_maior_numero (): real
    var
       a : real
    inicio
          a := vetorA[1]
            para i de 2 ate 5 faca
                 se (a < vetorA[i]) então
                    a <- vetorA[i]
                 fimse
            fimpara
    retorne a
    fimfuncao
    //-----------------------------------
    var
       vetorA : vetor[1..5] de real
       i : inteiro
    inicio
          EscrevaL("----------------------------")
          EscrevaL("        Maior Número        ")
          EscrevaL("----------------------------")
          EscrevaL()
          leiavetorA()
          EscrevaL("----------------------------")
          EscrevaL("O maior valor é:", dizer_maior_numero())
          EscrevaL("----------------------------")
    Fimalgoritmo

    Também quero saber se dá para definir um valor para o vetor onde o usuário informa o tamanho da lista. Por exemplo

    Escreva("Informe o número de valores a comparar")

    Leia(N)

    E o sistema cria um vetor com N posições.

     

    Abraços

    Editado por Simon Viegas
    Alterar tipo de CODE para "C Languages"
    • Curtir 2

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Olá @viniciusv21.
     

    9 horas atrás, viniciusv21 disse:

    Olá, dessa vez eu refiz o algoritmo e ficou assim:

     

    Bacana. O código ficou muito bom!

     

    Só sugiro uma atenção maior na indentação. É preferível que utilize o tamanho do espaçamento (quantidade de espaços) fixo, ou seja, algo em torno de 2 ou 3 espaços. No seu código, tem parte com 6, com 5, com 3... daí o código não fica alinhado.

     

    Segue um exemplo utilizando 3 de espaçamento:

    Algoritmo "Programa que diz o maior número"
    
    //-----------------------------------
    procedimento leiavetorA()
       {var} //não utilizada
       inicio
       para i de 1 ate 5 faca
          escreva("Digite um valor (",i," de 5 ): ")
          leia(vetorA[i])
          fimpara
       fimprocedimento
       
    //-----------------------------------
    funcao dizer_maior_numero():real
       var
          a :real
       inicio
       a:=vetorA[1]
       para i de 2 ate 5 faca
          se (a<vetorA[i]) então
             a<-vetorA[i]
          fimse
       fimpara
       retorne a
    fimfuncao
    
    //-----------------------------------
    var
       vetorA :vetor[1..5] de real
       i :inteiro
    
    inicio
    EscrevaL("----------------------------")
    EscrevaL("        Maior Número        ")
    EscrevaL("----------------------------")
    EscrevaL()
    leiavetorA()
    EscrevaL("----------------------------")
    EscrevaL("O maior valor é:", dizer_maior_numero())
    EscrevaL("----------------------------")
    fimalgoritmo

    Obs.: existem outra características usadas, mas no momento o foco é que devem-se manter uma quantidade de espaços para um dente.

     

     

     

    Sobre:

    9 horas atrás, viniciusv21 disse:

    Também quero saber se dá para definir um valor para o vetor onde o usuário informa o tamanho da lista. Por exemplo

    Escreva("Informe o número de valores a comparar")

    Leia(N)

    E o sistema cria um vetor com N posições.

    Agora me deu um branco... nem lembro se é possível ter "vetores dinâmicos em Visualg"... pesquisei rapidamente e não encontrei, mas de qualquer sorte, você poderia declarar uma vetor "grande" e ler a quantidade, sendo que deve ser >=1 e <= ao tamanho que estipulou.

     

    A declaração das variáveis poderia ficar algo assim:

    //-----------------------------------
    const
       MAX = 20 //tamanho máximo do vetor
    
    var
       vetorA     :vetor[1..MAX] de real
       quantidade :inteiro //quantidade de números escolhido para serem comparados
       i          :inteiro

     

    Ai só ajustar o restante do código para essa estrutura.

     

     

    No aguardo.

    • Curtir 2

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • Opa, desculpa a demora :D

    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

     

    • Curtir 2

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Olá @viniciusv21.

     

    Só uns adendos:

     

    - Você limitou o programa para até 20 números, mas não está tratando da exceção, ou seja, se digitar um número inválido, por exemplo 25, o programa vai travar. Para "resolver" isso você pode usar um laço de repetição até que digite um número válido (1 a 20).

     

    - a nomenclatura de uma função está como "dizer_maior_numero", mas elas não está "dizendo", está mais para "retornando" .

     

    - acharia mais interessante se declarasse as variáveis i e n como locais, assim como foi feito com a variável a. Obs.: nem tem problema em usar a mesma nomenclatura de variáveis em duas funções/procedimentos diferentes.

     

    - não é necessário espaços entre as vírgulas, mas vai do gosto. (não altera em nada o funcionamento do código)

     

    - aqui, no Visualg 3.0.6.5, os números depois do "de" (no "i de n") ficam com um espaço a mais (considero como um bug do Visualg). Para corrigir, ou tira o espaço depois do "de" ou deixa com espaço e usa uma formatação no n, ex.: "n:1".

     

    - Para efetuar testes, é possível utilizar o "ALEATORIO" ou Randi(). Com ele, os números são "digitados" automaticamente. Se tiver interesse, dê uma pesquisada sobre os comandos. O ALEATORIO é mais prático para implementar.. é possível determinar uma faixa de números também, por exemplo de 1 a 99.

     

     

     

    No aguardo.

    • Curtir 1

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  •  

    Citação

    - aqui, no Visualg 3.0.6.5, os números depois do "de" (no "i de n") ficam com um espaço a mais (considero como um bug do Visualg). Para corrigir, ou tira o espaço depois do "de" ou deixa com espaço e usa uma formatação no n, ex.: "n:1".

    Isso estava me dando dor de cabeça rs. Coloquei n:1

     

    Em 26/12/2017 às 09:33, Simon Viegas disse:

    - acharia mais interessante se declarasse as variáveis i e n como locais, assim como foi feito com a variável a. Obs.: nem tem problema em usar a mesma nomenclatura de variáveis em duas funções/procedimentos diferentes.

    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

     

    Editado por Vinícius Werneck

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Olá.

     

    Alguns pontos:

    - Deixe o aleatorio antes do Repita, pois dentro fica como se tivesse reconfigurando o aleatorio várias vezes.

       aleatorio on
       aleatorio 3,25
       Repita
          EscrevaL("Digite a quantidade de números para comparar [Máx: 20]: ")

    Outro ponto é que pode deixar um aleatório para quantidade e outro para os dados... por exemplo,  -10,40 para esse primeiro e 0,99 para os dados. Ou pode tirar o aleatorio  da quantidade e deixar que o usuário digite... e gerando o resto. Ex.:

    procedimento leiavetorA()
    var
       i : inteiro
    inicio
       {aleatorio -10,40} //deixando ler do usuário
       Repita
          EscrevaL("Digite a quantidade de números para comparar [Máx: 20]: ")
          Leia(n)
          Se (n>=20) ou (n<=1) ENTÃO
             EscrevaL("Opção Inválida!")
          Fimse
       Ate (n>=1) e (n<=20)
       aleatorio 0,99
       para i de 1 ate n faca
          escreva("Digite um valor (", i , " de ", n:1, "): ")
          leia(vetorA[i])
       fimpara
       aleatorio off

    Adendo.: observe que o "on" não é necessário quando define uma faixa.

     

    - No número antes do de, também ficou um espaço... ai, poderia tirar o espaço do texto e usar i:2.

     

    ***

     

    No aguardo.

     

     

     

     

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • 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

     

    Editado por Vinícius Werneck
    • Curtir 1

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Olá;

     

    12 horas atrás, Vinícius Werneck disse:

    funcao numero_eh_soh_inteiro(num): logico

    Essa assinatura não está válida. A definição do parâmetro está incorreta e dentro da função não está usando num.

     

     

    Outra coisa, se vai permitir reais, terá que muda o tipo de inteiro para real.

     

     

     

    Em 29/12/2017 às 18:08, Vinícius Werneck disse:

    Não pude colocar a n pois ela é necessária como variável global

     

    Não pôde porquê?

     

     

    Por favor, poste seu código completo para analisarmos.

     

    No aguardo.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • 6 horas atrás, Simon Viegas disse:

    Olá;

     

    Essa assinatura não está válida. A definição do parâmetro está incorreta e dentro da função não está usando num.

     

     

    Outra coisa, se vai permitir reais, terá que muda o tipo de inteiro para real.

     

     

     

     

    Não pôde porquê?

     

     

    Por favor, poste seu código completo para analisarmos.

     

    No aguardo.

    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.

     

    Em 29/12/2017 às 23:59, Simon Viegas disse:

    Olá.

     

    Alguns pontos:

    - Deixe o aleatorio antes do Repita, pois dentro fica como se tivesse reconfigurando o aleatorio várias vezes.

    
       aleatorio on
       aleatorio 3,25
       Repita
          EscrevaL("Digite a quantidade de números para comparar [Máx: 20]: ")

    Outro ponto é que pode deixar um aleatório para quantidade e outro para os dados... por exemplo,  -10,40 para esse primeiro e 0,99 para os dados. Ou pode tirar o aleatorio  da quantidade e deixar que o usuário digite... e gerando o resto. Ex.:

    
    procedimento leiavetorA()
    var
       i : inteiro
    inicio
       {aleatorio -10,40} //deixando ler do usuário
       Repita
          EscrevaL("Digite a quantidade de números para comparar [Máx: 20]: ")
          Leia(n)
          Se (n>=20) ou (n<=1) ENTÃO
             EscrevaL("Opção Inválida!")
          Fimse
       Ate (n>=1) e (n<=20)
       aleatorio 0,99
       para i de 1 ate n faca
          escreva("Digite um valor (", i , " de ", n:1, "): ")
          leia(vetorA[i])
       fimpara
       aleatorio off

    Adendo.: observe que o "on" não é necessário quando define uma faixa.

     

    - No número antes do de, também ficou um espaço... ai, poderia tirar o espaço do texto e usar i:2.

     

    ***

     

    No aguardo.

     

     

     

     

    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 :mellow: 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

     

     

    Editado por Vinícius Werneck

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Olá.

     

     

    1 hora atrás, Vinícius Werneck disse:

    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.

    Verdade. O valor de N está sendo necessário em duas funções distintas, ou seja, após os métodos terminarem, esse valor precisa ficar armazenado.

     

     

    E resumidamente seria:

    - Em relação ao seu código atual, não precisa de parâmetro no Verificar_se_inteiro(), basta usar o n diretamente.

    - Na função Verificar_se_inteiro(), se for usar parâmetro, não use a variável global também.

    - Sugiro que tente passar o máximo de dados externos pelo parâmetro, em vez de usar variáveis globais.

     

     

     

    Na versão estendida...

     

    Já que está acessando a variável global N (em vez de receber por parâmetro) nos 2 métodos, poderia fazer o mesmo com o Verificar_se_inteiro(), ou seja, deixando este método sem receber parâmetro também, simplesmente usando o N global diretamente.

     

    Obs.: Em relação ao código atual, já que estava recebendo, deveria usá-lo, ex.:

       {Se (N <> 0) ENTÃO} //você está recebendo o valor por parâmetro, use-o
       Se (num <> 0) ENTÃO
          Quociente <- num/Int(num)

    Entendeu?

     

     

     

    A minha sugestão é que todos os métodos usem apenas as suas variáveis locais, e tudo que precisa ser externo venha por parâmetro. Isso com exceção do vetor, pois no Visualg não é possível (ou desconheço uma forma). Ex.:

     

    Para as variáveis globais:

    var
       vetorA :vetor[1..MAX] de real //vetor que armazenará os números usados
       n      :inteiro //quantidade de número que serão usados

     

     

     

    E as assinaturas dos métodos:

    procedimento leiaVetorA(var qtdNum:inteiro)

    Recebe a quantidade de números que serão usados (e receberia o vetor também, mas como não dá...).  Faz o que tem que fazer e no final essa variável que foi recebida estará atualizada. Perceba que está recebendo um inteiro, pois a quantidade de número é inteira mesmo... como você implementou a verificação para não aceitar números não inteiros (com fração), usaria outra variável local real para ler, ai verificaria se é inteiro ou não, após obter um inteiro válido, atualizaria a variável qtdNum (que por consequência irá atualizar o n global que é inteiro).

     

    obs.1: teoricamente a nomenclatura da variável do parâmetro pode ser igual a nomenclatura da variável global... ou seja, seriam variáveis distintas com o mesmo nome, mas em escopos diferentes. Para não confundir, deixei propositalmente com outro nome.

     

    obs. 2: perceba que o parâmetro será recebido como referência (com o var), ou seja, a variável alterada dentro do método altera também a variável que foi enviada pelo parâmetro (no final do método, a variável global ficará com o mesmo valor que a variável do parâmetro da função ficou, em detrimento de quando não usa o var, que vai como valor, ou seja, uma cópia apenas do dado que foi passado... a variável de origem fica intacta).

     

     

     

    funcao Verificar_se_inteiro (x:real):logico

    Recebe um real qualquer, faz o que tem que fazer e retorna um lógico na própria função indicando a resposta.  Aqui x tem que ser real mesmo, já que é o número a ser verificado. Não precisa do var, pois o que necessita é apenas o valor do que foi lido. O objetivo da função é retornar se é inteiro ou não.

     

    obs.: perceba que essa função é genérica, ou seja, pode ser usado em outros contextos... outros algoritmos... sem (ou pouca) adaptação. Percebe que nela usei a nomenclatura "x" para sugerir que a função não é algo específico da seu algoritmo, daí não precisaria indicar que é referente ao auxiliar que foi usado para atualizar o qtdNum.

     

     

     

    funcao retorna_maior_numero (qtdNum:inteiro):real

    Assim como na leitura, recebe a quantidade de números (e receberia o vetor também), daí faz o que tem que fazer e retorna a resposta na própria função.

     

     

    Se achar interessante implementar, fique a vontade. Qualquer dúvida ou comentário, fico no aguardo.
     

     

    No aguardo.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • 18 horas atrás, Simon Viegas disse:

    Olá.

     

     

    Verdade. O valor de N está sendo necessário em duas funções distintas, ou seja, após os métodos terminarem, esse valor precisa ficar armazenado.

     

     

    E resumidamente seria:

    - Em relação ao seu código atual, não precisa de parâmetro no Verificar_se_inteiro(), basta usar o n diretamente.

    - Na função Verificar_se_inteiro(), se for usar parâmetro, não use a variável global também.

    - Sugiro que tente passar o máximo de dados externos pelo parâmetro, em vez de usar variáveis globais.

     

    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.

     

    18 horas atrás, Simon Viegas disse:

    obs.1: teoricamente a nomenclatura da variável do parâmetro pode ser igual a nomenclatura da variável global... ou seja, seriam variáveis distintas com o mesmo nome, mas em escopos diferentes. Para não confundir, deixei propositalmente com outro nome.

    Eu gosto mais de usar nomes diferentes para não me confundir rs

    18 horas atrás, Simon Viegas disse:

     

    
    funcao Verificar_se_inteiro (x:real):logico

     

    obs.: perceba que essa função é genérica, ou seja, pode ser usado em outros contextos... outros algoritmos... sem (ou pouca) adaptação. Percebe que nela usei a nomenclatura "x" para sugerir que a função não é algo específico da seu algoritmo, daí não precisaria indicar que é referente ao auxiliar que foi usado para atualizar o qtdNum.

     

    Boa ideia. Vou usar x também . Aí quando precisar fazer outro algoritmo é só eu copiar a função :)

    18 horas atrás, Simon Viegas disse:

     

    
    funcao retorna_maior_numero (qtdNum:inteiro):real

    Assim como na leitura, recebe a quantidade de números (e receberia o vetor também), daí faz o que tem que fazer e retorna a resposta na própria função.

     

     

    Se achar interessante implementar, fique a vontade. Qualquer dúvida ou comentário, fico no aguardo.
     

     

    No aguardo.

    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

     

    • Curtir 1

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Crie uma conta ou entre para comentar

    Você precisar ser um membro para fazer um comentário






    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

    ×