As part of my solution to a project I’m working on, I came across an algorithm on SO that does exactly what I want it to (generate an array of all possible variants from [0, 0, 0] up to the max value in each index position, for example [2, 1, 3]).

My issue is that due to the complex logic of the solution, I’m not entirely sure if I understand how it works. What I’ve done is annotated it with my own notes, and would like to submit those for review by the community here.

I feel like I more or less get the *gist* but have a feeling that I’m missing some subtleties that may in fact be quite important – but that’s just my hunch; you tell me if I’m wrong

Original answer: https://stackoverflow.com/a/14001422/14347717

(I’ve made two changes to the linked answer as I express it below: I changed the variable names for enhanced readability, and I wrapped the solution in a parent function that returns a 2D array of all iterations. The actual logic of generating the iterations remains unchanged; the only difference is that I’ve annotated them with comments and this is the part I am looking for feedback on.)

```
function getIterations(iterNums, iterBase) {
const nums = iterNums
// set a base to the 2nd arg; if no 2nd arg, create an array of 0's equal to nums.length
const base = iterBase ? iterBase : Array.from(Array(nums.length), () => 0)
// initialize an empty 2D array of iterations
const iterations = []
function step() {
let incomplete = false
// check if any value in nums is greater than base;
// if so, it means `step` process is incomplete;
// in this case, return false
for (let i = 0; i < base.length; i++) {
incomplete = incomplete || (base[i] < nums[i])
if (incomplete) break;
}
// "if complete (incomplete === false) return false"
// this turns `processing` to false and breaks the while loop
if (!incomplete) return false;
// run this loop while `step` is `incomplete`
for (let j = 0; j < base.length; j++) {
// check if `base` idx is less than nums
if (base[j] < nums[j]) {
// if so, increment the index of base by one;
// exit loop by returning true;
base[j]++
return true
} else {
// reset value of base[j] once increments are complete on a given index
// 'continue' to next increment in loop
base[j] = 0
continue // nothing changes when this is commented out but it helps explain logic:
// when idx value reaches max, it "continues" to the next index position, saying:
// increment the first value up to max, at which point the ~next~ index increments
// until the entire array has incremented and gets caught by `if incomplete` check
}
}
}
let processing = true
while (processing) {
processing = step()
if (processing) iterations.push([...base])
}
// this will log the output per OP's intention
console.log(iterations)
// this will (when uncommented) return a 2D array of all iterations
return iterations
}
getIterations([2, 1, 3])
```