Java 创建选择多个彩票号码的算法（数学和统计）

在西班牙的下注系统中，有一个称为“多个”的概念，这意味着如果你想玩的游戏有6个数字的下注，你可以创建7或8个数字，甚至9、10或11个数字的特殊下注。这种特殊的下注将产生X个6个数字的普通下注，这些数字将组合给定的数字

The multiple bet of 7 numbers will traduce in 7 bets of 6 numbers. 
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.

数字为1,2,3,4,5,6,7的7的倍数样本：

234567 134567 124567 123567 123467 123457 123456

数字为1,2,3,4,5,6,7,8的8的倍数样本：

123456 123457 123458 123467 123468 123478 123567 123568 123578 123678 124567 124568 124578 124678 125678 134567 134568 134578 134678 135678 145678 234567 234568 234578 234678 245678 345678

我的第一个目标是用Java实现一个生成

倍数的算法。我的意思是，每次下注的成本是1枚硬币，因此，例如，给定30个号码和800枚硬币，将800枚硬币浪费在X个号码的X多个下注中。多个赌注必须将30个数字组合在一起，出现的次数或多或少相等

倍数的总成本必须接近800欧元，可以少一点，但决不能超过800欧元该算法将提供不同的建议，例如，可以提供接近800欧元的结果，倍数为7，接近800欧元的结果，倍数为8，等等。。。用户将选择更喜欢哪一个。我不知道如何实现这一点

在这个网站上有一个web多重生成器，它可以生成7和8的倍数，但它的代码不是公开的：
@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;
}

请记住，输出中使用的数字来自
List numbers=…
的定义，因此您可以对其进行进一步的测试。我还建议在这种情况下使用有序集而不是列表

比如：

引用URL的屏幕截图：


我将为您添加一个递归实现，该方法将以基（子集长度）作为输入参数

在给定资源上使用的算法非常简单。你确定你也要使用它，还是你更感兴趣的是在生成的排列中添加更多的随机化？@dbl是的，我绝对肯定我需要那个算法。有人投票支持close，我不明白为什么。拜托，你能用你的算法来回答这个问题，让人们知道这是一个有答案的好问题吗？谢谢你，苏木秀，你想重新发明这个轮子（哈哈）：。希望这能有所帮助。@AakashM感谢你的链接，但我在google或StackOverflow中找不到任何带有彩票旋转算法示例的链接。你有吗？非常感谢你的方法，它很有用，但也许我没有正确地解释我自己。好的，我很欣赏你的代码示例，但是我正在搜索的算法将生成7、8、9、10或11个数字的“倍数”。是的，倍数相当于6个号码的7、28、84等下注，但我不是在搜索6个号码的下注，我是在搜索7、8、9、10或11个号码的“倍数”下注，它们相当于您的函数返回的下注。例如，如果用户想用20个号码花费500欧元，因此，该程序将以“倍数”的形式显示选项，这些选项将平均使用这20个数字，或大致相同，相当于500欧元（或稍低）。例如，结果可能类似于：如果您想要7的倍数，那么程序将返回71个7的倍数，这将在7个数字的下注中平均组合20个数字。在内部，这71个7位数的倍数相当于71x7=497次下注。你现在明白我的意思了吗？我想你不明白这个要求。对于20个符号集，有38760个唯一的不同组合，所有组合都由提供的代码生成。这也是非开源算法的工作原理。如果输入N（基数倍数），然后输入M个符号（N而不是现在的6。然后使用此算法从20个长度为7的子集中生成
子集，然后通过它们迭代生成长度为6的
子集，而它们的计数小于500或
长度为7的子集具有更多元素。如果长度为7的
子集都被使用了，而您仍然有一些钱可以花，那么也有不同的策略。。。
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);
}

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]

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]

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]