Design patterns 如何在[x]>；=[x+；1]？

我正在尝试编写一个算法，它接受一个大小为n的数组，并生成所有可能的整数值组合，最大值为size，其中x位置的数字大于或等于x+1

因此，对于大小为4且最大值为5的数组：

{0, 0, 0, 0}
{4, 3, 2, 1}
{2, 2, 0, 0}
{5, 5, 5, 5}

都是可接受的值

{0, 1, 2, 3}
{0, 3, 0, 0}
{6, 6, 6, 6}

无效

对于大小为4且最大值为1的数组，这将是所有可能的组合：

{0, 0, 0, 0}
{1, 0, 0, 0}
{1, 1, 0, 0}
{1, 1, 1, 0}
{1, 1, 1, 1}

我只是不知道如何为max实现它，所以我想问你们是否可以帮我一把：D

---

这些系列有名字吗？

哪里有问题？提示：递归是您的朋友（您可以对嵌套循环使用递归，其中嵌套级别仅在运行时确定）。

哪里有问题？提示：递归是您的朋友（您可以对嵌套循环使用递归，其中嵌套级别仅在运行时确定）。

有一个接受n和max并返回一组数组的子例程

如果n>1，它将使用n-1来递归调用自己，并且对于递归调用返回的每个结果，将生成一个或多个数组，其中包含一个额外的最左侧元素，该元素在前一个最左侧元素和max之间变化

---

如果n为1，则返回max+1个1元素数组，其中包含从0到max的值。

有一个子例程，该子例程接受n和max并返回一组数组

如果n>1，它将使用n-1来递归调用自己，并且对于递归调用返回的每个结果，将生成一个或多个数组，其中包含一个额外的最左侧元素，该元素在前一个最左侧元素和max之间变化

---

如果n是1，它将返回max+1个1元素数组，其中包含从0到max的值。

我计算出来了，不需要递归

我正在为任何正在寻找我所问问题答案的人发布答案

public static void next(int[] data)
{
    final int arrayLen = data.length;
    int lowestIndex = 0;
    int lowestValue = data[0];

    for (int i = 1; i < arrayLen; i++)
    {
        if (data[i] < lowestValue)
        {
            lowestValue = data[i];
            lowestIndex = i;
        }
    }

    data[lowestIndex]++;

    for (int j = lowestIndex + 1; j < arrayLen; j++)
    {
        data[j] = 0;
    }
}

publicstaticvoidnext（int[]数据）
{
最终int arrayLen=data.length；
int-lowestinex=0；
int lowerstvalue=数据[0]；
for（int i=1；i

---

它遍历整个数组并找到最小值的第一次出现。该值递增1，并将其之后的所有值重置为零

我算出来了，不需要递归

我正在为任何正在寻找我所问问题答案的人发布答案

public static void next(int[] data)
{
    final int arrayLen = data.length;
    int lowestIndex = 0;
    int lowestValue = data[0];

    for (int i = 1; i < arrayLen; i++)
    {
        if (data[i] < lowestValue)
        {
            lowestValue = data[i];
            lowestIndex = i;
        }
    }

    data[lowestIndex]++;

    for (int j = lowestIndex + 1; j < arrayLen; j++)
    {
        data[j] = 0;
    }
}

publicstaticvoidnext（int[]数据）
{
最终int arrayLen=data.length；
int-lowestinex=0；
int lowerstvalue=数据[0]；
for（int i=1；i

---

它遍历整个数组并找到最小值的第一次出现。该值递增1，并将其之后的所有值重置为零

如果这能让你感觉好一点，我也不能把头绕过去。如果这能让你感觉好一点，我也不能把头绕过去。