C# 数组拆分再根据指定条件组装

Question

C# 数组拆分再根据指定条件组装
比如：double[] X = {880, 479, 584, 487, 718, 872,1052, 476, 717, 578}; // 数组X
double[] Y = {579, 1092, 926, 1110, 749, 568, 465, 1088, 734, 909}; // 数组Y
double[] Score = {0.588, 0.623, 0.654, 0.824, 0.68, 0.707,0.745, 0.671, 0.863, 0.923}; // 数组Score
三个数组的元素值根据索引是 一 一 对应的，首先提取X、Y数组中元素差值同时满足在指定范围内（比如差值<=30）的元素并放在多个子数组中，同时数组Score中的元素也跟着放在多个子数组中，如下形式：
数组X的子数组： {880, 872} 数组Y的子数组：{579, 568} 数组Score 的子数组：{0.588, 0.707}
{479, 487, 476} {1092, 1110, 1088 } {0.623, 0.824, 0.671}
{584, 578} {926, 909} {0.654, 0.923}
{718, 717} {749, 734} {0.68, 0.863}
{1052} {465} {0.745}
完成后，再根据每个Score子数组中的最大元素值对应的索引输出X、Y子数组中的元素，将这些元素在放在一个数组中
最终输出：
数组X的子数组满足条件的数组： {872, 487, 578, 717, 1052}
数组Y的子数组满足条件的数组： {568, 1110, 909, 734, 465}

Answer 1

引自免费微信小程序：皆我百晓生

当然，我将为您提供一个C#代码示例来解决这个问题。首先，我们需要创建一个新的类（例如DataPoint）来存储X、Y和Score的对应关系，然后根据指定条件对数组进行分组，并找到每个子数组中Score最大值对应的索引。以下是完成这个任务的完整C#代码：

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

public class DataPoint
{
    public double X { get; set; }
    public double Y { get; set; }
    public double Score { get; set; }

    public DataPoint(double x, double y, double score)
    {
        X = x;
        Y = y;
        Score = score;
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 原始数据
        List<DataPoint> dataPoints = new List<DataPoint>
        {
            new DataPoint(880, 579, 0.588),
            new DataPoint(479, 1092, 0.623),
            new DataPoint(584, 926, 0.654),
            new DataPoint(487, 1110, 0.824),
            new DataPoint(718, 749, 0.680),
            new DataPoint(872, 568, 0.707),
            new DataPoint(1052, 465, 0.745),
            new DataPoint(476, 1088, 0.671),
            new DataPoint(717, 734, 0.863),
            new DataPoint(578, 909, 0.923),
        };

        // 指定差值范围
        const double deltaThreshold = 30;

        // 根据X-Y差值是否满足条件进行分组
        var groups = dataPoints.Select((dp, index) => new
        {
            Index = index,
            Point = dp,
            GroupKey = Enumerable.Range(0, dataPoints.Count - 1)
                .Where(i => Math.Abs(dp.X - dataPoints[i].X) <= deltaThreshold && Math.Abs(dp.Y - dataPoints[i].Y) <= deltaThreshold)
                .Select(i => i)
        })
        .GroupBy(x => x.GroupKey);

        // 找到每个子数组中Score最大值对应的DataPoint
        var resultDataPoints = groups.Select(group =>
        {
            var maxScoreDataPoint = group.OrderByDescending(gp => gp.Point.Score).First();
            return maxScoreDataPoint.Point;
        }).ToList();

        // 输出满足条件的X和Y数组
        var resultXArray = resultDataPoints.Select(dp => dp.X).ToArray();
        var resultYArray = resultDataPoints.Select(dp => dp.Y).ToArray();

        Console.WriteLine("数组X的子数组满足条件的数组： " + string.Join(", ", resultXArray));
        Console.WriteLine("数组Y的子数组满足条件的数组： " + string.Join(", ", resultYArray));
    }
}

这段代码首先将原始数据转换为包含X、Y、Score属性的DataPoint对象列表，然后根据X和Y的差值是否满足指定条件进行分组，并在每个分组中找出具有最大Score值的数据点。最后，输出满足条件的X和Y数组。请注意，这里假设的是X和Y同时满足差值小于等于30的条件，如果只需要其中一个满足条件，请相应地修改比较逻辑部分。