C# 合并一些列表<；双[]>；在列表中<；列表<；双[]>&燃气轮机；

我正在努力以一种特殊的方式合并列表。我想做的事情如下所述

我的输入列表如下：

列表A=

列表

列表B=

List

所需输出为：

列表C=

List

列表A中有一些

列表

，我想合并它们（例如，使用linq中的Union功能），并将结果列表存储在名为“ListC”的

列表

中

要在ListA中合并的列表的索引存储在ListB中。如果元素不应该被合并（它们的索引不出现在ListB中），那么我们直接将它们添加到ListC中

示例：

ListA = new List<List<double[]>>() { a0, a1, a2, a3, a4, a5}; 

输入：

ListA = new List<List<double[]>>() { a0, a1, a2, a3, a4, a5}; 

ListA=newlist（）{a0，a1，a2，a3，a4，a5}；

其中ai=

列表

ListB=newlist（）{newint[]{0,1,2}，newint[]{3,5}；

指示必须将列表0-1-2合并为一个。与清单3-5相同

输出：ListC=

列表

包含列表A的所有合并的

列表

以及所有唯一的

列表

。即：

-->c0=a0、a1、a2“三个列表合并为1”的并集

-->c1=a3、a5的并集“两个列表合并为2”

-->c2=a4“是唯一的列表”

注意：重复项不是问题

实现这一目标的好方法是什么

守则：

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


class _unionLists
{

    public static void Main(string[] args)
    {

        #region input lists
        //--------------------LIST A---------------------------------------------------
        //List a0
        var point1 = new double[] { 3, 3, 0 };
        var point2 = new double[] { 9, 6, 0 };
        var point3 = new double[] { 12, 8, 0 };
        var point4 = new double[] { 18, 8, 0 };
        List<double[]> a0 = new List<double[]>() { point1, point2, point3, point4 };

        //List a1
        var point5 = new double[] { 3, 3, 0 };
        var point6 = new double[] { 9, 7, 0 };
        var point7 = new double[] { 15, 7, 0 };
        var point8 = new double[] { 21, 15, 0 };
        List<double[]> a1 = new List<double[]>() { point5, point6, point7, point8 };

        //List a2
        var point9 = new double[] { 20, 13, 0 };
        var point10 = new double[] { 22, 16, 0 };
        List<double[]> a2 = new List<double[]>() { point9, point10 };

        //List a3
        var point11 = new double[] { 15, 19, 0 };
        var point12 = new double[] { 27, 19, 0 };
        List<double[]> a3 = new List<double[]>() { point11, point12 };

        //List a4
        var point13 = new double[] { 18, 20, 0 };
        var point14 = new double[] { 21, 19, 0 };
        List<double[]> a4 = new List<double[]>() { point13, point14 };

        //List a5
        var point15 = new double[] { 27, 19.5, 0 };
        var point16 = new double[] { 30, 5, 0 };
        List<double[]> a5 = new List<double[]>() { point15, point16 };          

        var ListA = new List<List<double[]>>() { a0, a1, a2, a3, a4, a5};

        //--------------------LIST B---------------------------------------------------
        var ListB = new List<int[]>() { new int[]{0,1,2} , new int[]{3,5} };

        #endregion

        //There are some of the List<double[]> within List A that I want to merge (e.g. using  the Union capability in linq) and store the resultant list in a List<List<double[]>> called "ListC".
        //The indices of the Lists to be merged within ListA are stored in the ListB. If the elements are not suposed to be merged (their index doesn't appear in ListB) then we add them directly to ListC.
        //
        //Example: 
        //  Inputs: ListA = new List<List<double[]>>() { a0, a1, a2, a3, a4, a5}; where ai=List<double[]>;
        //          ListB = new List<int[]>() { new int[]{0,1,2} , new int[]{3,5} }; indicates that the lists 0-1-2 have to be merged into one. Same with lists 3-5
        //  Output: ListC= List<List<double[]>> contains all the merged List<double[]> as well as all the unique List<double[]> of List A. That is:
        //          c0= union of a0, a1, a2 "three lists to be merged into 1"
        //          c1= union of a3, a5 "two lists to be merged into 2"
        //          c2= a4 "is a unique list"

        var ListC = new List<List<double[]>>();


    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
类联合列表
{
公共静态void Main（字符串[]args）
{
#区域输入列表
//--------------------列举---------------------------------------------------
//列表a0
var point1=新的双精度[]{3,3,0}；
var point2=新的双精度[]{9,6,0}；
var point3=新的双[]{12,8,0}；
var point4=新的双[]{18,8,0}；
List a0=新列表（）{point1，point2，point3，point4}；
//清单a1
var point5=新的双精度[]{3,3,0}；
var point6=新的双精度[]{9,7,0}；
var point7=新的双精度[]{15,7,0}；
var point8=新的双[]{21,15,0}；
列表a1=新列表（）{point5，point6，point7，point8}；
//清单a2
var point9=新的双[]{20,13,0}；
var point10=新的双[]{22,16,0}；
列表a2=新列表（）{point9，point10}；
//清单a3
var point11=新的双[]{15,19,0}；
var point12=新的双[]{27,19,0}；
列表a3=新列表（）{point11，point12}；
//清单a4
var point13=新的双[]{18,20,0}；
var point14=新的双[]{21,19,0}；
列表a4=新列表（）{point13，point14}；
//清单a5
var point15=新的双[]{27,19.5,0}；
var point16=新的双精度[]{30,5,0}；
列表a5=新列表（）{point15，point16}；
var ListA=新列表（）{a0，a1，a2，a3，a4，a5}；
//--------------------名单B---------------------------------------------------
var ListB=new List（）{new int[]{0,1,2}，new int[]{3,5}；
#端区
//我想合并列表A中的一些列表（例如，使用linq中的Union功能），并将结果列表存储在名为“ListC”的列表中。
//要在ListA中合并的列表的索引存储在ListB中。如果不支持合并元素（它们的索引不显示在ListB中），则直接将它们添加到ListC中。
//
//例如：
//输入：ListA=newlist（）{a0，a1，a2，a3，a4，a5}；其中ai=List；
//ListB=new List（）{new int[]{0,1,2}，new int[]{3,5}}；表示必须将列表0-1-2合并为一个。与列表3-5相同
//输出：ListC=List包含所有合并列表以及列表A的所有唯一列表。即：
//c0=a0、a1、a2“三个列表合并为1”的并集
//c1=a3、a5的并集“两个列表合并为2”
//c2=a4“是唯一的列表”
var ListC=新列表（）；
}
}

您可以编写

var C = A.SelectMany(x => x).Union(B);

var result=newlist（）；
foreach（列表B中的变量数组）
{
var ld=新列表（）；
foreach（数组中的var索引）
{
ld.Concat（列表[索引]）；
}
结果：添加（ld）；
}
var Index=listB.SelectMany（arr=>arr）；
result.AddRange（listA.Where（（列表，索引）=>！index.Contains（索引））；

试试这个：

var elementsACount = ListA.Count();
var groupedElementsIdxs = ListB.SelectMany(e => e);
var ungroupedElementsIdxs = Enumerable.Range(0, elementsACount).Except(groupedElementsIdxs);

var result = new List<List<double[]>>();
// Merge and add the grouped elements.
foreach (var el in ListB)
{
    result.Add(el.Select(e => ListA[e]).SelectMany(e => e).ToList());
}
// Merge and add the ungrouped elements.
result.Add(ungroupedElementsIdxs.Select(e => ListA[e]).SelectMany(e => e).ToList());

var elementsACount=ListA.Count（）；
var groupedElementsIdxs=ListB.SelectMany（e=>e）；
var ungroupedElementsIdxs=Enumerable.Range（0，elementsACount）.Except（groupedElementsIdxs）；
var result=新列表（）；
//合并并添加分组的元素。
foreach（列表B中的变量el）
{
Add（el.Select（e=>ListA[e]）.SelectMany（e=>e.ToList（））；
}
//合并并添加未分组的元素。
Add（ungroupedElementsIdxs.Select（e=>ListA[e]）.SelectMany（e=>e.ToList（））；

您实际尝试了什么？你看起来好像有所有的设置代码在这里，但我不能立即看到你实际上是在试图做合并？你的问题到底在哪里？你能想出一个算法来做到这一点吗？您是否有一个无法实现的算法？还有什么吗？创建一个更准确地表示数据的数据结构可能是值得的。我不确定这应该是一个矩阵还是一个多维数组或什么的，但是如果你写了一个类来表示它，那就更容易考虑需要对数据应用什么转换了。@Asad同意-人脑不擅长跟踪嵌套的数据结构，最好给他们分配一些meaning@Jodrell当我用问题中给出的数据测试它时，它既编译又工作。另外，您的答案包含一些语法错误，这些错误阻止了它的编译，但是我看到了

var elementsACount = ListA.Count();
var groupedElementsIdxs = ListB.SelectMany(e => e);
var ungroupedElementsIdxs = Enumerable.Range(0, elementsACount).Except(groupedElementsIdxs);

var result = new List<List<double[]>>();
// Merge and add the grouped elements.
foreach (var el in ListB)
{
    result.Add(el.Select(e => ListA[e]).SelectMany(e => e).ToList());
}
// Merge and add the ungrouped elements.
result.Add(ungroupedElementsIdxs.Select(e => ListA[e]).SelectMany(e => e).ToList());