# Program to reverse columns in given 2D Array (Matrix)

• Difficulty Level : Easy
• Last Updated : 27 Dec, 2021

Given a 2D array arr[][]of integers of size M x N, where N is the number of columns and M is the number of rows in the array. The task is to reverse every column of the given 2D array.

Input: arr[][] =

{{3, 2, 1}

{4, 5, 6},

{9, 8, 7}}

Output:

9 8 7

4 5 6

3 2 1

Input: arr[][] =

{{7, 9},

{1, 5},

{4, 6},

{19, 3}}

Output:

19 3

4 6

1 5

7 9

Approach:  For each and every column in the given 2 Dimensional Array or Matrix, do the following steps:

• Initialize the start index as 0 and end index as M – 1.
• Iterate a for loop till the start index is less than the ending index, swap the value at these indexes and update the index as:
```swap(arr[start][i], arr[end][i]);
start++;
end--;```

Below is the implementation of the above algorithm:

## C++

 `// C++ implementation of the``// above approach``#include ``using` `namespace` `std;` `const` `int` `M = 3;``const` `int` `N = 3;` `// A utility function``// for swapping two elements.``void` `swap(``int``* a, ``int``* b)``{``    ``int` `temp = *a;``    ``*a = *b;``    ``*b = temp;``}` `// Print the arr[][]``void` `printMatrix(``int` `arr[M][N])``{` `    ``for` `(``int` `i = 0; i < M; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {``            ``cout << arr[i][j] << ``' '``;``        ``}``        ``cout << endl;``    ``}``}` `// Function to reverse``// the given 2D arr[][]``void` `reverseColumnArray(``int` `arr[M][N])``{` `    ``// Print the arr[][] before``    ``// reversing every column``    ``printMatrix(arr);``    ``cout << endl;` `    ``// Traverse each column of arr[][]``    ``for` `(``int` `i = 0; i < N; i++) {``        ``// Initialise start and end index``        ``int` `start = 0;``        ``int` `end = M - 1;` `        ``// Till start < end, swap the``        ``// element at start and end index``        ``while` `(start < end) {``            ``// Swap the element``            ``swap(&arr[start][i], &arr[end][i]);` `            ``// Increment start and decrement``            ``// end for next pair of swapping``            ``start++;``            ``end--;``        ``}``    ``}` `    ``// Print the arr[][] after``    ``// reversing every column``    ``printMatrix(arr);``}` `// Driver Code``int` `main()``{``    ``int` `arr[][3]``        ``= { { 3, 2, 1 }, { 4, 5, 6 }, { 9, 8, 7 } };` `    ``// Function call``    ``reverseColumnArray(arr);``    ``return` `0;``}`

## Java

 `// Java implementation of the``// above approach``import` `java.util.*;``class` `GFG{` `  ``static` `int` `M = ``3``;``  ``static` `int` `N = ``3``;` `  ``// A utility function``  ``// for swapping two elements.``  ``private` `static` `int``[][] swap(``int``[][] arr, ``int` `start,``                              ``int` `i, ``int` `end, ``int` `j)``  ``{` `    ``int` `temp = arr[start][i];``    ``arr[start][i] = arr[end][j];``    ``arr[end][j] = temp;``    ``return` `arr;``  ``}` `  ``// Print the arr[][]``  ``static` `void` `printMatrix(``int` `arr[][])``  ``{` `    ``for` `(``int` `i = ``0``; i < M; i++) {``      ``for` `(``int` `j = ``0``; j < N; j++) {``        ``System.out.print(arr[i][j] +``" "``);``      ``}``      ``System.out.println();``    ``}``  ``}` `  ``// Function to reverse``  ``// the given 2D arr[][]``  ``static` `void` `reverseColumnArray(``int` `arr[][])``  ``{` `    ``// Print the arr[][] before``    ``// reversing every column``    ``printMatrix(arr);``    ``System.out.println();` `    ``// Traverse each column of arr[][]``    ``for` `(``int` `i = ``0``; i < N; i++) {``      ``// Initialise start and end index``      ``int` `start = ``0``;``      ``int` `end = M - ``1``;` `      ``// Till start < end, swap the``      ``// element at start and end index``      ``while` `(start < end)``      ``{` `        ``// Swap the element``        ``arr = swap(arr,start,i,end,i);` `        ``// Increment start and decrement``        ``// end for next pair of swapping``        ``start++;``        ``end--;``      ``}``    ``}` `    ``// Print the arr[][] after``    ``// reversing every column``    ``printMatrix(arr);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr[][]``      ``= { { ``3``, ``2``, ``1` `}, { ``4``, ``5``, ``6` `}, { ``9``, ``8``, ``7` `} };` `    ``// Function call``    ``reverseColumnArray(arr);``  ``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# python implementation of the``# above approach``M ``=` `3``N ``=` `3` `# Print the arr[][]``def` `printMatrix(arr):` `    ``for` `i ``in` `range``(``0``, M):``        ``for` `j ``in` `range``(``0``, N):``            ``print``(arr[i][j], end``=``' '``)` `        ``print``()` `# Function to reverse``# the given 2D arr[][]``def` `reverseColumnArray(arr):` `    ``# Print the arr[][] before``    ``# reversing every column``    ``printMatrix(arr)``    ``print``()` `    ``# Traverse each column of arr[][]``    ``for` `i ``in` `range``(``0``, N):``        ``# Initialise start and end index``        ``start ``=` `0``        ``end ``=` `M ``-` `1` `        ``# Till start < end, swap the``        ``# element at start and end index``        ``while` `(start < end):``            ``# Swap the element``            ``temp ``=` `arr[start][i]``            ``arr[start][i] ``=` `arr[end][i]``            ``arr[end][i] ``=` `temp` `            ``# Increment start and decrement``            ``# end for next pair of swapping``            ``start ``+``=` `1``            ``end ``-``=` `1` `        ``# Print the arr[][] after``        ``# reversing every column``    ``printMatrix(arr)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[[``3``, ``2``, ``1``], [``4``, ``5``, ``6``], [``9``, ``8``, ``7``]]` `    ``# Function call``    ``reverseColumnArray(arr)` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# implementation of the``// above approach``using` `System;``class` `GFG``{` `    ``static` `int` `M = 3;``    ``static` `int` `N = 3;` `    ``// A utility function``    ``// for swapping two elements.``    ``private` `static` `int``[,] swap(``int``[,] arr, ``int` `start,``                                ``int` `i, ``int` `end, ``int` `j)``    ``{` `        ``int` `temp = arr[start, i];``        ``arr[start, i] = arr[end, j];``        ``arr[end, j] = temp;``        ``return` `arr;``    ``}` `    ``// Print the arr[][]``    ``static` `void` `printMatrix(``int``[,] arr)``    ``{` `        ``for` `(``int` `i = 0; i < M; i++)``        ``{``            ``for` `(``int` `j = 0; j < N; j++)``            ``{``                ``Console.Write(arr[i, j] + ``" "``);``            ``}``            ``Console.WriteLine(``""``);``        ``}``    ``}` `    ``// Function to reverse``    ``// the given 2D arr[][]``    ``static` `void` `reverseColumnArray(``int``[,] arr)``    ``{` `        ``// Print the arr[][] before``        ``// reversing every column``        ``printMatrix(arr);``        ``Console.WriteLine();` `        ``// Traverse each column of arr[][]``        ``for` `(``int` `i = 0; i < N; i++)``        ``{``            ``// Initialise start and end index``            ``int` `start = 0;``            ``int` `end = M - 1;` `            ``// Till start < end, swap the``            ``// element at start and end index``            ``while` `(start < end)``            ``{` `                ``// Swap the element``                ``arr = swap(arr, start, i, end, i);` `                ``// Increment start and decrement``                ``// end for next pair of swapping``                ``start++;``                ``end--;``            ``}``        ``}` `        ``// Print the arr[][] after``        ``// reversing every column``        ``printMatrix(arr);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int``[,] arr = { { 3, 2, 1 }, { 4, 5, 6 }, { 9, 8, 7 } };` `        ``// Function call``        ``reverseColumnArray(arr);``    ``}``}` `// This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

Output
```3 2 1
4 5 6
9 8 7

9 8 7
4 5 6
3 2 1 ```

Time complexity: O(N2), two for loops are being used, one to iterate over all columns and the inner loop is swapping the start and end index of each column.
Auxiliary Complexity: 0(1) as no extra space, not even for swapping the two elements.

My Personal Notes arrow_drop_up