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

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

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

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

 

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

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

×