VisualG Reiniciar variável contadora no laço de repetição "para"

Fábio Tempesta · 12 de abril de 2018

Tenho o seguinte exercício: Construa um algoritmo que leia os valores de 10 números inteiros e diferentes entre si. (Usando o laço de repetição para, nao podendo usar o enquanto)

algoritmo "semnome"
var
   i1,i2:inteiro //i1 e i2: contadores para laços de repetições
   n:vetor[1..10] de inteiro //n: vetor para receber os números

inicio

   para i1 de 1 ate 10 faca
      escreva("Informe o valor do",i1,"º número:")
      leia (n[i1])
      para i2 de 1 ate i1 faca
         se (i1>i2) e (n[i1]=n[i2]) então
            escreval ("Número já informado, informe outro número:")
            leia (n[i1])
            i2<-0
         fimse
      fimpara
   fimpara

fimalgoritmo

O problema é que eu queria que a variável i2 reiniciasse assim que recebesse um novo valor para (n[i1]). O que acontece é que esse "i2<-0" é completamente ignorado e a variável contadora continua seu laço de repetição da onde ela tinha parado anteriormente como se eu nao tinha dado o comando para ela atribuir o valor 0.

Simon Viegas · 13 de abril de 2018

Olá.

1#

12 horas atrás, Fábio Tempesta disse:

O problema é que eu queria que a variável i2 reiniciasse assim que recebesse um novo valor para (n[i1]).

A variável i2 não pode ser mexida... ela é controlada pelo para. Pelo menos eu vejo isso como uma quebra de lógica..., ou seja, se o para é de, por exemplo, 1 a 10, tem que fazer de 1 a 10. Caso contrário, utilize outra estrutura, como repita ou enquanto.

RESUMINDO:

Por enquanto, entenda que você não pode mexer na variável que está sendo controlada pelo para.

2#

13 horas atrás, Fábio Tempesta disse:

O que acontece é que esse "i2<-0" é completamente ignorado e a variável contadora continua seu laço de repetição da onde ela tinha parado anteriormente como se eu nao tinha dado o comando para ela atribuir o valor 0.

O que acontece é que, por algum motivo, o Visualg de fato não se importa com a alteração... ao fluxo loop terminar, o i2 volta para posição original, ou seja, desfaz a alteração.

Então... aqui estamos no mesmo contexto... ou seja, a princípio, você não pode mexer no i2!!!. Mesmo que estivesse funcionando, beleza? Eu entendo como um erro de lógica! (obs.: eu só descobrir que o Visualg "protege" o valor agora fazendo testes... não sei se é um bug do Visualg ou se é proposital... mas talvez em outras linguagens isso não aconteça, ou seja, seria possível alterar, mas como disse... a princípio, isso seria uma erro. Pelo menos vejo assim)

RESUMINDO:

O para de Visualg está desfazendo a alteração feita dentro do laço, e continua a contagem como se nada tivesse acontecido.

Entretanto, mesmo que isso não ocorresse, não poderia mexer no i2. Teria que procurar outra possível solução.

3#

Uma formar seria utilizando uma flag. Ela servirá para identificar se o número está repetido ou não... Daí, seria também necessário uma novo laço de repetição, para ficar tentando ler até que não seja repetido... ou seja...

É um laço para ler os x números;

Um laço para ficar lendo uma mesma posição até que seja único;

E o laço para "varrer" o vetor para ver se é repetido ou não.

Abaixo um exemplo de como poderia ficar:

algoritmo "semnome"
var
   i1, i2   :inteiro //i1 e i2: contadores para laços de repetições
   n        :vetor[1..10] de inteiro //n: vetor para receber os números
   Repetido :logico //flag que marca se o número é repetido ou não

inicio
//PARA LEITURA DOS NÚMEROS
para i1 de 1 ate 10 faca
   repita
      //LER O NÚMERO A SER CADASTRADO
      escreva("Informe o valor do",i1,"º número:")
      leia (n[i1])
      //VERIFICA SE O NÚMERO JÁ EXISTE NO VETOR
      Repetido <- FALSO //inicializa como "não repetido"
      para i2 de 1 ate i1-1 faca //-1 porque não deve comparar com a prípria posição
         se (n[i1]=n[i2]) ENTÃO //se os valores forem iguais
            Repetido <- VERDADEIRO //marca como reptido (já cadastrado)
            escreval("Número já cadastrado na posição",i2)
         fimse
      fimpara
   ate (nao (Repetido)) //verifica se foi marcado como repetido
fimpara
fimalgoritmo

4#

Se analisar bem, verás que mesmo após achar o número, o segundo para continuará verificando... ou seja, se já foi encontrado um repetido, não precisaria continuar... Primeiro por que basta ter um repetido... segundo por que não terá outros.. já que para um número ser cadastrado, antes foi também feita essa verificação, logo, não existirá mais de um número repetido...

Existem algumas formas:

- Fazer o i2 ter um valor que interromperia o para. Certo? NÃO! Não poderia. Como sugiro, isso não pode ser feito! (e como citado, o Visualg não está permitindo)

- Outra forma seria utilizar uma outra flag e mudar de para para enquanto ou repita, daí ia controlando o i2, e só continuaria o loop de acordo com a flag.

- Utilizar o comando interrompa. Esse comando serve para interromper o laço... obs.: eu também acho essa estrutura errônea... mas é menos mal do que mexer diretamente na variável (i2). Ficaria algo assim:

algoritmo "semnome"
var
   i1, i2   :inteiro //i1 e i2: contadores para laços de repetições
   n        :vetor[1..10] de inteiro //n: vetor para receber os números
   Repetido :logico //flag que marca se o número é repetido ou não

inicio
//PARA LEITURA DOS NÚMEROS
para i1 de 1 ate 10 faca
   repita
      //LER O NÚMERO A SER CADASTRADO
      escreva("Informe o valor do",i1,"º número:")
      leia (n[i1])
      //VERIFICA SE O NÚMERO JÁ EXISTE NO VETOR
      Repetido <- FALSO //inicializa como "não repetido"
      para i2 de 1 ate i1-1 faca //-1 porque não deve comparar com a prípria posição
         se (n[i1]=n[i2]) ENTÃO //se os valores forem iguais
            Repetido <- VERDADEIRO //marca como reptido (já cadastrado)
            escreval("Número já cadastrado na posição",i2)
            interrompa
         fimse
      fimpara
   ate (nao (Repetido)) //verifica se foi marcado como repetido
fimpara
fimalgoritmo

5#

Para demonstrar a diferença de um código para o outro, ao mesmo tempo demonstrando como é possível criar estruturas para testar... seguem os 2 códigos:

1- CÓDIGO SEM O CONTROLE E REPETIÇÕES

algoritmo "semnome"
var
   i1, i2   :inteiro //i1 e i2: contadores para laços de repetições
   n        :vetor[1..10] de inteiro //n: vetor para receber os números
   Repetido :logico //flag que marca se o número é repetido ou não

inicio
//PARA LEITURA DOS NÚMEROS
para i1 de 1 ate 10 faca
   repita
      //LER O NÚMERO A SER CADASTRADO
      escreva("Informe o valor do",i1,"º número:")
      leia (n[i1])
      //VERIFICA SE O NÚMERO JÁ EXISTE NO VETOR
      Repetido <- FALSO //inicializa como "não repetido"
      para i2 de 1 ate i1-1 faca //-1 porque não deve comparar com a prípria posição
         escreval("[DEBUG] Loop",i2) //inserir apenas para demonstrar o número do loop
         se (n[i1]=n[i2]) ENTÃO //se os valores forem iguais
            Repetido <- VERDADEIRO //marca como reptido (já cadastrado)
            escreval("Número já cadastrado na posição",i2)
         fimse
      fimpara
   ate (nao (Repetido)) //verifica se foi marcado como repetido
fimpara
fimalgoritmo

Perceba que mesmo após verificar que é repetido, o programa continua verificado os próximo (como citado, bastaria um ser repetido, e também não poderia ser repetido, já que não dá para cadastrar repetidos... logo, uma perda de tempo e recursos).

2- CÓDIGO QUE PARA DE VERIFICAR QUANDO REPETIDO

algoritmo "semnome"
var
   i1, i2   :inteiro //i1 e i2: contadores para laços de repetições
   n        :vetor[1..10] de inteiro //n: vetor para receber os números
   Repetido :logico //flag que marca se o número é repetido ou não

inicio
//PARA LEITURA DOS NÚMEROS
para i1 de 1 ate 10 faca
   repita
      //LER O NÚMERO A SER CADASTRADO
      escreva("Informe o valor do",i1,"º número:")
      leia (n[i1])
      //VERIFICA SE O NÚMERO JÁ EXISTE NO VETOR
      Repetido <- FALSO //inicializa como "não repetido"
      para i2 de 1 ate i1-1 faca //-1 porque não deve comparar com a prípria posição
         escreval("[DEBUG] Loop",i2) //inserir apenas para demonstrar o número do loop
         se (n[i1]=n[i2]) ENTÃO //se os valores forem iguais
            Repetido <- VERDADEIRO //marca como reptido (já cadastrado)
            escreval("Número já cadastrado na posição",i2)
            interrompa
         fimse
      fimpara
   ate (nao (Repetido)) //verifica se foi marcado como repetido
fimpara
fimalgoritmo

Nesse caso, o para é "forçadamente interrompido"!. O que diminui a quantidade de loops.

Ou seja, ambos o códigos são eficazes, mas o segundo é mais eficiente.

***

Qualquer dúvida é só perguntar.

No aguardo.

Fábio Tempesta · 21 de abril de 2018

Muito boa cara, obrigado de verdade mesmo, desculpa só responder agora, estava meio ocupado com algumas coisas. Eu nesse meio tempo pensei igual dessa primeira maneira que você fez e está funcionando certinho, meu professor me soltou uma que não pode usar vetor porque ele não tinha ensinado ainda. Resumindo: vou ter que mudar o algoritmo praticamente que inteiro . . mas muito obrigado, nao sabia que tinha um jeito ainda mais eficiente de se fazer isso!

adicionado 11 minutos depois

Acabei de colocar em prática aqui, código limpo, coisa bonita de se ver kkk.

Simon Viegas · 21 de abril de 2018

Olá.

54 minutos atrás, Fábio Tempesta disse:

meu professor me soltou uma que não pode usar vetor porque ele não tinha ensinado ainda

Não pode usar vetores? sério? vai dar uma trabalheira danada.

Já conseguiu resolver, posta o código aqui para analisarmos e se tiver dúvidas, onde...

Fábio Tempesta · 23 de abril de 2018

Em 20/04/2018 às 23:45, Simon Viegas disse:

Não pode usar vetores? sério? vai dar uma trabalheira danada.

Já conseguiu resolver, posta o código aqui para analisarmos e se tiver dúvidas, onde...

Ainda não comecei, estou meio sem tempo, mas acho que com vetor seria mais difícil a lógica. Esse sem vetor acho que será mais fácil, porém mais trabalhoso. A lógica já está desenvolvida, agora é a parte trabalhosa kk.

Assim que der tempo de fazer eu posto aqui.

Simon Viegas · 24 de abril de 2018

Sugestão: tente fazer com apenas 5 números. A lógica será a mesma, mas reduzirá um pouco a trabalheira inicial. Após tudo pronto, reorganiza para 10.

Fábio Tempesta · 25 de abril de 2018

Você vai pro céu cara kkk

Boko Moko · 27 de abril de 2018

Tem algo errado no enunciado.

Para saber se 10 números informados são distintos, serão necessárias 10*9/2 comparações. Ou seja 45 se's

Verifique novamente o enunciado. Se for verdadeiro, vale denunciar o seu professor a Comitê Internacional de Direitos Humanos porque isso é uma crueldade acho que pior só o extermínio dos judeus na segunda guerra.