如何在C#中实现比较功能

Question

假设我在列表中有元素（X、Y 和 Z），我有一个函数，可以生成两个对象彼此相似程度的百分比。

我想做的是使用我的compareElements对Y和Z运行X，所以：

compareElements(X,Y); // equals 55
compareElements(X,Z); // equals 60

然后Y对X和Z

compareElements(Y,X); // equals 55
compareElements(Y,Z); // equals 62

然后Z对Y和X

compareElements(Z,X); // equals 60
compareElements(Z,Y); // equals 62

然后，我返回最高值，即62。

显然，那里有一些重复，我不需要重复，但我不知道如何消除它。

如何构建 LINQ 查询或函数/算法来对每个元素进行比较而不重复？

如果可以的话，我更愿意使用 LINQ，因为我正在传递一个可枚举值，并且该函数在实际枚举列表之前返回，因此我们可以节省执行比较的成本，直到枚举列表为止。

我所需要的只是比较函数的最高值 62。

注意：我的实际结果集我正在处理列表中 3 到 10 个元素之间的平均值，需要通过此比较函数运行这些平均值。< /em>

Answer 1

我倾向于这样做：

int count = list.Count;
var query = from index1 in Enumerable.Range(0, count)
            from index2 in Enumerable.Range(index1 + 1, count - (index1 + 1))
            select ComputeSimilarity(list[index1], list[index2]);
var maxSimilarity = query.Max();

Answer 2

我不确定我是否正确理解你，但尝试这样的事情：

    public int compareElementList(List<Element> elements)
    {
        int result = 0;
        for (int i = 0; i < elements.Count - 1; i++)
        {
            for (int q = i + 1; q < elements.Count; q++)
            {
                result = Math.Max(result, compareElements(elements[i], elements[q]));
            }
        }

        return result;
    }

这将为你消除重复的比较。它不使用 LINQ，但我认为它仍然具有很好的可读性。

更新：这是我修改后的版本以处理 IEnumerables。它与 Jon Hanna 的不同之处在于它不创建新列表，而只是跟踪两个迭代器。

    public int compareElementEnumerable(IEnumerable<Element> elements)
    {
        int result = 0, i = 0, q = 1;
        foreach (Element el in elements)
        {
            foreach (Element el2 in elements)
            {
                if (q > i)
                {
                    result = Math.Max(result, compareElements(el, el2));
                }
                q++;
            }
            i++;
        }

        return result;
    }

Answer 3

为了便于阅读，我会编写一个迭代器块以非重复的方式生成比较：

IEnumerable<Tuple<T, T>> GetComparisons<T>(IEnumerable<T> elements)
{
    var visited = new List<T>();

    foreach(T current in elements)
    {
        foreach(T previous in visited) 
            yield return new Tuple<T, T>(current, previous);

        visited.Add(current);
    }
}

然后您可以执行以下操作：（

var highScore = GetComparisons(listOfElements)
                    .Select(x=>compareElements(x.Item1, x.Item2)
                    .Max();

这就是说，对于没有实际理由使用 LINQ 或迭代器的情况，我更喜欢 Smelch 的建议，例如需要可组合例程。）

Answer 4

不知道这是否是您要搜索的内容，但我会尝试以这种方式使用 LINQ：

var linq = from el1 in list
           from el2 in list
           where el1 != el2
           select CompareFunction(el1, el2);

int max = linq.Max();

比较示例实现：

int CompareFunction(string a, string b)
{
    return a.Length - b.Length;
}

通过这种方式，您可以将每个元素与列表中的其他元素进行比较（我认为这是一种排列） )除自身外，然后选择比较值，最后选择最高值。

Answer 5

您可以将要测试的可能组合列表编译为 List>
然后选择最大值

 mylist.Select(i => new [] { Tuple.New(i.X, i.Y}, Tuple.New(i.X, i.Z), Tuple.New(i.Y, i.Z)})
       .Max(t => compareElements(t.First, t.Second))

Answer 6

与给出的一对几乎相同，但不需要首先分配给列表。

List<Element> soFar = new List<Element>();
// If I expected a good few duplicate values, and if 
// compareElements(x, x) isn't 100% - i.e. it's not a similarity
// check for example, then I'd use HashSet<Element> and skip
// when .Add() fails.

int result = 0;
foreach(Element el in sourceEnumeration)
{
  for(int i = 0; i != soFar.Count; ++i)
  {
    int cmp = compareElements(el, soFar[i]);
    if(cmp > result)
    {
      if(cmp == 100)
        return 100;
      cmp = result;
    }
  }
  soFar.Add(el);
}
return result;

Answer 7

不可读的 LINQ 实现（可能无法编译，我没有测试过）：

Enumerable.Range(0, listOfElements.Length).ToList().ForEach(i=>Enumerable.Range(i, listOfElements.Length-i-1).ToList().ForEach(j=>compareElements(listOfElements[i], listOfElements[j]))).Max();