Inverser les éléments d'un tableau

Je configurer un tableau et je voudrais créer une méthode qui retourne un tableau avec les éléments dans l'ordre inverse. par exemple, si il y a 10 slots puis array1[9] = 6 alors array2[0] = 6.
Je suppose que je dois retourner un tableau - comment puis-je faire?
Et je ne sais pas comment inverser et l'ajouter à un autre tableau.
Merci!!!!

        int[] arr = {43, 22, 1, 44, 90, 38, 55, 32, 31, 9};
        Console.WriteLine("Before");
        PrintArray(arr);
        Console.WriteLine("After");
        Reverse(arr);

         Console.ReadKey(true);

    }

    static int[] Reverse(int[] array)
    {
        for (int i = array.Length; i < 1; i--)
        {
            int x = 0;

            array[i] = array[x++];
            Console.WriteLine(array[i]);
        }

       }


         static void PrintArray(int[] array)
    {
        for (int j = 0; j < array.Length; j++)
        {
            Console.Write(array[j] + " ");

        }
        Console.WriteLine("");

Pouvez-vous ne pas simplement utiliser le tableau.Reverse();` ?

OriginalL'auteur baztown | 2013-08-23

arrays c#reverse

Vous pouvez utiliser Tableau.Inverse

Exemple ci-dessus de la ligne de

public static void Main()  {

  //Creates and initializes a new Array.
  Array myArray=Array.CreateInstance( typeof(String), 9 );
  myArray.SetValue( "The", 0 );
  myArray.SetValue( "quick", 1 );
  myArray.SetValue( "brown", 2 );
  myArray.SetValue( "fox", 3 );
  myArray.SetValue( "jumps", 4 );
  myArray.SetValue( "over", 5 );
  myArray.SetValue( "the", 6 );
  myArray.SetValue( "lazy", 7 );
  myArray.SetValue( "dog", 8 );

  //Displays the values of the Array.
  Console.WriteLine( "The Array initially contains the following values:" );
  PrintIndexAndValues( myArray );

  //Reverses the sort of the values of the Array.
  Array.Reverse( myArray );

  //Displays the values of the Array.
  Console.WriteLine( "After reversing:" );
  PrintIndexAndValues( myArray );
}


public static void PrintIndexAndValues( Array myArray )  {
  for ( int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
     Console.WriteLine( "\t[{0}]:\t{1}", i, myArray.GetValue( i ) );
}

OriginalL'auteur Ehsan

7

Vous devriez être en mesure d'utiliser la méthode d'extension Reverse
```
int[] arr = { 43, 22, 1, 44, 90, 38, 55, 32, 31, 9 };
Console.WriteLine("Before");
PrintArray(arr);
Console.WriteLine("After");
PrintArray(arr.Reverse().ToArray());
```
Ou si vous n'avez pas l'esprit modifiant la séquence d'origine, vous pouvez utiliser Array.Reverse
```
int[] arr = { 43, 22, 1, 44, 90, 38, 55, 32, 31, 9 };
Console.WriteLine("Before");
PrintArray(arr);
Array.Reverse(arr);
Console.WriteLine("After");
PrintArray(arr);
```
Vous avez un mess: en fait - arr.Reverse() ne pas modifier l'original, tout en Array.Reverse(arr) - des changements!
C'est EXACTEMENT ce que j'ai dit. "si vous n'avez pas l'esprit de la modification de la séquence d'origine, vous pouvez utiliser le Tableau.Reverse"
Juste un avis pour quelqu'un qui veut utiliser l'Inverse dans le premier exemple: vous avez besoin de "l'aide du Système.Linq".

OriginalL'auteur sa_ddam213
1

Vous pouvez inverser une matrice de permutation des éléments provenant des deux extrémités de la matrice jusqu'à ce que vous atteindre le milieu.
```
for(int start = 0, end = arr.Length - 1; start < arr.Length/2; start++, end--)
{
     swap(arr[start], arr[end]);
}
```
arr.length -> arr.Length
oui merci! Je l'ai écrit en considérant Java et maintenant, j'ai réalisé OP tagged C#.

OriginalL'auteur akaHuman

       int a;
        Console.WriteLine("Enter the array length");
        a=int.Parse(Console.ReadLine());
        Console.WriteLine("enter the array element");
        int[] sau = new int[a];
        for (int i = 0; i < a; i++)
        {
            sau[i] = int.Parse(Console.ReadLine());
        }
        for (int i =a.Length-1 ; i < 0;i--)
        {
            Console.WriteLine(sau[i]);
        }
            Console.ReadLine();
    }
}

}

OriginalL'auteur Saurabh Jaiswal

Créer un nouveau tableau qui a la même longueur que l'ancien tableau et arrière est fait de cette

index -> new index  
  0   -> length - 1  
  1   -> length - 1 - 1  
  2   -> length - 1 - 2  
..  
  i   -> length - 1 - i

donc, ce qui se traduit par le présent code

int[] myVariable = new int[] { 1, 2, 3, 4, 5 };
int[] reversedVariable =  new int[myVariable.Length]();
for (int i = 0; i < myVariable.Length ; i++)
{
    reversedVariable[myVariable.Length - 1 - i] = myVariable[i];
}
return reversedVariable;

OriginalL'auteur bigworld12

 public class MyList<T> : IEnumerable<T>
{
    private T[] arr;

    public int Count
    {
        get { return arr.Length; }
    }            
public void Reverse()
    {
        T[] newArr = arr;
        arr = new T[Count];
        int number = Count - 1;
        for (int i = 0; i < Count; i++)
        {
            arr[i] = newArr[number];
            number--;
        }
    }
}

S'il vous plaît ajouter une explication de ce que votre code est en train de faire.
dans la méthode Reverse (), vous pouvez trouver l'un des moyens pour inverser les éléments dans un tableau. C'est une partie de cod, avec elle, vous pouvez créer une collection de tout type et de renverser les éléments de la collection

OriginalL'auteur Nika

Vous devez vous connecter pour publier un commentaire.