[Redução de Sistema]

Esse seu fechamento apresentado 8-5-4-5(7) volantes, ou seja ele me obriga a acerta as 5 dezenas certo, já no caso abaixo como faço para não

ter essa obrigação, vou postar código em java para quem quiser.

 

total dezenas: 10
conjunto 6
garantia 4
para acerto 4

01 02 03 04 05 06
01 02 03 05 07 09
01 02 03 06 07 08
01 02 03 06 09 10
01 02 04 06 07 10
01 02 04 07 08 09
01 02 05 07 08 10
01 03 04 05 07 10
01 03 04 05 08 09
01 03 05 06 08 10
01 04 06 08 09 10
01 05 06 07 09 10
02 03 04 06 08 09
02 03 04 07 09 10
02 03 05 08 09 10
02 04 05 06 07 09
02 04 05 06 08 10
03 04 06 07 08 10
03 05 06 07 08 09
04 05 07 08 09 10

 

package Combina;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Combinacoes {

private static final class Volante {

        private final Set<Integer> numeros;

        public Volante(int[] valores) {
            this.numeros = IntStream.of(valores).boxed().collect(Collectors.toCollection(TreeSet::new));
        }

        public int dissimilaridade(Volante outro) {
            List<Integer> interseccao = new ArrayList<>(numeros);
            interseccao.removeAll(outro.numeros);
            return interseccao.size();
        }

        @Override
        public String toString() {
            return numeros.toString();
        }
    }

    public static List<Volante> busca(int quantidade, int numeros) {
        List<Volante> volantes = new ArrayList<>();
        busca(volantes, new int[quantidade], 0, numeros - quantidade, 0);
        return volantes;
    }

    private static void busca(List<Volante> volantes, int[] resultado, int inicio, int fim, int profundidade) {
        for (int x = inicio; x <= fim; x++) {
            resultado[profundidade] = x + 1;
            if (profundidade + 1 >= resultado.length) {
                volantes.add(new Volante(resultado));
            } else {
                busca(volantes, resultado, x + 1, fim + 1, profundidade + 1);
            }
        }
    }

    private static List<Volante> limitarSimilaridade(List<Volante> volantes, int dissimilaridadeMinima) {
        List<Volante> dissimilares = new ArrayList<>(volantes.size());

        externo:
        for (Volante volante : volantes) {
            for (Volante dejaVu : dissimilares) {
                if (volante.dissimilaridade(dejaVu) < dissimilaridadeMinima) {
                    continue externo;
                }
            }
            dissimilares.add(volante);
        }
        return dissimilares;
    }

    public static void main(String[] args) {
        List<Volante> volantes = busca(5, 8);
        //  System.out.println(volantes.toString().replace("],","],\n"));
        System.out.println("Total de combinacoes: " + volantes.size());

        List<Volante> filtrados = limitarSimilaridade(volantes,2);
        System.out.println("Tamanho final: " + filtrados.size());
        System.out.println("Resultado final");
        System.out.println(filtrados.toString().replace("],", ",\n"));
    }
}  
 

 

[Redução de Sistema]

Em 25/07/2016 at 14:48, -W6- disse:

Parabéns Substantivo pela explicação didática.

 

Um belo tutorial! O que encontrei até hoje sobre a criação de desdobramentos, matrizes, lotto wheels, etc..., foram artigos acadêmicos utilizando uma simbologia bem difícil de entender. Seu tópico inspirará novas descobertas e aprendizados! Grato!