Обратный массив без использования Array.Reverse()

Ответ 1

Вместо слова // some code here в вопросе стоит заменить следующий код:

for (int i = 0; i < arr.Length / 2; i++)
{
   int tmp = arr[i];
   arr[i] = arr[arr.Length - i - 1];
   arr[arr.Length - i - 1] = tmp;
}

Вы должны выполнять итерацию только через первую половину массива (arr.Length / 2). Если вы выполните итерацию по всему массиву (arr.Length), он будет дважды изменен, что даст тот же порядок элементов, что и до его начала.

Ответ 2

В принципе, вас попросят переопределить Array.Reverse(Array). Если вы посмотрите, как реализован в самой структуре и игнорирует многие технические детали, вы обнаружите, что он просто вызывает трехпараметрическую версию (который меняет указанную часть массива) на весь массив.

Array.Reverse(Array,Int32,Int32) - это цикл while, который свопирует элементы и поддерживает два индекса:

• i указывает на первый элемент обращенной части и
• j указывает на последний элемент обращенной части.

Переписано вместо // some code here вместо вопроса <<24 > :

int i = 0;
int j = arr.Length - 1;
while (i < j)
{
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
    i++;
    j--;
}

Это легче понять, чем реализация с использованием for-loop, делает меньше арифметических и элегантно уклоняется от gotcha с двойной реверсией.

Ответ 3

int[] arr1 = {1,3,4,9,8};
int[] arr2 = new int[5];

int j = 0;

for(int i = arr1.Length - 1; i >= 0; i--)
{
  arr2[j] = arr1[i];
  j++;
}

Ответ 4

Ну, очевидно, вы можете просто скопировать в новый массив в обратном порядке.

Чтобы выполнить операцию "на месте", вы можете работать с обоих концов по направлению к середине: загрузите первый и последний элементы, затем сохраните их, первый в последнее место и последний в первое место. Затем выполните второй и следующий-последний и т.д. Если у вас есть четное число элементов, вы выполняете N/2 итерации. Если вы выполняете нечетное число (N-1)/2 итерации и оставляете средний элемент там, где он был.

Возможно, существуют и другие алгоритмы, которые будут немного быстрее при рассмотрении размера строки кеша и других характеристик памяти, но они не стоили бы этого, если бы вы не были в действительно критичной для производительности ситуации.

Ответ 5

Вы можете сделать это разными способами: от самого быстрого до самого глупого:

int[] arr = new int[] { 1,2,3 };
arr = (from a in arr orderby a descending select a).ToArray();

Но я не могу понять, почему вы преследуете такой бесполезный квест, если это что-то произвело на кого-то кого-то, а затем использовать вместо циклов for:)

Ответ 6

for (int i = 0; i < array.Length - i; i++)
 {
   var value = array[array.Length - i - 1];
   array[array.Length - i - 1] = array[i];
   array[i] = value;
 }

Ответ 7

char[] strx = { '1','2','3','4','5','6','7','8','9' };
int i = strx.Length;
string ktr ="";

while (i>0)
{
   i--;
   ktr += strx[i];

   if (i==0)
   {
      i = strx.Length;

      while (i > 0)
      {
         i--;
         strx[i] = ktr[i];
      }

   }
}
int j;
Console.WriteLine("Array strx in reverse order: ");
for (j = 0; j < strx.Length; j++ ) 
{
  Console.Write("{0}", strx[j]);
}

Ответ 8

То есть цикл So Simple Start из Array legth и так далее, смотрите код, и вы поймете :)))

        int[] arr = new int[5] { 1, 2, 3, 4, 5 };

        for (int i = arr.Length-1; i >= 0; i--)
        {
            Console.WriteLine(arr[i]);
        }

Ответ 9

попробуйте что-то вроде:

var counter = 1;
var newArr = new int[arr.length];
for(int i = 0; i < arr.length; i++)
{
  newArr[i] = arr[arr.length - counter];
  counter++;
}

Я не тестировал это, но он должен быть на правильном пути. Любая причина, по которой вы не хотите использовать Array.Reverse? Вероятно, это хорошо оптимизированная версия алгоритма.

Ответ 10

Лучше использовать метод Array.Reverse

int[] arr ={1,3,4,9,8};
Array.Reverse(arr);

Вы можете прочитать больше описания Здесь

Ответ 11

//без использования метода обратного и без использования дополнительного массива // Попробуйте выполнить оператор, начиная с последнего элемента

public IEnumerable<int> Reverse (int[] array)
{
    for (int i = array.Length - 1; i >= 0; i--) {
        yield return array [i];
    }
}

Ответ 12

Я не очень хорош в петлях. Но это то, что мне кажется простым -

 int[] array1 = { 1, 2, 3, 4, 5 };

 int[] reverseArray = new int[array1.Length];

 for (int i = 0; i <= array1.Length - 1; i++)
  {
    reverseArray[i] = array1[array1.Length - i - 1];
  }

Ответ 13

Это динамическое решение для обращения к массиву любого типа данных. Некоторые из ключевых моментов в моем алгоритме - это сначала вычислить половину длины массива и добавить проверку, чтобы остановить итерацию, когда индексы массива имеют одинаковое значение. Этап, имеющий те же индексы, показывает, что он Снова запустите обратную операцию. На этом этапе прервите внешний цикл, используя " Оператор goto ".

string[] unreversed = {"A","B","C","D","E","F","G","H","I","J","K"};
            int q=unreversed.Length;
            int t = q / 2;
            var temp1 = "A";
            for(int i = 0;i<unreversed.Length;i++)
            {
                q = q - 1;
                for(int k=q;k<=q;k++)
                {
                    if (unreversed[k] != unreversed[i] && i!=t)
                    {
                        temp1 = unreversed[i];
                        unreversed[i] = unreversed[k];
                        unreversed[k] = temp1;

                    }
                    else
                    {
                        goto printarray;

                    }

                }

            }
            printarray:
            foreach (var k in unreversed)
            {
                Console.WriteLine(k);

            }

Ответ 14

Stack stack=new Stack;
var newArr = new int[arr.length];

for(int i = 0; i < arr.length; i++)
{
  stack.push(arrr[i])
}
for(int i = 0; i < arr.length; i++)
{
  newarr[i]= stack.pop()
}

Ответ 15

int[] array1 = { 1, 2, 3, 4, 5 };

for (int x = 4; x < array1.Length && x != -1; x--)
{
    int tmp;
    tmp=array1[x];
    Console.Write("{0} ", tmp);
}

Это мое решение для этого.

Ответ 16

int[] triangles = new int[]{0,1,2,3}    
for (int j = triangles.Length; j > (triangles.Length / 2); j--)
                    {
                        var temp = triangles[j - 1];
                        triangles[j - 1] = triangles[triangles.Length - j];
                        triangles[triangles.Length - j] = temp;
                    }

Я бы предпочел изменить массив с конца. Мое решение выше.

Ответ 17

Можно сделать это с помощью одиночного для цикла.

   int[] arr ={1,3,4,9,8};

   for(int i=arr.length-1;i>=0;i--)
   {
      Console.Write(arr[i]+",");
   }   

Ответ 18

   function printReverse(arr) {
      for(var i = arr.length - 1; i >= 0; i--){

    console.log(arr[i]);
      }
   }
printReverse([1, 2, 3, 6, 47, 88]);

function printReverse(arr) {
    for (var i = arr.length - 1; i >= 0; i--) {

        console.log(arr[i]);
    }
}
printReverse([1, 2, 3, 6, 47, 88])

Ответ 19

Console.WriteLine("Enter a string");
string input = Console.ReadLine();

string s = "";
for (int i = input.Length-1 ; i >= 0; i--)
{
    s = s + input[i];
}
Console.WriteLine(s);

Ответ 20

Вы можете просто перевернуть назад:

int[] arr= new int[] {1, 2, 3, 4, 6};
for(int i=arr.Length-1 ;i>= 0 ; i--)
{
    Console.WriteLine(arr[i].ToString());
}