Question

我让我们说下面的数组..

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

我希望我能清楚地解决问题，并期待有关如何开始的任何建议，因为我是编程新手。

Answer 1

您基本上是在尝试将3D位置重塑为2D阵列，您需要从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] = ...
        }
    }
}

Answer 2

    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;
    }

Answer 3

    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;
    }

Answer 4

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

        }

    }
}

正如您所看到的，循环将运行arraysize1 * arraysize2 * arraysize3并为您刚刚列出的情况生成所有组合。

如果未提前知道数组的数量。您必须了解recursion。

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

4 个答案: