如何 运行 逻辑 'xnor' 跨多维数组(linq 或简单算法)中的列?
How do I run logical 'xnor' across a column in a multi-dimensional array (linq or simple algorithm)?
目前,我有一个 possibilities 数组,我希望根据该列表计算 facts(逻辑异或) 种可能性。
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 ]
我最初的方法是开始构建嵌套循环并遍历每种可能性,获取索引并进行比较,但这看起来非常 'hackish',我相信有一种更简单(更好)的处理方式通过 LINQ(但是我对 LINQ 的了解还不够多,无法编写它)或不需要丑陋的嵌套循环的算法。
编辑 #1:使用的 'logic' 术语不正确
正如下面的答案中提到的,正确的逻辑实际上不是 AND 而是 XNOR(所有列都相等)。 AND 实际上会在所有列都为 0 的情况下生成 0(如上所述),如果所有值都相等,那么我实际上正在寻找 1(或 true)的结果。
您正在查找扩展邮编。但是你需要使用聚合来处理两个以上。唯一的差异是结果为 1 的三个零。与运算符 (&) 将为零。
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();
}
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;
}
这里最简单的实现就是这样说:
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
这是一种仅使用 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();
}
Returns [0, 1, 1, 1, 1, 1, 1, 0] 作为第一个例子。
Returns [0, 1, 0, 0, 1, 0, 1, 0] 第二个例子。
目前,我有一个 possibilities 数组,我希望根据该列表计算 facts(逻辑异或) 种可能性。
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 ]
我最初的方法是开始构建嵌套循环并遍历每种可能性,获取索引并进行比较,但这看起来非常 'hackish',我相信有一种更简单(更好)的处理方式通过 LINQ(但是我对 LINQ 的了解还不够多,无法编写它)或不需要丑陋的嵌套循环的算法。
编辑 #1:使用的 'logic' 术语不正确
正如下面的答案中提到的,正确的逻辑实际上不是 AND 而是 XNOR(所有列都相等)。 AND 实际上会在所有列都为 0 的情况下生成 0(如上所述),如果所有值都相等,那么我实际上正在寻找 1(或 true)的结果。
您正在查找扩展邮编。但是你需要使用聚合来处理两个以上。唯一的差异是结果为 1 的三个零。与运算符 (&) 将为零。
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();
}
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;
}
这里最简单的实现就是这样说:
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
这是一种仅使用 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();
}
Returns [0, 1, 1, 1, 1, 1, 1, 0] 作为第一个例子。 Returns [0, 1, 0, 0, 1, 0, 1, 0] 第二个例子。