Ответ 1

Вы можете использовать следующий метод для разбиения массива на 2 отдельных массива

public void Split<T>(T[] array, int index, out T[] first, out T[] second) {
  first = array.Take(index).ToArray();
  second = array.Skip(index).ToArray();
}

public void SplitMidPoint<T>(T[] array, out T[] first, out T[] second) {
  Split(array, array.Length / 2, out first, out second);
}

Ответ 2

Использовать общий метод разделения:

public static void Split<T>(T[] source, int index, out T[] first, out T last)
{
    int len2 = source.Length - index;
    first = new T[index];
    last = new T[len2];
    Array.Copy(source, 0, first, 0, index);
    Array.Copy(source, index, last, 0, len2);
}

Ответ 3

Я также хочу добавить решение для разбиения массива на несколько меньших массивов, содержащих определенное количество ячеек.

Хорошим способом было бы создать универсальный/расширенный метод для разбиения любого массива. Это мое:

/// <summary>
/// Splits an array into several smaller arrays.
/// </summary>
/// <typeparam name="T">The type of the array.</typeparam>
/// <param name="array">The array to split.</param>
/// <param name="size">The size of the smaller arrays.</param>
/// <returns>An array containing smaller arrays.</returns>
public static IEnumerable<IEnumerable<T>> Split<T>(this T[] array, int size)
{
    for (var i = 0; i < (float)array.Length / size; i++)
    {
        yield return array.Skip(i * size).Take(size);
    }
}

Кроме того, это решение отложено. Затем просто вызовите split(size) в свой массив.

var array = new byte[] {10, 20, 30, 40, 50};
var splitArray = array.Split(2);

Удачи:)

Ответ 4

У меня возникла проблема с функциями Linq Skip() и Take() при работе с массивами с огромным количеством элементов (например, байтовых массивов), где количество элементов в миллионах.

Этот подход значительно сократил время выполнения разделения для меня.

public static IEnumerable<IEnumerable<T>> Split<T>(this ICollection<T> self, int chunkSize)
{
    var splitList = new List<List<T>>();
    var chunkCount = (int)Math.Ceiling((double)self.Count / (double)chunkSize);

    for(int c = 0; c < chunkCount; c++)
    {
        var skip = c * chunkSize;
        var take = skip + chunkSize;
        var chunk = new List<T>(chunkSize);

        for(int e = skip; e < take && e < self.Count; e++)
        {
            chunk.Add(self.ElementAt(e));
        }

        splitList.Add(chunk);
    }

    return splitList;
}

Ответ 5

Если у вас нет Linq, вы можете использовать Array.Copy:

public void Split(ref UList list)
{
    string[] s = list.mylist.ToArray();

    //split the array into top and bottom halfs
    string[] top = new string[s.Length / 2];
    string[] bottom = new string[s.Length - s.Length / 2];
    Array.Copy(s, top, top.Length);
    Array.Copy(s, top.Length, bottom, 0, bottom.Length);

    Console.WriteLine("Top: ");
    foreach (string item in top) Console.WriteLine(item);
    Console.WriteLine("Bottom: ");
    foreach (string item in bottom) Console.WriteLine(item);
}

Ответ 6

Почему вы не выделяете два массива и не копируете содержимое?

EDIT: здесь вы идете:

        String[] origin = new String[4];
        origin[0] = "zero";
        origin[1] = "one";
        origin[2] = "two";
        origin[3] = "three";

        Int32 topSize = origin.Length / 2;
        Int32 bottomSize = origin.Length - topSize;
        String[] sTop = new String[topSize];
        String[] sBottom = new String[bottomSize];
        Array.Copy(origin, sTop, topSize);
        Array.Copy(origin, topSize , sBottom, 0, bottomSize);

Ответ 7

Почему вы передаете UList как ref? Кажется, для этого не требуется.

Я бы использовал общий метод Split, если мне нужно было это сделать:

public void Split<T>(T[] array, out T[] left, out T[] right)
{
    left = new T[array.Length / 2];
    right = new T[array.Length - left.Length];

    Array.Copy(array, left, left.Length);
    Array.Copy(array, left.Length, right, 0, right.Length);
}

Ответ 8

Я думаю, что вы ищете класс Array, в частности статический метод Array.Copy. Вы можете думать о том, что этот класс содержит методы, которые были бы экземпляром методов массивов, если бы массивы С# имели методы.

Ответ 9

вот что мне нужно

PartItemCount = Math.Max( PartItemCount , 1 );
lstlst = new List<List<T>>();

for ( ; lst.Count > 0 ; )
{
    int partCount = Math.Min( lst.Count , PartItemCount );
    List<T> lsttmp = new List<T>( lst.Take( partCount ).ToArray() );
    lstlst.Add( lsttmp );
    lst = lst.Skip( partCount ).ToList();
}
return lstlst.Count;