Entrée: un tableau I de k entiers positifs. Les entiers ne seront pas supérieurs à 100 et k ≤ 100 .

Sortie: Votre code doit sortir tous les tableaux possibles O d'entiers non négatifs de longueur k avec la restriction 0 ≤ O _i ≤ I _i . Pour passer d'un tableau au suivant, vous pouvez ajouter ou soustraire 1 à une valeur du tableau. Votre code ne doit pas sortir deux fois le même tableau. Si le nombre de tableaux différents à générer est très élevé, votre code doit simplement continuer à produire jusqu'à ce qu'il soit tué.

Exemples

• Si I est un tableau de k unités, c'est exactement le problème d'itérer sur tous les codes Gray de largeur de bit k , sauf que le premier et le dernier élément n'ont pas besoin d'être accessibles en une seule étape.

• Si I = [2,1]alors un ordre possible des tableaux de sortie est(0,0),(0,1),(1,1),(1,0),(2,0),(2,1)

• Si I = [2,1,3]alors un ordre possible des tableaux de sortie est (0,0,0),(0,0,1),(0,0,2),(0,0,3),(0,1,3),(0,1,2),(0,1,1),(0,1,0),(1,1,0),(1,1,1),(1,1,2),(1,1,3),(2,1,3),(2,1,2),(2,1,1),(2,1,0),....

Il s'agit d'un défi de code-golf, la soumission avec le code source avec la plus courte durée l'emporte. Ne laissez pas les réponses courtes dans les langues de golf vous décourager de poster une réponse dans d'autres langues. Essayez de trouver la réponse la plus courte dans n'importe quelle langue.

Il s'agit également d'un défi de complexité limitée. Chaque nouveau tableau doit être sorti avec O (k) temps écoulé depuis le tableau sorti précédent (ou le début du programme pour le premier tableau sorti). Cela signifie que le temps d'exécution par nouveau tableau de sortie (ils sont chacun de longueur k ) ne doit pas être supérieur à O (k) . C'est-à-dire que cela devrait prendre une proportion de temps à k et non pas, par exemple k ² ou 2 ^k . Notez que ce n'est pas le temps moyen par sortie, mais le pire des cas pour chaque tableau sorti.

Vous pouvez supposer que toute l'arithmétique sur des entiers 64 bits peut être effectuée en temps constant, tout comme la lecture et la sortie ainsi que l'affectation et la recherche et la modification des valeurs dans les tableaux.

Une conséquence de la complexité restreinte est que les solutions qui ne sortent qu'à la sortie du programme ne sont pas acceptables.

Python 3 , 116 octets

def f(a):
 l=len(a);t=[0]*l;d=[1]*l
 while 1:
  i=0;yield t
  while not-1<t[i]+d[i]<=a[i]:d[i]*=-1;i+=1
  t[i]+=d[i]

Essayez-le en ligne!

Merci Mnemonic pour -1 octet.

Fonction générateur. (merci Dennis de me l'avoir rappelé, j'ai oublié que la fonctionnalité existe) Si la sortie doit être imprimée sur stdout, utilisez-la print(t,flush=1)pour 9 octets supplémentaires, ou si Python est appelé avec-u , print(t)suffit pour +1 octet.

Arrête avec une erreur ( IndexError). Si vous voulez appeler cette fonction et continuer le programme, vous devez l'attraper.

Stax , 22 octets

▒)∙ñ╚▀NK♀F☺S(A#P`░]╪Db

Exécuter et déboguer

En voici un grand pour montrer le comportement asymptotique Appuyez sur Exécuter.

Déballé, non golfé et commenté, il ressemble à ceci.

,           pop from input to main stack
W           run the rest of the program repeatedly until explicitly cancelled
  cJP       copy top of stack and print, delimited by spaces
            get the index to mutate
  i^            iteration index + 1
  x{^|%}I       repeatedly apply divmod using l[k]+1 from input
                get the index of the first value that returns modulus >0
  cU=C      if the result is -1 (no match), then terminate the program
            get the direction to mutate
  s             get the "div" part of the last div operation called "d"
  ^|1           -1 ^ (d+1)
  ~{+}&     increment element in array at the index by the calculated amount

Exécutez celui-ci

JavaScript (Node.js) , 114 octets

a=>{b=a.map(_=>0);c=a.map(_=>1);for(i=0;a[i];b[i]+=c[i]||-1){console.log(b);for(i=0;b[i]==a[i]*c[i];i++)c[i]^=1;}}

Essayez-le en ligne! Non golfé:

function ggray(maxima) {
    var current = Array(maxima.length).fill(0);
    var flag = Array(maxima.length).fill(1);
    for (;;) {
        console.log(current);
        for (var i = 0; ; i++) {
            if (i == maxima.length) return;
            if (current[i] != maxima[i] * flag[i]) break;
            flag[i] = 1 - flag[i];
        }
        if (flag[i]) current[i]++;
        else current[i]--;
    }
}

Kotlin , 181 178 octets

Merci à: Anush a souligné que j'avais mal compris le défi d'économiser 2 octets. ovs a souligné une économie de 1 octet.

val p={a:List<Int>->var l=a.size
val v=Array(l,{0})
val i=Array(l,{1})
l-=1
o@while(0<1){println(v)
var p=l
while(v[p]+i[p]!in 0..a[p]){i[p]*=-1
p-=1
if(p<0)break@o}
v[p]+=i[p]}}

Essayez-le en ligne!