Строковое объединение списка зубчатых массивов в c #

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. Все массивы в одном списке будут зазубренными с двумя измерениями, но ни одно из двух измерений не будет иметь фиксированную / известную длину (размер).

* «помочь» - это эвфемизм для того, кто говорит мне, как это сделать

Answer 1

Вы можете создать расширение, которое будет объединять массивы так, как вам нужно, поэтому оно будет выглядеть так: 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 2

Вы можете начать с чего-то подобного, который добавляет элементы каждой строки 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 3

В качестве окончательного решения для моего варианта использования я просто объединил ответ Дэвида и Валдимира в единственный метод, который может обрабатывать списки различной длины (> = 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
        }
    }
}