VisualG Vetor com números aleatórios sem repetição no VisuAlg

Antoniorr · 2 de novembro de 2014

Olá a todos, venho solicitar a ajudar de vocês no seguinte problema:

Um algoritmo, implementado no Visualg, que insere números aleatórios sem repetição em um vetor com 10 números, por exemplo.

Já queimei todos os meus neurônios tentando resolver isso e não consegui até o momento. vi que tem solução em outras linguagens, mas no Visualg não encontrei solução.

Segue o código que eu achava que resolveria o problema;

algoritmo "semnome"
var
   vet: vetor [0..9] de inteiro
inicio
para i de 0 ate 9 faca
   vet[i] <- Randi(10)
   se i > 0 então
      para j de 0 ate i-1 faca
         se vet[i] = vet[j] então
            vet[i] <- randi(10)
            j <- 0
         fimse
      fimpara
   fimse
   escreval(vet[i])
fimpara
fimalgoritmo

Se puderem ajudar, agradeço. ou me informar se é possível ou não fazer isso.

Obrigado.

Só acrescentando que esse algoritmo ai em cima tá repetindo os números.

Catí Kurumim 7 · 15 de novembro de 2014

Infelizmente não existe nenhum artifício no visualg que possa dar essa solução.

Antoniorr · 23 de novembro de 2014

Infelizmente não dá mesmo. Já no Java é possível com o seguinte código:

package teste;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class Teste {
   private static final int LIMITE = 10;
   private static final int QUANT = 10;
   String resp;
   public static void main(String[] args) {
      metodo1();
      System.out.println();
   }
   private static void metodo1() {
      List<Integer> lista = new ArrayList<Integer>();
      for (int i = 1; i <= LIMITE; i++) {
         lista.add(i);
      }
      Random random = new Random();
      for (int i = 0; i < QUANT;i++) {
         // 4 - repita os passos 2 e 3 19 vezes
         int max = lista.size();
         int indice = random.nextInt(max);
         int valor = lista.remove(indice);
         System.out.println(valor + " ");
      }
   }
}

De qualquer forma, agradeço.

MrVictor · 27 de abril de 2018

Desculpe a ressuscitação, pois só quero deixar a solução para posteriores pesquisas, assim como fiz agora e não encontrei.

No Visualg dá sim.

Estive a procurar por isso e não encontrei em lugar algum.

Mas trago a solução que eu mesmo fiz. Após isso, seria interessante fechar o tópico rs. Aí não corre risco de ressuscitações posteriores.

algoritmo "FCdH"
var
  i,p:inteiro
  v  :vetor [1..5] de inteiro
inicio
para i de 1 ate 5 faca
   v[i] <- p
   enquanto (p = v[1]) ou (p = v[2]) ou (p = v[3]) ou (p = v[4]) ou (p = v[5]) faca
      p<-randi(5)
   fimenquanto
fimpara
fimalgoritmo

Simon Viegas · 27 de abril de 2018

Olá.

Tópico é antigo, mas vamos tentar recapitular.

Obs.: Fiz análises utilizando o Visualg 2.0 (hoje está na versão 3.0.6.5, creio que não ia fazer diferença, mas não custa utilizar a versão antiga),

Vamos lá:

Vamos inicialmente analisar o código do @Antoniorr:

Em 02/11/2014 às 16:22, Antoniorr disse:

Segue o código que eu achava que resolveria o problema;


algoritmo "semnome"
var
   vet: vetor [0..9] de inteiro
inicio
para i de 0 ate 9 faca
   vet[i] <- Randi(10)
   se i > 0 então
      para j de 0 ate i-1 faca
         se vet[i] = vet[j] então
            vet[i] <- randi(10)
            j <- 0
         fimse
      fimpara
   fimse
   escreval(vet[i])
fimpara
fimalgoritmo

1#

Faltou declarar as variáveis i e j.

Algo assim:

var
   vet  :vetor [0..9] de inteiro
   i,j  :inteiro

2#

         se vet[i] = vet[j] então
            vet[i] <- randi(10)
            j <- 0 //esse comanda inválido!!!
         fimse

Então, particularmente considero essa "tentativa de zerar o j" como uma falha na lógica... o programador não poderia fazer esse procedimento... entretanto, de qualquer forma o Visualg não aceita, ou seja, mesmo que zere o j, ao continuar, o para retoma para o valor anterior!!! Ou seja, se j tiver com 3, você ali diz que ela valerá 0... na próxima linha ele volta a ser 3 novamente!!! O para projeto o valor da variável!!!

Resumindo:

Apesar de fazer sentido... a lógica é inválida (no sentido técnico)... e ao mesmo tempo o Visualg não aceita (desfaz a alteração sozinho).

3#

Então, a ideia da lógica em si está correta, apenas ocorre o citado no item 2#.

Para corrigir, poderia apenas reformular com outro estrutura de repetição. Ex.:

algoritmo "FCdH"
var
   vet  :vetor [0..9] de inteiro
   i,j  :inteiro
inicio
para i de 0 ate 9 faca
   vet[i] <- Randi(10)
   se i > 0 então
      j <- 0
      enquanto (j < i) faca
         se vet[i] = vet[j] então
            vet[i] <- randi(10)
            j <- 0
         senao
            j <- j+1
         fimse
      fimenquanto
   fimse
   escreval(vet[i])
fimpara
fimalgoritmo

Pronto. Problema resolvido.

***

Agora vamos analisar o código do @MrVictor .

1 hora atrás, MrVictor disse:


algoritmo "FCdH"
var
  i,p:inteiro
  v  :vetor [1..5] de inteiro
inicio
para i de 1 ate 5 faca
   v[i] <- p
   enquanto (p = v[1]) ou (p = v[2]) ou (p = v[3]) ou (p = v[4]) ou (p = v[5]) faca
      p<-randi(5)
   fimenquanto
fimpara
fimalgoritmo

4#

A posição 1 sempre está ficando com 0. Creio que isso é uma falha, já que não está aleatória. Precisa ser corrigido.

5#

O código aqui ficou num loop infinito... não consegue sortear para última posição.

***

No aguardo.

MrVictor · 27 de abril de 2018

17 horas atrás, Simon Viegas disse:
Olá.

Tópico é antigo, mas vamos tentar recapitular.

Obs.: Fiz análises utilizando o Visualg 2.0 (hoje está na versão 3.0.6.5, creio que não ia fazer diferença, mas não custa utilizar a versão antiga),

Vamos lá:

Vamos inicialmente analisar o código do @Antoniorr:

1#

Faltou declarar as variáveis i e j.

Algo assim:
var
   vet  :vetor [0..9] de inteiro
   i,j  :inteiro
2#
         se vet[i] = vet[j] então
            vet[i] <- randi(10)
            j <- 0 //esse comanda inválido!!!
         fimse
Então, particularmente considero essa "tentativa de zerar o j" como uma falha na lógica... o programador não poderia fazer esse procedimento... entretanto, de qualquer forma o Visualg não aceita, ou seja, mesmo que zere o j, ao continuar, o para retoma para o valor anterior!!! Ou seja, se j tiver com 3, você ali diz que ela valerá 0... na próxima linha ele volta a ser 3 novamente!!! O para projeto o valor da variável!!!

Resumindo:

Apesar de fazer sentido... a lógica é inválida (no sentido técnico)... e ao mesmo tempo o Visualg não aceita (desfaz a alteração sozinho).

3#

Então, a ideia da lógica em si está correta, apenas ocorre o citado no item 2#.

Para corrigir, poderia apenas reformular com outro estrutura de repetição. Ex.:
algoritmo "FCdH"
var
   vet  :vetor [0..9] de inteiro
   i,j  :inteiro
inicio
para i de 0 ate 9 faca
   vet[i] <- Randi(10)
   se i > 0 então
      j <- 0
      enquanto (j < i) faca
         se vet[i] = vet[j] então
            vet[i] <- randi(10)
            j <- 0
         senao
            j <- j+1
         fimse
      fimenquanto
   fimse
   escreval(vet[i])
fimpara
fimalgoritmo
Pronto. Problema resolvido.

***

Agora vamos analisar o código do @MrVictor .

4#

A posição 1 sempre está ficando com 0. Creio que isso é uma falha, já que não está aleatória. Precisa ser corrigido.

5#

O código aqui ficou num loop infinito... não consegue sortear para última posição.

***

No aguardo.

Esqueci de testar o código, simplesmente peguei o pedaço aqui que seria interessante ao autor do tópico, e colei. (Falha minha rs.)

Segue o algoritmo corrigido e funcionando (testei no visualg 3).

Algoritmo "victor"

var
   i,p:inteiro
   v  :vetor [1..5] de inteiro
inicio
   p<-1
   para i de 1 ate 5 faca
      v[i]<-p
      enquanto (p = v[1]) ou (p = v[2]) ou (p = v[3]) ou (p = v[4]) ou (p = v[5]) faca
         p<-randi(6)
      fimenquanto
   fimpara
fimalgoritmo

adicionado 1 minuto depois

Acontece que se deixar o randi com valor 5, ele pega valores aleatórios até 4, por isso deve-se colocar 1 posição a mais do q você precisa.

isrnick · 27 de abril de 2018

Basta preencher um vetor com os números no intervalo, e depois usar um algoritmo para embaralhar os números no vetor:

algoritmo "Embaralha"
var
   vet : vetor [0..9] de inteiro
   i,n,m : inteiro
inicio
    //Preenche o vetor com todos os numeros de 0 a 9
    para i de 0 ate 9 faca
       vet[i] <- i
    fimpara
    //Embaralha os numeros no vetor usando o algoritmo Knuth Fisher-Yates
    para i de 9 ate 1 passo -1 faca
       n <- randi(i+1)
       m <- vet[i]
       vet[i] <- vet[n]
       vet[n] <- m
    fimpara
    //Imprime os numeros do vetor
    para i de 0 ate 9 faca
       escreval(vet[i])
    fimpara
fimalgoritmo

Simon Viegas · 28 de abril de 2018

Olá.

1#

@MrVictor, sobre:

18 horas atrás, Simon Viegas disse:

4#

A posição 1 sempre está ficando com 0. Creio que isso é uma falha, já que não está aleatória. Precisa ser corrigido.

A mesma falha ainda persiste, apenas que agora sempre está ficando com 1.

2#

@MrVictor, sobre:

17 horas atrás, MrVictor disse:

Acontece que se deixar o randi com valor 5, ele pega valores aleatórios até 4, por isso deve-se colocar 1 posição a mais do q você precisa.

O randi() estava certo, o que estava falhando era a lógica do algoritmo... Ao usar rand(5), está sorteando 5 possibilidades: de 0 a 5... até ai está certo... o que acontece, é que o algoritmo está "queimando" um número no processo, ou seja, dos 5 números, apenas 4 ficam disponíveis, daí o algoritmo não conseguia encontrar um quinto, e ficava num loop infinito.

Ao aumentar a faixa, resolveu o problema da quantidade, mas manteve o problema de desperdiçar um número.

3#

@isrnick, interessante esse algoritmo do "Knuth Fisher-Yatse". Só não consegui encontrar muitas informações na internet, vi basicamente o Wikipedia ... não achei um vídeo falando do cara, rs.

***

No aguardo,

isrnick · 28 de abril de 2018

Procure por Fisher-Yates shuffle ou Knuth shuffle, tem vários vídeos:

Boko Moko · 30 de abril de 2018

eu faria assim

Criaria o vetor com os números de 1 a 10. Coloque-os na ordem normal.

Em outro vetor de 10 posições, coloque números aleatórios entre 1 e 1000 e some a ele a o número do vetor dividido por 10. Isso garantirá que existem 10 números distintos.

Utilize o segundo vetor como indexador do primeiro vetor e terá os 10 números originais em uma ordem aleatória.

JuniorFrota · 12 de maio de 2018

Eu estava com a mesma dúvida. Ontem aconteceu a festinha dos dias das mães na escola em que eu trabalho e foi feito um sorteio de brindes. O complicado foi ter que ditar números que ainda não haviam sido chamados. Daí eu tive a ideia de criar um algoritmo que gerasse números aleatórios não repetitivos e deu nisso:

algoritmo "Números Aleatórios Não Repetidos"
// Função : Gerar números aleatórios de 1 até 100 sem repetição.
// Autor : Junior Frota
// Data : 11/05/2018
// Seção de Declarações
var
n,m, i, j, k : inteiro
a : vetor[0..99] de inteiro
c : caractere

inicio
// Seção de Comandos
para i de 0 ate 99 faca
repita
m <- randi(100)
n <- m + 1
para j de 0 ate i faca
se (a[j] = n) então
k <- k + 1
fimse
fimpara
se (k = 0) então
a <- n
escreval(a)
interrompa
senao
k <- 0
fimse
fimrepita
k <- 0
fimpara
fimalgoritmo

Dependendo da quantidade de números que precisa ser gerado, basta modificar a dimensão do vetor (a : vetor[0..99] de inteiro), o limite máximo de iteração do comando para (para i de 0 ate 99 faca) e o range da função randi, colocando sempre um a mais do que a dimensão do vetor (m <- randi(100)).

O m recebe o valor aleatório, mas como tem a possibilidade de gerar o número zero, e isso não satisfaz a função do algoritmo, então n recebe m mais um. Isso faz gerar números de 1 até 100, neste caso.

Espero que tenha ajudado, uma vez que sua postagem é de 2014.

isrnick · 12 de maio de 2018

@JuniorFrota Para postar códigos no fórum use a tag CODE apertando o botão <> no campo de resposta. O fórum sumiu com os [ i ] do seu código pois ele está fora a tag CODE.

O problema do seu código é que ele é muito ineficiente, pois vai ficar sorteando números repetidos, e quanto mais números aleatórios já tiverem sido sorteados maior a chance de repetir, o que significa que o seu programa vai pode ter que ficar re-sorteando centenas ou milhares de vezes até achar um número que ainda não foi sorteado. Além de que toda vez que sortear um número ele tem que checar o vetor inteiro de números aleatórios que já apareceram.

Dê uma olhada no meu código usando um algoritmo para embaralhar um vetor contendo todos os números do intervalo, é uma solução bem mais eficiente.

Rafael Cezar · 26 de novembro de 2022

Olá a todos. Meio "tarde" para ressuscitar esse post, mas eu queria compartilhar a solução simples e rápida que eu consegui achar para esse problema que você teve. Não sei se você já conseguiu resolver esse problema, creio que sim, mas queria deixar registrado uma das soluções para caso alguém tenha esse mesmo problema.

Basicamente, eu criei um vetor do tipo inteiro e 3 variáveis, sendo uma variável para armazenar a posição do índice do vetor, uma outra variável para a estrutura de repetição que vai realizar de adicionar os números aos índices do vetor, e a última variável que será para a outra estrutura de repetição que servirá para mostrar todos os números gerados e que foram adicionados ao vetor.

A variável I será a variável que servirá para armazenar o número aleatório que foi gerado. Eu optei por gerar qualquer número entre 0 e 100 por dar mais opções de números que podem ser gerados. Para que, depois de gerado o número, não seja gerado outro número no mesmo índice, eu usei a função de incremento para aumentar a posição do índice antes da estrutura de repetição repetir a mesma instrução dada à maquina;
A variável C será a variável que servirá de guia para a estrutura de repetição "Para" saber em qual parte está e quando deve ser finalizada;
A variável R servirá para a segunda estrutura de repetição, a qual mostra na tela para o usuário cada número gerado.

A estrutura de repetição que usei é a função Para, por ser a mais simples e melhor para trabalhar com esse tipo de problema na minha opinião. O código basicamente ficou assim:

Algoritmo "NumeroAleatorioVetor"
Var
     Numero: vetor[0..9] de Inteiro
     I, C, R: Inteiro
Inicio

   Para C de 0 ate 9 Faca
      Numero[I] <- RandI(100)
      I <- I + 1
      C <- C + 1
   FimPara
  
   Para R de 0 ate 9 Faca
      Escreval(Numero[R])
      R <- R + 1
   FimPara
Fimalgoritmo

Aqui está um print de um teste que eu fiz:

Espero ter ajudado alguém

Simon Viegas · 26 de novembro de 2022

@Rafael Cezar, a ideia ficou muito boa, mas teu algoritmo não atende ao requisito do problema.

Em 02/11/2014 às 17:22, Antoniorr disse:

Um algoritmo, implementado no Visualg, que insere números aleatórios sem repetição em um vetor com 10 números, por exemplo.

Em nenhum momento do teu algoritmo está sendo tratada a "não repetição de valores", ou seja, é possível que valores se repitam.

Exemplo para demonstrar:

Outro ponto é que o laço de repetição para "já controla a sua varável de controle"... ou seja, não precisa/não deve ficar atualizando ela dentro do laço.

Em vez de:

2 horas atrás, Rafael Cezar disse:

   Para C de 0 ate 9 Faca
      Numero[I] <- RandI(100)
      I <- I + 1
      C <- C + 1
   FimPara

Seria algo como:

   para i de 0 ate 9 Faca
      numero[i] <- RandI(100)
   fimPara

Observe que deixei o i para ser usado como controle... mas tanto faz... se utilizar c, r, girafa, dkadkwkdw, ou qualquer nome válido. O ponto aqui que a variação dessa variável será justamente a variação das posições do vetor, logo, poder ser usado diretamente no vetor.

Sobre:

2 horas atrás, Rafael Cezar disse:

A variável I será a variável que servirá para armazenar o número aleatório que foi gerado. [...]

Então, quem armazena o valor é o vetor... a variável i serve apenas para controlar a posição do vetor.

Seu código simplifica poderia ficar assim:

algoritmo "Número Aleatório Vetor"
var
     numero: vetor[0..9] de Inteiro
     i, c, r: Inteiro
inicio
   para i de 0 ate 9 Faca
      numero[i] <- RandI(100)
   fimPara

   para i de 0 ate 9 Faca
      escreval(numero[i])
   fimPara
fimAlgoritmo