sexta-feira, 19 de novembro de 2010

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.

Nenhum comentário:

Postar um comentário