Rotate Image

                                            
class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        
        // Transpose the matrix
        for(int i=0; i<n; i++){
            for(int j=i; j<n; j++){
                swap(matrix[i][j], matrix[j][i]);
            }
        }
        
        // Reverse each row
        for(int i=0; i<n; i++){
            reverse(matrix[i].begin(), matrix[i].end());
        }
    }
};

                                            
class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;
        for (int i = 0; i < n / 2; i++) {
            for (int j = i; j < n - i - 1; j++) {
                int temp = matrix[i][j];
                matrix[i][j] = matrix[n - 1 - j][i];
                matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j];
                matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i];
                matrix[j][n - 1 - i] = temp;
            }
        }
    }
}

                                            
class Solution(object):
    def rotate(self, matrix):
        n = len(matrix)
        for i in range(n // 2):
            for j in range(i, n - i - 1):
                tmp = matrix[i][j]
                matrix[i][j] = matrix[n - 1 - j][i]
                matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j]
                matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i]
                matrix[j][n - 1 - i] = tmp

                                            
void rotate(int** matrix, int matrixSize, int* matrixColSize) {
    int i, j, temp;
    
    // Transpose the matrix
    for(i = 0; i < matrixSize; i++) {
        for(j = i; j < matrixColSize[i]; j++) {
            temp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = temp;
        }
    }
    
    // Reverse each row
    for(i = 0; i < matrixSize; i++) {
        for(j = 0; j < matrixColSize[i] / 2; j++) {
            temp = matrix[i][j];
            matrix[i][j] = matrix[i][matrixColSize[i] - 1 - j];
            matrix[i][matrixColSize[i] - 1 - j] = temp;
        }
    }
}

                                            
public class Solution {
    public void Rotate(int[][] matrix) {
        int n = matrix.Length;
        
        // Transpose the matrix
        for(int i=0; i<n; i++){
            for(int j=i; j<n; j++){
                int temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }
        
        // Reverse each row
        for(int i=0; i<n; i++){
            Array.Reverse(matrix[i]);
        }
    }
}

                                            
var rotate = function(matrix) {
    const n = matrix.length;

    // Transpose the matrix
    for (let i = 0; i < n; i++) {
        for (let j = i; j < n; j++) {
            [matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];
        }
    }

    // Reverse each row
    for (let i = 0; i < n; i++) {
        matrix[i].reverse();
    }
};

                                            
/**
 Do not return anything, modify matrix in-place instead.
 */
function rotate(matrix: number[][]): void {
    const n = matrix.length;
    
    // Transpose the matrix
    for (let i = 0; i < n; i++) {
        for (let j = i; j < n; j++) {
            [matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];
        }
    }
    
    // Reverse each row
    for (let i = 0; i < n; i++) {
        matrix[i].reverse();
    }
};

                                            
class Solution {
    /**
     * @param Integer[][] $matrix
     * @return NULL
     */
    function rotate(&$matrix) {
        $n = count($matrix);
        // Transpose the matrix
        for ($i = 0; $i < $n; $i++) {
            for ($j = $i; $j < $n; $j++) {
                $temp = $matrix[$i][$j];
                $matrix[$i][$j] = $matrix[$j][$i];
                $matrix[$j][$i] = $temp;
            }
        }
        
        // Reverse each row
        for ($i = 0; $i < $n; $i++) {
            $start = 0;
            $end = $n - 1;
            while ($start < $end) {
                $temp = $matrix[$i][$start];
                $matrix[$i][$start] = $matrix[$i][$end];
                $matrix[$i][$end] = $temp;
                $start++;
                $end--;
            }
        }
    }
}

                                            
class Solution {
    func rotate(_ matrix: inout [[Int]]) {
        let n = matrix.count
        
        // Transpose the matrix
        for i in 0..<n {
            for j in i..<n {
                let temp = matrix[i][j]
                matrix[i][j] = matrix[j][i]
                matrix[j][i] = temp
            }
        }
        
        // Reverse each row
        for i in 0..<n {
            matrix[i].reverse()
        }
    }
}

                                            
class Solution {
    fun rotate(matrix: Array<IntArray>): Unit {
        val n = matrix.size
        for (i in 0 until n / 2) {
            for (j in i until n - i - 1) {
                val temp = matrix[i][j]
                matrix[i][j] = matrix[n - 1 - j][i]
                matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j]
                matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i]
                matrix[j][n - 1 - i] = temp
            }
        }
    }
}

                                            
class Solution {
  void rotate(List<List<int>> matrix) {
      int n = matrix.length;
      
      for (int i = 0; i < (n + 1) ~/ 2; i++) {
        for (int j = 0; j < n ~/ 2; j++) {
          int temp = matrix[n - 1 - j][i];
          matrix[n - 1 - j][i] = matrix[n - 1 - i][n - j - 1];
          matrix[n - 1 - i][n - j - 1] = matrix[j][n - 1 - i];
          matrix[j][n - 1 - i] = matrix[i][j];
          matrix[i][j] = temp;
        }
      }
    }
}

                                            
func rotate(matrix [][]int) {
    n := len(matrix)

    // Transpose the matrix
    for i := 0; i < n; i++ {
        for j := i; j < n; j++ {
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
        }
    }

    // Reverse each row
    for i := 0; i < n; i++ {
        left := 0
        right := n - 1
        for left < right {
            matrix[i][left], matrix[i][right] = matrix[i][right], matrix[i][left]
            left++
            right--
        }
    }
}

                                            
# @param {Integer[][]} matrix
# @return {Void} Do not return anything, modify matrix in-place 
# instead.
def rotate(matrix)
    n = matrix.length
    (0...n).each do |i|
        (i...n).each do |j|
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
        end
    end
    matrix.each { |row| row.reverse! }
end

                                            
object Solution {
    def rotate(matrix: Array[Array[Int]]): Unit = {
        val n = matrix.length
        for (i <- 0 until n / 2) {
            for (j <- i until n - i - 1) {
                val temp = matrix(i)(j)
                matrix(i)(j) = matrix(n - j - 1)(i)
                matrix(n - j - 1)(i) = matrix(n - i - 1)(n - j - 1)
                matrix(n - i - 1)(n - j - 1) = matrix(j)(n - i - 1)
                matrix(j)(n - i - 1) = temp
            }
        }
    }
}

                                            
impl Solution {
    pub fn rotate(matrix: &mut Vec<Vec<i32>>) {
        let n = matrix.len();
        
        for i in 0..n/2 {
            for j in i..n-i-1 {
                let temp = matrix[i][j];
                matrix[i][j] = matrix[n-1-j][i];
                matrix[n-1-j][i] = matrix[n-1-i][n-1-j];
                matrix[n-1-i][n-1-j] = matrix[j][n-1-i];
                matrix[j][n-1-i] = temp;
            }
        }
    }
}

To solve this coding challenge of rotating an n x n 2D matrix by 90 degrees clockwise, we need to work directly on the given matrix without using any additional space for another matrix. This requires a deep understanding of manipulating indices within the 2D matrix. Below is a detailed explanation of the approach followed by pseudocode that thoroughly explains each step.

Explanation

The goal is to rotate the entire matrix 90 degrees to the right (clockwise) in place. Here's how we can achieve this:

Step-by-Step Explanation:

Understanding Rotation:

When rotating a matrix 90 degrees to the right, the first row of the original matrix becomes the last column of the rotated matrix, the second row becomes the second last column, and so on.

Index Mapping:

For a given element at position (i, j) in the original matrix, it will move to the position (j, n-1-i) in the rotated matrix. This can be observed if we look at an example and manually map out the elements.

Performing In-Place Rotation:

Since we are asked to do this in-place, we need to swap the elements in groups. A common way to think about in-place rotation is to cyclically permute the elements of four edges at a time.
We only need to work through the first half of the matrix layers because each rotation operation affects four cells.

Detailed swapping:

We will iterate over each layer of the matrix from the outermost layer towards the middle.
For each layer, we will perform the swapping by cyclically moving four corresponding elements from each corner.

Detailed Steps in Pseudocode:

Initialize Matrix Size:

Calculate the size of the matrix
n

.

Iterate Through Layers:

Loop through the layers (from 0 to n//2).

Iterate Through Elements in the Current Layer:

For each element in the current layer, perform the cyclic swaps among the four corresponding cells.

Swapping Mechanism:

Store one of the elements in a temporary variable to facilitate the swaps.

Pseudocode:

                                            
# Function to rotate the matrix in place by 90 degrees clockwise
FUNCTION rotateMatrixInPlace(matrix):
    # Calculate size of matrix
    size = LENGTH(matrix)
    
    # Loop through each layer of the matrix
    FOR layer FROM 0 TO (size//2 - 1):
        # Calculate the first index and the last index of the current layer
        first_index = layer
        last_index = size - 1 - layer
        
        # Iterate over each element in the current layer
        FOR i FROM first_index TO last_index - 1:
            # Calculate offset within the current layer
            offset = i - first_index

            # Save the top element temporarily
            temp = matrix[first_index][i]

            # Move left element to top
            matrix[first_index][i] = matrix[last_index - offset][first_index]

            # Move bottom element to left
            matrix[last_index - offset][first_index] = matrix[last_index][last_index - offset]

            # Move right element to bottom
            matrix[last_index][last_index - offset] = matrix[i][last_index]

            # Assign temp (top element) to right
            matrix[i][last_index] = temp
            
# Example matrix rotation steps for matrix = [ [1,2,3], [4,5,6], [7,8,9] ]
# Original Matrix:
# 1 2 3
# 4 5 6
# 7 8 9

# After rotation:
# 7 4 1
# 8 5 2
# 9 6 3

By following these detailed steps, the given matrix will be rotated 90 degrees clockwise in-place, meeting the problem constraints effectively.