Posted on by Kalkicode
Code Matrix

# Replace corner element in matrix

The problem at hand is to replace the corner elements of a square matrix with elements from the opposite corners. Specifically, we want to swap the elements of the left-top corner with the elements of the bottom-right corner and vice versa, and then swap the elements of the right-top corner with the elements of the bottom-left corner and vice versa.

## Problem Statement and Example

Consider the following square 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``````

After replacing the corner elements, the matrix will look like this:

``````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``````

## Idea to Solve the Problem

To replace the corner elements in the square matrix, we can follow the following approach:

1. First, we need to check if the given matrix is a valid odd-sized square matrix. If it is not, we return as the problem cannot be solved with an invalid matrix.
2. We find the middle element of the matrix, which will be the index for dividing the matrix into the four corners (left-top, right-top, left-bottom, and right-bottom).
3. We perform two operations: a. Move elements from the left-top corner to the bottom-right corner and vice versa. b. Move elements from the right-top corner to the bottom-left corner and vice versa.
4. The 'left_to_bottom' function handles the first operation, where we traverse the left-top corner to the bottom-right corner and swap the elements with the corresponding elements in the opposite corner.
5. The 'right_to_top' function handles the second operation, where we traverse the right-top corner to the bottom-left corner and swap the elements with the corresponding elements in the opposite corner.

## Pseudocode

``````left_to_bottom(matrix, mid):
for i from mid + 1 to cols:
for j from 0 to mid:
swap(matrix[j][i + j], matrix[rows - (i + j) - 1][j])

right_to_top(matrix, mid):
for i from mid - 1 to 0:
for j from 0 to mid:
swap(matrix[j][i - j], matrix[rows - (i - j) - 1][cols - 1 - j])

replace_corner(matrix):
mid = cols / 2
if rows != cols or cols % 2 == 0:
print "Not a valid perfect Odd square matrix"
return
left_to_bottom(matrix, mid)
right_to_top(matrix, mid)``````

## Algorithm Explanation

1. The 'left_to_bottom' function takes 'matrix' and 'mid' as input parameters. 'matrix' is the square matrix, and 'mid' is the middle element index of the matrix (rows and columns are 0-based indexed).
2. The function traverses the left-top corner from 'mid + 1' to the last column and from 0 to 'mid'.
3. For each element in the left-top corner, it swaps it with the corresponding element in the bottom-right corner using the 'swap' function.
4. The 'right_to_top' function takes 'matrix' and 'mid' as input parameters. 'matrix' is the square matrix, and 'mid' is the middle element index of the matrix.
5. The function traverses the right-top corner from 'mid - 1' to the first column and from 0 to 'mid'.
6. For each element in the right-top corner, it swaps it with the corresponding element in the bottom-left corner using the 'swap' function.
7. The 'replace_corner' function checks if the matrix is a valid odd-sized square matrix and then calls 'left_to_bottom' and 'right_to_top' functions to replace the corner elements.

## Code Solution

``````/*
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_reader :rows, :cols
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
``````

## Output Explanation

The given Java code creates a square matrix, calls the 'replace_corner' function to replace the corner elements, and then displays the original and modified matrices. The output displays the original and modified matrices as follows:

``````Original 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

Modified Matrix:
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``````

## Time Complexity

The time complexity of the provided solution is O(N), where N is the total number of elements in the square matrix. The functions 'left_to_bottom' and 'right_to_top' traverse the corners of the matrix, and each element is swapped once. The swap operation takes constant time. Therefore, the overall time complexity is linear in the number of elements in the matrix.

## 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.

Categories
Relative Post