Sortear números mega-sena

Você pode usar um vetor 'usados[ ]', onde usados[i] = 1 indica que o valor 'i' já foi sorteado!

public class MegaSena {

    protected int[] sorteados;
    protected int[] usados;

    public MegaSena(){

	sorteados=new int[6];
	usados = new int[61];
    }
    public int sorteio(){

	for(int i=0; i<6; i++){

	    int sort=((int)Math.random()*60)+1;
	    if(usados[sort] != 1){ 
		sorteados[i]=sort;
		usados[sort] = 1;
	    }
	}
	// Limpa o vetor para usar uma próxima vez...
	for(int i=0; i<6; i++)
	    usados[ sorteados[i] ] = 0;
    }
}

Olá Thais ^^ , blza?

Veja se da uma luz. Eu tive que fazer um desse tbm, mas o professor ficava pedindo para fazer pensando em processamento e tals, mas não vamos pensar nisso agora.
O que vc pode pensar é o seguinte:

Cada vez que for sorteado, verifica se existe um número igual no vetor. Não inclua logo de cara. Se existir, sorteia novamente. Se não, inclua.
Depois, faça uma ordenação e exiba.

Este não é o jeito que o meu professor gostou, mas pode dar uma boa ajudada.

Tente fazer e depois mande o código de novo.

Abraço

Ah, eu vi que vc esta com uma dúvida sobre comparação.
Pensa no seguinte:

Vc já sorteou o número, e agora precisa comparar com os demais do vetor.
Crie um outro laço de repetição, comparando a sua nova variável com cada índice do vetor.
Outra coisa. Sempre que vc incluir efetivamente um valor, incremente uma variável, como se fosse “quantidade de números sorteados até o momento”. Pois quando vc for fazer a comparação, vc não vai percorrer o vetor completo, só até “quantidade de números sorteados até o momento”.

public int sorteio() { int quantidade = 0; for(int i=0; i<6; i++) { int sort=((int)Math.random()*60)+1; if(quantidade == 0){ sorteados[i]=sort quantidade++; }else{ while(quantidade < 6){ //Implemente aqui seu método de ordenação e insere no próximo indice. //Ex: o Método Bolha que os profs adoram ensinar XD. quantidade++; }

Confundi mais???
É que é complicado explicar algumas lógicas. Se vc preferir eu coloco o meu código aqui pra vc ver as idéias.

Abraço.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class MegaSena {
    public static void main(String[] args) {
        List<Integer> urnaDeBolas = new ArrayList<Integer>(60); //cria uma urna para 60 bolas
        for(int i = 1; i<=60; i++)
            urnaDeBolas.add(i); //adciona as bolas de 1 ate 60 na urna...

        int[] resultados = new int[6]; //lugar onde guardar os resultados

        Random roleta = new Random(); //cria uma roleta para o sorteio

        for(int i = 0 ; i < 6; i++) {
            Collections.shuffle(urnaDeBolas); //embaralhando as bolas da urna.
            int indexSorteado = roleta.nextInt(urnaDeBolas.size());
            resultados[i] = urnaDeBolas.remove(indexSorteado);
            //remove uma bola da urna, sorteada entre o index 0 e o numero de bolas
            //na urna, esse index não quer dizer quer será o proprio numero
            //e raramente será... ele é somento o indice da bola q será sorteada
            //que foi previamente embaralhada
        }
        System.out.println(Arrays.toString(resultados)); //imprime os resultados
    }
}

embaralhar os itens da urna é opicional... mas fica mais parecido com o sorteio da mega sena...
Collections.shuffle(urnaDeBolas);

vc pode omitir o embaralhamento, o resultado continuará valido, e imprevisivel, alem de nunca haver repetições...

rodei ele aki algumas vezes... segue resultados

[37, 22, 5, 30, 32, 1]
[26, 58, 19, 25, 32, 2]
[41, 24, 12, 33, 51, 20]
[34, 59, 43, 57, 9, 1]
[43, 22, 8, 17, 34, 23]
[55, 40, 59, 37, 9, 22]
[56, 45, 53, 29, 37, 28]

se quiser que o resultado seja impresso em ordem crescente... basta usar

Arrays.sort(resultados);

Você poderia facilitar a tua própria vida e estruturar teu código da maneira que você pensa:

import java.util.Random;

public class MegaSena
{
    private int[] sorteados;

    public int[] sortear()
    {
        sorteados = new int[6];

        for (int i = 0; i < sorteados.length; i++)
        {
            int numero = sortearUmNumero();

            while (jaFoiSorteado(numero))
            {
                numero = sortearUmNumero();
            }

            sorteados[i] = numero;
        }

        return sorteados;
    }

    Random r = new Random();
    private int sortearUmNumero()
    {
        return r.nextInt(60) + 1;
    }

    private boolean jaFoiSorteado(int numero)
    {
        for (int i = 0; i < sorteados.length; i++)
        {
            if (sorteados[i] == numero)
                return true;
        }

        return false;
    }
}

Sem nenhum comentário você consegue entender? Caso afirmativo, o código está do jeito certo.

se não pode usar nada novo paciencia… mas c não pode o que vc precisa saber é o seguinte…

vc vai precisar de uma array de 6 posições para guardar o resultado

private int[] resultado = new int[6];

o sorteio vc pode separar em um método, ai ficaria mais legivel…
sorteia um numero de (0 a 59) + 1 … ou seja de 1 a 60

public int sortear() { return Math.random()*59+1; }

ai vc precisa fazer um método para saber se um item é repetido

public boolean isRepetido(int sorteado) { for (int i = 0; i < resultado.length; i++) if (resultado[i] == sorteado ) return true; return false; }

e então vc precisara sortear o resultado, são 6 sorteios (que é o tamanho da array), porem vc deve repetir o sorteio, enquanto houver números que ja foram sorteados.

public void sortearResutados() { for(int i = 0; i < resultado.length; i++) { int sorteado = 0; do { sorteado = sortear(); } while(isRepetido(sorteado)); resultado[i]=sorteado; } }

ai é bom colocar um método para retornar o resultado

public int[] getResultado() { return resultado; }

portanto assim, vc pode realizar o sorteio e garantir que não houver repetições, além de separar bem as responsabilidades do seu código…

ai bastaria instancia o objeto… executar .sortearResultado() e depois .getResultado()

Outra maneira de resolver o problema, normalmente mais rápida pois não depende de sorte, é fazer um conjunto de 60 números diferentes e desse conjunto remover a quantidade de números que você quer, assim como acontece no sorteio de verdade.

Quando remover um número desse conjunto, no próximo sorteio ele não vai estar no conjunto, somente números não sorteados vão estar lá.

Bruno Laturner:

Outra maneira de resolver o problema, normalmente mais rápida pois não depende de sorte, é fazer um conjunto de 60 números diferentes e desse conjunto remover a quantidade de números que você quer, assim como acontece no sorteio de verdade.

Quando remover um número desse conjunto, no próximo sorteio ele não vai estar no conjunto, somente números não sorteados vão estar lá.

é eu fiz isso, a uns 4 posts atras… mas ela falou q o professor não aceitaria classes q ela ainda n viu na faculdade

Ah, sobre o sorteio ali, tem que ser

sorteado[i]=(int)Math.random()*60+1;

multiplicado por 60, pq o Math.random sorteia um número <=0.0 e >1, ou seja, o 60 não está incluído
se eu fizesse assim estaria certo?

public class MegaSena { protected int[] sorteado; public MegaSena() { sorteado=new int[6]; } public int[] sorteio() { for(int i=0; i<6; i++) { sorteado[i]=((int)Math.random()*60)+1; for(int m=5; m>=0; m--) { if(sorteado[i]==sorteado[m]) { sorteado[i]=((int)Math.random()*60)+1; m=6; } } } return sorteado; } }
Daí iria retornar o arranjo? o.O

é tem razaão quanto ao Math.random() faz tanto tempo q não uso, posi so uso diretamente o objeto random, que não lembrava q era 1 exclusive ...

mas enfim, essa forma q vc faz não da certo... é improvavel, mas existe a possibilidade sim, de vc ter o numero repetido mais de 1 vez seguida, se isso ocorrer no seu código, ele vai dar problema, pois vc esta colocando um for dentro de outro, e fazendo o testa, e caso axe igual esta sorteando novamente... o correto é continuar sorteando equanto o numero não for diferente, por isso deve usar um while, que é para manter no loop um número indefinido de vezes

se vc quer numeros diferentes vai ter q sortear, verificar c foi repetido, se for sortear novamente, ate não ser mais repetido, e so ai sortear o proximo....

separar em métodos é a maneira certa... fazer tudo dentro de um método só é conceitualmente errado, divida as responsabilidades, fica melhor de manter, de identificar possiveis erros, e de entender o código

public class MegaSena {
  private int[] resultado = new int[6];  

  public void sortearResutados() {  
     for(int i = 0; i < resultado.length; i++) {  
        int sorteado = 0;  
        do {  
           sorteado = sortear();  
        } while(isRepetido(sorteado));  
        resultado[i]=sorteado;  
     }  
  }

  public boolean isRepetido(int sorteado) {  
     for (int i = 0; i < resultado.length; i++)  
         if (resultado[i] == sorteado )  
            return true;  
     return false;  
  } 

  public int sortear() {  
     return Math.random()*60+1;  
  } 

  public int[] getResultado() {  
     return resultado;  
  }
}

veja como é mais facil de divir as responsabilidades ?? vc consegue enxergar cada parte

Valeu mesmoo õ/
Muito obrigada

usa uma condição de laço para testar o numero sorteado com os ja existentes no array, se não acho melhor que use uma list para isso, vai ser mais rápido em tempo de execução.

Isso tudo só pra depois seu professor lhe mostrar TreeSet.
Com no máximo 6,7 linha já está resolvido.

Meu professor fez igualzinho

ola estou tentando fazer um acerto perfeito na mega sena estou a mais de 4 anos nisso,
talvez nós possamos acerta isso juntos vc topa? ser uma colega de estudo para fechar isso eu tenho um método platico
já ecertei a quadra por 10 vezes só a quadra porque estar faltando algo que não sei oque, vc aceita me ajudar nisso
vc não me conhece mais pretendo saber de sua ajuda, vc parece saber bem sobre isso que tal??sem mais Ednaldo Braz

vc pode me contaquitar no meu msn
se vc quiser, [email removido]

Lavieri ,

estava testando seu código aqui da megasena… queria deixar eles ordenados… mas nao to conseguindo usar o Array.sort

como posso usar o Arrays.sort(resultados); ?

ta me dando erro no system.out.print… como eu posso arrumar isso?

abraços

Tenta usando collections

public void gerarnumeros() { List<Integer> possibilidades = new ArrayList<Integer>(); for (int i = 1; i <= 60; i++) { possibilidades.add(i); } // Embaralhamos a lista Collections.shuffle(possibilidades); }
Ae é simples, você pega os 6 primeiros numeros

for (int i = 0; i<6; i++) { System.out.println(possibilidades.get(i)); }

Outra solução usando HashSet:

public static void main(String[] args) { HashSet sorteados = new HashSet(); for (int i=0;i<6;i++){ Integer S = new Integer((int) (Math.random()*60+1)); if (!sorteados.contains(S)){ sorteados.add(S); } else{ i--; } } System.out.println(sorteados.toString()); }

model2.clear();
        
        // TODO add your handling code here:
          c3=-1;
          int y2=0;
          int lacowhile2=0;                                           
       
          y2=0;
          lacowhile2=0;
          while(y2==0&&lacowhile2<99){
          lacowhile2=lacowhile2+1;
          x2 = Math.random()*59;
          x2=x2+1;
          b2 =(int)x2;
          if(model2.contains(b2)){
          x2 = Math.random() * 59;
          b2 = (int) x2;
         } 
         else {
          c3=c3+1;
          model2.add(c3, b2);
          jTsorteio2.setText(""+b2);
          
          numero1=b2;
          y2=y2+1;
         lacowhile2=100;
          }
     }//fecha o while...  para garantir que vai achar numero

este model é um list

DefaultListModel model = new DefaultListModel();
   JList list = new JList(model);

cada número usa o método todo escrito novamente, até porque mudam coisas ali.
mas da para fazer ser tudo um método só. se comparar o numero1 com os proximos e garantindo que seja diferente.

Fala Thais^^ tudo beleza?

Estou fazendo agora esse mesmo problema pra faculdade. Se eu não estiver enganado quando você usá o código abaixo ele vai gerar um número de 1 até 61:

(int)(Math.radom() * 60) + 1

Ai eu acabei usando a “gambiarra”:

(int)(Math.random() * 59) + 1;

É isso ae, até mais…

Outra solução com HashSet

public int[] sortear() {
		HashSet<Integer> sorteados = new HashSet<Integer>();
		Random roleta = new Random();
		
		while(sorteados.size() < 6) {
			sorteados.add(new Integer(roleta.nextInt(60))); //60 é o número maximo que vc quer alcançar
		}
		
		int[] retorno = new int[6];
		int count = 0;
		for(Integer i: sorteados)
			retorno[count++] = i;
		
		return retorno;
	}