# Replace corner element in matrix

Here given code implementation process.

``````/*
C Program
+ Replace corner element in matrix
*/
#include <stdio.h>
#define ROW 7
#define COL 7

//Left top to bottom
void left_to_bottom(int matrix[ROW][COL],int mid)
{
int temp=0;
for (int i = mid+1; i < COL ; ++i)
{
for (int j = 0,k=i; j < mid && i+j < COL && k < ROW; ++j,k++)
{
temp = matrix[j][i+j];
matrix[j][i+j]= matrix[k][j] ;
matrix[k][j] = temp;
}

}
}

void right_to_top(int matrix[ROW][COL],int mid)
{
int temp=0;
for (int i = mid-1,l=mid+1; i >= 0 ; --i,l++)
{
for (int j = 0,k=COL-1; j < mid && i-j >=0 && k >mid && l+j <ROW; ++j,k--)
{
temp = matrix[j][i-j] ;
matrix[j][i-j] = matrix[l+j][k] ;
matrix[l+j][k] = temp;
}

}
}
//Display matrix elements
void show_data(int arr[][COL])
{
for (int i = 0; i < ROW; ++i)
{
for (int j = 0; j < COL; ++j)
{
printf("%4d",arr[i][j] );
}
printf("\n");
}
printf("\n");
}
void replace_corner(int matrix[ROW][COL])
{
if(ROW != COL || COL % 2 == 0)
{
printf("\nNot a valid perfect Odd square matrix");
return;
}
int mid=(COL)/2;

left_to_bottom(matrix,mid);
right_to_top(matrix,mid);
}
int main(){

int matrix[ROW][COL] = {
{1,  2,   3,  4,  5   ,6, 7},
{8,  9,  10,  11, 12, 13, 14},
{15, 16, 17, 18,  19, 20, 21},
{22, 23, 24, 25,  26, 27, 28},
{29, 30, 31, 32,  33, 34, 35},
{36, 37, 38, 39,  40, 41, 42},
{43, 44, 45, 46,  47, 48, 49}
};
show_data(matrix);
replace_corner(matrix);
show_data(matrix);
return 0;
}```
```

#### Output

``````   1   2   3   4   5   6   7
8   9  10  11  12  13  14
15  16  17  18  19  20  21
22  23  24  25  26  27  28
29  30  31  32  33  34  35
36  37  38  39  40  41  42
43  44  45  46  47  48  49

49  42  35   4  29  36  43
48  41  10  11  12  37  44
47  16  17  18  19  20  45
22  23  24  25  26  27  28
5  30  31  32  33  34   3
6  13  38  39  40   9   2
7  14  21  46  15   8   1
``````
``````/*
C++ Program
Replace corner element in matrix
*/
#include<iostream>
#define ROW 7
#define COL 7
using namespace std;

class MyMatrix {
public:
int rows;
int cols;
MyMatrix() {
//Get the size of matrix
this->rows = ROW;
this->cols = COL;
}
//Left top to bottom
void left_to_bottom(int matrix[][COL], int mid) {
int temp = 0;
for (int i = mid + 1; i < this->cols; ++i) {
for (int j = 0, k = i; j < mid && i + j < this->cols && k < this->rows; ++j, k++) {
temp = matrix[j][i + j];
matrix[j][i + j] = matrix[k][j];
matrix[k][j] = temp;
}
}
}
void right_to_top(int matrix[][COL], int mid) {
int temp = 0;
for (int i = mid - 1, l = mid + 1; i >= 0; --i, l++) {
for (int j = 0, k = this->cols - 1; j < mid && i - j >= 0 && k > mid && l + j < this->rows; ++j, k--) {
temp = matrix[j][i - j];
matrix[j][i - j] = matrix[l + j][k];
matrix[l + j][k] = temp;
}
}
}
//Display matrix elements
void show_data(int arr[][COL]) {
for (int i = 0; i < this->rows; ++i) {
for (int j = 0; j < this->cols; ++j) {
cout << " " << arr[i][j];
}
cout << "\n";
}
cout << "\n";
}
void replace_corner(int matrix[][COL]) {
if (this->rows != this->cols || this->cols % 2 == 0) {
cout << "\nNot a valid perfect Odd square matrix";
return;
}
int mid = (this->cols) / 2;
this->left_to_bottom(matrix, mid);
this->right_to_top(matrix, mid);
}
};
int main() {
int matrix[][COL] = {
{
1,
2,
3,
4,
5,
6,
7
},
{
8,
9,
10,
11,
12,
13,
14
},
{
15,
16,
17,
18,
19,
20,
21
},
{
22,
23,
24,
25,
26,
27,
28
},
{
29,
30,
31,
32,
33,
34,
35
},
{
36,
37,
38,
39,
40,
41,
42
},
{
43,
44,
45,
46,
47,
48,
49
}
};
MyMatrix obj ;
obj.show_data(matrix);
obj.replace_corner(matrix);
obj.show_data(matrix);
return 0;
}```
```

#### Output

`````` 1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35
36 37 38 39 40 41 42
43 44 45 46 47 48 49

49 42 35 4 29 36 43
48 41 10 11 12 37 44
47 16 17 18 19 20 45
22 23 24 25 26 27 28
5 30 31 32 33 34 3
6 13 38 39 40 9 2
7 14 21 46 15 8 1
``````
``````/*
Java Program
Replace corner element in matrix
*/
public class MyMatrix {

public int rows;
public int cols;
public MyMatrix(int [][]matrix)
{
//Get the size of matrix
rows = matrix.length;
cols = matrix[0].length;
}

//Left top to bottom
public void left_to_bottom(int [][]matrix,int mid)
{
int temp=0;
for (int i = mid+1; i < cols ; ++i)
{
for (int j = 0,k=i; j < mid && i+j < cols && k < rows; ++j,k++)
{
temp = matrix[j][i+j];
matrix[j][i+j]= matrix[k][j] ;
matrix[k][j] = temp;
}

}
}

public void right_to_top(int [][]matrix,int mid)
{
int temp=0;
for (int i = mid-1,l=mid+1; i >= 0 ; --i,l++)
{
for (int j = 0,k=cols-1; j < mid && i-j >=0 && k >mid && l+j <rows; ++j,k--)
{
temp = matrix[j][i-j] ;
matrix[j][i-j] = matrix[l+j][k] ;
matrix[l+j][k] = temp;
}

}
}
//Display matrix elements
public void show_data(int [][]arr)
{
for (int i = 0; i < rows; ++i)
{
for (int j = 0; j < cols; ++j)
{
System.out.print("  "+arr[i][j] );
}
System.out.print("\n");
}
System.out.print("\n");
}
public void replace_corner(int [][]matrix)
{
if(rows != cols || cols % 2 == 0)
{
System.out.print("\nNot a valid perfect Odd square matrix");
return;
}
int mid=(cols)/2;

left_to_bottom(matrix,mid);
right_to_top(matrix,mid);
}
public static void main(String[] args) {

//Define matrix
int [][]matrix = {
{1,  2,   3,  4,  5   ,6, 7},
{8,  9,  10,  11, 12, 13, 14},
{15, 16, 17, 18,  19, 20, 21},
{22, 23, 24, 25,  26, 27, 28},
{29, 30, 31, 32,  33, 34, 35},
{36, 37, 38, 39,  40, 41, 42},
{43, 44, 45, 46,  47, 48, 49}
};
MyMatrix obj = new MyMatrix(matrix);
obj.show_data(matrix);
obj.replace_corner(matrix);
obj.show_data(matrix);

}
}```
```

#### Output

`````` 1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35
36 37 38 39 40 41 42
43 44 45 46 47 48 49

49 42 35 4 29 36 43
48 41 10 11 12 37 44
47 16 17 18 19 20 45
22 23 24 25 26 27 28
5 30 31 32 33 34 3
6 13 38 39 40 9 2
7 14 21 46 15 8 1
``````
``````/*
C# Program
Replace corner element in matrix
*/
using System;
public class MyMatrix {
int rows;
int cols;
MyMatrix(int[,] matrix) {
//Get the size of matrix
rows = matrix.GetLength(0);
cols = matrix.GetLength(1);
}
//Left top to bottom
public void left_to_bottom(int[,] matrix, int mid) {
int temp = 0;
for (int i = mid + 1; i < cols; ++i) {
for (int j = 0, k = i; j < mid && i + j < cols && k < rows; ++j, k++) {
temp = matrix[j,i + j];
matrix[j,i + j] = matrix[k,j];
matrix[k,j] = temp;
}
}
}
public void right_to_top(int[,] matrix, int mid) {
int temp = 0;
for (int i = mid - 1, l = mid + 1; i >= 0; --i, l++) {
for (int j = 0, k = cols - 1; j < mid && i - j >= 0 && k > mid && l + j < rows; ++j, k--) {
temp = matrix[j,i - j];
matrix[j,i - j] = matrix[l + j,k];
matrix[l + j,k] = temp;
}
}
}
//Display matrix elements
public void show_data(int[,] arr) {
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
Console.Write(" " + arr[i,j]);
}
Console.Write("\n");
}
Console.Write("\n");
}
public void replace_corner(int[,] matrix) {
if (rows != cols || cols % 2 == 0) {
Console.Write("\nNot a valid perfect Odd square matrix");
return;
}
int mid = (cols) / 2;
left_to_bottom(matrix, mid);
right_to_top(matrix, mid);
}
public static void Main(String[] args) {
int[,]
//Define matrix
matrix = {
{
1,
2,
3,
4,
5,
6,
7
},
{
8,
9,
10,
11,
12,
13,
14
},
{
15,
16,
17,
18,
19,
20,
21
},
{
22,
23,
24,
25,
26,
27,
28
},
{
29,
30,
31,
32,
33,
34,
35
},
{
36,
37,
38,
39,
40,
41,
42
},
{
43,
44,
45,
46,
47,
48,
49
}
};
MyMatrix obj = new MyMatrix(matrix);
obj.show_data(matrix);
obj.replace_corner(matrix);
obj.show_data(matrix);
}
}```
```

#### Output

`````` 1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35
36 37 38 39 40 41 42
43 44 45 46 47 48 49

49 42 35 4 29 36 43
48 41 10 11 12 37 44
47 16 17 18 19 20 45
22 23 24 25 26 27 28
5 30 31 32 33 34 3
6 13 38 39 40 9 2
7 14 21 46 15 8 1
``````
``````<?php
/*
Php Program
Replace corner element in matrix
*/
class MyMatrix {
public \$rows;
public \$cols;

function __construct(\$matrix) {
//Get the size of matrix
\$this->rows = count(\$matrix);
\$this->cols = count(\$matrix[0]);
}
//Left top to bottom

public 	function left_to_bottom(&\$matrix, \$mid) {
\$temp = 0;
for (\$i = \$mid + 1; \$i < \$this->cols; ++\$i) {
for (\$j = 0, \$k = \$i; \$j < \$mid && \$i + \$j < \$this->cols && \$k < \$this->rows; ++\$j, \$k++) {
\$temp = \$matrix[\$j][\$i + \$j];
\$matrix[\$j][\$i + \$j] = \$matrix[\$k][\$j];
\$matrix[\$k][\$j] = \$temp;
}
}
}
public 	function right_to_top(&\$matrix, \$mid) {
\$temp = 0;
for (\$i = \$mid - 1, \$l = \$mid + 1; \$i >= 0; --\$i, \$l++) {
for (\$j = 0, \$k = \$this->cols - 1; \$j < \$mid && \$i - \$j >= 0 && \$k > \$mid && \$l + \$j < \$this->rows; ++\$j, \$k--) {
\$temp = \$matrix[\$j][\$i - \$j];
\$matrix[\$j][\$i - \$j] = \$matrix[\$l + \$j][\$k];
\$matrix[\$l + \$j][\$k] = \$temp;
}
}
}
//Display matrix elements

public 	function show_data(\$arr) {
for (\$i = 0; \$i < \$this->rows; ++\$i) {
for (\$j = 0; \$j < \$this->cols; ++\$j) {
echo(" ". \$arr[\$i][\$j]);
}
echo("\n");
}
echo("\n");
}
public 	function replace_corner(&\$matrix) {
if (\$this->rows != \$this->cols || \$this->cols % 2 == 0) {
echo("\nNot a valid perfect Odd square matrix");
return;
}
\$mid = intval((\$this->cols) / 2);
\$this->left_to_bottom(\$matrix, \$mid);
\$this->right_to_top(\$matrix, \$mid);
}
};

function main() {
//Define matrix
\$matrix = array(
array(1, 2, 3, 4, 5, 6, 7),
array(8, 9, 10, 11, 12, 13, 14),
array(15, 16, 17, 18, 19, 20, 21),
array(22, 23, 24, 25, 26, 27, 28),
array(29, 30, 31, 32, 33, 34, 35),
array(36, 37, 38, 39, 40, 41, 42),
array(43, 44, 45, 46, 47, 48, 49)
);
\$obj = new MyMatrix(\$matrix);
\$obj->show_data(\$matrix);
\$obj->replace_corner(\$matrix);
\$obj->show_data(\$matrix);

}
main();```
```

#### Output

`````` 1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35
36 37 38 39 40 41 42
43 44 45 46 47 48 49

49 42 35 4 29 36 43
48 41 10 11 12 37 44
47 16 17 18 19 20 45
22 23 24 25 26 27 28
5 30 31 32 33 34 3
6 13 38 39 40 9 2
7 14 21 46 15 8 1
``````
``````/*
Node Js Program
Replace corner element in matrix
*/
class MyMatrix {
;;
constructor(matrix) {
//Get the size of matrix
this.rows = matrix.length;
this.cols = matrix[0].length;
}

//Left top to bottom
left_to_bottom(matrix, mid) {
var temp = 0;
for (var i = mid + 1; i < this.cols; ++i) {
for (var j = 0,k = i; j < mid && i + j < this.cols && k < this.rows; ++j, k++) {
temp = matrix[j][i + j];
matrix[j][i + j] = matrix[k][j];
matrix[k][j] = temp;
}
}
}
right_to_top(matrix, mid) {
var temp = 0;
for (var i = mid - 1,l = mid + 1; i >= 0; --i, l++) {
for (var j = 0,k = this.cols - 1; j < mid && i - j >= 0 && k > mid && l + j < this.rows; ++j, k--) {
temp = matrix[j][i - j];
matrix[j][i - j] = matrix[l + j][k];
matrix[l + j][k] = temp;
}
}
}

//Display matrix elements
show_data(arr) {
for (var i = 0; i < this.rows; ++i) {
for (var j = 0; j < this.cols; ++j) {
process.stdout.write(" " + arr[i][j]);
}

process.stdout.write("\n");
}

process.stdout.write("\n");
}
replace_corner(matrix) {
if (this.rows != this.cols || this.cols % 2 == 0) {
process.stdout.write("\nNot a valid perfect Odd square matrix");
return;
}
var mid = parseInt((this.cols) / 2);
this.left_to_bottom(matrix, mid);
this.right_to_top(matrix, mid);
}
}

function main(args) {
//Define matrix
var matrix = [
[1, 2, 3, 4, 5, 6, 7],
[8, 9, 10, 11, 12, 13, 14],
[15, 16, 17, 18, 19, 20, 21],
[22, 23, 24, 25, 26, 27, 28],
[29, 30, 31, 32, 33, 34, 35],
[36, 37, 38, 39, 40, 41, 42],
[43, 44, 45, 46, 47, 48, 49]
];
var obj = new MyMatrix(matrix);
obj.show_data(matrix);
obj.replace_corner(matrix);
obj.show_data(matrix);
}
main();```
```

#### Output

`````` 1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35
36 37 38 39 40 41 42
43 44 45 46 47 48 49

49 42 35 4 29 36 43
48 41 10 11 12 37 44
47 16 17 18 19 20 45
22 23 24 25 26 27 28
5 30 31 32 33 34 3
6 13 38 39 40 9 2
7 14 21 46 15 8 1
``````
``````# Python 3 Program
# Replace corner element in matrix
class MyMatrix :

def __init__(self, matrix) :
# Get the size of matrix
self.rows = len(matrix)
self.cols = len(matrix[0])

# Left top to bottom
def left_to_bottom(self, matrix, mid) :
temp = 0
i = mid + 1
while (i < self.cols) :
j = 0
k = i
while (j < mid and i + j < self.cols and k < self.rows) :
temp = matrix[j][i + j]
matrix[j][i + j] = matrix[k][j]
matrix[k][j] = temp
j += 1
k += 1

i += 1

def right_to_top(self, matrix, mid) :
temp = 0
i = mid - 1
l = mid + 1
while (i >= 0) :
j = 0
k = self.cols - 1
while (j < mid and i - j >= 0 and k > mid and l + j < self.rows) :
temp = matrix[j][i - j]
matrix[j][i - j] = matrix[l + j][k]
matrix[l + j][k] = temp
j += 1
k -= 1

i -= 1
l += 1

# Display matrix elements
def show_data(self, arr) :
i = 0
while (i < self.rows) :
j = 0
while (j < self.cols) :
print(" ", arr[i][j], end = "")
j += 1

print("\n", end = "")
i += 1

print("\n", end = "")

def replace_corner(self, matrix) :
if (self.rows != self.cols or self.cols % 2 == 0) :
print("\nNot a valid perfect Odd square matrix", end = "")
return

mid = int((self.cols) / 2)
self.left_to_bottom(matrix, mid)
self.right_to_top(matrix, mid)

def main() :
matrix = [
[1, 2, 3, 4, 5, 6, 7],
[8, 9, 10, 11, 12, 13, 14],
[15, 16, 17, 18, 19, 20, 21],
[22, 23, 24, 25, 26, 27, 28],
[29, 30, 31, 32, 33, 34, 35],
[36, 37, 38, 39, 40, 41, 42],
[43, 44, 45, 46, 47, 48, 49]
]
obj = MyMatrix(matrix)
obj.show_data(matrix)
obj.replace_corner(matrix)
obj.show_data(matrix)

if __name__ == "__main__":
main()```
```

#### Output

``````  1  2  3  4  5  6  7
8  9  10  11  12  13  14
15  16  17  18  19  20  21
22  23  24  25  26  27  28
29  30  31  32  33  34  35
36  37  38  39  40  41  42
43  44  45  46  47  48  49

49  42  35  4  29  36  43
48  41  10  11  12  37  44
47  16  17  18  19  20  45
22  23  24  25  26  27  28
5  30  31  32  33  34  3
6  13  38  39  40  9  2
7  14  21  46  15  8  1
``````
``````# Ruby Program
# Replace corner element in matrix
class MyMatrix
# Define the accessor and reader of class MyMatrix
attr_accessor :rows, :cols
def initialize(matrix)
# Get the size of matrix
@rows = matrix.length
@cols = matrix[0].length
end
# Left top to bottom
def left_to_bottom(matrix, mid)
temp = 0
i = mid + 1
while (i < @cols)
j = 0
k = i
while (j < mid and i + j < @cols and k < @rows)
temp = matrix[j][i + j]
matrix[j][i + j] = matrix[k][j]
matrix[k][j] = temp
j += 1
k += 1
end
i += 1
end
end
def right_to_top(matrix, mid)
temp = 0
i = mid - 1
l = mid + 1
while (i >= 0)
j = 0
k = @cols - 1
while (j < mid and i - j >= 0 and k > mid and l + j < @rows)
temp = matrix[j][i - j]
matrix[j][i - j] = matrix[l + j][k]
matrix[l + j][k] = temp
j += 1
k -= 1
end
i -= 1
l += 1
end
end
# Display matrix elements
def show_data(arr)
i = 0
while (i < @rows)
j = 0
while (j < @cols)
print(" ", arr[i][j])
j += 1
end
print("\n")
i += 1
end
print("\n")
end
def replace_corner(matrix)
if (@rows != @cols or @cols % 2 == 0)
print("\nNot a valid perfect Odd square matrix")
return
end
mid = (@cols) / 2
self.left_to_bottom(matrix, mid)
self.right_to_top(matrix, mid)
end
end
def main()
matrix = [
[1, 2, 3, 4, 5, 6, 7],
[8, 9, 10, 11, 12, 13, 14],
[15, 16, 17, 18, 19, 20, 21],
[22, 23, 24, 25, 26, 27, 28],
[29, 30, 31, 32, 33, 34, 35],
[36, 37, 38, 39, 40, 41, 42],
[43, 44, 45, 46, 47, 48, 49]
]
obj = MyMatrix.new(matrix)
obj.show_data(matrix)
obj.replace_corner(matrix)
obj.show_data(matrix)
end

main()```
```

#### Output

`````` 1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35
36 37 38 39 40 41 42
43 44 45 46 47 48 49

49 42 35 4 29 36 43
48 41 10 11 12 37 44
47 16 17 18 19 20 45
22 23 24 25 26 27 28
5 30 31 32 33 34 3
6 13 38 39 40 9 2
7 14 21 46 15 8 1

``````
``````/*
Scala Program
Replace corner element in matrix
*/
class MyMatrix(var rows: Int,var cols: Int) {
def this(matrix: Array[Array[Int]]) {
//Get the size of matrix
this(matrix.length,matrix(0).length);
}
//Left top to bottom
def left_to_bottom(matrix: Array[Array[Int]], mid: Int): Unit = {
var temp: Int = 0;
var i: Int = mid + 1;
while (i < this.cols) {
var j: Int = 0;
var k: Int = i;
while (j < mid && i + j < this.cols && k < this.rows) {
temp = matrix(j)(i + j);
matrix(j)(i + j) = matrix(k)(j);
matrix(k)(j) = temp;
j += 1;
k += 1;
}
i += 1;
}
}
def right_to_top(matrix: Array[Array[Int]], mid: Int): Unit = {
var temp: Int = 0;
var i: Int = mid - 1;
var l: Int = mid + 1;
while (i >= 0) {
var j: Int = 0;
var k: Int = this.cols - 1;
while (j < mid && i - j >= 0 && k > mid && l + j < this.rows) {
temp = matrix(j)(i - j);
matrix(j)(i - j) = matrix(l + j)(k);
matrix(l + j)(k) = temp;
j += 1;
k -= 1;
}
i -= 1;
l += 1;
}
}
//Display matrix elements
def show_data(arr: Array[Array[Int]]): Unit = {
var i: Int = 0;
while (i < this.rows) {
var j: Int = 0;
while (j < this.cols) {
print(" " + arr(i)(j));
j += 1;
}
print("\n");
i += 1;
}
print("\n");
}
def replace_corner(matrix: Array[Array[Int]]): Unit = {
if (this.rows != this.cols || this.cols % 2 == 0) {
print("\nNot a valid perfect Odd square matrix");

return;
}
val mid: Int = ((this.cols) / 2).toInt;
this.left_to_bottom(matrix, mid);
this.right_to_top(matrix, mid);
}
}
object Main {
def main(args: Array[String]): Unit = {
val matrix: Array[Array[Int]] = Array(
Array(1, 2, 3, 4, 5, 6, 7),
Array(8, 9, 10, 11, 12, 13, 14),
Array(15, 16, 17, 18, 19, 20, 21),
Array(22, 23, 24, 25, 26, 27, 28),
Array(29, 30, 31, 32, 33, 34, 35),
Array(36, 37, 38, 39, 40, 41, 42),
Array(43, 44, 45, 46, 47, 48, 49));
val obj: MyMatrix = new MyMatrix(matrix);
obj.show_data(matrix);
obj.replace_corner(matrix);
obj.show_data(matrix);
}
}```
```

#### Output

`````` 1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35
36 37 38 39 40 41 42
43 44 45 46 47 48 49

49 42 35 4 29 36 43
48 41 10 11 12 37 44
47 16 17 18 19 20 45
22 23 24 25 26 27 28
5 30 31 32 33 34 3
6 13 38 39 40 9 2
7 14 21 46 15 8 1
``````
``````/*
Swift 4 Program
Replace corner element in matrix
*/
class MyMatrix {
var rows : Int;
var cols : Int;
init(_ matrix: [[Int]]) {
//Get the size of matrix
self.rows = matrix.count;
self.cols = matrix[0].count;
}
//Left top to bottom
func left_to_bottom(_ matrix: inout [[Int]], _ mid: Int) {
var temp: Int = 0;
var i: Int = mid + 1;
while (i < self.cols) {
var j: Int = 0;
var k: Int = i;
while (j < mid && i + j < self.cols && k < self.rows) {
temp = matrix[j][i + j];
matrix[j][i + j] = matrix[k][j];
matrix[k][j] = temp;
j += 1;
k += 1;
}
i += 1;
}
}
func right_to_top(_ matrix: inout[[Int]], _ mid: Int) {
var temp: Int = 0;
var i: Int = mid - 1;
var l: Int = mid + 1;
while (i >= 0) {
var j: Int = 0;
var k: Int = self.cols - 1;
while (j < mid && i - j >= 0 && k > mid && l + j < self.rows) {
temp = matrix[j][i - j];
matrix[j][i - j] = matrix[l + j][k];
matrix[l + j][k] = temp;
j += 1;
k -= 1;
}
i -= 1;
l += 1;
}
}
//Display matrix elements
func show_data(_ arr: [[Int]]) {
var i: Int = 0;
while (i < self.rows) {
var j: Int = 0;
while (j < self.cols) {
print(" ", arr[i][j], terminator: "");
j += 1;
}
print("\n", terminator: "");
i += 1;
}
print("\n", terminator: "");
}
func replace_corner(_ matrix: inout [[Int]]) {
if (self.rows != self.cols || self.cols % 2 == 0) {
print("\nNot a valid perfect Odd square matrix", terminator: "");
return;
}
let mid: Int = (self.cols) / 2;
self.left_to_bottom(&matrix, mid);
self.right_to_top(&matrix, mid);
}
}
func main() {
var matrix: [
[Int]
] = [
[1, 2, 3, 4, 5, 6, 7],
[8, 9, 10, 11, 12, 13, 14],
[15, 16, 17, 18, 19, 20, 21],
[22, 23, 24, 25, 26, 27, 28],
[29, 30, 31, 32, 33, 34, 35],
[36, 37, 38, 39, 40, 41, 42],
[43, 44, 45, 46, 47, 48, 49]
];
let obj: MyMatrix = MyMatrix(matrix);
obj.show_data(matrix);
obj.replace_corner(&matrix);
obj.show_data(matrix);
}
main();```
```

#### Output

``````  1  2  3  4  5  6  7
8  9  10  11  12  13  14
15  16  17  18  19  20  21
22  23  24  25  26  27  28
29  30  31  32  33  34  35
36  37  38  39  40  41  42
43  44  45  46  47  48  49

49  42  35  4  29  36  43
48  41  10  11  12  37  44
47  16  17  18  19  20  45
22  23  24  25  26  27  28
5  30  31  32  33  34  3
6  13  38  39  40  9  2
7  14  21  46  15  8  1
``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.