c# - 如何使用 LINQ 和 C# 找到最接近 0,0 点的点

Question

我有一个点列表（列表）

• 7,43
• 7,42
• 6,42
• 5,42
• 6,43
• 5,43

我想使用 linq 表达式来获得最接近 0,0 的点。例如 - 对于这个列表，我期望 5,42 的值。

如何使用 LINQ 找到最接近 0,0 点的点？

Answer 1

下面找到具有最低L^2范数的点（二维中“距离”的最常见定义），而无需对整个列表执行昂贵的排序：

var closestToOrigin = points
    .Select(p => new { Point = p, Distance2 = p.X * p.X + p.Y * p.Y })
    .Aggregate((p1, p2) => p1.Distance2 < p2.Distance2 ? p1 : p2)
    .Point;

Answer 2

试试这个：

List<Point> points = new List<Point>();
// populate list
var p = points.OrderBy(p => p.X * p.X + p.Y * p.Y).First();

或更快速的解决方案：

var p = points.Aggregate(
            (minPoint, next) =>
                 (minPoint.X * minPoint.X + minPoint.Y * minPoint.Y)
                 < (next.X * next.X + next.Y * next.Y) ? minPoint : next);

Answer 3

Rawling 的解决方案肯定更短，但这里有一个替代方案

// project every element to get a map between it and the square of the distance
var map = pointsList                                            
    .Select(p => new { Point = p, Distance = p.x * p.x + p.y * p.y });

var closestPoint = map // get the list of points with the min distance
    .Where(m => m.Distance == map.Min(t => t.Distance)) 
    .First() // get the first item in that list (guaranteed to exist)
    .Point; // take the point

如果您需要找到与 的距离最短的所有0,0元素，只需删除First并执行 aSelect(p => p.Point)即可获取点（与映射相反）。

Answer 4

作为一种替代方法，您可以考虑向标准库中添加 IEnumerable.MinBy() 和 IEnumerable.MaxBy() 的实现。

如果你有可用的，代码就变得简单了：

var result = points.MinBy( p => p.X*p.X + p.Y*p.Y );

Jon Skeet 提供了一个很好的 MinBy 和 MaxBy 实现。

他在这里谈论它：How to use LINQ to select object with minimum or maximum property value

不过，那里的链接已经过时了；最新版本在这里：

http://code.google.com/p/morelinq/source/browse/MoreLinq/MinBy.cs

http://code.google.com/p/morelinq/source/browse/MoreLinq/MaxBy.cs

这是一个完整的样本。显然，这是一个大锤，但我认为这些方法足够有用，可以包含在您的标准库中：

using System;
using System.Collections.Generic;
using System.Drawing;

namespace Demo
{
    public static class EnumerableExt
    {
        public static TSource MinBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector, IComparer<TKey> comparer)
        {
            using (IEnumerator<TSource> sourceIterator = source.GetEnumerator())
            {
                if (!sourceIterator.MoveNext())
                {
                    throw new InvalidOperationException("Sequence was empty");
                }

                TSource min = sourceIterator.Current;
                TKey minKey = selector(min);

                while (sourceIterator.MoveNext())
                {
                    TSource candidate = sourceIterator.Current;
                    TKey candidateProjected = selector(candidate);

                    if (comparer.Compare(candidateProjected, minKey) < 0)
                    {
                        min    = candidate;
                        minKey = candidateProjected;
                    }
                }

                return min;
            }
        }

        public static TSource MinBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector)
        {
            return source.MinBy(selector, Comparer<TKey>.Default);
        }
    }

    public static class Program
    {
        static void Main(string[] args)
        {
            List<Point> points = new List<Point>
            {
                new Point(7, 43),
                new Point(7, 42),
                new Point(6, 42),
                new Point(5, 42),
                new Point(6, 43),
                new Point(5, 43)
            };

            var result = points.MinBy( p => p.X*p.X + p.Y*p.Y );

            Console.WriteLine(result);
        }
    }
}