Agrupar itens de uma List variando com todas possibilidades <RESOLVIDO>

Programação Java
#1

Pessoal, estou sem ideias de como resolver este problema.
Tenho uma List com um numero x de elementos, sendo x > 6.
Preciso agrupar em grupos de 6, variando todas possibilidades. Exemplo: numeros[1, 2, 3, 4, 5, 6, 7]
Devo escrever todas possibilidades possiveis de combinações com estes 7 números, tal que não repita os numeros e a ordem diferente não é considerado uma nova combinação ([1, 2, 3, 4, 5, 6] == [6, 5, 4, 3, 2, 1])
Alguem tem alguma ideia ou alguma sugestão por onde começar?

Desde já agradeço.

#2

Olá Thiago!

Não entendi bem seu problema:

  1. Você terá no JList os elementos:
    [1] Primeiro elemento do JList
    [2] Segundo elemento do JList
    [3] Terceiro elemento do JList
    [4] Quarto elemento do JList
    … (e assim por diante)

  2. Ou desse modo:
    [1, 2, 3, 4, 5, 6] Primeiro elemento do JList
    [1, 3, 4, 5, 6, 2] Segundo elemento do JList
    [1, 2, 5, 6, 3, 4] Terceiro elemento do JList
    [1, 4, 5, 6, 2, 3] Quarto elemento do JList
    … (e assim por diante)

  3. Quando fala em “agrupar”, o que seria exatamente?

#3

Olá.
É assim a minha lista:
[1] Primeiro elemento do JList
[2] Segundo elemento do JList
[3] Terceiro elemento do JList
[4] Quarto elemento do JList
… (e assim por diante)

Exemplo:
numeros[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

Agora tenho que agrupar de 6 em seis. As regras são: os núneros não podem se repetir, e a uma ordem diferente não é considerada um novo grupo ([1, 2, 3, 4, 5, 6] == [6, 5, 4, 3, 2, 1])

O resultado seria:
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 7]
[1, 2, 3, 4, 5, 8]
…
[6, 7, 8, 9, 10, 11]
e assim por diante, desde que não falte nenhuma combinação possivel.

#4

Oi Thiago,

Ainda não entendi o seguinte: você irá agrupar de 6 em 6 elementos. No JList apresentará 6 elementos em um determinado momento, e conforme alguma ação do usuário você apresentará outros seis elementos?

#5

Boa noite!!!
Acho que ele quer fazer um jogo da mega sena, então vai pegar tipo 10 numeros e ver quantas combinações diferentes da. Eu havia tentado fazer isto mas não consegui, acho que é mais matematica do que programação.

#6

É exatamente o que o rpassos81 disse. É muita matemática mesmo.

#7

Deve haver algum jeito mais elegante de se fazer, mas 6 for’s aninhados resolvem. Veja:

import java.util.ArrayList;
import java.util.List;

public class Combinacoes {

	// ====================== LISTA DE VALORES =============================
	// vamos usar esse List<Integer> para armazenar todos os valores que podem
	// ser escolhidos
	private static final List<Integer> VALORES = new ArrayList<Integer>();

	static {
		// populando o List de 1 até 11
		for (int i = 1; i <= 11; i++) {
			VALORES.add(i);
		}
	}

	// =====================================================================

	/**
	 * Método main.
	 * 
	 */
	public static void main(String[] args) {
		// resgata as possíveis combinações
		List<List<Integer>> combinacoes = getCombinacoesDeSeis(VALORES);
		for (List<Integer> possibilidade : combinacoes) {
			// e mostra uma a uma
			System.out.println(possibilidade);
		}
		// depois mostra quantas combinações existem
		System.out.println(combinacoes.size() + " possibilidades diferentes");
		System.out.println("=============================================");
		// se quiséssemos somente o número de combinações, faríamos assim:
		System.out.printf("Propabilidade de acertar a sena na Mega Sena:"
				+ " 1 em %d%n", calculaPossibilidades(60, 6));
	}

	/**
	 *Retorna um List contendo todas as combinações possíveis para um sorteio
	 * de seis números diferentes.
	 * 
	 * @param valores
	 *            os valores que podem ser escolhidos
	 * @return um List de List de inteiros, contendo todas as possíveis
	 *         combinações para um sorteio com seis números
	 */
	public static List<List<Integer>> getCombinacoesDeSeis(List<Integer> valores) {
		int numValores = valores.size();
		int numPropabilidades = calculaPossibilidades(numValores, 6);
		System.out.println(numPropabilidades);
		List<List<Integer>> combinacoes = new ArrayList<List<Integer>>(
				numPropabilidades);
		List<Integer> possibilidade;
		for (int a = 0; a < numValores; a++) {
			for (int b = a + 1; b < numValores; b++) {
				for (int c = b + 1; c < numValores; c++) {
					for (int d = c + 1; d < numValores; d++) {
						for (int e = d + 1; e < numValores; e++) {
							for (int f = e + 1; f < numValores; f++) {
								possibilidade = new ArrayList<Integer>(6);
								possibilidade.add(valores.get(a));
								possibilidade.add(valores.get(b));
								possibilidade.add(valores.get(c));
								possibilidade.add(valores.get(d));
								possibilidade.add(valores.get(e));
								possibilidade.add(valores.get(f));
								// a próxima linha poderia ser substituida pela
								// escrita em um arquivo ou mostrar na linha de
								// comando, por exemplo. Isso
								// permitira manipular valores maiores, uma vez
								// que a memória não seria ocupada pela lista.
								// Da maneira atual, é possível calcular a
								// probabilidade para até 32 valores com a
								// quantidade de memória padrão da JVM. Mais que
								// isso lançará um OutOfMemoryError.
								combinacoes.add(possibilidade);
							}
						}
					}
				}
			}
		}
		return combinacoes;
	}

	/**
	 * Calcula o número de diferentes possibilidades que podemos ter.
	 * 
	 * Assumindo que <code>p</code> é a quantidade de combinações possíveis,
	 * <code>n</code> é o número de valores que podem ser escolhidos e
	 * <code>p</code> é a quantidade de elementos que serão sorteados, o cálculo
	 * baseia-se na fórmula:
	 * 
	 * <pre>
	 * <code>p = n! / (t! * (n - t)!)</code>
	 * </pre>
	 * 
	 * Que, na prática, é aplicada da seguinte forma:
	 * 
	 * <pre>
	 * <code>p = n * (n - 1) * ... * (n - t + 1) / t!</code>
	 * </pre>
	 * 
	 * @param n
	 *            o números de valores que podem ser escolhidos (seria 60 na
	 *            Mega Sena)
	 * @param t
	 *            quantidade de valores que serão escolhidos (seria 6 na Mega
	 *            Sena)
	 * @return o número de possibilidades de determinada combinação ser
	 *         escolhida
	 */
	private static int calculaPossibilidades(int n, int t) {
		long p = n;
		for (int i = n - 1; i > n - 6; i--) {
			p *= i;
		}
		return (int) (p / fatorial(t));
	}

	/**
	 * Calcula o fatorial de um número.
	 * 
	 * @param num
	 *            o número cujo fatorial será calculado
	 * @return o fatorial do número
	 */
	private static int fatorial(int num) {
		if (num < 2) {
			return 1;
		}
		int f = num;
		for (int i = num - 1; i > 1; i--) {
			f *= i;
		}
		return f;
	}

}
#8