0

如何在数组 c# 中应用布尔运算符。我有三个相同大小的 3D 数组，我想对两个数组应用布尔运算符并将结果保存在 array3 中。例如：

int[, ,] array1 = new int[,,] { { { 1, 2, 3 }, { 4, 5, 6 } }, 
                             { { 7, 8, 9 }, { 10, 11, 12 } } };
int[, ,] array2 = new int[,,] { { { 1, 1, 1 }, { 0, 0, 0 } }, 
                             { { 0, 0, 0 }, { 0, 0, 0 } } };
int [, ,] array3 = new int[4,3]; 
result = array1 (AND operator) array2;

预期结果：

array3 = { { 1, 2, 3 }, { 0, 0, 0 } },{ { 0, 0, 0 }, { 0, 0, 0 } };

我的问题是有什么方法可以在不访问数组元素的情况下在两个数组上实现布尔运算？

谢谢你的提前。

4

2 回答 2

2

好消息是从框架 4.0 开始有Zip 方法：

Enumerable.Zip 方法 将指定的函数应用于两个序列的相应元素，从而生成结果序列。

对于一维数组，它很简单：

        int[] array1 = new int[] { 1, 2, 3 };
        int[] array2 = new int[] { 0, 1, 0 };

        var zipped = array1.Zip(array2, (first, second) => second == 0 ? 0 : first);
        //zipped = {0, 2, 0}

坏消息是多维数组不实现 IEnumerable，但您可以将 Zip 与锯齿数组一起使用。你可以尝试这样的事情：

        int[][] jagged1 = new int[][]
                {
                    new int[] {1,2,3},
                    new int[] {4,5,6},
                    new int[] {7,8,9}
                };

        int[][] jagged2 = new int[][]
                {
                    new int[] {1,1,1},
                    new int[] {0,0,0},
                    new int[] {0,0,0}
                };

        var zipped = jagged1.Zip(jagged2, (firstArray, secondArray)                             
                        => firstArray.Zip(secondArray, 
                              (first, second) => second == 0 ? 0 : first)
                     );

        //zipped = {{1,2,3}, {0,0,0}, {0,0,0}}
于 2013-06-26T09:07:35.570 回答
1

我不完全确定你的意思，但是：

int[,,] array3 = new int[array1.GetLength(0), array1.GetLength(1), array1.GetLength(2)];

for (int x = 0; x < array1.GetLength(0); ++x)
    for (int y = 0; y < array1.GetLength(1); ++y)
        for (int z = 0; z < array1.GetLength(2); ++z)
            array3[x, y, z] = (array2[x, y, z] != 0) ? array1[x, y, z] : 0;

如果 array2[x,y,z] 不为零，则将 array3[x,y,z] 设置为 array1[x,y,z] 否则将 array3[x,y,z] 设置为 0。

这是你的意思吗？

于 2013-06-26T08:30:08.273 回答