Question

我希望获得帮助*，以创建一种方法或（linq）表达式，该方法或表达式可以按行连接锯齿数组的列表（长度不同），如下所示：

List<double[][]> orgArrayList = new List<double[][]>();

double[][] one = {
new [] {5d, 6},
new [] {7d, 9}};

double [][] two =  {
new [] {5d, 6},
new [] {7d, 9}};

double [][] three= {
new [] {5d, 6},
new [] {7d, 9}};

orgArrayList.AddRange(new[] {one, two, three});

以使结果数组等于该数组：

double[][] expected = {
new [] {5d, 6, 5, 6, 5, 6},
new [] {7d, 9, 7, 9, 7, 9}};

我的输入列表中锯齿状数组的数量将> = 1。单个列表中的所有数组都将带有2个维度的锯齿状，但是2个维度中的任何一个都不具有固定的/已知的长度（大小）。

*'help'是委婉的说法，有人告诉我该怎么做

Answer 1

您可以从类似这样的内容开始，它将add[]的每一行的元素追加到src[]的行，从而产生一个新的二维数组：

public static double[][] AppendToRows(double[][] src, double[][] add)
{
    // Allocate new array to hold elements from src[] and add[]
    double[][] res = new double[src.Length][];

    // Append elements to each row of res[]
    for (int i = 0;  i < src.Length;  i++)
    {
        // Allocate row res[i] large enough to hold elements from src[i] and add[i]
        res[i] = new double[src[i].Length + add[i].Length];

        // Copy/append elements from src[i] to res[i]
        int ri = 0;
        for (int j = 0;  j < src[i].Length;  j++)
            res[i][ri++] = src[i][j];

        // Copy/append elements from add[i] to res[i]
        if (i >= add.Length)
            continue;
        for (int j = 0;  j < add[i].Length;  j++)
            res[i][ri++] = add[i][j];
    }
    return res;
}

要将多个数组附加在一起，只需多次调用此方法，就需要将每个附加数组连接到结果数组上一次。

更全面的解决方案是获取List<double[][]>输入数组，并在构建结果的每一行时遍历列表中的每个数组。但是我把它留给读者练习。

Answer 2

您可以创建扩展名，该扩展名将以所需的方式连接数组，因此看起来像Linq：

public static class Extension
{
    public static T[][] ConcatArrays<T>(this T[][] array, T[][] concatWith)
    {

        var max = Math.Max(array.Length, concatWith.Length);
        var result = new T[max][];
        for (var index = 0; index < max; index++)
        {
            var list = new List<T>();
            if (index < array.Length)
            {
                list.AddRange(array[index]);                   
            }

            if (index < concatWith.Length)
            {
                list.AddRange(concatWith[index]);
            }

            result[index] = list.ToArray();
        }

        return result;
    }
}

所以它的用法是：

var expected = one.ConcatArrays(two).ConcatArrays(three);

希望有道理

Answer 3

作为我的用例的最终解决方案，我只是将David和Valdimir的答案组合成一个单个方法，该方法可以处理不同长度的列表（> = 1）。

// ========================================
// My interpretation of David's suggestion
// using Valdimir's solution as a basis
// ========================================
public static double[][] RowWiseConcatListedJaggedArrays(List<double[][]> listOfJaggedArray)
{
    var resArray = listOfJaggedArray[0];

    for (int rInd = 1; rInd < listOfJaggedArray.Count; rInd++)
    {
        resArray = resArray.ConcatArrays(listOfJaggedArray[rInd]);
    }

    return resArray;
}

把所有东西放在一起...

using System;
using System.Collections.Generic;

namespace RowWiseConcat
{
    public static class Extension
    {
        // ====================
        // Vladimir's solution
        // ====================
        public static T[][] ConcatArrays<T>(this T[][] array, T[][] concatWith)
        {

            var max = Math.Max(array.Length, concatWith.Length);
            var result = new T[max][];
            for (var index = 0; index < max; index++)
            {
                var list = new List<T>();
                if (index < array.Length)
                {
                    list.AddRange(array[index]);
                }

                if (index < concatWith.Length)
                {
                    list.AddRange(concatWith[index]);
                }

                result[index] = list.ToArray();
            }

            return result;
        }
    }

    class Program
    {
        // ========================================
        // My interpretation of David's suggestion
        // using Valdimir's solution as a basis
        // ========================================
        public static double[][] RowWiseConcatListedJaggedArrays(List<double[][]> listOfJaggedArray)
        {
            var resArray = listOfJaggedArray[0];

            for (int rInd = 1; rInd < listOfJaggedArray.Count; rInd++)
            {
                resArray = resArray.ConcatArrays(listOfJaggedArray[rInd]);
            }

            return resArray;
        }

        static void Main(string[] args)
        {

            // ... do something that results in orgArrayList, e.g.
            double[][] one =
            {
                new[] {5d, 6},
                new[] {7d, 9}
            };
            double[][] two =
            {
                new[] {5d, 6},
                new[] {7d, 9}
            };
            double[][] three =
            {
                new[] {5d, 6},
                new[] {7d, 9}
            };

            List<double[][]> orgArrayList = new List<double[][]>()
                { one, two, three};

            // Concat list items
            var resArray = RowWiseConcatListedJaggedArrays(orgArrayList);

            // ... continue with resArray
        }
    }
}

按行连接C＃中的锯齿状数组列表

3 个答案: