Создание алгоритма выбора нескольких номеров лотереи (математика и статистика)

Question

В испанской системе ставок существует концепция под названием multiple, которая означает, что если в игре, в которую вы хотите играть, ставки сделаны из 6 номеров, вы можете создать специальную ставку из 7 или 8 номеров, или даже 9, 10 или11 номеров.Эта специальная ставка будет преобразована в X нормальных ставок из 6 чисел, которые будут объединять данные числа.

The multiple bet of 7 numbers will traduce in 7 bets of 6 numnbers. 
The multiple bet of 8 numbers will traduce in 28 bets of 6 numbers.
The multiple bet of 9 numbers will traduce in 84 bets of 6 numbers.
The multiple bet of 10 numbers will traduce in 210 bets of 6 numbers.
The multiple bet of 11 numbers will traduce in 462 bets of 6 numbers.

Образец, кратный 7, с числами 1,2,3,4,5,6,7:

234567 134567 124567 123567 123467 123457 123456

Образец, кратный 8 с числами 1,2,3,4,5,6,7,8:

123456 123457 123458 123467 123468 123478 123567 123568 123578 123678 124567 124568 124578 124678 125678 134567 134568 134578 134578 134678 135678 145678 234567 234568 234578 234678 23 * 67 * 101 * 101 * 101 * 101 * 101 * 101 * 1014 345 285 868 8достичь алгоритма в Java для генерации multiples.Я имею в виду, что каждая ставка имеет стоимость 1 монеты, поэтому, например, с учетом 30 номеров и 800 монет, тратите 800 монет на X многократных ставок на X номеров.Многократные ставки должны объединять 30 номеров в более или менее равных количествах повторений.Общая стоимость магазинов должна быть около 800 евро, может быть немного меньше, но не более 800 евро. Алгоритм будет предлагать разные предложения, например, может предложить результат около 800 евро с кратными 7, результат около 800 с кратными 8 и т. Д., И пользователь выберет, какой из них предпочтительнее. Я понятия не имею, как этого добиться, я не очень хорошо разбираюсь в математике или статистике, поэтому буду признателен за помощь в решении этой проблемы

На этом веб-сайте есть веб-генератор, который может генерировать кратные числа 7 ииз 8, но это не общедоступный код: http://www.miramiprimi.miraestudio.es/MetodoMultiplePrimitiva.php

Большое спасибо.

Answer 1

@ NullPointerException То, что я имел в виду ранее сегодня, заключается в том, что алгоритм, примененный к данному URL-адресу, в значительной степени является алгоритмом грубой силы для генерации всех комбинаций длины 6 из N набора символов.Код для этого довольно прост:

private static List<List<Integer>> bruteForce(List<Integer> numbers) {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> current;
    for (int position1 = 0; position1 < numbers.size(); position1++) {
        for (int position2 = position1 + 1; position2 < numbers.size(); position2++) {
            for (int position3 = position2 + 1; position3 < numbers.size(); position3++) {
                for (int position4 = position3 + 1; position4 < numbers.size(); position4++) {
                    for (int position5 = position4 + 1; position5 < numbers.size(); position5++) {
                        for (int position6 = position5 + 1; position6 < numbers.size(); position6++) {
                            current = new ArrayList<>();

                            current.add(numbers.get(position1));
                            current.add(numbers.get(position2));
                            current.add(numbers.get(position3));
                            current.add(numbers.get(position4));
                            current.add(numbers.get(position5));
                            current.add(numbers.get(position6));

                            result.add(current);
                        }
                    }
                }
            }
        }
    }
    return result;
}

, а затем некоторые варианты использования: // просто имейте в виду, что он работает для array_length> = 6!

public static void main(String[] args) {
    List<Integer> numbers;

    System.out.println("N = 6, resulting in 1 element in the list.");
    numbers = new ArrayList<Integer>() {{ add(1); add(2); add(3); add(4); add(5); add(6);}};
    bruteForce(numbers).forEach(System.out::println);

    System.out.println("N = 7, resulting in 7 element in the list.");
    numbers = new ArrayList<Integer>() {{ add(1); add(2); add(3); add(4); add(5); add(6); add(7);}};
    bruteForce(numbers).forEach(System.out::println);

    System.out.println("N = 8, resulting in 28 element in the list.");
    numbers = new ArrayList<Integer>() {{ add(1); add(2); add(3); add(4); add(5); add(6); add(7); add(8);}};
    bruteForce(numbers).forEach(System.out::println);

    System.out.println("N = 9, resulting in 84 element in the list.");
    numbers = new ArrayList<Integer>() {{ add(1); add(2); add(3); add(4); add(5); add(6); add(7); add(8); add(9);}};
    bruteForce(numbers).forEach(System.out::println);
}

и вывод будетbe:

N = 6, resulting in 1 element in the list.
[1, 2, 3, 4, 5, 6]
N = 7, resulting in 7 element in the list.
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 7]
[1, 2, 3, 4, 6, 7]
[1, 2, 3, 5, 6, 7]
[1, 2, 4, 5, 6, 7]
[1, 3, 4, 5, 6, 7]
[2, 3, 4, 5, 6, 7]
N = 8, resulting in 28 element in the list.
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 7]
[1, 2, 3, 4, 5, 8]
[1, 2, 3, 4, 6, 7]
[1, 2, 3, 4, 6, 8]
[1, 2, 3, 4, 7, 8]
[1, 2, 3, 5, 6, 7]
[1, 2, 3, 5, 6, 8]
[1, 2, 3, 5, 7, 8]
[1, 2, 3, 6, 7, 8]
[1, 2, 4, 5, 6, 7]
[1, 2, 4, 5, 6, 8]
[1, 2, 4, 5, 7, 8]
[1, 2, 4, 6, 7, 8]
[1, 2, 5, 6, 7, 8]
[1, 3, 4, 5, 6, 7]
[1, 3, 4, 5, 6, 8]
[1, 3, 4, 5, 7, 8]
[1, 3, 4, 6, 7, 8]
[1, 3, 5, 6, 7, 8]
[1, 4, 5, 6, 7, 8]
[2, 3, 4, 5, 6, 7]
[2, 3, 4, 5, 6, 8]
[2, 3, 4, 5, 7, 8]
[2, 3, 4, 6, 7, 8]
[2, 3, 5, 6, 7, 8]
[2, 4, 5, 6, 7, 8]
[3, 4, 5, 6, 7, 8]
N = 9, resulting in 84 element in the list.
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 7]
[1, 2, 3, 4, 5, 8]
[1, 2, 3, 4, 5, 9]
[1, 2, 3, 4, 6, 7]
[1, 2, 3, 4, 6, 8]
[1, 2, 3, 4, 6, 9]
[1, 2, 3, 4, 7, 8]
[1, 2, 3, 4, 7, 9]
[1, 2, 3, 4, 8, 9]
[1, 2, 3, 5, 6, 7]
[1, 2, 3, 5, 6, 8]
[1, 2, 3, 5, 6, 9]
[1, 2, 3, 5, 7, 8]
[1, 2, 3, 5, 7, 9]
[1, 2, 3, 5, 8, 9]
[1, 2, 3, 6, 7, 8]
[1, 2, 3, 6, 7, 9]
[1, 2, 3, 6, 8, 9]
[1, 2, 3, 7, 8, 9]
[1, 2, 4, 5, 6, 7]
[1, 2, 4, 5, 6, 8]
[1, 2, 4, 5, 6, 9]
[1, 2, 4, 5, 7, 8]
[1, 2, 4, 5, 7, 9]
[1, 2, 4, 5, 8, 9]
[1, 2, 4, 6, 7, 8]
[1, 2, 4, 6, 7, 9]
[1, 2, 4, 6, 8, 9]
[1, 2, 4, 7, 8, 9]
[1, 2, 5, 6, 7, 8]
[1, 2, 5, 6, 7, 9]
[1, 2, 5, 6, 8, 9]
[1, 2, 5, 7, 8, 9]
[1, 2, 6, 7, 8, 9]
[1, 3, 4, 5, 6, 7]
[1, 3, 4, 5, 6, 8]
[1, 3, 4, 5, 6, 9]
[1, 3, 4, 5, 7, 8]
[1, 3, 4, 5, 7, 9]
[1, 3, 4, 5, 8, 9]
[1, 3, 4, 6, 7, 8]
[1, 3, 4, 6, 7, 9]
[1, 3, 4, 6, 8, 9]
[1, 3, 4, 7, 8, 9]
[1, 3, 5, 6, 7, 8]
[1, 3, 5, 6, 7, 9]
[1, 3, 5, 6, 8, 9]
[1, 3, 5, 7, 8, 9]
[1, 3, 6, 7, 8, 9]
[1, 4, 5, 6, 7, 8]
[1, 4, 5, 6, 7, 9]
[1, 4, 5, 6, 8, 9]
[1, 4, 5, 7, 8, 9]
[1, 4, 6, 7, 8, 9]
[1, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7]
[2, 3, 4, 5, 6, 8]
[2, 3, 4, 5, 6, 9]
[2, 3, 4, 5, 7, 8]
[2, 3, 4, 5, 7, 9]
[2, 3, 4, 5, 8, 9]
[2, 3, 4, 6, 7, 8]
[2, 3, 4, 6, 7, 9]
[2, 3, 4, 6, 8, 9]
[2, 3, 4, 7, 8, 9]
[2, 3, 5, 6, 7, 8]
[2, 3, 5, 6, 7, 9]
[2, 3, 5, 6, 8, 9]
[2, 3, 5, 7, 8, 9]
[2, 3, 6, 7, 8, 9]
[2, 4, 5, 6, 7, 8]
[2, 4, 5, 6, 7, 9]
[2, 4, 5, 6, 8, 9]
[2, 4, 5, 7, 8, 9]
[2, 4, 6, 7, 8, 9]
[2, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7, 8]
[3, 4, 5, 6, 7, 9]
[3, 4, 5, 6, 8, 9]
[3, 4, 5, 7, 8, 9]
[3, 4, 6, 7, 8, 9]
[3, 5, 6, 7, 8, 9]
[4, 5, 6, 7, 8, 9]

Просто имейте в виду, что числа, используемые в выходных данных, взяты из определения List<Integer> numbers = ..., так что вы можете поиграть и протестировать его дальше.Также я бы предложил использовать упорядоченный набор вместо списка в деле.

Как:

numbers = new ArrayList<Integer>() {{ add(11); add(22); add(33); add(44); add(45); add(46); add(47);}};
bruteForce(numbers).forEach(System.out::println);

отпечатков:

[11, 22, 33, 44, 45, 46]
[11, 22, 33, 44, 45, 47]
[11, 22, 33, 44, 46, 47]
[11, 22, 33, 45, 46, 47]
[11, 22, 44, 45, 46, 47]
[11, 33, 44, 45, 46, 47]
[22, 33, 44, 45, 46, 47]

Снимок экрана с указанного URL:

Я добавлю вам рекурсивную реализацию того же метода, который также будет принимать в качестве входного параметра базу (длину подмножества).

private static List<List<Integer>> bruteForceRecursive(List<Integer> numbers, List<Integer> indexes, int base) {
    List<List<Integer>> result = new ArrayList<>();

    if (indexes.size() == base) {
        List<Integer> list = new ArrayList<>();

        indexes.forEach(x -> list.add(numbers.get(x)));
        result.add(list);

        return result;
    }

    for (int i = indexes.isEmpty() ? 0 : indexes.get(indexes.size() - 1) + 1; i < numbers.size(); i++) {
        indexes.add(i);
        result.addAll(bruteForceRecursive(numbers, indexes, base));
        indexes.remove(indexes.size() - 1);
    }

    return result;
}

, а затем пример использования:

public static void main(String[] args) {
    List<Integer> numbers;

    numbers = new ArrayList<Integer>() {{ add(11); add(22); add(33); add(44); add(45); add(46); add(47);}};

    bruteForceRecursive(numbers, new ArrayList<>(), 2).forEach(System.out::println);
    bruteForceRecursive(numbers, new ArrayList<>(), 4).forEach(System.out::println);
    bruteForceRecursive(numbers, new ArrayList<>(), 6).forEach(System.out::println);
}

, который печатает:

[11, 22]
[11, 33]
[11, 44]
[11, 45]
[11, 46]
[11, 47]
[22, 33]
[22, 44]
[22, 45]
[22, 46]
[22, 47]
[33, 44]
[33, 45]
[33, 46]
[33, 47]
[44, 45]
[44, 46]
[44, 47]
[45, 46]
[45, 47]
[46, 47]
[11, 22, 33, 44]
[11, 22, 33, 45]
[11, 22, 33, 46]
[11, 22, 33, 47]
[11, 22, 44, 45]
[11, 22, 44, 46]
[11, 22, 44, 47]
[11, 22, 45, 46]
[11, 22, 45, 47]
[11, 22, 46, 47]
[11, 33, 44, 45]
[11, 33, 44, 46]
[11, 33, 44, 47]
[11, 33, 45, 46]
[11, 33, 45, 47]
[11, 33, 46, 47]
[11, 44, 45, 46]
[11, 44, 45, 47]
[11, 44, 46, 47]
[11, 45, 46, 47]
[22, 33, 44, 45]
[22, 33, 44, 46]
[22, 33, 44, 47]
[22, 33, 45, 46]
[22, 33, 45, 47]
[22, 33, 46, 47]
[22, 44, 45, 46]
[22, 44, 45, 47]
[22, 44, 46, 47]
[22, 45, 46, 47]
[33, 44, 45, 46]
[33, 44, 45, 47]
[33, 44, 46, 47]
[33, 45, 46, 47]
[44, 45, 46, 47]
[11, 22, 33, 44, 45, 46]
[11, 22, 33, 44, 45, 47]
[11, 22, 33, 44, 46, 47]
[11, 22, 33, 45, 46, 47]
[11, 22, 44, 45, 46, 47]
[11, 33, 44, 45, 46, 47]
[22, 33, 44, 45, 46, 47]