Данный отчёт сгенерирован 04.04.2023 06:21:13 UTC.
HTML версия (этот сайт) сгенерирован 04.04.2023 06:21:31 UTC.
Коммит: [bfeb65b9] add automatic zip creation 04.04.2023 06:21:13
HTML версия (этот сайт) сгенерирован 04.04.2023 06:21:31 UTC.
Коммит: [bfeb65b9] add automatic zip creation 04.04.2023 06:21:13
Задача: Зворотній Масив
04.04.2023 06:21:13
Описание: Оголосіть статичний метод Invert(), який отримує цілий масив і повертає інший масив, в якому елементи вихідного масиву йдуть у зворотному порядку.
04.04.2023 06:21:13
Решений: 116
04.04.2023 06:21:13
Зворотній Масив
04.04.2023 06:21:13
static int[] Invert(int[] m){
Array.Reverse(m);
return m;
}
static int[] Invert(int[] m) => m.Reverse().ToArray();
static int[] Invert(int[] m)
{
int[] arr = new int[m.Length];
for (int i = m.Length - 1, j = 0; i >= 0 && j < m.Length; i--, j++)
{
arr[j] = m[i];
}
return arr;
}
static int[] Invert(int[] m){
int[] m2=new int[m.Length];
for (int i=m.Length-1, j=0; i>=0; i--, j++){
m2[j]=m[i];
}
return m2;
}
static int[] Invert(int[] m)
{
int[] k = new int[m.Length];
for(int i=m.Length-1,j=0; i>=0 && j< m.Length; i--, j++)
{
k[j] = m[i];
}
return k;
}
static int[] Invert(int[] m){
int[] answ = new int[m.Length];
int counter = 0;
for(int i = m.Length-1; i >-1; i--){
answ[counter] = m[i];
counter++;
}
return answ;
}
static int[] Invert(int[] m){
int n = m.Length;
int[] inverted = new int[n];
for(int i = 0; i < n; i++){
inverted[i] = m[n-i-1];
}
return inverted;
}
static int[] Invert(int[] m)
{
int[] array = new int[m.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = m.Length - i - 1;
}
return array;
}
static int[] Invert(int[] m)
{
for(int i = 0;i< m.Length/2;i++)
{
int q = m[i];
m[i] = m[(m.Length-1)-i];
m[m.Length-1-i] = q;
}
return m;
}
static int[] Invert(int[] m){
int[] arr=new int[m.Length];
for(int i = 0;i< m.Length;i++)
arr[i]=m[m.Length-1-i];
return arr;
}
static int[] Invert(int[] m){
int[] reversedArr = new int[m.Length];
for(int i = 0; i < m.Length; i++) {
reversedArr[m.Length - 1 - i] = m[i];
}
return reversedArr;
}
static int[] Invert(int[] m) => m.ToArray();
static int[] Invert(int[] m)
{
int[] arr = new int[m.Length];
for(int i=0; i<=m.Length-1; i++)
{
arr[i] = m[m.Length-1-i];
}
return arr;
}
static int[] Invert(int[] m){
int[] array = new int[m.Length];
Array.Copy(m, array, m.Length);
Array.Reverse(array);
return array;
}
static int[] Invert(int[] m){
int[] arr = new int[m.Length];
for(int i = m.Length-1; i > 0; i--){
arr[m.Length - i] = m[i];
}
return arr;
}
static int[] Invert(int[] m) {
int[] array = m;
int a = 0;
int b = array.Length - 1;
while (a < b) {
int t = array[a];
array[a] = array[b];
array[b] = t;
a++;
b--;
}
return array;
}
static int[] Invert(int[] m)
=> m.Reverse().ToArray();
static int[] Invert(int[] m){
int[] reversed = Enumerable.Reverse(m).ToArray();
return reversed;
}
public static int[] Invert(int[] arr)
{
int[] invertedArr = new int[arr.Length];
for (int i = 0, j = arr.Length - 1; i < arr.Length; i++, j--)
{
invertedArr[i] = arr[j];
}
return invertedArr;
}
static int[] Invert(int[] arr){
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;
}
return arr;
}
static int[] Invert(int[] m)
{
int[] arr = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
arr[m.Length - 1 - i] = m[i];
}
return arr;
}
static int[] Invert(int[] m)
{
int[] invertedArray = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
invertedArray[i] = m[m.Length - 1 - i];
}
return invertedArray;
}
static int[] Invert(int[] m)
{
var n = m.Length;
var ar = new int[n];
for (var i = 0; i < n; i++)
{
ar[n - 1 - i] = m[i];
}
return ar;
}
static int[] Invert(int[] m)=>m.Reverse().ToArray();
static int[] Invert(int[] m) {
int n = m.Length;
for (int i = 0; i < n / 2; i++) {
int t = m[n - i - 1];
m[n - i - 1] = m[i];
m[i] = t;
}
return m;
}
//Меняйте местами нулевой элемент с последним, первый с предпоследим и т.д.
static int[] Invert(int[] m){
int tmp;
for(int i = 0;i< m.Length/2;i++){
tmp = m[i];
m[i] = m[m.Length-1-i];
m[m.Length -1 -i] = tmp;
}
return m;
}
static int[] Invert(int[] m)
{
int[] arr = new int[m.Length];
for(int i = 0; i < m.Length; i++)
{
for (int j = m.Length - 1; j <= 0; j--)
{
arr[i] = m[j];
}
}
return arr;
}
static int[] Invert(int[] m){
Array.Reverse(m);
return m;
}
static int[] Invert(int[] m){
int[] result = new int[m.Length];
for(int i = m.Length-1; i <= 0; i--){
result[m.Length-1 - i] = m[i];
}
return result;
}
static int[] Invert(int[] m) {
var len = m.Length;
var result = new int[len];
var index = len-1;
for (int i = 0; i < index; i++)
{
result[i] = result[index-i];
}
return result;
}
public static int[] Invert(int[] arr)
{
int[] invertedArr = new int[arr.Length];
for (int i = 0; i < arr.Length; i++)
{
invertedArr[i] = arr[arr.Length - i - 1];
}
Array.Reverse(invertedArr);
return invertedArr;
}
static int[] Invert(int[] m)
{
int[] res = new int[m.Length];
for (int i = 0; i < res.Length; i++)
{
res[i] = m[res.Length-1-i];
}
return res;
}
static int[] Invert(int[] m)
{
int[] govno = new int[m.Length];
Array.Copy(m, govno, m.Length);
Array.Reverse(govno);
return govno;
}
static int[] Invert(int[] m){
int[] arr = new int[m.Length];
for(int i = 0; i < m.Length; i++){
arr[i] = m[(m.Length-1) - i];
}
return arr;
}
static int[] Invert(int[] m)
{
int[] result = new int[m.Length];
int j = 0;
for (int i = m.Length - 1; i >= 0; i--)
{
result[j] = m[i];
j++;
}
return result;
}
static int[] Invert(int[] m)
{
int[] res = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
res[i] = m[^(i + 1)];
}
return res;
}
static int[] Invert(int[] m)
{
int[] result = new int[m.Length];
for (int i = 0; i < m.Length; i++)
result[i] = m[m.Length - 1 - i];
return result;
}
static int[] Invert(int[] m)
{
int[] arr = new int[m.Length];
for (int i = 0; i < m.Length ; i++)
{
arr[i] = m[m.Length-1-i];
}
return arr;
}
static int[] Invert(int[] m)
{
int[] invertedArr = new int[m.Length];
for (int i = m.Length - 1, j = 0; i >= 0; i--, j++)
{
invertedArr[j] = m[i];
}
return invertedArr;
}
static int[] Invert(int[] m)
{
int[] a = new int[m.Length];
for(int i=0;i< m.Length;i++)
{
a[i]=m[m.Length-i-1];
}
return a;
}
static int[] Invert(int[] m){
int[] newArray = new int[m.Length];
for (int i = 0, j = m.Length - 1; i < m.Length; i++, j--)
{
newArray[i] = m[j];
}
return newArray;
}
static int[] Invert(int[] array){
int[] invertedArray = new int[array.Length];
for (int i = 0; i < array.Length; i++)
{
invertedArray[i] = array[array.Length - i - 1];
}
return invertedArray;
}
static int[] Invert(int[] m) => m.Reverse().ToArray();
static int[] Invert(int[] m){
int[] newArr = new int[m.Length];
int index=0;
for( int i=m.Length-1; i>=0; i-=1)
{
newArr[index]=m[i];
index+=1;
}
return newArr;
}
static int[] Invert(int[] m)
{
int[] result = new int[m.Length];
for(int i = 0; i < result.Length; i++)
result[i] = m[m.Length - 1 - i];
return result;
}
static int[] Invert(int[] m){
int[] arr = new int[m.Length];
for(int i = 0; i < m.Length; i++)
arr[i] = m[m.Length - 1 - i];
return arr;
}
static int[] Invert(int[] m)
{
Array.Reverse(m);
return m;
}
static int[] Invert(int[] m)
{
for (int i = 0; i < m.Length / 2; i++)
{
int tmp = m[i];
m[i] = m[m.Length - 1 - i];
m[m.Length - 1 - i] = tmp;
}
return m;
}
static int[] Invert(int[] m) {
for (int i = 0; i < m.Length / 2; i++)
{
int tmp = m[i];
m[i] = m[m.Length - i - 1];
m[m.Length - i - 1] = tmp;
}
return m;
}
static int[] Invert(int[] m)
{
return Enumerable.Reverse(m).ToArray();
}
static int[] Invert(int[] m)
{
return m.Reverse().ToArray();
}
static int[] Invert(int[] m)
{
int[] res = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
res[res.Length - 1 - i] = m[i];
}
return res;
}
static int[] Invert(int[] m) {
int[] invertedArray = new int[m.Length];
for(int i = 0; i < m.Length; i++) {
invertedArray[i] = m[m.Length - 1 - i];
}
return invertedArray;
}
static int[] Invert(int[] m) => m.Reverse().ToArray();
static int[] Invert(int[] m){
int k;
for (int i = 0; i < m.Length - 1; i++){
k = m[i];
m[i]=m[m.Length-1-i];
m[m.Length - 1 - i] = k;
}
return m;
}
static int[] Invert(int[] m) {
Array.Reverse(m);
foreach (int i in m) {
return m;
}
return m;
}
static int[] Invert(int[] m)
{
int[] arrInvent = new int[m.Length];
for (int i = m.Length - 1, j = 0; i >= 0; i--, j++)
{
arrInvent[i] = m[j];
}
return arrInvent;
}
static int[] Invert(int[] m)
{
return Enumerable.Reverse(m).ToArray();
}
static int[] Invert(int[] m)
{
int[] a = new int[m.Length];
for (int i = 0; i < a.Length; i++) a[i] = m[m.Length - 1 - i];
return a;
}
static int[] Invert(int[] m){
int[] arr = new int[m.Length];
for(int i = m.Length - 1, j = 0; i >= 0; i--){
arr[j] = m[i];
j++;
}
return arr;
}
static int[] Invert(int[] m){
for(int i = 0; i< m.Length/2.0; ++i){
m[i] ^= m[m.Length-i-1];
m[m.Length-i-1] ^= m[i];
m[i] ^= m[m.Length-i-1];
}
return m;
}
static int[] Invert(int[] m)
{
int[] x = new int[m.Length];
for (int i = 0; i < m.Length-1; i++)
for (int j = m.Length-1; j >= 0; j--)
{
m[i] = x[j];
}
return x;
}
static int[] Invert(int[] m)
{
int[] a = new int[m.Length];
for(int i = 0; i< m.Length-1;i++) a[i] = m[m.Length-1-i];
return a;
}
static int[] Invert(int[] m)=>m.Reverse().ToArray();
static int[] Invert(int[] m){
int[] newArr = new int[m.Length];
int tmp = m.Length - 1;
for(int i = 0; i < m.Length; i++){
newArr[i] = m[tmp];
tmp --;
}
return newArr;
}
static int[] Invert(int[] m)
{
int[] arr = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
arr[i] = m[i];
}
return arr;
}
static int[] Invert(int[] m)
{
int[] mas = new int[m.Length];
for(int i = m.Length-1; i >= 0; i--)
{
mas[i] = m[i];
}
return mas;
}
static int[] Invert(int[] arr) {
int[] arr2 = new int[arr.Length];
for (int i = arr.Length - 1, j = 0; i >= 0; i--, j++) arr2[j] = arr[i];
return arr2;
}
static int[] Invert(int[] m)
{
int[] temp= new int[m.Length];
for (int i = 0; i < m.Length-1; i++)
{
temp[i]= m[m.Length-1-i];
}
return temp;
}
static int[] Invert(int[] m)
{
int [] answ= new int[m.Length];
for (int i = m.Length-1, j = 0; i > 0; --i, j++) {
answ[j] = m[i];
}
return answ;
}
static int[] Invert(int[] m){
int a;
for ( int i =0, j = m.Length -1; i<= j; i ++, j--){
a = m[i];
m[i] = m[j];
m[j] = a;
}
return m;
}
static int[] Invert(int[] m)
{
int[] mass = new int[m.Length];
for(int i = 0;i < m.Length;i++)
{
mass[i] = m[m.Length - 1 - i];
}
return mass;
}
static int[] Invert(int[] m) {
for(int i = 0; i < (m.Length/2) >> 0; i++) {
int t = m[m.Length-1-i];
m[m.Length-1-i] = m[i];
m[i] = t;
}
return m;
}
static int[] Invert(int[] m)
{
int[] array = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
array[i] = m[m.Length-1-i];
}
return array;
}
static int[] Invert(int[] m){
int[] arr = new int[m.Length];
for(int i = 0; i < m.Length; i++)
{
arr[i] = m[m.Length-1-i];
}
return arr;
}
static int[] Invert(int[] m){
int n = m.Length;
int[] inverted = new int[n];
for(int i = 0; i < n / 2 + 1; i++){
inverted[i] = m[n-i-1];
inverted[n-i-1] = m[i];
}
return inverted;
}
static int[] Invert(int[] m){
Array.Reverse(m);
return m;
}
static int[] Invert(int[] m){
int[] res = new int [m.Length];
for(int i=0; i< m.Length; i++) res[i]=m[m.Length-i-1];
return res;
}
static int[] Invert(int[] m)
{
int[] array = new int[5];
for (int i = Array.LastIndexOf(m, m[^1]); i >= 0; i--)
{
array[4 - i] = m[i];
}
return array;
}
// int[] numbers = {1, 2, 3, 4, 5};
// foreach(int i in Invert(numbers))
// {
// Console.WriteLine(i);
// }
static int[] Invert(int[] m){
int[] arr = new int[m.Length];
for(int i = m.Length - 1, n = 0; i >= 0; i--, n++){
arr[n] = m[i];
}
return arr;
}
static int[] Invert(int[] m){
int[] inv= new int[m.Length];
for(int i = 0; i < m.Length; i++){
inv[i] = m[m.Length-1-i];
}
return inv;
}
static int[] Invert(int[] m) => m.Reverse().ToArray();
static int[] Invert(int[] m)
{
return m.Reverse().ToArray();
}
static int[] Invert(int[] m){
int[] result = new int[m.Length];
for(int i = m.Length - 1;i != 0;i--){
result[i] = m[i];
}
return result;
}
static int[] Invert(int[] m)
{
int[] invertedArr = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
invertedArr[i] = m[m.Length - 1 - i];
}
return invertedArr;
}
static int[] Invert(int[] m){
int t;
for(int i=0;i< m.Length/2;i++){
t=m[i];
m[i]=m[m.Length-1-i];
m[m.Length-1-i]=t;
}
return m;
}
static int[] Invert(int[] m) {
int[] array = new int[m.Length];
for (int i = 0; i < array.Length/2; i++) {
int temporary = array[i];
array[i] = array[array.Length - 1 - i];
array[array.Length - 1 - i] = temporary;
}
return array;
}
static int[] Invert(int[] m){
int[] k = new int[m.Length];
for(int i = m.Length-1; i>=0; i--){
k[m.Length-i-1]=m[i];
}
return k;
}
static int[] Invert(int[] m) {
Array.Reverse(m);
return m;
}
static int[] Invert(int[] m)
{
int[] array = new int[m.Length];
int n = 0;
for (int i = m.Length - 1; i > 0; i--)
{
array[n] = m[i];
n++;
}
return array;
}
static int[] Invert(int[] arr){
int len = arr.Length;
for (int i = 0; i < len / 2; i++)
{
int temp = arr[i];
arr[i] = arr[len - i - 1];
arr[len - i - 1] = temp;
}
return arr;
}
static int[] Invert(int[] m) => m.Reverse().ToArray();
static int[] Invert(int[] m){
Array.Reverse(m);
return m;
}
static int[] Invert(int[] m)
{
int[] nums = new int[m.Length];
for (int i = 0, j = m.Length - 1; i < m.Length; i++, j--)
nums[i] = m[j];
return nums;
}
static int[] Invert(int[] m){
int halflenght = m.Length / 2;
for(int i = 0; i < halflenght; i++){
int a = m[i];
int b = m[m.Length - i - 1];
int t = a;
a = b;
b = t;
}
return m;
}
static int[] Invert(int[] m){
return m.Reverse().ToArray();
}
static int[] Invert(int[] m)
{
int[] invertM = new int[m.Length];
Console.WriteLine(m.Length);
Console.WriteLine(invertM.Length);
int i = 1;
foreach (var item in m)
{
invertM[i - 1] = m[m.Length - i];
i++;
}
return invertM;
}
static int[] Invert(int[] m) {
int[] revArr = new int[m.Length];
for (int i = 0; i < m.Length; i++) {
revArr[i] = m[m.Length-i-1];
}
return revArr;
}
static int[] Invert(int[] m)
{
Array.Reverse(m);
return m;
}
static int[] Invert(int[] m) {
Array.Reverse(m);
return m;
}
static int[] Invert(int[] m){
int[] n= new int[m.Length];
for(int i=0; i< m.Length; i++){
n[i]=m[m.Length-1-i];
}
return n;
}
static int[] Invert(int[] m){
Array.Reverse(m);
return m;
}
static int[] Invert(int[] m){
int[] a = new int[m.Length];
for (int i = 0; i < a.Length; i++) a[i] = m[m.Length - 1 - i];
return a;
}
static int[] Invert(int[] m)
{
m = new int[m.Length];
for (int i = m.Length - 1; i >= 0; i--)
{
m[i] = i;
}
return m;
}
static int[] Invert(int[] m){
int[] arr = new int[m.Length];
for (int index = 0; index < m.Length; index++)
{
arr[index] += m[m.Length - 1 - index];
}
return arr;
}
static int[] Invert(int[] m){
int[] arr = new int[m.Length];
for (int i = m.Length-1, j=0; i >= 0; i--, j++)
{
arr[j] = m[i];
}
return arr;
}
static int[] Invert(int[] arr)
{
int[] arr2 = new int[arr.Length];
int d = 0;
for(int x = arr.Length - 1; x>=0; x--)
{
arr2[d] = arr[x];
d++;
}
return arr2;
}
static int[] Invert(int[] m) => m.Reverse().ToArray();
static int[] Invert(int[] m)
{
int[] arr = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
arr[i] = m[m.Length-1-i];
}
return arr;
}
static int[] Invert(int[] m)
{
int[] n = new int[m.Length];
for(int i = 0, j = m.Length - 1; i < m.Length; i++, j--)
{
n[i] = m[j];
}
return n;
}
static int[] Invert(int[] m){
Array.Reverse(m);
return m;
}
static int[] Invert(int[] m)
{
int s = m.Length;
int[] arr = new int[s];
for (int i = 0, j = s - 1; i < s; i++, j--)
{
arr[i] = m[j];
}
return arr;
}
static int[] Invert(int[] m){
int t = 1;
for (int i = 0; i < m.Length/2; i++){
int n = m[i];
m[i]= m[^t];
m[^t] = n;
t++;
}
return m;
}
static int[] Invert(int[] m){
int[] arr = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
arr[i] = m[m.Length - i - 1];
}
return arr;
}
static int[] Invert(int[] m)
{
Array.Reverse(m);
return m;
}
static int[] Invert(int[] m){
int[] reversed = m;
reversed.Reverse();
return reversed;
}
Array.Reverse(m);
return m;
}
{
int[] arr = new int[m.Length];
for (int i = m.Length - 1, j = 0; i >= 0 && j < m.Length; i--, j++)
{
arr[j] = m[i];
}
return arr;
}
int[] m2=new int[m.Length];
for (int i=m.Length-1, j=0; i>=0; i--, j++){
m2[j]=m[i];
}
return m2;
}
{
int[] k = new int[m.Length];
for(int i=m.Length-1,j=0; i>=0 && j< m.Length; i--, j++)
{
k[j] = m[i];
}
return k;
}
int[] answ = new int[m.Length];
int counter = 0;
for(int i = m.Length-1; i >-1; i--){
answ[counter] = m[i];
counter++;
}
return answ;
}
int n = m.Length;
int[] inverted = new int[n];
for(int i = 0; i < n; i++){
inverted[i] = m[n-i-1];
}
return inverted;
}
{
int[] array = new int[m.Length];
for (int i = 0; i < array.Length; i++)
{
array[i] = m.Length - i - 1;
}
return array;
}
{
for(int i = 0;i< m.Length/2;i++)
{
int q = m[i];
m[i] = m[(m.Length-1)-i];
m[m.Length-1-i] = q;
}
return m;
}
int[] arr=new int[m.Length];
for(int i = 0;i< m.Length;i++)
arr[i]=m[m.Length-1-i];
return arr;
}
int[] reversedArr = new int[m.Length];
for(int i = 0; i < m.Length; i++) {
reversedArr[m.Length - 1 - i] = m[i];
}
return reversedArr;
}
{
int[] arr = new int[m.Length];
for(int i=0; i<=m.Length-1; i++)
{
arr[i] = m[m.Length-1-i];
}
return arr;
}
int[] array = new int[m.Length];
Array.Copy(m, array, m.Length);
Array.Reverse(array);
return array;
}
int[] arr = new int[m.Length];
for(int i = m.Length-1; i > 0; i--){
arr[m.Length - i] = m[i];
}
return arr;
}
int[] array = m;
int a = 0;
int b = array.Length - 1;
while (a < b) {
int t = array[a];
array[a] = array[b];
array[b] = t;
a++;
b--;
}
return array;
}
=> m.Reverse().ToArray();
int[] reversed = Enumerable.Reverse(m).ToArray();
return reversed;
}
{
int[] invertedArr = new int[arr.Length];
for (int i = 0, j = arr.Length - 1; i < arr.Length; i++, j--)
{
invertedArr[i] = arr[j];
}
return invertedArr;
}
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;
}
return arr;
}
{
int[] arr = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
arr[m.Length - 1 - i] = m[i];
}
return arr;
}
{
int[] invertedArray = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
invertedArray[i] = m[m.Length - 1 - i];
}
return invertedArray;
}
{
var n = m.Length;
var ar = new int[n];
for (var i = 0; i < n; i++)
{
ar[n - 1 - i] = m[i];
}
return ar;
}
int n = m.Length;
for (int i = 0; i < n / 2; i++) {
int t = m[n - i - 1];
m[n - i - 1] = m[i];
m[i] = t;
}
return m;
}
static int[] Invert(int[] m){
int tmp;
for(int i = 0;i< m.Length/2;i++){
tmp = m[i];
m[i] = m[m.Length-1-i];
m[m.Length -1 -i] = tmp;
}
return m;
}
{
int[] arr = new int[m.Length];
for(int i = 0; i < m.Length; i++)
{
for (int j = m.Length - 1; j <= 0; j--)
{
arr[i] = m[j];
}
}
return arr;
}
Array.Reverse(m);
return m;
}
int[] result = new int[m.Length];
for(int i = m.Length-1; i <= 0; i--){
result[m.Length-1 - i] = m[i];
}
return result;
}
var len = m.Length;
var result = new int[len];
var index = len-1;
for (int i = 0; i < index; i++)
{
result[i] = result[index-i];
}
return result;
}
{
int[] invertedArr = new int[arr.Length];
for (int i = 0; i < arr.Length; i++)
{
invertedArr[i] = arr[arr.Length - i - 1];
}
Array.Reverse(invertedArr);
return invertedArr;
}
{
int[] res = new int[m.Length];
for (int i = 0; i < res.Length; i++)
{
res[i] = m[res.Length-1-i];
}
return res;
}
{
int[] govno = new int[m.Length];
Array.Copy(m, govno, m.Length);
Array.Reverse(govno);
return govno;
}
int[] arr = new int[m.Length];
for(int i = 0; i < m.Length; i++){
arr[i] = m[(m.Length-1) - i];
}
return arr;
}
{
int[] result = new int[m.Length];
int j = 0;
for (int i = m.Length - 1; i >= 0; i--)
{
result[j] = m[i];
j++;
}
return result;
}
{
int[] res = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
res[i] = m[^(i + 1)];
}
return res;
}
{
int[] result = new int[m.Length];
for (int i = 0; i < m.Length; i++)
result[i] = m[m.Length - 1 - i];
return result;
}
{
int[] arr = new int[m.Length];
for (int i = 0; i < m.Length ; i++)
{
arr[i] = m[m.Length-1-i];
}
return arr;
}
{
int[] invertedArr = new int[m.Length];
for (int i = m.Length - 1, j = 0; i >= 0; i--, j++)
{
invertedArr[j] = m[i];
}
return invertedArr;
}
{
int[] a = new int[m.Length];
for(int i=0;i< m.Length;i++)
{
a[i]=m[m.Length-i-1];
}
return a;
}
int[] newArray = new int[m.Length];
for (int i = 0, j = m.Length - 1; i < m.Length; i++, j--)
{
newArray[i] = m[j];
}
return newArray;
}
int[] invertedArray = new int[array.Length];
for (int i = 0; i < array.Length; i++)
{
invertedArray[i] = array[array.Length - i - 1];
}
return invertedArray;
}
int[] newArr = new int[m.Length];
int index=0;
for( int i=m.Length-1; i>=0; i-=1)
{
newArr[index]=m[i];
index+=1;
}
return newArr;
}
{
int[] result = new int[m.Length];
for(int i = 0; i < result.Length; i++)
result[i] = m[m.Length - 1 - i];
return result;
}
int[] arr = new int[m.Length];
for(int i = 0; i < m.Length; i++)
arr[i] = m[m.Length - 1 - i];
return arr;
}
{
Array.Reverse(m);
return m;
}
{
for (int i = 0; i < m.Length / 2; i++)
{
int tmp = m[i];
m[i] = m[m.Length - 1 - i];
m[m.Length - 1 - i] = tmp;
}
return m;
}
for (int i = 0; i < m.Length / 2; i++)
{
int tmp = m[i];
m[i] = m[m.Length - i - 1];
m[m.Length - i - 1] = tmp;
}
return m;
}
{
return Enumerable.Reverse(m).ToArray();
}
{
return m.Reverse().ToArray();
}
{
int[] res = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
res[res.Length - 1 - i] = m[i];
}
return res;
}
int[] invertedArray = new int[m.Length];
for(int i = 0; i < m.Length; i++) {
invertedArray[i] = m[m.Length - 1 - i];
}
return invertedArray;
}
int k;
for (int i = 0; i < m.Length - 1; i++){
k = m[i];
m[i]=m[m.Length-1-i];
m[m.Length - 1 - i] = k;
}
return m;
}
Array.Reverse(m);
foreach (int i in m) {
return m;
}
return m;
}
{
int[] arrInvent = new int[m.Length];
for (int i = m.Length - 1, j = 0; i >= 0; i--, j++)
{
arrInvent[i] = m[j];
}
return arrInvent;
}
{
return Enumerable.Reverse(m).ToArray();
}
{
int[] a = new int[m.Length];
for (int i = 0; i < a.Length; i++) a[i] = m[m.Length - 1 - i];
return a;
}
int[] arr = new int[m.Length];
for(int i = m.Length - 1, j = 0; i >= 0; i--){
arr[j] = m[i];
j++;
}
return arr;
}
for(int i = 0; i< m.Length/2.0; ++i){
m[i] ^= m[m.Length-i-1];
m[m.Length-i-1] ^= m[i];
m[i] ^= m[m.Length-i-1];
}
return m;
}
{
int[] x = new int[m.Length];
for (int i = 0; i < m.Length-1; i++)
for (int j = m.Length-1; j >= 0; j--)
{
m[i] = x[j];
}
return x;
}
{
int[] a = new int[m.Length];
for(int i = 0; i< m.Length-1;i++) a[i] = m[m.Length-1-i];
return a;
}
int[] newArr = new int[m.Length];
int tmp = m.Length - 1;
for(int i = 0; i < m.Length; i++){
newArr[i] = m[tmp];
tmp --;
}
return newArr;
}
{
int[] arr = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
arr[i] = m[i];
}
return arr;
}
{
int[] mas = new int[m.Length];
for(int i = m.Length-1; i >= 0; i--)
{
mas[i] = m[i];
}
return mas;
}
int[] arr2 = new int[arr.Length];
for (int i = arr.Length - 1, j = 0; i >= 0; i--, j++) arr2[j] = arr[i];
return arr2;
}
{
int[] temp= new int[m.Length];
for (int i = 0; i < m.Length-1; i++)
{
temp[i]= m[m.Length-1-i];
}
return temp;
}
{
int [] answ= new int[m.Length];
for (int i = m.Length-1, j = 0; i > 0; --i, j++) {
answ[j] = m[i];
}
return answ;
}
int a;
for ( int i =0, j = m.Length -1; i<= j; i ++, j--){
a = m[i];
m[i] = m[j];
m[j] = a;
}
return m;
}
{
int[] mass = new int[m.Length];
for(int i = 0;i < m.Length;i++)
{
mass[i] = m[m.Length - 1 - i];
}
return mass;
}
for(int i = 0; i < (m.Length/2) >> 0; i++) {
int t = m[m.Length-1-i];
m[m.Length-1-i] = m[i];
m[i] = t;
}
return m;
}
{
int[] array = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
array[i] = m[m.Length-1-i];
}
return array;
}
int[] arr = new int[m.Length];
for(int i = 0; i < m.Length; i++)
{
arr[i] = m[m.Length-1-i];
}
return arr;
}
int n = m.Length;
int[] inverted = new int[n];
for(int i = 0; i < n / 2 + 1; i++){
inverted[i] = m[n-i-1];
inverted[n-i-1] = m[i];
}
return inverted;
}
Array.Reverse(m);
return m;
}
int[] res = new int [m.Length];
for(int i=0; i< m.Length; i++) res[i]=m[m.Length-i-1];
return res;
}
{
int[] array = new int[5];
for (int i = Array.LastIndexOf(m, m[^1]); i >= 0; i--)
{
array[4 - i] = m[i];
}
return array;
}
// int[] numbers = {1, 2, 3, 4, 5};
// foreach(int i in Invert(numbers))
// {
// Console.WriteLine(i);
// }
int[] arr = new int[m.Length];
for(int i = m.Length - 1, n = 0; i >= 0; i--, n++){
arr[n] = m[i];
}
return arr;
}
int[] inv= new int[m.Length];
for(int i = 0; i < m.Length; i++){
inv[i] = m[m.Length-1-i];
}
return inv;
}
{
return m.Reverse().ToArray();
}
int[] result = new int[m.Length];
for(int i = m.Length - 1;i != 0;i--){
result[i] = m[i];
}
return result;
}
{
int[] invertedArr = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
invertedArr[i] = m[m.Length - 1 - i];
}
return invertedArr;
}
int t;
for(int i=0;i< m.Length/2;i++){
t=m[i];
m[i]=m[m.Length-1-i];
m[m.Length-1-i]=t;
}
return m;
}
int[] array = new int[m.Length];
for (int i = 0; i < array.Length/2; i++) {
int temporary = array[i];
array[i] = array[array.Length - 1 - i];
array[array.Length - 1 - i] = temporary;
}
return array;
}
int[] k = new int[m.Length];
for(int i = m.Length-1; i>=0; i--){
k[m.Length-i-1]=m[i];
}
return k;
}
Array.Reverse(m);
return m;
}
{
int[] array = new int[m.Length];
int n = 0;
for (int i = m.Length - 1; i > 0; i--)
{
array[n] = m[i];
n++;
}
return array;
}
int len = arr.Length;
for (int i = 0; i < len / 2; i++)
{
int temp = arr[i];
arr[i] = arr[len - i - 1];
arr[len - i - 1] = temp;
}
return arr;
}
Array.Reverse(m);
return m;
}
{
int[] nums = new int[m.Length];
for (int i = 0, j = m.Length - 1; i < m.Length; i++, j--)
nums[i] = m[j];
return nums;
}
int halflenght = m.Length / 2;
for(int i = 0; i < halflenght; i++){
int a = m[i];
int b = m[m.Length - i - 1];
int t = a;
a = b;
b = t;
}
return m;
}
return m.Reverse().ToArray();
}
{
int[] invertM = new int[m.Length];
Console.WriteLine(m.Length);
Console.WriteLine(invertM.Length);
int i = 1;
foreach (var item in m)
{
invertM[i - 1] = m[m.Length - i];
i++;
}
return invertM;
}
int[] revArr = new int[m.Length];
for (int i = 0; i < m.Length; i++) {
revArr[i] = m[m.Length-i-1];
}
return revArr;
}
{
Array.Reverse(m);
return m;
}
Array.Reverse(m);
return m;
}
int[] n= new int[m.Length];
for(int i=0; i< m.Length; i++){
n[i]=m[m.Length-1-i];
}
return n;
}
Array.Reverse(m);
return m;
}
int[] a = new int[m.Length];
for (int i = 0; i < a.Length; i++) a[i] = m[m.Length - 1 - i];
return a;
}
{
m = new int[m.Length];
for (int i = m.Length - 1; i >= 0; i--)
{
m[i] = i;
}
return m;
}
int[] arr = new int[m.Length];
for (int index = 0; index < m.Length; index++)
{
arr[index] += m[m.Length - 1 - index];
}
return arr;
}
int[] arr = new int[m.Length];
for (int i = m.Length-1, j=0; i >= 0; i--, j++)
{
arr[j] = m[i];
}
return arr;
}
{
int[] arr2 = new int[arr.Length];
int d = 0;
for(int x = arr.Length - 1; x>=0; x--)
{
arr2[d] = arr[x];
d++;
}
return arr2;
}
{
int[] arr = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
arr[i] = m[m.Length-1-i];
}
return arr;
}
{
int[] n = new int[m.Length];
for(int i = 0, j = m.Length - 1; i < m.Length; i++, j--)
{
n[i] = m[j];
}
return n;
}
Array.Reverse(m);
return m;
}
{
int s = m.Length;
int[] arr = new int[s];
for (int i = 0, j = s - 1; i < s; i++, j--)
{
arr[i] = m[j];
}
return arr;
}
int t = 1;
for (int i = 0; i < m.Length/2; i++){
int n = m[i];
m[i]= m[^t];
m[^t] = n;
t++;
}
return m;
}
int[] arr = new int[m.Length];
for (int i = 0; i < m.Length; i++)
{
arr[i] = m[m.Length - i - 1];
}
return arr;
}
{
Array.Reverse(m);
return m;
}
int[] reversed = m;
reversed.Reverse();
return reversed;
}