This is totally possible and efficient in O(n) using only swaps. I don't know what lab view is so I'll show some C that manipulates a string, and I'll use the left/right convention instead of up/down. I understand we're trying to delete a contiguous section of array elements and reinsert them at another index while preserving the order of the remainder of the array. The heart of the algorithm is tail recursive and easily converted to a loop. First, know that shifting G elements to the right by D is the same as shifting D elements to the left by G. From this we see it is possible to always work left to right, placing a final value into each index as it is encountered. Nearing the end of the array we find some rotated version of the elements having size G being moved. They are rotated by D%G. So simply recurse to unrotate this array until D%G is zero.
Here's the heart of it.
void moverecurse(char *a, int g, int d)
{
if (d == 0) return;
for (int i=0; i<d; i++)
swap(a[i], a[i+g]);
moverecurse(a+d, g-d%g, d%g);
}
Now to handle negative values of g and d, and to cover the strange case G = 0, add some setup code. The purpose is to transform forward and backward offsets into forward offsets only.
/* Moves group of elements size g distance d in array a */
void move(char *a, int g, int d)
{
/* Group size < 0 means look backward in array */
if (g < 0) {
a += g;
g = -g;
}
/* Distance < 0 means move left */
if (d < 0) {
a += d;
d = -d;
swap(d, g);
}
if (g)
moverecurse(a, g, d);
}
If you dislike recursion you can replace the call to moverecurse with this.
while (d) {
for (int i=0; i<d; i++)
swap(a[i], a[i+g]);
a += d;
d %= g;
g -= d;
}
I hope this is of use to someone as I did make a minor sacrafice to obtain it. On my last flight I made a fool of myself moving bits of shredded napkin around on my tray table figuring it out.
