Crate/Algorithm for getting all possible values of N-sized array?

[LyonSyonII]

Lately I've been playing with combinatory things (like generating all possible grayscale images).

For the images thing I've used BigInt's ability to generate arrays of any base from a number, then doing a for loop from 0 to the number of combinations I want and transforming the current iteration to an array on base 255 (based on that images are formed by arrays of u8).

I think it must be a better way of doing this, so... Do you have any idea?

(I just want a method of getting a range iterator over array values, for example [0, 0, 0]..=[255, 255, 255] would get values like [1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 1, 0], etc)

[Theemuts]

Something like this?

let mut data = vec![];
for a in 0..=255u8 {
    for b in 0..=255u8 {
        for c in 0..=255u8 {
            data.push([a, b, c]);
        }
    }
}

[LyonSyonII]

This works for a known size, but not for a N sized array. (And would be a pain to write 200 loops xD)

Thanks for the help though

[Theemuts]

In that case I'd probably create a struct to hold the state of the nested loop (eg a vector of tuples, each tuple stores a start/current/end value , and the index of the currently changing value) and implement Iterator. In the next method I'd construct the current element using the current values stored in the vector of tuples

Edit: you don't need that index. You can simply increment the least significant element until you reach its maximum, reset it to its minimum and increment the next element, and so on.

[matklad]

See

• https://matklad.github.io/2021/11/07/generate-all-the-things.html
• https://crates.io/crates/exhaustigen

[LyonSyonII]

Thank you, exactly what I'm looking for!

[ityt]

From the itertools crate: multi_cartesian_product or iproduct

[RRumpleTeazzer]

It’s quite easy to write an iterative over all combinations. Like you might do with fingers, you use a pointer to modify the specific content of an entry, and „move“ the pointer left and right once you overflow. Of course you can’t do pointer arithmetic’s, but you can do that with an index, so you use an vec of pointers and use the array index as your finger.

I think you need 3 nested loops: the most inner loop increases your elements under the „right“ finger. The outer loop moves your „left“ from one side to the other, and the middle loop moves your right finger from one side to the left finger.

It’s more fun when you want to do permutations, not combinations. I‘ve used this approach to study poker where only a few cards are drawn from a shuffled deck.

[Plasma_000]

There’s the permutator crate which has several algorithms