Programa Loto: LotoFacil, LotoMania, MegaSena e Quina

2 respostas
java
Hadel_Rachid_Daher_J

Olá, comunidade,

  • tem como melhorar esse algoritmo para um projeto de site que gera números aleatórios para loterias?
  • Existe um meio de enxugar mais esse algoritmo?

import java.util.Random;

// Definição da classe Loto
public class Loto {
	
	private int[] numbers;       // Array para receber os números sorteados
	private int[] compare;       // Array para comparar e controlar números sorteados
	private Random generator;    // Gerador de números aleatórios
	
	private int size;    // Armazenas todos os números de uma loteria
	private int dozens;  // Dezenas para cada tipo de loteria
	private int type;    // Tipo de sorteio para gerar números
	
	public enum LOTO{LOTOFACIL, LOTOMANIA, MEGASENA, QUINA};
	
	// Método construtor
	Loto(LOTO loto)
	{
		// Verifica o tipo de loteria
		switch(loto)
		{
			case LOTOFACIL:      // Caso seja Lotofacil
				size = 25;   // Lotofacil tem 25 dezenas
				dozens = 15; // São sorteadas apenas 15 dezenas
				type = 0;    // Tipo 0
			break;
			
			case LOTOMANIA:      // Caso seja Lotomania
				size = 100;  // Lotomania tem 100 dezenas
				dozens = 50; // São sorteados apenas 50 dezenas
				type = 1;    // Tipo 1
			break;
				
			case MEGASENA:       // Caso seja Megasena
				size = 60;   // Megasena tem 60 dezenas
				dozens = 6;  // São sorteados apenas 6 dezenas
				type = 0;    // Tipo 0
			break;
			
			case QUINA:         // Caso seja Quina
				size = 80;  // Quina tem 80 dezenas
				dozens = 5; // São sorteados 5 dezenas
				type = 0;   // Tipo 0
			break;
			
		    default:
			break;
		} // Fim do switch
	
		
		compare = new int[size];     // Cria o Array
		numbers = new int[dozens];   // Cria o Array
		generator = new Random();    // Cria o Random
				
		generatorNumbers();   // Chama o método para gerar numeros
		ascendingOrder();     // Ordena os números em ordem crescente
		
	} // Fim do método construtor 1
	
	// Método para gerar números aleatórios
	private void generatorNumbers()
	{		
		int x = 0;           // controla o número gerado
		boolean var = false; // controle
		
		// Inicializa o compare com valores de 1 até length - 1
		for(int i = 0; i < compare.length; i++)
		   compare[i] = i + 1;
		
		for(int i = 0; i < numbers.length; i++) 
		{			
			var = true;
			x = launch_Random();  // Chama o método para gerar número
			
			// Equanto for verdadeiro o var
			while(var) {
				// Compara número sorteado com elementos do array compare
				for(int j = 0; j < compare.length; j++)
				{
					// Se valor de x sorteado for igual ao elemento de compare
					if(x == compare[j])
					{
						var = false;     // muda o valor de var para false
						numbers[i] = x;  // Atribui número sorteado
						compare[j] = -1; // Negativa número escolhido no compare (marca que foi escolhido)
						break;           // Sai do if e do for
					} // Fim do if
				} // Fim do for
				
				x = launch_Random();  // Chama o método para gerar número
			} // Fim do while
		}
		
	} // Fim do método generatorNumbers

	// Método para lançar o tipo de número aleatório
	private int launch_Random()
	{
		int value = 0;
		
		switch(type)
		{
			case 0:
				value = generator.nextInt(size) + 1; // Gera 0 a (size - 1) + 1	
			break;
			
			case 1:
				value = generator.nextInt(size);     // Gera 0 a (size - 1)
			break;
				
		    default:
			break;
		}
		
		return value;
	} // Fim do método launch_Random
	
	// Método para ordenar os números em 
	// ordem crescente
	private void ascendingOrder()
	{
		int x = 0; // Variável intermediária de controle
		
		// Método bolha de ordenação crescente
		for(int i = 0; i < numbers.length - 1; i++)
			for(int j = i + 1; j < numbers.length; j++)
				if(numbers[i] > numbers[j])
				{
					x = numbers[j];          // x recebe o conteúdo de numbers[j]
					numbers[j] = numbers[i]; // numbers[j] recebe o conteúdo de numbers[i]
					numbers[i] = x;          // numbers[i] recebe o conteúdo de x
				} // Fim do if
		
	} // Fim do método ascendingOrder
	
	// Mostra os valores aleatórios
	public String showNumbers()
	{
		String result = "";
		
		for(int i = 0; i < numbers.length; i++)
			result = result + "  " + numbers[i];
		
		return result;
	} // Fim do método showNumbers
	
} // Fim da classe Loto

2 Respostas

Villagram

@Hadel_Rachid_Daher_J
Não deu para fazer muita coisa, não mudei nenhuma funcionalidade apenas fiz uma refatoração usando novos meios introduzidos na linguagem, espero que ajude em algo.

/**
 * Definição da classe Loto
 */
public final class Loto {

    private final int[][] values = {{25, 15, 0}, {100, 50, 1}, {60, 6, 0}, {80, 5, 0}};
    private int size, dozens, type;
    private int[] numbers; // Array para receber os números sorteados
    private int[] compare; // Array para comparar e controlar números sorteados
    private Random generator; // Gerador de números aleatórios

    public enum LOTO {
        LOTOFACIL(0), LOTOMANIA(1), MEGASENA(2), QUINA(3);
        int valor;

        private LOTO(int valor) {
            this.valor = valor;
        }
    };

    /**
     * Método construtor
     *
     * @param loto Enum tipo de jogo
     */
    public Loto(LOTO loto) {
        initComponents(loto);
    }

    /**
     * Inicializa a classe
     *
     * @param loto Enum tipo de jogo
     */
    private void initComponents(LOTO loto) {
        // Verifica o tipo de loteria
        size = values[loto.valor][0]; //dezenas máximas
        dozens = values[loto.valor][1]; //dezenas possíveis
        type = values[loto.valor][2]; //tipo

        compare = new int[size];     // Cria o Array
        numbers = new int[dozens];   // Cria o Array
        generator = new Random();    // Cria o Random

        generatorNumbers();   // Chama o método para gerar numeros
        ascendingOrder();     // Ordena os números em ordem crescente
    }

    /**
     * Método para gerar números aleatórios
     */
    private void generatorNumbers() {
        IntStream.range(0, compare.length).forEach(i -> compare[i] = i + 1);

        IntStream.range(0, numbers.length).forEach(i -> {
            boolean ctl = false;
            while (!ctl) {
                ctl = setNumber(i, launch_Random());
            }
        });
    }

    /**
     * Seta o valor dentro do array de números
     * @param i posição do número no array
     * @param x número a ser inserido no array
     * @return boolean sucesso da operação
     */
    private boolean setNumber(int i, int x) {
        for (int j = 0; j < compare.length; j++) {
            if (x == compare[j]) {
                numbers[i] = x;
                compare[j] = -1;
                return true;
            }
        }
        return false;
    }

    /**
     * Gera valor inteiro randonico
     *
     * @return int valor
     */
    private int launch_Random() {
        return type == 0 ? generator.nextInt(size) + 1 : generator.nextInt(size);
    }

    /**
     * Método para ordenar os números em
     */
    private void ascendingOrder() {
        numbers = IntStream.of(numbers).sorted().toArray();
    }

    /**
     * Mostra os valores aleatórios
     *
     * @return String com valores
     */
    public String showNumbers() {
        return IntStream.of(numbers).mapToObj(String::valueOf).reduce("", (s1, s2) -> s1.concat("  " + s2));
    }

}
Hadel_Rachid_Daher_J

Mas já está ajudando sim para aumentar na eficiência do código! Ainda bem que você usou lambdas! Eu tinha esquecido disso, muito obrigado!

Criado 15 de abril de 2019
Ultima resposta 16 de abr. de 2019
Respostas 2
Participantes 2