Comment générer toutes les valeurs possibles dans un tableau où [x]> = [x + 1]?

Question

Je tente d'écrire un algorithme qui prend une matrice de taille n et pour générer toutes les combinaisons possibles de valeurs entières jusqu'à la taille maximum où le nombre de positions x est supérieur ou égal à x + 1.

Donc, pour un tableau de taille 4 et au maximum de 5:

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

sont toutes les valeurs acceptables.

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

ne sont pas valides.

Pour un tableau de taille 4 et maximum de 1 ce serait toutes les combinaisons possibles:

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

Je ne peux pas sembler obtenir ma tête autour de la façon de l'appliquer pour toute valeur pour max. Donc, je vous demande les gars si vous pouviez me donner un coup de main: D

Y at-il un nom pour ces séries?

Answer 1

Je l'ai travaillé sur, pas récursion nécessaire.

Je souhaite publier la réponse pour toute autre personne qui cherche la réponse à la question que je posais.

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;
    }
}

Il parcourt le tableau entier et trouve la première occurrence de la plus petite valeur. Cette valeur est incrémenté d'une et remet à zéro toutes les valeurs à zéro après.

Answer 2

Où êtes-vous des problèmes? Astuce:. Récursion est votre ami (vous pouvez utiliser récursion pour les boucles imbriquées où le niveau d'imbrication est déterminé que lors de l'exécution)

Answer 3

Avoir un sous-programme qui prend n et max et renvoie un ensemble de tableaux.

Si n> 1, il appelle lui-même à la place de façon récursive avec n-1, et pour chaque résultat de l'appel récursif de retour, génère un ou plusieurs réseaux avec un variant le plus à gauche de l'élément supplémentaire entre l'élément de gauche précédent et max.

Si n est 1, elle renvoie max + 1 matrices 1-éléments contenant des valeurs de 0 à max.