Question

我有两个相同的列表需要比较，所以我认为我将创建一个二维数组并存储有关条件是否通过或失败的布尔值，但我想减少对每个条件进行检查的次数元素，因为它毫无意义：

a) compare the exact same elements (as this condition would always pass 
   in my scenario).

   |0|1|2|
----------
 |0|x| | |
 |1| |x| |
 |2| | |x|
----------

b) compare exact opposite elements in the array where if a condition
   passed where i=1 and j=2 we'd know that i=2 and j=1 would also pass.

   Array1: [2,6,9]
   Array2: [2,6,9]

   |0|1|2|
----------
 |0| | | |
 |1| | |p|
 |2| |p| |
----------

 Where p[2,1] would be (9,6) for example and p[1,2] would be (6,9) which
 in my case would mean they are identical.

因此，基于以上所述，有没有办法使所需的循环最小化？还是我必须使用类似的方法来循环？

for (int i = 0; i < source.Count; i++)
{
    for (int j = 0; j < compare.Count; j++)
{
    if ((i != j) && 
            !alreadyProcessed[i, j] && !alreadyProcessed[j, i])
    {
            alreadyProcessed[i, j] = true;
            alreadyProcessed[j, i] = true;
            bool condition = ...;
            if (condition)
            {
    }
        }
    else
        {
            if (i == j)
            {
        alreadyProcessed[i, j] = true;
        }
    }
    }
}

我希望使用linq和交集，例如，我可以排除（0,0），（1,1）和（2,2）之类的东西，然后以某种方式将唯一组合的单个组合作为我们只需要（0,1）以及（0,2）和（1,2），因为我们知道（1,0），（2,0）和（2,1）与它们的相同相反。

希望有道理。

Answer 1

由于在任何时候i都可以忽略索引小于i的列表中的所有内容（等于相同的元素并且较小，我们已经检查过），因此您可以简单地具有以下内容：

var array = new int[] {1, 2, 3, 4};

for (int i = 0; i < array.Count(); i++) {
    for (int j = i + 1; j < array.Count(); j++) {
        Console.WriteLine($"Comparirf {i}:{array[i]} and {j}:{array[j]}");
    }
}

Linq确实没有有效地执行此操作的工具（至少据我所知）。

Answer 2

好吧，由于序列是相同的，所以您实际上是在谈论单个序列。

下面是如何使用LINQ从序列中获得唯一组合的工作示例。

如果您想查看两对是否相等，可以这样做

pairs.Select(p => p.First.Equals(p.Second));

这里是Fiddle，下面是代码

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        var pairs = ((IEnumerable<int>)new[] { 1, 2, 3, 4 }).Pairs();
        Console.WriteLine(
            string.Join(
                $",{Environment.NewLine}", 
                pairs.Select(p => $"{{first:{p.First}, second:{p.Second}}}")));
    }
}

public static class Ext
{
    public static IEnumerable<Pair<T>> Pairs<T>(
        this IEnumerable<T> source)
    {
        return source.SelectMany(
            (value, index) => source.Skip(index + 1),
            (first, second) => new Pair<T>(first, second));
    }

    public sealed class Pair<T>
    {
        internal Pair(T first, T second)
        {
            this.First = first;
            this.Second = second;
        }

        public T First { get; }

        public T Second { get; }
    }
}

比较c＃

2 个答案: