Cleanest way to generate all combinations of n arrays

What I am trying to get is all the possible values given an array [0, 1, 2] and a number n. The result for n=3 would be:


So basically all the numbers in base 3 given as separate elements in an array.

I have been trying to get this output by using Base.Iterators.product([0,1,2],[0,1,2],[0,1,2])and this does indeed work but I’m having trouble finding a way to be able to do so programatically, as I can’t pass the arguments to product separately.

I tried generating the list of arrays by using repeat([0,1,2], 1, n) and this does give me a matrix of n columns with each being one [0, 1, 2] arrays, but I can’t find a way to pass each of these columns separately as input to product()



1 Like

Let me get you an answer.

I tried this but splatting a 3x3 array does not give you 3 1x3 arrays (and product expects n iterables as argument.

julia> x = repeat([1,2,3],1,3)
3×3 Array{Int64,2}:
 1  1  1
 2  2  2
 3  3  3

julia> collect(Base.Iterators.product(x...))
0-dimensional Array{NTuple{9,Int64},0}:
(1, 2, 3, 1, 2, 3, 1, 2, 3)


Probably not efficient but one way to do so is built the representation of this ternary number.

So you should do a loop up to 3 ^ n - 1 and for each number build its representation per index.

N = 3

Not the most efficient :slight_smile:

This is a naive Combinations iterator, doing something similar to what bennedich proposed.

import Base.iterate,Base.length
struct Combinations{T}
    function Combinations(itr::Vector{T},count::Int) where T

function iterate(c::Combinations,state::Int64=0)
    if state>=length(c)
        return nothing
    [c.itr[i] for i in (indices .+1)],state+1

function length(c::Combinations)
    length(c.itr) ^ c.count

julia> collect(Combinations([0,1,2],3))
27-element Array{Any,1}:
 [0, 0, 0]
 [1, 0, 0]
 [2, 0, 0]
 [0, 1, 0]
 [1, 1, 0]
 [2, 1, 0]
 [0, 2, 0]
 [1, 2, 0]
 [2, 2, 0]
 [0, 0, 1]
 [1, 0, 1]
 [2, 0, 1]
 [0, 1, 1]
 [1, 1, 1]
 [2, 1, 1]
 [0, 2, 1]
 [1, 2, 1]
 [2, 2, 1]
 [0, 0, 2]
 [1, 0, 2]
 [2, 0, 2]
 [0, 1, 2]
 [1, 1, 2]
 [2, 1, 2]
 [0, 2, 2]
 [1, 2, 2]
 [2, 2, 2]

Here’s how to do it with Iterators.product:

N = 3

Recursive lambda comprehension:

N = 3
(p=(a,c)->c<2 ? a : [[x;y] for x=a for y=p(a,c-1)])(0:N-1,N)
1 Like

Here’s a way using digits:

fun(arr::Vector, num::Int) = 
    [ getindex.(Ref(arr), 1 .+ digits(i-1; base=length(arr), pad=num)) for i=1:length(arr)^num ]



N = 3
1 Like

You can also try:

Iterators.product(ntuple(i->0:N-1, N)...)

See: Julia docs FAQ - The two uses of the ... operator - slurping and splatting


Does anybody know an optimized solution for this problem ?
I need to write a code that generates all of the possible patterns in a set of categorical data and it turns out that generating the combination is really the step that makes the overall operation incredibly slow (takes about 25 minutes tand then ends up into a memory error when I do it with real data).
I have tried using for loops :

function withloops(x,y)
    OUT = zeros(Float64, m,2)
    for i = 1:lenx
        for j = 1:leny
            OUT[c,1] = x[i]
            OUT[c,2] = y[j]
    return OUT

I also tried what @bennedich and @improbable22 suggested :



[ getindex.(Ref(arr), 1 .+ digits(i-1; base=length(arr), pad=num)) for i=1:length(arr)^num ]

turns out solution using Iterators.product is the most efficient but it still is too much for my computer.
Is there a better way to do it ?

You realize this is an exponential operation in terms of both time and memory, right? It is O(K^N) where K is the base and N is the length of the number. Moreover, by asking to materialize all of these digit combinations all at once, it forces the problem to not only have exponential run time but also to allocate exponential memory. This brute force approach is only going to work for tiny toy problems.

You’d be much better off not materializing all the arrays at once. Even better still would be not materializing then at all and allowing them to be represented implicitly as integers: you can then iterate through them very quickly and ask properties of them as integers. If you want something really fast and scalable you need to avoid considering most of the combinations at all.

Hard to give more advice without knowing what you’re trying to compute.


@StefanKarpinski Yes you are right … but I have no idea how to do this with integers.
What I am trying to do is the following : given N categories, find out all the possible combinations of n (among N) elements, with allowed repetition. Then look at the frequency of occurence of each of these patterns in the data to try to identify patterns.
Since I also want to look at the possibility to vary the space ordering of the elements inside of a pattern, it does indeed generate a huge amount of combinations.

If it’s based on data then you know that all K^N combinations cannot possibly happen for large values of K and N. So instead of scanning for all the possibilities—which would be O(D*K^N) where D is the size of the data—just scan the data once and record all the combinations that actually occur which will only be O(D). It’s a linear scan of your data; hard to do better than that.


for my problem this helped me
collect(Iterators.product(-1:1, -1:1))[:]