Matrix elements combination - algorithm

Question

There is a m x n array, I need to output each possible combination Of each line's element. For example, for array{{1,2,3},{4,5,6}}, I need to output{{1,4},{1,5},{1,6},{2,4},{2,5},{2,6},{3,4},{3,5},{3,6}}.
I think there should be a m loop to solve this. For the example above, I wrote the code:
int[,] array = new int[,] {{1, 2, 3}, {4, 5, 6}};
for (var i = 0; i < 3; i++)
{
for (var j = 0; j < 3; j++)
{
Console.WriteLine($"{{{array[0, i]},{array[1, j]}}}");
}
}
With m changes, the number of for loop also changes. But m is unknown when I write the code. How can I solve it?

Answer 1

Maintain a list of active combinations c. Initialize c to be the array's first row. Then iterate every additional row and update c. Basically, you augment each of the current combinations with each of the row's items. Here is some pseudo code:
c = array[0]; //read: the first row of the array
for(var i = 1; i < m; ++i) { //iterate all rows
var c_modified = [];
for(var j = 0; j < n; ++j) { //iterate all row entries
for(var k = 0; k < c.length; ++k) { //iterate all entries of c
add c[k].array[i, j] to c_modified; // . represents concatenation
}
}
c = c_modified;
}

Answer 2

This combination of elements (n^m sets) is called Cartesian product. There are ready-to-use functions for its generation in some language libraries
I believe that the simplest code is recursive one.
type
TArr2D = TArray<TArray<Integer>>;
procedure CartesianProduct(const A: TArr2D; Line: Integer; Reslt: TArray<Integer>);
var
i: integer;
begin
if Line > High(A) then
Memo1.Lines.Add(ArrayToString(Reslt)) // output m-element set
else
for i in A[Line] do
CartesianProduct(A, Line + 1, Reslt + [i]); // include element in set
end;
var
A: TArr2D;
n, m, i, j: Integer;
begin
m := 3;
n := 3;
SetLength(A, m, n);
for j := 0 to m - 1 do
for i := 0 to n - 1 do
A[j, i] := j * n + i;
//0 1 2
//3 4 5
//6 7 8
CartesianProduct(A, 0, []);
gives
0 3 6
0 3 7
0 3 8
0 4 6
0 4 7
0 4 8
0 5 6
0 5 7
0 5 8
1 3 6
1 3 7
1 3 8
1 4 6
1 4 7
1 4 8
1 5 6
1 5 7
1 5 8
2 3 6
2 3 7
2 3 8
2 4 6
2 4 7
2 4 8
2 5 6
2 5 7
2 5 8