How to swap two different length group of variable in array?

Question

How to swap two different-length groups of variables of the same array in the same array? Even if I need the code in C#, in the meantime the theoretical procedure would be enough for me.

I've already tried several methods, but I was looking for a less redundant and\or less heavy.

for example I have string[] lines with these lines:

line 0
line 1
line 2
line 3
line 4
line 5
line 6
line 7
line 8

If you want to swap lines 1 2 3 with lines 5 6 this should look like this:

line 0
line 5
line 6
line 4
line 1
line 2
line 3
line 7
line 8

n.b. : each time which and how many lines to swap are different.

Here I put my code: Swap two different length group of variable in array.

Answer 1

public static class Extension
{
    public static string[] Shift(this string[] array, int startIndex, int length, int newIndex)
    {
        string[] items = array.Skip(startIndex).Take(length).ToArray();
        ArrayList arrayList = new ArrayList(array);
        arrayList.RemoveRange(startIndex, length);
        arrayList.InsertRange(newIndex, items);

        arrayList.CopyTo(array);
        return array;
    }
}

private static void Main(string[] args)
{
    string[] array =
        {
        "line 0",
        "line 1",
        "line 2",
        "line 3",
        "line 4",
        "line 5",
        "line 6",
        "line 7",
        "line 8"
    };
    array = array.Shift(5, 2, 1);
    array = array.Shift(3, 3, 4);
}

Could do it with an extension class. Not fully tested.

Answer 2

With results

0,1,2,3,4,5,6,7,8,9,10
0,8,9,5,6,7,1,2,3,4,10

I have the following code:

internal class Program
{
    static void Main(string[] args)
    {
        int[] array = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        Console.WriteLine(string.Join(",", array));

        SwapElements(ref array, 1..5, 8..10);

        Console.WriteLine(string.Join(",", array));
    }

    static void SwapElements<T>(ref T[] array, Range a, Range b)
    {
        (int a_Offset, int a_Length) = a.GetOffsetAndLength(array.Length);
        (int b_Offset, int b_Length) = b.GetOffsetAndLength(array.Length);

        if (a_Offset > b_Offset)
        {
            ((b_Offset, b_Length), (a_Offset, a_Length)) = ((a_Offset, a_Length), (b_Offset, b_Length));
        }

        Range pre_a = Range.EndAt(a_Offset);
        a = new Range(a_Offset, a_Offset + a_Length);
        Range between = new Range(a_Offset + a_Length, b_Offset);
        b = new Range(b_Offset, b_Offset + b_Length);
        Range post_b = Range.StartAt(b_Offset + b_Length);

        array = Concat(array[pre_a], array[b], array[between], array[a], array[post_b]);
    }

    /// <summary>
    /// Concatenates two or more arrays into a single one.
    /// </summary>
    /// <remarks>
    /// Code taken from https://stackoverflow.com/a/52749536/380384
    /// </remarks>
    public static T[] Concat<T>(params T[][] arrays)
    {
        // return (from array in arrays from arr in array select arr).ToArray();

        var result = new T[arrays.Sum(a => a.Length)];
        int offset = 0;
        for (int x = 0; x < arrays.Length; x++)
        {
            arrays[x].CopyTo(result, offset);
            offset += arrays[x].Length;
        }
        return result;
    }
}

Notes.

1. I am using Range objects to define the array slices to be swapped. I use a custom Concat function stolen from [SO] to re-assemble the array from the different slices. An ordering of the slices is done before the operation to ensure the elements between the two slices are defined properly.

2. C# Ranges use some obscure notion defining a range from start to end as start..(end+1) for some reason. 70 years ago Fortran did the same with start:end that made sense, and every other vector language since (like Matlab etc), yet when C# introduced slices, they completely foobar'd in order to make it Python-like for no good reason. End of rant.

Answer 3

public static T[] Swap<T>(this T[] array, int startIndexA, int lengthA, int startIndexB, int lengthB) 
{
    List<T[]> arrays = new List<T[]>();

    if(startIndexA > startIndexB)
    {
        int tempIndex = startIndexA;
        int tempLength = lengthA;

        startIndexA = startIndexB;
        lengthA = lengthB;

        startIndexB = tempIndex;
        lengthB = tempLength;
    }

    var sliceA = array[startIndexA..(startIndexA + lengthA)];
    var sliceB = array[startIndexB..(startIndexB + lengthB)];


    if (startIndexA > 0)
        arrays.Add(array[0..startIndexA]);

    arrays.Add(sliceB);

    if (startIndexA + sliceA.Length < startIndexB)
        arrays.Add(array[(startIndexA + sliceA.Length)..startIndexB]);

    arrays.Add(sliceA);

    if ((startIndexB + sliceB.Length) < array.Length)
        arrays.Add(array[(startIndexB + sliceB.Length)..]);

    return arrays.SelectMany(a => a).ToArray();
}

Call it in the following way

string[] array =
            {
            "line 0",
            "line 1",
            "line 2",
            "line 3",
            "line 4",
            "line 5",
            "line 6",
            "line 7",
            "line 8"
        };
    var result = array.Swap(5, 2, 1, 3);