Сдвиг рваного массива вниз/вверх

107

13 июня 2021, 13:00

Турдность состоит в том, что сдвиг должен быть циклическим по строкам и создавать дополнительные(временные) массивы нельзя. По задаче требуеться, что бы сдвиг происходил вверх и вниз

    int shift = InputShift(array);
        for (int count = 0; count < shift; count++)
        {
            for (int i = 0; i < array.Length; i++)
            {
                int temp = array[array.Length - 1][i];
                int j = 0;
                for (j = array.Length - 1; j > 0; j--)
                {
                    array[j][i] = array[j - 1][i];
                }
                array[j][i] = temp;
            }
        }

Вот, что получаеться, но по факту, не то что требуеться. Должно получатся так:

            //До:       После:
            //1234      54876
            //54876     23
            //23        1234
            //2456      2456

Answer 1

Просто по приколу, вот вариант вообще без использования переменных.

public static void Shift(ref int[] array, in int amount)
{
    if (amount == 0)
        return;
    if (amount > 0)
    {
        ShiftFront(ref array);
        Shift(ref array, amount - 1);
    }
    if (amount < 0)
    {
        ShiftBack(ref array);
        Shift(ref array, amount + 1);
    }
}
static void ShiftBack(ref int[] array)
{
    for (int i = array.Length - 1; i >= 1; i--)
        Swap(ref array[i], ref array[i - 1]);
}
static void ShiftFront(ref int[] array)
{
    for (int i = 0; i + 1 < array.Length; i++)
        Swap(ref array[i], ref array[i + 1]);
}
static void Swap(ref int v1, ref int v2)
{
    v1 += v2;
    v2 = v1 - v2;
    v1 -= v2;
}

Ну и вызывать:

var array = new[] { 0, 1, 2, 3 };
Shift(ref array, -1);

Answer 2

Какое значение здесь имеет "рваность" массива, если Вы (в примере) двигаете строку как одно целое?

for (int i = 0; i < shift % array.GetLength(0); i++) {
  for (int j = 0; j < array.GetLength(0) - 1; j++) {
    var temp = array[j];
    array[j] = array[j + 1];
    array[j + 1] = temp;
  }
}

function shiftArray(array, shift) { 
  for (var i = 0; i < shift % array.length; i++) { 
    for (var j = 0; j < array.length - 1; j++) { 
      var temp = array[j]; 
      array[j] = array[j + 1]; 
      array[j + 1] = temp; 
    } 
  } 
} 
 
var array = [1234, 54876, 23, 2456]; 
shiftArray(array, 2); 
console.log(JSON.stringify(array));

Answer 3

Вот более быстрый способ сдвига массива методом трёх реверсов. И как по задаче умеет двигать в обе стороны.

using System;
namespace JaggedArrayShift
{
    class Program
    {
        static void Main(string[] args)
        {
            int shift = 3;
            int[][] array =
            {
                new[] { 1 }, new[] { 2 }, new[] { 3 },
                new[] { 4 }, new[] { 5 }, new[] { 6 },
                new[] { 7 },
            };
            Display(array);
            Console.WriteLine("------------");
            Rotate(array, shift, true);
            Display(array);
            Console.WriteLine("------------");
        }
        private static void Rotate(int[][] array, int shift, bool forward)
        {
            shift %= array.GetLength(0);
            if (forward)
            {
                shift = array.GetLength(0) - shift;
            }
            Reverse(array, 0, shift - 1);
            Reverse(array, shift, array.GetLength(0) - 1);
            Reverse(array, 0, array.GetLength(0) - 1);
        }
        private static void Reverse(int[][] array, int startIndex, int endIndex)
        {
            while (startIndex < endIndex)
            {
                var temp = array[endIndex];
                array[endIndex] = array[startIndex];
                array[startIndex] = temp;
                ++startIndex;
                --endIndex;
            }
        }
        private static void Display(int[][] array)
        {
            for (int i = 0; i < array.GetLength(0); i++)
            {
                Console.WriteLine(string.Join(",", array[i]));
            }
        }
    }
}