Programa Loto Fácil

Oi galera

Se você arranjar um livro com todas apostas já feitas de loto fácil, podemos pensar num algoritmo que busca sequências de números que sairam menos.

A minha idéia é separar em grupos de números que já sairam.

A quantidade de grupos é definida através do Binômio de Newton.


Faça um programa cuja entrada é uma tabela em formato texto com resultados da loto fácil, o resultado é armazenado numa tabela num banco de dados.


Suponha que a loto fácil tenha um total de seis números e você ganha prêmios para quatro números acertados:

1,2,3,4,5,6


Binômio de Newton = (n p) = (n!/(p!*(n-p)!))

Vamos adotar a estratégia de grupos de 2, cada grupo de 2 que se repetir entre os jogos, terá um contador numa tabela, os grupos com o contador mais baixo,

tem mais chance de sair.


(6 2) = 6!/(2!*(6-2)!)= 6*5/2= 15 combinações

A baixo uma simulação de 3 jogos


Jogo 1, resultado = 1, 2, 3, 4
Jogo 2, resultado = 2, 3, 4, 5
Jogo 3, resultado = 1, 4, 5, 6

[Posição](combinação) -> vezes que o grupo saiu em todos os jogos

[01](1, 2) -> 1
[02](1, 3) -> 1
[03](1, 4) -> 2
[03](1, 4) -> 2
[05](1, 6) -> 1
[06](2, 3) -> 2
[07](2, 4) -> 2
[08](2, 5) -> 1
[09](2, 6) -> 0
[10](3, 4) -> 1
[11](3, 5) -> 1
[12](3, 6) -> 0
[13](4, 5) -> 2
[15](5, 6) -> 1

Ordenando os grupos por contador, aproveitando a ordem natural dos grupos:
[09](2, 6) -> 0
[12](3, 6) -> 0
[01](1, 2) -> 1
[02](1, 3) -> 1
[04](1, 5) -> 1
[05](1, 6) -> 1
[08](2, 5) -> 1
[10](3, 4) -> 1
[11](3, 5) -> 1
[14](4, 6) -> 1
[15](5, 6) -> 1
[03](1, 4) -> 2
[06](2, 3) -> 2
[07](2, 4) -> 2
[13](4, 5) -> 2


Uma regra que você pode criar, é que não pode haver números repetidos entre grupos, assim, o sorteio, fica da seguinte forma:

Random([09],[12])

As possíveis combinações que surgem são:

[09],Random([02],[04],[10],[11])
[12], Random([01],[04],[08])

Os números que você tem mais chance de ganhar são:

2, 6, 1, 3
2, 6, 1, 5
2, 6, 3, 4
2, 6, 3, 5

3, 6, 1, 2
3, 6, 1, 5
3, 6, 2, 5

Observação: Se [09] fosse (2, 6) e [12] fosse (3,5), o número escolhido seria 2, 6, 3, 5, pois não há repetição entre eles.


Depois desse exemplo prático, vamos analisar o caso da Loto Fácil, são no total 25 números, 15 posições escolhidas, sugestão:

Ou particionar os 15 números em 3 grupos de 5 números (Caso 1), ou particionar em 5 grupos de 3 números (Caso 2).

Caso 1) O número total de combinações é (25 3) = 2300

Escrevendo as combinações na tabela do banco de dados:

int posicao=1;

for(i=1; i <= 25-2;i++){

###for(j=i+1; j<= 25-1; j++){

######for(k=j+1; k<= 25; k++){
#########String nomeCampo=i+"_"+j+"_"+k;
#########int contador=0;
#########escreverTabela(posicao,nomeCampo, contador, tabela1);
#########posicao++;
######}

###}

}

Incrementando contadores:

int [] v=ordenar(numeroSorteado);

for(i=0;l < v.length-2;l++){
###for(j=i+1; j < v.length-1; j++){

######for(k=j+1; k< v.length; k++){
#########String combinacaoASerIncrementada=v[i]+"_"+v[j]+"_"+v[k];
#########listaCombinacao.add(combinacaoASerIncrementada);
######}
###}
}

Percorre elementos ordenadamente na tabela1{
###Se (elementoTabela1==elementoListaCombinação){
######elementoTabela1.contador++;
######elementoListaCombinação++;
###}
elementoTabela1++;
}

O Resto do código é lição de casa.

Caso 2) O número total de combinações é (25 5) = 53130

Lição de Casa.