创建新的多维数组，并用其他数组中的值填充它

本文关键字：数组 其他 填充 创建 | 更新日期: 2023-09-27 17:58:13

我有下面的数组。。

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，并为您刚才列出的案例生成所有组合。

如果阵列的数量没有提前知道。你必须学习递归。

相关文章：