我有下面的数组。。
int[] array_1 = new int[1] { 2 };
int[] array_2 = new int[2] { 3, 4 };
int[] array_3 = new int[3] { 7,5, 6 };
int combinations;
combinations = array_1.Length * array_2.Length * array_3.Length;
我想做的是创建一个新的数组，其中每列将包含来自上述每个数组的元素，行数将是上述数组所有元素的组合。在这种情况下，列数为3（因为我有3个数组），列数是6，如下所示所有元素的组合是1*2*3=6。所以，我的新数组将是：
int array_num = 3;
int[,] comb = new int[combinations, array_num];
我想用以下方式填写每一列：第一列将包含array_1数组中的元素，该数组将更改每个
int c0 = (combinations / array_1.Length);
元素。第二列将包含array_2中的元素，这些元素将改变每个
int c1=(c0/array_2.Length);
元素。第三列将包含thw-array_3中的元素，这些元素将改变每个
int c2=(c1/array_3.Length);
元素。对于这个特定的例子，结果梳状阵列将是这样的：
2 3 7
2 3 5
2 3 6
2 4 7
2 4 5
2 4 6
我希望我已经把我的问题说清楚了，我期待着任何关于我应该如何开始的建议，因为我是编程新手。
static int[,] Combine(params int[][] arrays)
{
int[][] combined = CombineRecursive(arrays).Select(x=>x.ToArray()).ToArray();
return JaggedToRectangular(combined);
}
static IEnumerable<IEnumerable<int>> CombineRecursive(IEnumerable<IEnumerable<int>> arrays)
{
if (arrays.Count() > 1)
return from a in arrays.First()
from b in CombineRecursive(arrays.Skip(1))
select Enumerable.Repeat(a, 1).Union(b);
else
return from a in arrays.First()
select Enumerable.Repeat(a, 1);
}
static int[,] JaggedToRectangular(int[][] combined)
{
int length = combined.Length;
int width = combined.Min(x=>x.Length);
int[,] result = new int[length, width];
for (int y = 0; y < length; y++)
for (int x = 0; x < width; x++)
result[y, x] = combined[y][x];
return result;
}
您基本上是在尝试将3D位置重塑为2D阵列，您需要从三维位置计算二维位置并复制值。
用于环路，例如
for (int dim0 = 0; dim0 < array1.Length; dim0++)
{
for (int dim1 = 0; dim1 < array2.Length; dim1++)
{
for (int dim2 = 0; dim2 < array3.Length; dim2++)
{
var pos = (dim0 * array2.Length + dim2) * array3.Length + dim2;
var pos0 = pos / array2.Length / array2.Length;
var pos1 = pos % (array2.Length * array2.Length);
matrix[pos0, pos1] = ...
}
}
}
static int[,] Combine(params int[][] arrays)
{
int[] pointers = new int[arrays.Length];
int total = arrays.Aggregate(1, (m, array) => m * array.Length);
int[,] result = new int[total, arrays.Length];
for (int i = 0; i < arrays.Length; i++)
result[0, i] = arrays[i][0];
for (int y = 1; y < total; y++)
for (int x = arrays.Length - 1; x >= 0; x--)
{
++pointers[x];
for (int i = x; i >= 0; i-- )
if (pointers[i] >= arrays[i].Length)
{
pointers[i] = 0;
if (i>0)
pointers[i - 1]++;
}
result[y, x] = arrays[x][pointers[x]];
}
return result;
}
for i = 0 to arraysize1
{
for j = 0 to arraysize2
{
for k = 0 to arraysize3
{
array1[i] , array1[j] , array1[k] is what you are looking for
}
}
}
正如您所看到的，循环将运行arrayize1*arrayize2*arrayize3，并为您刚才列出的案例生成所有组合。
如果阵列的数量没有提前知道。你必须学习递归。