2

目前，我有一系列可能性，我希望根据该可能性列表计算事实（逻辑 XNOR）。

var possibilities = new[] {
    new[] {0, 1, 1, 1, 1, 1, 1, 1},
    new[] {1, 1, 1, 1, 1, 1, 1, 0}
}

我正在尝试将其转换为 XNOR 的布尔数组（所有值都相等）

预期结果：

[ 0, 1, 1, 1, 1, 1, 1, 0 ]

可能性的数量是 1 .. n。另一个例子是：

var possibilities = new[] {
    new[] {1, 1, 0, 1, 1, 0, 0, 0},
    new[] {1, 1, 0, 1, 1, 0, 0, 1},
    new[] {0, 1, 1, 0, 1, 1, 0, 1}
}

结果将是：

[ 0, 1, 0, 0, 1, 0, 1, 0 ]

我最初的方法是开始构建嵌套循环并遍历每种可能性，获取索引并进行比较，但这似乎非常“骇人听闻”，我相信有一种更简单（更好）的方法可以通过 LINQ 处理它（但是我这样做了不太了解 LINQ 来编写它）或不需要丑陋的嵌套循环的算法。

编辑#1：使用了不正确的“逻辑”术语

正如下面的答案中提到的，正确的逻辑实际上不是 AND 而是 XNOR（所有列都相等）。实际上，当我（如上所述）时，AND 会在所有列都为 0 的情况下产生 0，如果所有值都相等，那么它实际上是在寻找 1（或真）的结果。

4

4 回答 4

5 
int size = possibilities[0].Length;
int i = 0;
var a = possibilities.SelectMany(x => x).GroupBy(x => i++ % size)
              .Select(x => x.Any(z => z == 0) ? 0 : 1);

并使用循环：

int j = 0, size = possibilities[0].Length;
int[] result = new int[size];
for (int i = 0; i < size; i++)
{ 
     for (j = 0; j < possibilities.Length; j++)
         if (possibilities[j][i] == 0) { result[i] = 0; break; }
     if (j == possibilities.Length) result [i] = 1;
}

异或：

int i = 0;
var a = possibilities.SelectMany(x => x).GroupBy(x => i++ % size)
            .Select(x => x.All(z => z == 0) || x.All(z => z == 1) ? 1 : 0);

带循环的 XNOR：

int size = possibilities[0].Length;
int[] result = new int[size];
for (int i = 0; i < size; i++)
{ 
     int q = possibilities[0][i];
     for (j = 1; j < possibilities.Length; j++)
         if (possibilities[j][i] != q) { result[i] = 0; break; }
     if (j == possibilities.Length) result[i] = 1;
}

现场演示

于 2018-11-13T21:40:20.020 回答
1

您正在寻找 zip 扩展名。但是您需要使用聚合来处理两个以上。唯一的差异是您的结果为 1 的三个零。and 运算符 (&) 将为零。

    static void Main(string[] args)
    {
        var possibilities = new[]
        {
            new[] {0, 1, 1, 1, 1, 1, 1, 1},
            new[] {1, 1, 1, 1, 1, 1, 1, 0}
        };
        //[ 0, 1, 1, 1, 1, 1, 1, 0 ]
        var result = possibilities.Aggregate((f, s) => f.Zip(s, (fi, si) => fi & si).ToArray());
        var possibilities2 = new[]
        {
            new[] {1, 1, 0, 1, 1, 0, 0, 0},
            new[] {1, 1, 0, 1, 1, 0, 0, 1},
            new[] {0, 1, 1, 0, 1, 1, 0, 1}
        };
        //[ 0, 1, 0, 0, 1, 0, 1, 0 ]
        var result2 = possibilities2.Aggregate((f, s) => f.Zip(s, (fi, si) => fi & si).ToArray());

        Console.ReadLine();
    }
于 2018-11-13T21:38:38.890 回答
1

这是一种仅使用 1 个循环来携带相关元素索引的方法...

static void Main(string[] args)
{
    var possibilities = new[] {
        new[] {1, 1, 0, 1, 1, 0, 0, 0},
        new[] {1, 1, 0, 1, 1, 0, 0, 1},
        new[] {0, 1, 1, 0, 1, 1, 0, 1}
    };

    IList<int> output = new List<int>();

    for (int i = 0; i < possibilities[0].Length; i++)
    {
         output.Add(possibilities.All(x => x.ElementAt(i) == possibilities[0][i]) ? 1 : 0);
    }

    Console.WriteLine("[{0}]", string.Join(", ", output));

    Console.ReadKey();
}

对于第一个示例，返回 [0, 1, 1, 1, 1, 1, 1, 0]。对于第二个示例，返回 [0, 1, 0, 0, 1, 0, 1, 0]。

于 2018-11-13T21:44:43.760 回答
0

这里最简单的实现是这样说：

for(i = 0; i < list1.Count(); i++){
list3[i] = list1[i] && list2[i]
}

如果您必须使用 linq，您可以导入 MoreLinq 库，然后将 .interleave 与 .batch 结合使用

https://morelinq.github.io/2.0/ref/api/html/M_MoreLinq_MoreEnumerable_Interleave__1.htm http://www.toplinestrategies.com/blogs/application-development/grouping-data-morelinq-batch-extension-method https： //github.com/morelinq

于 2018-11-13T21:41:24.213 回答